Instrumenting / Monitoring

Dynamic dispatching library for metrics and instrumentations

A generic interface to different metrics systems in Erlang.

Telemetry instrumentation for Cowboy

Provides a common interface for defining metrics based on Telemetry events.

Periodically collect measurements and dispatch them as Telemetry events.

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

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

Trace Ecto queries with OpenTelemetry.

Registry and helpers for Telemetry events

Provides a Prometheus format reporter for Telemetry.Metrics definitions.

Erlang node failure detector

Telemetry.Metrics reporter for StatsD-compatible metric servers

OpenTelemetry Cowboy Instrumentation

Rate-limiting system_monitor event handler

A distributed, compacting, multidimensional, telemetry-powered time series datastore

Prometheus monitoring system and time series database client in Erlang.

OpenTelemetry tracing for Oban

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

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

OpenTelemetry Instrumentation utilities for HTTP libraries

Fast and reliable Elixir client for StatsD-compatible servers.

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

Adds OpenTelemetry trace identifiers to logs

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

Trace Redix queries with OpenTelemetry.

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

A function decorator for OpenTelemetry traces

Generalizable utilities for working with OpenTelemetry in Elixir.

A platform agnostic tracing library. Contributors welcome.

Elixir-friendly Prometheus monitoring system client.

A datadog API adapter for spandex.

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

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

Counters registry

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

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

Tools for integrating Ecto with Spandex.

A small, fast, and unobtrusive metrics library

Telemetry handler that creates Opentelemetry spans from Bandit events.

New Relic's Open-Source Elixir Agent

Prometheus monitoring system client Phoenix instrumenter.

Prometheus monitoring system client Ecto integration. Observes queries duration.

OpenTelemetry tracing for Req

Trace Finch request with OpenTelemetry.

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.

OpenTelemetry tracing for Broadway

analytics_elixir

ZenMonitor provides efficient monitoring of remote processes.

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

Tiny application to gather VM statistics

Prometheus.io inets httpd exporter

Prometheus instrumenters and handlers for Cowboy 1&2.

Apollo Tracing middleware for Absinthe

OpenTelemetry tracing for Phoenix LiveView

OpenTelemetry Zipkin Exporter

Tools for integrating Phoenix with Spandex.

OpenTelemetry tracing for Nebulex

An elixir plug for handling health and ready endpoints

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

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

Erlang based metrics system

Req plugin to instrument requests with Telemetry events

Trace Dataloader with OpenTelemetry.

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

Add Flame graphs to Live Dashboard or your own LiveView

grpcbox interceptor for OpenTelemetry instrumentation

Code instrumentation and metrics collection package.

A simple Phoenix Live Dashboard for Oban jobs

A tiny plug for responding to heartbeat requests

A small library for exporting jemalloc allocation data in Elixir

Otel sampler for Honeycomb

Adds OpenTelemetry trace identifiers to logs in the Datadog format

Telemetry based metrics UI

Teleplug is a dead simple opentelemetry-instrumented plug.

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

Tracing integration between tesla and spandex

Ephemeral metrics history storage for Phoenix LiveDashboard

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

Simple instrumentation framework inspired by ActiveSupport::Notifications.

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

Generic health check endpoint for Phoenix/Plug web apps.

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

Send StatsD metrics to Datadog

Prometheus metrics exporter using Telemetry.Metrics as a foundation

The AppSignal APM integration for Ash Framework

`Telemetry.Metrics` reporter for AppSignal.

An unofficial OTel-compatible metric exporter

An adapter to export hackney metrics to telemetry

Counters for BEAM.

A function decorator for telemetry

Small wrappers to enhance usage of the telemetry library.

Web based metrics, monitoring, and observer.

A set of Plugs to be used for Kubernetes healthchecks.

Erlang stats collection and distributed tracing framework

OpenTelemetry support for AWS X-Ray

PromEx integration for Poolex

New Relic Instrumentation adapter for Absinthe

Dynamic Distributed Performance tracing for the BEAM

TelemetryMetrics for Membrane Multimedia Framework

`Telemetry.Metrics` reporter and metrics backend based on Mnesia DB.

DataDog data streams library for Elixir

server side data collector for Orion profiler

Pluggable metrics for Absinthe GraphQL.

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

StatsD instrumenting middleware for Tesla HTTP client

The Opentelemetry integration for Ash Framework

A StatsD/DogStatsD client for Elixir

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

The easiest way to add a health check for your background services

A small collector to collect Hackney pool metrics.

Notion is a thin wrapper around telemetry that defines functions that dispatch telemetry events, documentation, and specs for your applications events.

Asynchronous dependency health checks library

Helps you to create OpenTelemetry spans with the least effort

OpenCensus Zipkin reporter

OpenTelemetry tracing for the Phoenix.Channels

A health check utility for any OTP application

A StatsD client for Elixir

OpenTracing Toolkit for ERlang

Real-time Monitoring for Oban with Phoenix.LiveDashboard

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

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

Plug health check module

Trace MongoDB queries with OpenTelemetry.

Deprecated instrumentation adapter for Phoenix

AWS X-Ray reporter

honeycomb.io Phoenix plug to assist in tracing

Integration between OpenCensus and Honeycomb

OpenTelemetry Experimental API

Local metrics library

Instrumentation library to intercept and collect Plug requests.

Plug to log Phoenix requests and responses with a more accurate time than the custom Phoenix logger

A simple abstraction for standardized observability with telemetry and more.

Implementation of unstable OpenTelemetry signals

Implements an interface for recording traces and sending them to a Zipkin server.

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

The helper application that simplifies and standardizes telemetry usage.

Trace Snowpack (Snowflake driver) queries with OpenTelemetry.

Health Check Plug with Kubernetes semantics

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

Putting the best the BEAM has to offer, right in your Phoenix Live Dashboard

Prometheus interceptor for gRPC

A load shedding application