open-telemetry/opentelemetry-erlang-contrib

This repository is a collection of Elixir and Erlang libraries and example applications designed to integrate OpenTelemetry distributed tracing into BEAM-based systems. It provides instrumentation packages for common frameworks and services, including Phoenix, Cowboy, Ecto, Oban, and various HTTP clients, to automatically capture and export trace data. Additionally, it includes utilities for context propagation across Erlang processes and bridges standard telemetry events to OpenTelemetry spans.

18 changes.

This period focused on expanding the OpenTelemetry ecosystem by adding initial instrumentation libraries for Oban, Bandit, and Absinthe, alongside a new Telemetry bridge utility. Significant updates were made to existing packages like Phoenix, Cowboy, and Ecto to align with Semantic Conventions v1.27.0, introducing breaking changes and multi-adapter support. Comprehensive test suites and configuration files were added across all affected packages to ensure reliability and proper span generation.

14 changes.

This period focused on expanding the project's ecosystem by releasing new instrumentation libraries for Dataloader, Elli, Tesla, Finch, and Nebulex, alongside a dedicated process context propagator for Erlang/Elixir. The work also included adding comprehensive test coverage for Broadway and Tesla middleware, as well as providing an example Phoenix application to demonstrate integration with OpenTelemetry.

15 changes.

This period focused on significantly expanding the project's instrumentation capabilities by introducing new libraries for diverse technologies, including Req, gRPC, Broadway, Commanded, Absinthe, and Xandra. The work also included updating existing tools like HTTPoison and otel\_http to align with current OpenTelemetry semantic conventions and improving configuration patterns. Additionally, comprehensive example applications were added to demonstrate distributed tracing and metrics integration for both Elixir and Erlang stacks.

The \opentelemetry\_aws\_xray\ utility now provides an \otel\_aws\_xray\_id\_generator\ that produces 128-bit trace IDs compatible with the AWS X-Ray format (first 32 bits are the epoch timestamp, followed by 96 random bits). Users can configure OpenTelemetry to use this generator via the \id\_generator\ setting in \opentelemetry\_api\ (version 1.2) to ensure trace IDs align with AWS X-Ray expectations.

_utilities/opentelemetry\_aws\xray · high confidence

This change introduces the \opentelemetry\_dataloader\ instrumentation library, providing configuration and test infrastructure for tracing Ecto-based Dataloader operations. It includes default configuration files for managing application settings across environments, a test-specific configuration that sets up a PostgreSQL test repository (\OpentelemetryDataloader.TestRepo\) and configures the OpenTelemetry simple processor, and a database migration to create the necessary \posts\ table for testing purposes.

_instrumentation/opentelemetry\_dataloader/config, instrumentation/opentelemetry\_dataloader/priv, instrumentation/opentelemetry\grpcbox · high confidence

Introduces a new example application demonstrating an Erlang HTTP server using the Elli framework, instrumented with OpenTelemetry for distributed tracing and metrics. The example includes the necessary Erlang source files, configuration, and a Docker Compose setup to run the application alongside the OpenTelemetry Collector and Jaeger for trace visualization. It showcases how to configure the OpenTelemetry SDK, use the \opentelemetry\_elli\ middleware for automatic span creation, and manually create spans and counters for business logic.

_examples/roll\_dice\elli · high confidence

A new Erlang example application using the Elli web server has been added to the examples directory. This example is configured to export metrics via OpenTelemetry using the OTLP protocol to localhost, with batch span processing and a 1-second metric export interval. The configuration also excludes static paths from tracing and sets up standard logging.

_examples/roll\_dice\elli/config · high confidence

This change introduces the \opentelemetry\_nebulex\ library, which uses Telemetry handlers to create OpenTelemetry spans from Nebulex cache command events. It supports both Nebulex v2 and v3, emitting spans for operations like \get\, \put\, and \fetch\ with attributes such as cache name, operation type, and hit/miss status. The library includes setup functions to attach handlers to specific caches or all caches, and provides tests for local, partitioned, and multi-level cache adapters.

