Instrumenting / Monitoring

Dynamic dispatching library for metrics and instrumentations

A generic interface to different metrics systems in Erlang.

Provides a common interface for defining metrics based on Telemetry events.

Periodically collect measurements and dispatch them as Telemetry events.

Telemetry instrumentation for Cowboy

Real-time performance dashboard for Phoenix

OpenTelemetry API

Implementation of stable OpenTelemetry signals

OpenTelemetry Protocol Exporter

OpenTelemetry Semantic Conventions

Bridge library between Telemetry events and OpenTelemetry Erlang

Tools for opentelemetry context propagation across process boundaries

OpenTelemetry tracing for the Phoenix Framework

Trace Ecto queries with OpenTelemetry.

Provides a Prometheus format reporter for Telemetry.Metrics definitions.

Erlang node failure detector

A distributed, compacting, multidimensional, telemetry-powered time series datastore

Counters registry

Rate-limiting system_monitor event handler

OpenTelemetry Cowboy Instrumentation

Ecto PostgreSQL database performance insights. Locks, index usage, buffer cache hit ratios, vacuum stats and more.

Registry and helpers for Telemetry events

OpenTelemetry Instrumentation utilities for HTTP libraries

OpenTelemetry tracing for Oban

Prometheus monitoring system and time series database client in Erlang.

Prometheus metrics and Grafana dashboards for all of your favorite Elixir libraries

Telemetry.Metrics reporter for StatsD-compatible metric servers

Tesla middleware that creates OpenTelemetry spans and injects tracing headers into HTTP requests for Tesla clients.

Collects error and performance data from your Elixir applications and sends it to AppSignal

Adds OpenTelemetry trace identifiers to logs

Provides an opinionated Telemetry.Metrics reporter that supports StatsD and Prometheus.

Trace Redix queries with OpenTelemetry.

Generalizable utilities for working with OpenTelemetry in Elixir.

A function decorator for OpenTelemetry traces

Fast and reliable Elixir client for StatsD-compatible servers.

A small, fast, and unobtrusive metrics library

AppSignal's Phoenix instrumentation instruments calls to Phoenix applications to gain performance insights and error reporting

Telemetry handler that creates Opentelemetry spans from Bandit events.

Tesla middleware for adding x-request-id to outgoing requests.

AppSignal's Plug instrumentation instruments calls to Plug applications to gain performance insights and error reporting

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

Provides a Prometheus format reporter and server for Telemetry.Metrics definitions.

Elixir-friendly Prometheus monitoring system client.

Pluggable metrics for Absinthe GraphQL.

A platform agnostic tracing library. Contributors welcome.

A library for analysing absinthe GraphQL runtime usage.

A datadog API adapter for spandex.

ZenMonitor provides efficient monitoring of remote processes.

New Relic's Open-Source Elixir Agent

Trace Finch request with OpenTelemetry.

OpenTelemetry tracing for Req

Prometheus monitoring system client Plugs. Http metrics collector and exporter.

This package provides functions to help propagating OpenTelemetry context across functions that are executed asynchronously

Alchemetrics Web is a boilerplate to report basic metrics for a typical web application, such as request count, response time, ecto and erlang metrics.

Tools for integrating Ecto with Spandex.

Tiny application to gather VM statistics

Prometheus.io inets httpd exporter

Prometheus monitoring system client Ecto integration. Observes queries duration.

Fast and reliable Elixir client for StatsD-compatible servers.

Prometheus monitoring system client Phoenix instrumenter.

OpenTelemetry tracing for Broadway

Prometheus instrumenters and handlers for Cowboy 1&2.

Alchemetrics is a wrapper around exometer, that uses GenStage to backpressure the reports.

Apollo Tracing middleware for Absinthe

Prometheus.io process collector Collector exports the current state of process metrics including cpu, memory, file descriptor usage and native threads count as well as the process start and up times.

AlchemetricsTesla is a Tesla middleware to report external call metrics.

Manage, subscribe and create alarms compatible with Erlang's built in Alarm Handler

analytics_elixir

OpenTelemetry tracing for Phoenix LiveView

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

Universal analytics client, currently only supports Mixpanel and Segment.io

A small library for exporting jemalloc allocation data in Elixir

Teleplug is a dead simple opentelemetry-instrumented plug.

A library tracking how many visitors a Phoenix-based application receives per day without collecting any data from the user

OpenTelemetry tracing for Nebulex

PlugCheckup provides a Plug for adding simple health checks to your app.

An Elixir library for LLM agent observability. Provides instrumentation for agent loops, tool calls, and LLM requests with support for OpenTelemetry and OpenInference semantic conventions.

Code instrumentation and metrics collection package.

Tools for integrating Phoenix with Spandex.

Erlang based metrics system

Req plugin to instrument requests with Telemetry events

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

Adds OpenTelemetry trace identifiers to logs in the Datadog format

The Opentelemetry integration for Ash Framework

A simple Phoenix Live Dashboard for Oban jobs

PrimaOpentelemetryEx is a utility library for opentelemetry instrumentation in Prima elixir projects.

Trace Dataloader with OpenTelemetry.

A tiny plug for responding to heartbeat requests

An elixir plug for handling health and ready endpoints

Add Flame graphs to Live Dashboard or your own LiveView

Small wrappers to enhance usage of the telemetry library.

A client for DogStatsd, an extension of the StatsD metric server for Datadog.

Send StatsD metrics to Datadog

OpenTelemetry Zipkin Exporter

Generic health check endpoint for Phoenix/Plug web apps.

Prometheus metrics exporter using Telemetry.Metrics as a foundation

The AppSignal APM integration for Ash Framework

Plug compatible health check system in Elixir based on https://github.com/jbarnette/pinglish.

Telemetry based metrics UI

Tracing integration between tesla and spandex

Counters for BEAM.

`Telemetry.Metrics` reporter for AppSignal.

Simple instrumentation framework inspired by ActiveSupport::Notifications.

grpcbox interceptor for OpenTelemetry instrumentation

OpenTelemetry Experimental API

OpenTelemetry support for AWS X-Ray

An unofficial OTel-compatible metric exporter

Implementation of unstable OpenTelemetry signals

StatsD instrumenting middleware for Tesla HTTP client

DataDog data streams library for Elixir

TelemetryMetrics for Membrane Multimedia Framework

An adapter to export hackney metrics to telemetry

statsd interceptor/middleware for https://github.com/elixir-grpc/grpc

Erlang stats collection and distributed tracing framework

An Elixir Plug to collect statistics in your application and send them to your favorite backend.

OpenTelemetry tracing for the Phoenix.Channels

Ephemeral metrics history storage for Phoenix LiveDashboard

Web based metrics, monitoring, and observer.

A function decorator for telemetry

server side data collector for Orion profiler

A (Phoenix) plug for sending request counts and response times to statsd

Otel sampler for Honeycomb

A set of Plugs to be used for Kubernetes healthchecks.

The easiest way to add a health check for your background services

Dynamic Distributed Performance tracing for the BEAM

New Relic Instrumentation adapter for Absinthe

OpenCensus Zipkin reporter

Health Check Plug with Kubernetes semantics

Elixir client library to log telemetry data on Azure Application Insights.

Implements an interface for recording traces and sending them to a Zipkin server.

The helper application that simplifies and standardizes telemetry usage.

Plug and play analytics for Phoenix applications.

A StatsD client for Elixir

Cowboy stream and middleware for opentelemetry http server spans

A health check utility for any OTP application