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.

Telemetry instrumentation for Cowboy

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

Trace Ecto queries with OpenTelemetry.

Provides a Prometheus format reporter for Telemetry.Metrics definitions.

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

Erlang node failure detector

Counters registry

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

Rate-limiting system_monitor event handler

Telemetry.Metrics reporter for StatsD-compatible metric servers

OpenTelemetry tracing for Oban

Prometheus monitoring system and time series database client in Erlang.

OpenTelemetry Instrumentation utilities for HTTP libraries

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.

Fast and reliable Elixir client for StatsD-compatible servers.

Trace Redix queries with OpenTelemetry.

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

Adds OpenTelemetry trace identifiers to logs

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

Generalizable utilities for working with OpenTelemetry in Elixir.

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

A function decorator for OpenTelemetry traces

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

A small, fast, and unobtrusive metrics library

OpentelemetryAbsinthe is a OpenTelemetry instrumentation library for Absinthe.

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

A platform agnostic tracing library. Contributors welcome.

Telemetry handler that creates Opentelemetry spans from Bandit events.

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

A datadog API adapter for spandex.

Elixir-friendly Prometheus monitoring system client.

ZenMonitor provides efficient monitoring of remote processes.

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

Trace Finch request with OpenTelemetry.

Tools for integrating Ecto with Spandex.

New Relic's Open-Source Elixir Agent

OpenTelemetry tracing for Req

Tiny application to gather VM statistics

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

Prometheus monitoring system client Phoenix instrumenter.

Prometheus.io inets httpd exporter

Prometheus monitoring system client Ecto integration. Observes queries duration.

OpenTelemetry tracing for Broadway

Apollo Tracing middleware for Absinthe

analytics_elixir

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.

Prometheus instrumenters and handlers for Cowboy 1&2.

OpenTelemetry Zipkin Exporter

OpenTelemetry tracing for Phoenix LiveView

Telepoison is a opentelemetry-instrumented wrapper around HTTPPoison.

A small library for exporting jemalloc allocation data in Elixir

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

Code instrumentation and metrics collection package.

Tools for integrating Phoenix with Spandex.

OpenTelemetry tracing for Nebulex

Req plugin to instrument requests with Telemetry events

Provides an AWS CloudWatch reporter for Telemetry Metrics definitions.

Erlang based metrics system

Telemetry based metrics UI

A simple Phoenix Live Dashboard for Oban jobs

Teleplug is a dead simple opentelemetry-instrumented plug.

A tiny plug for responding to heartbeat requests

Prometheus metrics exporter using Telemetry.Metrics as a foundation

Adds OpenTelemetry trace identifiers to logs in the Datadog format

An elixir plug for handling health and ready endpoints

grpcbox interceptor for OpenTelemetry instrumentation

Add Flame graphs to Live Dashboard or your own LiveView

Otel sampler for Honeycomb

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

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

Counters for BEAM.

Trace Dataloader with OpenTelemetry.

Tracing integration between tesla and spandex

Send StatsD metrics to Datadog

Generic health check endpoint for Phoenix/Plug web apps.

Ephemeral metrics history storage for Phoenix LiveDashboard

OpenTelemetry support for AWS X-Ray

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

Small wrappers to enhance usage of the telemetry library.

`Telemetry.Metrics` reporter for AppSignal.

The AppSignal APM integration for Ash Framework

Simple instrumentation framework inspired by ActiveSupport::Notifications.

An adapter to export hackney metrics to telemetry

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

A set of Plugs to be used for Kubernetes healthchecks.

Erlang stats collection and distributed tracing framework

A function decorator for telemetry

An unofficial OTel-compatible metric exporter

DataDog data streams library for Elixir

TelemetryMetrics for Membrane Multimedia Framework

StatsD instrumenting middleware for Tesla HTTP client

The helper application that simplifies and standardizes telemetry usage.

Web based metrics, monitoring, and observer.

The Opentelemetry integration for Ash Framework

Helps you to create OpenTelemetry spans with the least effort

Pluggable metrics for Absinthe GraphQL.

A StatsD/DogStatsD client for Elixir

New Relic Instrumentation adapter for Absinthe

OpenTelemetry tracing for the Phoenix.Channels

OpenCensus Zipkin reporter

server side data collector for Orion profiler

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.

A small collector to collect Hackney pool metrics.

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

PromEx integration for Poolex

AWS X-Ray reporter

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

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

Health Check Plug with Kubernetes semantics

A StatsD client for Elixir

Trace MongoDB queries with OpenTelemetry.

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

A health check utility for any OTP application

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

OpenTelemetry Experimental API

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

OpenTracing Toolkit for ERlang

honeycomb.io Phoenix plug to assist in tracing

Asynchronous dependency health checks library

Temporary library to integration telemetry_metrics with open telemetry

A load shedding application

Plug and play analytics for Phoenix applications.

Implementation of unstable OpenTelemetry signals

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

Elixir library for OpenCensus tracing

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

Integration between OpenCensus and Honeycomb

Instrumentation library to intercept and collect Plug requests.

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

Plug for providing Telemetry metrics within browser DevTools

ExWebRTC statistics visualization for the Phoenix LiveDashboard

Cowboy stream and middleware for opentelemetry http server spans

Deprecated instrumentation adapter for Phoenix