_instrumentation/opentelemetry\nebulex · high confidence

The Phoenix instrumentation package now includes explicit configuration files to set up OpenTelemetry tracing. A new \config.exs\ file provides the standard Mix configuration structure, allowing for environment-specific overrides via \dev.exs\, \test.exs\, etc. Additionally, a \test.exs\ file is introduced to configure the \:opentelemetry\ application to use the \:otel\_simple\_processor\ during testing, ensuring that traces are processed simply without complex batching or exporting logic in test environments.

_instrumentation/opentelemetry\phoenix/config · high confidence

Introduces the \opentelemetry\_commanded\ package, which provides telemetry handlers to create OpenTelemetry spans for Commanded commands and events. The library instruments Application Dispatch, Aggregate Execute, Event Handler Handle, Process Manager Handle, and Event Store operations (such as \append\_to\_stream\ and \stream\_forward\). It includes a \OpentelemetryCommanded.Middleware\ for propagating span context across process boundaries and a \setup/0\ function to attach the necessary telemetry handlers.

_instrumentation/opentelemetry\commanded · high confidence

The \opentelemetry\_process\_propagator\ library now includes \OpentelemetryProcessPropagator.Task.Supervisor\ and \OpentelemetryProcessPropagator.Task.Wrapper\ to automatically propagate OpenTelemetry context across task boundaries. The new Supervisor module provides variants of standard \Task.Supervisor\ functions (such as \async\, \async\_nolink\, \async\_with\_span\, and \async\_with\_linked\_span\) that capture the current context before spawning a task and restore it within the task's execution. The Wrapper module supports these operations by handling context attachment and span creation logic, allowing users to maintain distributed tracing continuity without manual context management in asynchronous code.

_propagators/opentelemetry\_process\propagator/lib/task · high confidence

The \OpentelemetryTelemetry\ module has been added to provide conveniences for leveraging \telemetry\ events for OpenTelemetry bridge libraries. It introduces helper functions (\start\_telemetry\_span\, \set\_current\_telemetry\_span\, \end\_telemetry\_span\) to automatically manage span contexts, ensuring that telemetry-based spans are correctly correlated to their shared parent span even when executed in separate handlers. This allows library authors to integrate OpenTelemetry tracing into their \telemetry\-based event systems seamlessly.

_utilities/opentelemetry\telemetry/lib · high confidence

Introduces a new example application demonstrating how to integrate OpenTelemetry tracing with a Phoenix and Ecto stack. The example includes a full Phoenix web application with LiveView support, Ecto models for users and blog posts, and configuration for exporting traces via the OpenTelemetry Collector to Zipkin and Jaeger. It also provides Docker Compose and Dockerfile configurations to run the application alongside PostgreSQL and the collector, along with environment variable templates for external exporters like Honeycomb and Lightstep.

_examples/basic\_phoenix\ecto · high confidence

Introduces a new example application built with Phoenix that demonstrates OpenTelemetry instrumentation in Elixir. The example includes a simple API endpoint at \/api/rolldice\ which generates a random number and emits a trace span with the result as an attribute. It provides a complete setup including Docker Compose files for running the OpenTelemetry Collector and Jaeger, along with configuration for batch span processing and OTLP export to visualize the traces.

_examples/roll\dice · high confidence

This location introduces a new sample Elixir application demonstrating how to instrument code with OpenTelemetry. The example includes a GenServer worker that creates spans and events using the OpenTelemetry API, configured to export traces via the OTLP protocol to an OpenTelemetry Collector. The setup is containerized using a Dockerfile (based on Elixir 1.20.4) and a docker-compose file that orchestrates the app, the collector (v0.160.0), Zipkin, and Jaeger for visualization. Configuration files define the batch processor endpoint and standard Elixir project structure (formatter, ignores, tests).

_examples/basic\elixir · high confidence

The repository now includes a new 'roll dice' example application built with Erlang and Elli. This example features a frontend that integrates OpenTelemetry for distributed tracing, specifically instrumenting document loads and XMLHttpRequests, and exporting traces to a local OTLP endpoint. The user interface is a simple HTML page using HTMX to trigger dice rolls via HTTP requests, with the result displayed dynamically on the page.

