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

Counters registry

OpenTelemetry Cowboy Instrumentation

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.

Pluggable metrics for Absinthe GraphQL.

Telemetry.Metrics reporter for StatsD-compatible metric servers

A small, fast, and unobtrusive metrics library

Fast and reliable Elixir client for StatsD-compatible servers.

A library for analysing absinthe GraphQL runtime usage.

Telemetry handler that creates Opentelemetry spans from Bandit events.

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

ZenMonitor provides efficient monitoring of remote processes.

Trace Redix queries with OpenTelemetry.

Generalizable utilities for working with OpenTelemetry in Elixir.

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

A function decorator for OpenTelemetry traces

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

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.

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

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

Elixir-friendly Prometheus monitoring system client.

AlchemetricsTesla is a Tesla middleware to report external call metrics.

A datadog API adapter for spandex.

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.

Fast and reliable Elixir client for StatsD-compatible servers.

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

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

Prometheus instrumenters and handlers for Cowboy 1&2.

Tiny application to gather VM statistics

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

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 Broadway

Prometheus monitoring system client Ecto integration. Observes queries duration.

Prometheus monitoring system client Phoenix instrumenter.

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.

A small library for exporting jemalloc allocation data in Elixir

analytics_elixir

OpenTelemetry tracing for Phoenix LiveView

Req plugin to instrument requests with Telemetry events

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

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.

Add Flame graphs to Live Dashboard or your own LiveView

Trace Dataloader with OpenTelemetry.

OpenTelemetry tracing for Nebulex

A tiny plug for responding to heartbeat requests

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.

Prometheus metrics exporter using Telemetry.Metrics as a foundation

TelemetryMetrics for Membrane Multimedia Framework

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

Telemetry based metrics UI

Send StatsD metrics to Datadog

Adds OpenTelemetry trace identifiers to logs in the Datadog format

Tracing integration between tesla and spandex

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

An elixir plug for handling health and ready endpoints

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

An unofficial OTel-compatible metric exporter

Counters for BEAM.

OpenTelemetry Zipkin Exporter

`Telemetry.Metrics` reporter for AppSignal.

Tools for integrating Phoenix with Spandex.

Ephemeral metrics history storage for Phoenix LiveDashboard

grpcbox interceptor for OpenTelemetry instrumentation

DataDog data streams library for Elixir

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

An adapter to export hackney metrics to telemetry

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

Simple instrumentation framework inspired by ActiveSupport::Notifications.

Health Check Plug with Kubernetes semantics

A set of Plugs to be used for Kubernetes healthchecks.

New Relic Instrumentation adapter for Absinthe

A function decorator for telemetry

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

Plug for providing Telemetry metrics within browser DevTools