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

Erlang node failure detector

Counters registry

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

Rate-limiting system_monitor event handler

Registry and helpers for Telemetry events

OpenTelemetry Cowboy Instrumentation

OpenTelemetry Instrumentation utilities for HTTP libraries

OpenTelemetry tracing for Oban

Prometheus monitoring system and time series database client in Erlang.

Pluggable metrics for Absinthe GraphQL.

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

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

A library for analysing absinthe GraphQL runtime usage.

Telemetry.Metrics reporter for StatsD-compatible metric servers

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

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

Adds OpenTelemetry trace identifiers to logs

A small, fast, and unobtrusive metrics library

Trace Redix queries with OpenTelemetry.

Generalizable utilities for working with OpenTelemetry in Elixir.

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.

Telemetry handler that creates Opentelemetry spans from Bandit events.

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

Fast and reliable Elixir client for StatsD-compatible servers.

ZenMonitor provides efficient monitoring of remote processes.

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.

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

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

Fast and reliable Elixir client for StatsD-compatible servers.

Elixir-friendly Prometheus monitoring system client.

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

A platform agnostic tracing library. Contributors welcome.

AlchemetricsTesla is a Tesla middleware to report external call metrics.

A datadog API adapter for spandex.

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

OpenTelemetry tracing for Req

Trace Finch request with OpenTelemetry.

New Relic's Open-Source Elixir Agent

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

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

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

Prometheus.io inets httpd exporter

Tools for integrating Ecto with Spandex.

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.

Prometheus monitoring system client Ecto integration. Observes queries duration.

Prometheus monitoring system client Phoenix instrumenter.

OpenTelemetry tracing for Broadway

Prometheus instrumenters and handlers for Cowboy 1&2.

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

A small library for exporting jemalloc allocation data in Elixir

OpenTelemetry tracing for Phoenix LiveView

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

Teleplug is a dead simple opentelemetry-instrumented plug.

Code instrumentation and metrics collection package.

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

Erlang based metrics system

OpenTelemetry tracing for Nebulex

Req plugin to instrument requests with Telemetry events

The Opentelemetry integration for Ash Framework

A simple Phoenix Live Dashboard for Oban jobs

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

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

Tools for integrating Phoenix with Spandex.

Trace Dataloader with OpenTelemetry.

Add Flame graphs to Live Dashboard or your own LiveView

Adds OpenTelemetry trace identifiers to logs in the Datadog format

A tiny plug for responding to heartbeat requests

Small wrappers to enhance usage of the telemetry library.

An elixir plug for handling health and ready endpoints

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

Generic health check endpoint for Phoenix/Plug web apps.

Telemetry based metrics UI

OpenTelemetry Experimental API

Prometheus metrics exporter using Telemetry.Metrics as a foundation

Implementation of unstable OpenTelemetry signals

Send StatsD metrics to Datadog

Tracing integration between tesla and spandex

The AppSignal APM integration for Ash Framework

grpcbox interceptor for OpenTelemetry instrumentation

Counters for BEAM.

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

OpenTelemetry Zipkin Exporter

TelemetryMetrics for Membrane Multimedia Framework

`Telemetry.Metrics` reporter for AppSignal.

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

DataDog data streams library for Elixir

An unofficial OTel-compatible metric exporter

StatsD instrumenting middleware for Tesla HTTP client

An adapter to export hackney metrics to telemetry

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

OpenTelemetry support for AWS X-Ray

Simple instrumentation framework inspired by ActiveSupport::Notifications.

Erlang stats collection and distributed tracing framework

Web based metrics, monitoring, and observer.

OpenTelemetry tracing for the Phoenix.Channels

Ephemeral metrics history storage for Phoenix LiveDashboard

A function decorator for telemetry

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

A set of Plugs to be used for Kubernetes healthchecks.

New Relic Instrumentation adapter for Absinthe

Health Check Plug with Kubernetes semantics

Otel sampler for Honeycomb

server side data collector for Orion profiler

Plug and play analytics for Phoenix applications.

OpenCensus Zipkin reporter

Dynamic Distributed Performance tracing for the BEAM

A (Phoenix) plug for sending request counts and response times to statsd

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