_examples/roll\_dice\_elli/js, examples/roll\_dice\elli/priv · high confidence

Adds the \OpentelemetryOban\ library to automatically create OpenTelemetry spans for Oban background job events, including job start, stop, and exceptions. The module provides a \setup/1\ function to initialize telemetry handlers, supporting configurable options for job and plugin tracing via \NimbleOptions\. It also wraps Oban's \insert\ and \insert\_all\ functions to record producer spans with messaging semantic conventions, allowing users to trace job submission alongside execution.

_instrumentation/opentelemetry\oban/lib · high confidence

Adds OpenTelemetry tracing support for Oban background job processing and plugin lifecycle events. The new \JobHandler\ module instruments job start, stop, and exception events, attaching spans with semantic conventions for messaging systems (identifying Oban as the system) and custom attributes such as job ID, worker, queue, priority, attempt counts, and timing metrics. It supports configurable context propagation via \span\_relationship\ options (\:child\, \:link\, or \:none\). The \PluginHandler\ module instruments Oban plugins (including Cron, Gossip, Lifeline, Pruner, and Pro variants), recording plugin-specific metrics like job counts, discarded/rescued jobs, and scaling events, while properly handling plugin failures and exceptions.

_instrumentation/opentelemetry\_oban/lib/opentelemetry\oban · high confidence

This entry introduces the \opentelemetry\_dataloader\ library, which automatically instruments the Dataloader library by creating OpenTelemetry spans from its telemetry events. Users can enable this by calling \OpentelemetryDataloader.setup()\ in their application behavior before the top-level supervisor starts. The library attaches to \:dataloader.source.run\ and \:dataloader.source.batch\ events, creating client spans named \dataloader.run\ and \dataloader.batch\. It correctly propagates the current OpenTelemetry context to these spans, falling back to the caller's context if none is present. For batch operations, it adds attributes to identify the batch key, supporting both Ecto sources (MapSet) and KV sources (atom or binary keys).

(repo-wide) · high confidence

This entry introduces the \opentelemetry\_telemetry\ utility library, which bridges BEAM \telemetry\ events to OpenTelemetry spans. It allows instrumentation libraries to leverage existing telemetry events for creating and managing spans, adding attributes, and setting span names without requiring library authors to support multiple monitoring conventions. The package is licensed under Apache 2.0 and depends on \opentelemetry\_api\ and \telemetry\.

_utilities/opentelemetry\_telemetry, utilities/opentelemetry\telemetry/src · high confidence

Adds the opentelemetry\_elli library, providing Elli middleware for automatic OpenTelemetry HTTP tracing. The middleware extracts trace context from W3C and B3 headers, creates server spans with attributes compliant with OpenTelemetry Semantic Conventions v1.27+, and supports excluding specific paths from tracing via configuration or environment variables.

_instrumentation/opentelemetry\elli · high confidence

Adds the \opentelemetry\_grpc\ library, providing automatic distributed tracing for gRPC applications in Elixir. The package includes client instrumentation that creates spans for outgoing RPC calls and a context propagator interceptor to inject trace headers, as well as server instrumentation that creates spans for incoming requests with configurable span relationships (child, link, or none). It follows OpenTelemetry semantic conventions for RPC attributes and error status codes.

_instrumentation/opentelemetry\grpc · high confidence

Adds the \OpentelemetryProcessPropagator\ library, which provides utilities to maintain trace continuity across Erlang/Elixir process boundaries. The \OpentelemetryProcessPropagator\ module exposes functions like \fetch\_ctx/1\ and \fetch\_parent\_ctx/1\ to retrieve OpenTelemetry context from parent or ancestor processes, addressing the lack of transparent context passing in the runtime. Additionally, the \OpentelemetryProcessPropagator.Task\ module offers extended \Task\ functions (e.g., \async\_with\_span\, \async\_stream\_with\_linked\_span\) that automatically attach the current context and optionally create new child or linked spans, reducing boilerplate for tracing asynchronous operations.

