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.

OpenTelemetry Instrumentation utilities for HTTP libraries

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 Cowboy Instrumentation

OpenTelemetry tracing for Oban

Counters registry

Erlang node failure detector

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

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

Telemetry handler that creates Opentelemetry spans from Bandit events.

Rate-limiting system_monitor event handler

Fast and reliable Elixir client for StatsD-compatible servers.

A small, fast, and unobtrusive metrics library

Prometheus monitoring system and time series database client in Erlang.

Telemetry.Metrics reporter for StatsD-compatible metric servers

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

Adds OpenTelemetry trace identifiers to logs

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

ZenMonitor provides efficient monitoring of remote processes.

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

Trace Redix queries with OpenTelemetry.

Generalizable utilities for working with OpenTelemetry in Elixir.

A function decorator for OpenTelemetry traces

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

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

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

OpenTelemetry tracing for Req

A platform agnostic tracing library. Contributors welcome.

A datadog API adapter for spandex.

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

Elixir-friendly Prometheus monitoring system client.

Trace Finch request with OpenTelemetry.

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

New Relic's Open-Source Elixir Agent

Prometheus.io inets httpd exporter

Tools for integrating Ecto with Spandex.

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

Prometheus instrumenters and handlers for Cowboy 1&2.

Tiny application to gather VM statistics

OpenTelemetry tracing for Broadway

Fast and reliable Elixir client for StatsD-compatible servers.

A small library for exporting jemalloc allocation data in Elixir

Prometheus monitoring system client Ecto integration. Observes queries duration.

Prometheus monitoring system client Phoenix instrumenter.

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.

Apollo Tracing middleware for Absinthe

Pluggable metrics for Absinthe GraphQL.

The Opentelemetry integration for Ash Framework

analytics_elixir

A library for analysing absinthe GraphQL runtime usage.

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

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

Code instrumentation and metrics collection package.

OpenTelemetry tracing for Phoenix LiveView

OpenTelemetry Experimental API

Req plugin to instrument requests with Telemetry events

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

Erlang based metrics system

Implementation of unstable OpenTelemetry signals

A simple Phoenix Live Dashboard for Oban jobs

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

Teleplug is a dead simple opentelemetry-instrumented plug.

Add Flame graphs to Live Dashboard or your own LiveView

Trace Dataloader with OpenTelemetry.

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

A tiny plug for responding to heartbeat requests

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

An unofficial OTel-compatible metric exporter

AlchemetricsTesla is a Tesla middleware to report external call metrics.

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

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

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

TelemetryMetrics for Membrane Multimedia Framework

OpenTelemetry tracing for Nebulex

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

Prometheus metrics exporter using Telemetry.Metrics as a foundation

Adds OpenTelemetry trace identifiers to logs in the Datadog format

Generic health check endpoint for Phoenix/Plug web apps.

Ephemeral metrics history storage for Phoenix LiveDashboard

Small wrappers to enhance usage of the telemetry library.

Temporary library to integration telemetry_metrics with open telemetry

Telemetry based metrics UI

Send StatsD metrics to Datadog

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

The AppSignal APM integration for Ash Framework

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

Phoenix LiveDashboard page for inspecting Commanded EventStore

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.

OpenTelemetry tracing for the Phoenix.Channels

Tracing integration between tesla and spandex

An elixir plug for handling health and ready endpoints

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

Counters for BEAM.

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

`Telemetry.Metrics` reporter for AppSignal.

OpenTelemetry Zipkin Exporter

OpenTelemetry support for AWS X-Ray

An adapter to export hackney metrics to telemetry

A set of Plugs to be used for Kubernetes healthchecks.

New Relic Instrumentation adapter for Absinthe

Health Check Plug with Kubernetes semantics

StatsD instrumenting middleware for Tesla HTTP client

Otel sampler for Honeycomb

Web based metrics, monitoring, and observer.

Erlang stats collection and distributed tracing framework

Plug for providing Telemetry metrics within browser DevTools

grpcbox interceptor for OpenTelemetry instrumentation

Simple instrumentation framework inspired by ActiveSupport::Notifications.

Fast metrics library for Erlang with Prometheus export

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

DataDog data streams library for Elixir

server side data collector for Orion profiler

Plug and play analytics for Phoenix applications.

Dynamic Distributed Performance tracing for the BEAM

A function decorator for telemetry

Cowboy stream and middleware for opentelemetry http server spans

Plug health check module

Local metrics library

Helps you to create OpenTelemetry spans with the least effort