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.

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.

OpenTelemetry Instrumentation utilities for HTTP libraries

Registry and helpers for Telemetry events

OpenTelemetry Cowboy Instrumentation

Counters registry

Erlang node failure detector

Rate-limiting system_monitor event handler

OpenTelemetry tracing for Oban

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

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

Prometheus monitoring system and time series database client in Erlang.

Fast and reliable Elixir client for StatsD-compatible servers.

A small, fast, and unobtrusive metrics library

Telemetry.Metrics reporter for StatsD-compatible metric servers

Telemetry handler that creates Opentelemetry spans from Bandit events.

Pluggable metrics for Absinthe GraphQL.

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

A library for analysing absinthe GraphQL runtime usage.

Adds OpenTelemetry trace identifiers to logs

ZenMonitor provides efficient monitoring of remote processes.

Trace Redix queries with OpenTelemetry.

Generalizable utilities for working with OpenTelemetry in Elixir.

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

A function decorator for OpenTelemetry traces

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

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.

OpenTelemetry tracing for Req

A platform agnostic tracing library. Contributors welcome.

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

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

Elixir-friendly Prometheus monitoring system client.

A datadog API adapter for spandex.

AlchemetricsTesla is a Tesla middleware to report external call metrics.

Trace Finch request with OpenTelemetry.

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

New Relic's Open-Source Elixir Agent

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

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

Fast and reliable Elixir client for StatsD-compatible servers.

Prometheus instrumenters and handlers for Cowboy 1&2.

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

Tiny application to gather VM statistics

OpenTelemetry tracing for Broadway

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.

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

Prometheus monitoring system client Ecto integration. Observes queries duration.

Prometheus monitoring system client Phoenix instrumenter.

A small library for exporting jemalloc allocation data in Elixir

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.

analytics_elixir

OpenTelemetry tracing for Phoenix LiveView

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

Req plugin to instrument requests with Telemetry events

Code instrumentation and metrics collection package.

Erlang based metrics system

A simple Phoenix Live Dashboard for Oban jobs

Teleplug is a dead simple opentelemetry-instrumented plug.

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

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

The Opentelemetry integration for Ash Framework

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

Trace Dataloader with OpenTelemetry.

Add Flame graphs to Live Dashboard or your own LiveView

A tiny plug for responding to heartbeat requests

OpenTelemetry tracing for Nebulex

Small wrappers to enhance usage of the telemetry library.

OpenTelemetry Experimental API

Implementation of unstable OpenTelemetry signals

Generic health check endpoint for Phoenix/Plug web apps.

TelemetryMetrics for Membrane Multimedia Framework

Prometheus metrics exporter using Telemetry.Metrics as a foundation

Telemetry based metrics UI

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

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

The AppSignal APM integration for Ash Framework

Send StatsD metrics to Datadog

Adds OpenTelemetry trace identifiers to logs in the Datadog format

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

Tracing integration between tesla and spandex

An elixir plug for handling health and ready endpoints

An unofficial OTel-compatible metric exporter

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

Ephemeral metrics history storage for Phoenix LiveDashboard

Counters for BEAM.

`Telemetry.Metrics` reporter for AppSignal.

OpenTelemetry Zipkin Exporter

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

DataDog data streams library for Elixir

An adapter to export hackney metrics to telemetry

grpcbox interceptor for OpenTelemetry instrumentation

Tools for integrating Phoenix with Spandex.

Web based metrics, monitoring, and observer.

OpenTelemetry support for AWS X-Ray

OpenTelemetry tracing for the Phoenix.Channels

StatsD instrumenting middleware for Tesla HTTP client

Erlang stats collection and distributed tracing framework

Otel sampler for Honeycomb

A set of Plugs to be used for Kubernetes healthchecks.

Simple instrumentation framework inspired by ActiveSupport::Notifications.

Health Check Plug with Kubernetes semantics

New Relic Instrumentation adapter for Absinthe

A function decorator for telemetry

Plug for providing Telemetry metrics within browser DevTools

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