_propagators/opentelemetry\_process\propagator/lib · high confidence

Adds the \opentelemetry\_tesla\ library, providing a Tesla middleware that creates OpenTelemetry spans and injects distributed tracing headers into HTTP requests. The middleware implements required and recommended Client HTTP Span semantic conventions, allowing users to configure opt-in experimental attributes (such as URL templates and body sizes), define static span names, and control which HTTP status codes are marked as errors. It also supports capturing specific request and response headers as span attributes and includes documentation on recommended middleware ordering to ensure accurate trace data.

_instrumentation/opentelemetry\tesla · high confidence

Adds the \opentelemetry\_req\ library, providing a plugin that wraps \Req\ HTTP requests in OpenTelemetry spans. This enables automatic distributed tracing for HTTP client calls, including support for trace header propagation, configurable request/response header attributes, and adherence to OpenTelemetry HTTP semantic conventions (such as span naming and URL attributes). Users can attach this instrumentation to their \Req\ clients to gain visibility into outgoing HTTP traffic.

_instrumentation/opentelemetry\req · high confidence

The new \opentelemetry\_xandra\ package allows Elixir applications using the Xandra Cassandra driver to automatically generate OpenTelemetry spans for database queries. By calling \OpentelemetryXandra.setup/1\, users can attach a Telemetry handler that records span data (such as operation type, database system, and server address) for Xandra \execute\_query\ events, supporting both standard and prepared queries with a configurable operation parser.

_instrumentation/opentelemetry\xandra · high confidence

This change adds the \opentelemetry\_broadway\ library, providing OpenTelemetry tracing for Broadway message processing and batch handling. Users can enable basic instrumentation via \OpentelemetryBroadway.setup/1\ or configure distributed tracing context propagation using the \span\_relationship\ option (supporting \:link\, \:child\, or \:none\). The instrumentation attaches telemetry handlers to capture message and batch lifecycle events, emitting spans with standard messaging attributes as well as Broadway-specific metrics like successful and failed batch counts.

_instrumentation/opentelemetry\broadway · high confidence

The \opentelemetry\_sqlcommenter\ package (v0.2.0) is now available as an Elixir library that automatically injects OpenTelemetry trace context into PostgreSQL SQL queries as comments. By delegating the \prepare\_query\ function in your Ecto repository to \OpentelemetrySqlcommenter\, database logs will include W3C-compliant \traceparent\ identifiers, linking database operations to distributed traces. The library defaults to disabling prepared statements (\prepare: :unnamed\) to ensure query uniqueness for caching purposes, though it preserves any explicitly provided \prepare\ option.

_instrumentation/opentelemetry\sqlcommenter · high confidence

This release introduces the OpenTelemetry Process Propagator library, enabling context propagation across Erlang process boundaries. The implementation provides functions to fetch the current context and inspect parent contexts by traversing process ancestors. It includes optimized logic for retrieving the OpenTelemetry context from a process's dictionary, with specific handling for OTP 27+ where single-key dictionary lookups are available, falling back to full dictionary inspection for earlier versions.

_propagators/opentelemetry\_process\propagator/src · high confidence

The \opentelemetry\_absinthe\ library (version 2.4.0) has been added to the \instrumentation\ directory, providing OpenTelemetry tracing for Absinthe GraphQL applications. This instrumentation automatically captures GraphQL operation traces, including query documents, operation names, types, and field selections. It introduces a new \error\_status\ configuration option that allows users to control when GraphQL errors mark a span as failed—supporting \:all\ (default), \:none\, or a custom classifier function—to prevent business-level errors from inflating error-rate metrics. The library also includes \batch\_keep\_span\ helpers to preserve trace context during Absinthe batch operations and supports tracing GraphQL subscriptions when enabled.

_instrumentation/opentelemetry\absinthe · high confidence

This release introduces the \opentelemetry\_finch\ package, which uses Telemetry handlers to automatically create OpenTelemetry client spans from Finch HTTP events. It conforms to the Client HTTP Span v1.39 semantic conventions, allowing users to configure opt-in attributes (such as URL templates, body sizes, and specific headers) and custom span names via Finch request private options. The instrumentation handles span status and attributes for standard requests, including support for streamed responses.

