Instrumenting / Monitoring

Dynamic dispatching library for metrics and instrumentations

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

Periodically collect measurements and dispatch them as Telemetry events.

A generic interface to different metrics systems in Erlang.

Real-time performance dashboard for Phoenix

Telemetry instrumentation for Cowboy

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

Provides a Prometheus format reporter for Telemetry.Metrics definitions.

OpenTelemetry Instrumentation utilities for HTTP libraries

Trace Ecto queries with OpenTelemetry.

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

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

Registry and helpers for Telemetry events

OpenTelemetry tracing for Oban

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

OpenTelemetry Cowboy Instrumentation

Telemetry handler that creates Opentelemetry spans from Bandit events.

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

Erlang node failure detector

Counters registry

Telemetry.Metrics reporter for StatsD-compatible metric servers

Prometheus monitoring system and time series database client in Erlang.

Rate-limiting system_monitor event handler

Fast and reliable Elixir client for StatsD-compatible servers.

A small, fast, and unobtrusive metrics library

Adds OpenTelemetry trace identifiers to logs

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

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

ZenMonitor provides efficient monitoring of remote processes.

OpenTelemetry tracing for Req

Generalizable utilities for working with OpenTelemetry in Elixir.

Trace Redix queries with OpenTelemetry.

A function decorator for OpenTelemetry traces

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

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

Elixir-friendly Prometheus monitoring system client.

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

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

A platform agnostic tracing library. Contributors welcome.

A datadog API adapter for spandex.

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

Trace Finch request with OpenTelemetry.

Prometheus.io inets httpd exporter

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

OpenTelemetry tracing for Broadway

Tools for integrating Ecto with Spandex.

A small library for exporting jemalloc allocation data in Elixir

New Relic's Open-Source Elixir Agent

Prometheus instrumenters and handlers for Cowboy 1&2.

Prometheus monitoring system client Ecto integration. Observes queries duration.

Tiny application to gather VM statistics

Prometheus monitoring system client Phoenix instrumenter.

Phoenix LiveDashboard page for inspecting Commanded EventStore

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.

The Opentelemetry integration for Ash Framework

Trace Dataloader with OpenTelemetry.

Fast and reliable Elixir client for StatsD-compatible servers.

Apollo Tracing middleware for Absinthe

analytics_elixir

Code instrumentation and metrics collection package.

OpenTelemetry Experimental API

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

Implementation of unstable OpenTelemetry signals

Erlang based metrics system

Generic health check endpoint for Phoenix/Plug web apps.

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

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

An unofficial OTel-compatible metric exporter

Tower reporter that records exceptions as OpenTelemetry span events following the OpenTelemetry semantic conventions for exceptions.

A simple Phoenix Live Dashboard for Oban jobs

Teleplug is a dead simple opentelemetry-instrumented plug.

OpenTelemetry tracing for Nebulex

A tiny plug for responding to heartbeat requests

TelemetryMetrics for Membrane Multimedia Framework

OpenTelemetry tracing for Phoenix LiveView

Prometheus metrics exporter using Telemetry.Metrics as a foundation

Send StatsD metrics to Datadog

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

Adds OpenTelemetry trace identifiers to logs in the Datadog format

Telemetry based metrics UI

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

Req plugin to instrument requests with Telemetry events

Counters for BEAM.

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

Small wrappers to enhance usage of the telemetry library.

The AppSignal APM integration for Ash Framework

A set of Plugs to be used for Kubernetes healthchecks.

Add Flame graphs to Live Dashboard or your own LiveView

Fast metrics library for Erlang with Prometheus export

Simple health check library for Elixir applications with support for Ecto, Redix and Kaffe.

OpenTelemetry support for AWS X-Ray

New Relic Instrumentation adapter for Absinthe

Plug and play analytics for Phoenix applications.

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.

Tracing integration between tesla and spandex

A function decorator for telemetry

OpenTelemetry Zipkin Exporter

`Telemetry.Metrics` reporter for AppSignal.

An elixir plug for handling health and ready endpoints

OpenTelemetry tracing for the Phoenix.Channels

Temporary library to integration telemetry_metrics with open telemetry

Health Check Plug with Kubernetes semantics

Pluggable metrics for Absinthe GraphQL.

Web based metrics, monitoring, and observer.

grpcbox interceptor for OpenTelemetry instrumentation

Community-maintained Armature analytics instrumentation for Elixir MCP servers.

Erlang stats collection and distributed tracing framework

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

An adapter to export hackney metrics to telemetry

Otel sampler for Honeycomb

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

StatsD instrumenting middleware for Tesla HTTP client

Simple instrumentation framework inspired by ActiveSupport::Notifications.

Embedded time series database for Elixir with a Rust-native hot path.

Helps you to create OpenTelemetry spans with the least effort

Plug for providing Telemetry metrics within browser DevTools

server side data collector for Orion profiler

Ephemeral metrics history storage for Phoenix LiveDashboard

Asynchronous dependency health checks library