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

Trace Ecto queries with OpenTelemetry.

OpenTelemetry Instrumentation utilities for HTTP libraries

Provides a Prometheus format reporter for Telemetry.Metrics definitions.

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

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

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

Rate-limiting system_monitor event handler

Telemetry.Metrics reporter for StatsD-compatible metric servers

Prometheus monitoring system and time series database client in Erlang.

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

Adds OpenTelemetry trace identifiers to logs

Fast and reliable Elixir client for StatsD-compatible servers.

A small, fast, and unobtrusive metrics library

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

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

ZenMonitor provides efficient monitoring of remote processes.

OpenTelemetry tracing for Req

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

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

Elixir-friendly Prometheus monitoring system client.

A platform agnostic tracing library. Contributors welcome.

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

A datadog API adapter for spandex.

Trace Finch request with OpenTelemetry.

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

Prometheus.io inets httpd exporter

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

Tools for integrating Ecto with Spandex.

New Relic's Open-Source Elixir Agent

Prometheus instrumenters and handlers for Cowboy 1&2.

OpenTelemetry tracing for Broadway

Tiny application to gather VM statistics

Prometheus monitoring system client Ecto integration. Observes queries duration.

A small library for exporting jemalloc allocation data in Elixir

The Opentelemetry integration for Ash Framework

Prometheus monitoring system client Phoenix instrumenter.

Fast and reliable Elixir client for StatsD-compatible servers.

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

analytics_elixir

Code instrumentation and metrics collection package.

Trace Dataloader with OpenTelemetry.

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

Phoenix LiveDashboard page for inspecting Commanded EventStore

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

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

OpenTelemetry Experimental API

Erlang based metrics system

Implementation of unstable OpenTelemetry signals

An unofficial OTel-compatible metric exporter

A simple Phoenix Live Dashboard for Oban jobs

Teleplug is a dead simple opentelemetry-instrumented plug.

OpenTelemetry tracing for Phoenix LiveView

A tiny plug for responding to heartbeat requests

Generic health check endpoint for Phoenix/Plug web apps.

Req plugin to instrument requests with Telemetry events

Add Flame graphs to Live Dashboard or your own LiveView

Prometheus metrics exporter using Telemetry.Metrics as a foundation

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

OpenTelemetry tracing for Nebulex

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

Adds OpenTelemetry trace identifiers to logs in the Datadog format

Temporary library to integration telemetry_metrics with open telemetry

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

TelemetryMetrics for Membrane Multimedia Framework

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

Send StatsD metrics to Datadog

Telemetry based metrics UI

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

OpenTelemetry tracing for the Phoenix.Channels

Counters for BEAM.

The AppSignal APM integration for Ash Framework

Small wrappers to enhance usage of the telemetry library.

A set of Plugs to be used for Kubernetes healthchecks.

OpenTelemetry Zipkin Exporter

Ephemeral metrics history storage for Phoenix LiveDashboard

Tracing integration between tesla and spandex

New Relic Instrumentation adapter for Absinthe

OpenTelemetry support for AWS X-Ray

Plug and play analytics for Phoenix applications.

An elixir plug for handling health and ready endpoints

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

`Telemetry.Metrics` reporter for AppSignal.

An adapter to export hackney metrics to telemetry

Pluggable metrics for Absinthe GraphQL.

Health Check Plug with Kubernetes semantics

Web based metrics, monitoring, and observer.

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

Fast metrics library for Erlang with Prometheus export

Erlang stats collection and distributed tracing framework

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.

Simple instrumentation framework inspired by ActiveSupport::Notifications.

A function decorator for telemetry

Otel sampler for Honeycomb

StatsD instrumenting middleware for Tesla HTTP client

grpcbox interceptor for OpenTelemetry instrumentation

Plug for providing Telemetry metrics within browser DevTools

server side data collector for Orion profiler

Dynamic Distributed Performance tracing for the BEAM

Helps you to create OpenTelemetry spans with the least effort

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

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

Cowboy stream and middleware for opentelemetry http server spans

Plug health check module

Asynchronous dependency health checks library

ScoutAPM agent for Phoenix & Elixir projects. For more information, visit https://scoutapm.com/elixir.

Local metrics library

Telemetry.Metrics reporter for Splunk metrics indexes using the Splunk HTTP Event Collector (HEC)

PromEx integration for Poolex