_instrumentation/opentelemetry\finch · high confidence

The Phoenix instrumentation now correctly instruments every endpoint when \setup/1\ is called multiple times, resolving a bug where only the first endpoint generated spans. Additionally, users can opt into route-based span names for LiveView events (e.g., \live\_view.mount /resources/:id\) via the new \liveview\_span\_names\ configuration option, which defaults to the existing module-based naming.

_instrumentation/opentelemetry\phoenix · high confidence

This release improves the reliability and accuracy of OpenTelemetry spans for Oban plugins. It prevents crashes in the Cron plugin when scheduled inserts fail (which omit job metadata) by defaulting the job count to zero, and corrects the Lifeline plugin to report actual discarded and rescued job counts instead of nil values. Plugin failure states are now correctly marked as errors on spans, and exception messages are recorded properly using the Elixir API. Additionally, plugin module names are now emitted in their short form (e.g., "Oban.Plugins.Cron") to align with configuration requirements and Oban's own storage format.

_instrumentation/opentelemetry\oban · high confidence

The \opentelemetry\_cowboy\ package has been updated to version 1.0.0, introducing breaking changes to align with OpenTelemetry Semantic Conventions v1.27.0. This release updates dependencies such as \opentelemetry\_api\ to 1.4 and \opentelemetry\_semantic\_conventions\ to 1.27, and adds support for opt-in attributes (like request body size) and public endpoint configuration to handle trace continuation versus linking. Users must review the HTTP Stability Migration Guide for details on the attribute and behavior changes.

_instrumentation/opentelemetry\cowboy · high confidence

The opentelemetry\ecto instrumentation has been updated to version 2.0.0-beta.1, introducing support for OpenTelemetry Semantic Conventions v1.27 and expanding database compatibility to include MySQL, MSSQL, and SQLite in addition to PostgreSQL. This release brings several behavioral changes: time measurement attributes are now namespaced under \ecto.\\ (e.g., \ecto.query\_time.duration\), span names now conform to the SemConv 1.27 specification, and connection settings are derived from \init\ events to ensure accurate source tracking. Additionally, users can now configure per-query options (such as custom span names and attributes) and opt out of specific recommended attributes like \db.query.text\. Existing setups may require updates due to these breaking changes, particularly regarding the namespacing of time attributes and API adjustments.

_instrumentation/opentelemetry\ecto · high confidence

The \OpentelemetryHTTPoison.setup/1\ function is now deprecated in favor of standard Elixir application configuration via \config :opentelemetry\_httpoison\. Configuration options like \:ot\_attributes\ and \:infer\_route\ are now read from the Application environment, with validation performed at setup time. Additionally, the library has migrated to \opentelemetry\_semantic\_conventions \~\> 1.27\, ensuring compliance with the latest OpenTelemetry semantic conventions for HTTP spans.

_instrumentation/opentelemetry\httpoison · high confidence

The \opentelemetry\_instrumentation\_http\ package has been renamed to \otel\_http\ (v0.2.0), requiring users to update their dependency declarations. This release introduces new utility functions for HTTP instrumentation, including \extract\_client\_info\, \extract\_scheme\, and \extract\_server\_info\ for parsing request headers according to semantic conventions, as well as \extract\_headers\_attributes\ for mapping selected headers to attribute maps. The library also exposes \normalize\_header\_name\ and \parse\_forwarded\_header\ for common header manipulation tasks.

_utilities/otel\http · high confidence

Add test environment configuration for OpenTelemetry Ecto instrumentation; Added comprehensive test suite for the Cowboy HTTP instrumentation; Added integration and unit tests for Phoenix and LiveView tracing; Added test infrastructure and helper jobs for Oban OpenTelemetry instrumentation; Added tests for Oban job and plugin tracing behavior; Added tests for OpenTelemetry Broadway instrumentation; Initial test coverage for OpenTelemetry Oban instrumentation; Initial test coverage for OpentelemetryReq instrumentation; Initial test suite for OpenTelemetry Ecto instrumentation; Initial test suite for OpenTelemetry Tesla middleware; Initial test suite for the process propagator library; Test environment configuration and database migration added.

This change introduces new example applications (\basic\_elixir\, \basic\_phoenix\_ecto\, \roll\_dice\) and instrumentation libraries (\opentelemetry\_absinthe\, \opentelemetry\_bandit\) to the repository. The example apps demonstrate how to integrate OpenTelemetry with Elixir and Phoenix, specifying dependencies such as \opentelemetry\, \opentelemetry\_exporter\, \phoenix\, and \ecto\ in their \mix.exs\ files. The new instrumentation packages provide telemetry handlers for Absinthe and Bandit, defining their own dependencies on \opentelemetry\_api\ and \telemetry\ to enable distributed tracing for these specific frameworks.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 76.

• Code Health 98
• Architecture 96
• Maturity 69
• Readiness 76
• Security 84

• 300 commits — 268 feature/other, 32 fixes

• .github/workflows — 71 commits
• instrumentation/opentelemetry_bandit — 31 commits
• instrumentation/opentelemetry_oban — 21 commits
• (root) — 16 commits
• examples/roll_dice_elli — 15 commits
• instrumentation/opentelemetry_phoenix — 15 commits
• instrumentation/opentelemetry_dataloader — 14 commits
• instrumentation/opentelemetry_broadway — 12 commits
• instrumentation/opentelemetry_commanded — 11 commits
• instrumentation/opentelemetry_ecto — 11 commits
• examples/basic_elixir — 10 commits
• instrumentation/opentelemetry_tesla — 10 commits
• examples/basic_phoenix_ecto — 9 commits
• instrumentation/opentelemetry_finch — 8 commits
• instrumentation/opentelemetry_nebulex — 7 commits
• instrumentation/opentelemetry_redix — 6 commits
• instrumentation/opentelemetry_grpc — 5 commits
• instrumentation/opentelemetry_xandra — 4 commits
• examples/roll_dice — 3 commits
• instrumentation/opentelemetry_absinthe — 3 commits

• fix: Fix - Crash when propagator fetches context from a remote node (#480)
• fix: Fix GitHub URL to use 'open-telemetry' organization (#590)
• fix: SemConv 1.27 support and various fixes (#481)
• fix: fix(bandit): handles bandit throw/exit events (#467)
• fix: fix(ci): resolve release-drafter _extends from repo root (#711)
• fix: fix(deps): update dependency @opentelemetry/context-zone to v2 (#745)
• fix: fix(deps): update dependency @opentelemetry/exporter-trace-otlp-http to ^0.221.0 (#755)
• fix: fix(deps): update dependency @opentelemetry/exporter-trace-otlp-http to ^0.222.0 (#801)
• fix: fix(deps): update dependency esbuild to v0.25.0 [security] (#736)
• fix: fix(deps): update dependency esbuild to v0.28.1 (#744)
• fix: fix(deps): update dependency htmx.org to v2 (#746)
• fix: fix(deps): update opentelemetry-js-contrib monorepo to ^0.66.0 (#756)
• fix: fix(deps): update opentelemetry-js-contrib monorepo to ^0.67.0 (#802)
• fix: fix(deps): update patch updates (#781)
• fix: fix(opentelemetry_broadway): SQS attribute and message attribute handling (#576)
• fix: fix(opentelemetry_broadway): update semantic conventions to use new MessagingAttributes module (#575)
• fix: fix(opentelemetry_cowboy): prevent telemetry handler crash on invalid HTTP/2 scheme (#568)
• fix: fix(opentelemetry_dataloader): add support for dataloader kv sources (#762)
• fix: fix(opentelemetry_dataloader): keep self-attached context instead of a more distant $callers ancestor (#749)
• fix: fix(opentelemetry_elli): migrate to SemConv v1.27+ (#594)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

open-telemetry/opentelemetry-erlang-contrib was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.