open-telemetry/opentelemetry-erlang

This system is an OpenTelemetry implementation for Erlang and Elixir that provides the core API and SDK for distributed tracing, metrics, and logging. It enables applications to instrument code, manage context propagation, and export telemetry data via OTLP or Zipkin. The project also includes auto-generated semantic conventions and experimental support for metrics to align with the OpenTelemetry specification.

19 changes.

This period established the foundational structure of the OpenTelemetry Erlang and Elixir implementation, introducing the standalone API and SDK applications alongside the OTLP exporter. It focused on aligning internal data structures and macros with the OpenTelemetry specification, including support for W3C Trace Context and B3 propagation formats. Comprehensive test suites were added to verify core tracing, metrics, and configuration behaviors across both languages.

18 changes.

This period focused on introducing experimental support for OpenTelemetry metrics in Erlang and Elixir, including the creation of dedicated API and SDK applications with comprehensive test coverage. It also involved adding a Zipkin exporter to the main repository and establishing a new semantic conventions application with auto-generated constants and stability opt-in mechanisms.

10 changes.

This period focused on updating the OpenTelemetry semantic conventions library to version 1.40.0, introducing extensive new metrics and attributes for domains such as GenAI, Kubernetes, and cloud providers. The work involved restructuring code generation templates for both Erlang and Elixir, implementing stability opt-in mechanisms, and adding comprehensive test coverage for the new registry and configuration features.

New Erlang header files have been added to define semantic conventions for specific metric types. The \db\_metrics.hrl\ file introduces the \DB\_CLIENT\_OPERATION\_DURATION\ macro, while \http\_metrics.hrl\ defines \HTTP\_CLIENT\_REQUEST\_DURATION\ and \HTTP\_SERVER\_REQUEST\_DURATION\. These additions provide the necessary macro definitions for Erlang applications to reference these standard OpenTelemetry metric names.

_apps/opentelemetry\_semantic\conventions/include/metrics · high confidence

A new Erlang application, opentelemetry\_semantic\_conventions, has been added to provide macros defining OpenTelemetry semantic convention keys, aligned with version 1.40.0 of the semantic conventions specification. The app includes a stability opt-in mechanism via the \stability\_opt\_in/0\ function, which reads the \OTEL\_SEMCONV\_STABILITY\_OPT\_IN\ environment variable to allow users to select specific stability profiles (such as \http\ or \http\_dup\) for HTTP-related attributes, improving usability and control over semantic convention behavior.

_apps/opentelemetry\_semantic\conventions/src · high confidence

A new interop service has been added to validate W3C Trace Context propagation. The service starts an HTTP server on port 5000 that accepts JSON payloads containing URLs and arguments. For each entry, it extracts the incoming trace context headers, creates a span named 'interop-test', injects the context into outgoing HTTP requests to the specified URLs, and returns a 200 OK response upon completion.

interop · high confidence

New auto-generated Elixir modules (DBMetrics, HTTPMetrics) were added to expose semantic convention constants for database client operation duration and HTTP client/server request duration, providing standardized metric identifiers for Elixir and Erlang applications.

_apps/opentelemetry\_semantic\conventions/lib/metrics · high confidence

Added a new Erlang benchmark module (otel\_benchmarks.erl) and an Elixir runner script (run.exs) to the samples directory. The benchmark compares two context propagation methods—using process dictionary versus explicit span context—and the runner script enables executing these benchmarks in CI via mix run to ensure they continue to work.

samples · high confidence

The \otel\_metrics.hrl\ header file has been added to the \include\ directory, establishing the fundamental record definitions for the metrics API. This includes structures for meters, measurements, and various aggregation types such as sum, last value, and explicit histograms. It also defines the data point and metric records used to represent collected telemetry data, providing the necessary schema for metrics instrumentation and export.

_apps/opentelemetry\experimental/include · high confidence

Added the Elixir-specific templates for the semantic conventions code generator, including common helper macros, attribute module generation, and metric module generation. These templates define how OpenTelemetry semantic conventions are translated into Elixir modules, handling stability separation (stable vs. incubating/experimental), attribute naming conventions, and type mappings for Elixir. The weaver configuration specifies which semantic convention groups to include and how to filter them based on stability.

_apps/opentelemetry\_semantic\conventions/templates/registry/elixir · high confidence

The \OpenTelemetry\ API module in the Elixir application has been significantly expanded to provide a more complete interface for tracing and telemetry. New modules \OpenTelemetry.Baggage\ and \OpenTelemetry.Ctx\ have been added to allow users to manage and propagate baggage items and context values within processes. The \OpenTelemetry.Span\ module now exposes additional utility functions, including \hex\_span\_ctx\, \hex\_span\_id\, and \hex\_trace\_id\ for retrieving hex-encoded identifiers, as well as \record\_exception\ for capturing exception details as span events. Furthermore, \OpenTelemetry.Tracer\ has been updated to support context-aware span creation via \start\_span\ and \with\_span\ macros that accept a context argument, and \end\_span\ now accepts an optional timestamp.

_apps/opentelemetry\_api/lib/open\telemetry · high confidence

The incubating metrics module now includes auto-generated Elixir and Erlang semantic conventions for a broader range of domains. New metric modules cover Azure Cosmos DB (active instances, request charge), CICD pipelines (active runs, duration, errors, worker count), container and host hardware (CPU, disk, battery), database connection pools, DNS, FaaS (cold starts, invocations, duration), GenAI (token usage, time-to-first-token), HTTP client/server, Kubernetes resource quotas and container limits, MCP sessions, messaging (consumed/sent messages, processing duration), and NFS client operations. Additionally, legacy CPU metrics (frequency, time, utilization) are marked as deprecated in favor of the system namespace equivalents, and the messaging module replaces several older published/publish/receive metrics with updated client-side sent/consumed and operation duration metrics.

_apps/opentelemetry\_semantic\conventions/lib/incubating/metrics · high confidence

The experimental metrics API now provides Erlang macros and record types for creating and recording metrics. New header files define the \instrument\ record (including fields like \temporality\ and \advisory\_params\) and macros for creating counters, histograms, and observable gauges, as well as recording measurements via \counter\_add\, \updown\_counter\_add\, and \histogram\_record\. These macros automatically resolve the current meter using the application scope, simplifying metric instrumentation for users.

_apps/opentelemetry\_api\experimental/include · high confidence

The \opentelemetry\_experimental\ application has been introduced to provide early access to OpenTelemetry metrics functionality for Erlang/Elixir users. This new component includes the core metrics API and SDK, supporting various aggregation types (sum, drop, last value, explicit bucket histogram) and configurable views to filter and process measurements. Users can configure metric readers (periodic or pull-based) and exporters (console or OTLP) via the OTP application environment to export data to backends like the OpenTelemetry Collector. The release also includes comprehensive documentation on configuration, aggregation, and views, along with standard project scaffolding such as a CHANGELOG, LICENSE, and .gitignore.

_apps/opentelemetry\experimental · high confidence

The \opentelemetry\_exporter\ application is introduced, enabling Elixir and Erlang applications to export telemetry data (traces, metrics, and logs) via the OpenTelemetry Protocol (OTLP). It supports both gRPC and HTTP/protobuf transports, with default configuration targeting \http://localhost:4318/v1/traces\. The exporter relies on the \opentelemetry\ SDK (\~\> 1.7.0) and \opentelemetry\_api\ (\~\> 1.5.0), uses \grpcbox\ for gRPC communication, and \tls\_certificate\_check\ (\~\> 1.18) for secure HTTPS requests. Configuration is handled via application environment variables, OS environment variables (e.g., \OTEL\_EXPORTER\_OTLP\_ENDPOINT\), or direct map arguments passed to the span processor.

_apps/opentelemetry\exporter · high confidence

The OpenTelemetry API is now distributed as a separate application, providing the API portion of the OpenTelemetry specification for Erlang and Elixir. This library does not start any processes and is intended to be the only OpenTelemetry dependency for applications, handling trace context, span creation, and attribute management via macros and functions. The release includes a CHANGELOG documenting fixes for W3C Trace Context Level 2 tracestate key grammar and OTP 28 regex caching, as well as configuration files for rebar3, dialyzer, and Elixir formatting.

_apps/opentelemetry\api · high confidence

The repository is initialized with essential configuration files to support development and release workflows. This includes a \.gitmodules\ file to manage the \opentelemetry-proto\ submodule, a \rebar.config\ for Erlang build and dependency management, and a \docker-compose.yml\ for local testing services (OpenTelemetry Collector, Zipkin, Jaeger). Documentation generation is configured via \docs.sh\ and \cliff.toml\, while \renovate.json\ automates dependency updates. Additional files like \CODEOWNERS\, \CONTRIBUTING.md\, and \VERSIONING.md\ establish project governance and contribution guidelines.

(repo-wide) · high confidence

This change adds a new application, \opentelemetry\_semantic\_conventions\, which provides auto-generated constants for OpenTelemetry Semantic Conventions (specifically targeting version 1.40.0 as indicated in the build configuration). The app supports both Elixir and Erlang: Elixir users access attributes via functions (e.g., \OpenTelemetry.SemConv.URLAttributes.url\_path/0\), while Erlang users use macros from header files (e.g., \?URL\_PATH\). The implementation distinguishes between stable and experimental (incubating) attributes, placing the latter in separate namespaces or header files. The code is generated using the \weaver\ tool from the upstream semantic-conventions repository, and the app includes standard project scaffolding such as \.formatter.exs\, \.gitignore\, and a Makefile for managing the generation process.

_apps/opentelemetry\_semantic\conventions · high confidence

The Zipkin exporter is now available in the main repository (version 1.1.1), providing a new mechanism to export OpenTelemetry traces to Zipkin via HTTP POST using Protocol Buffers. The exporter automatically resolves the local service name from resource attributes and maps OpenTelemetry span statuses and attributes into Zipkin tags. It also handles edge cases such as converting character lists to binaries for span names and attributes, ensuring robust encoding even when character conversion fails.

_apps/opentelemetry\zipkin/src · high confidence

Adds a new \opentelemetry\_api\_experimental\ application (version 0.6.0) that provides the API for unstable OpenTelemetry signals, specifically metrics. This release introduces synchronous instruments (\Counter\, \UpDownCounter\, \Histogram\) and asynchronous instruments (\ObservableCounter\, \ObservableGauge\, \ObservableUpDownCounter\), along with the necessary meter and meter provider abstractions to create and record measurements.

_apps/opentelemetry\_api\experimental/src · high confidence

The \opentelemetry\_api\_experimental\ application has been introduced to provide an experimental metrics API for Elixir and Erlang. This new component exposes macros for creating and recording data points using synchronous instruments (Counter, Updown Counter, Histogram) and observable instruments (Observable Counter, Observable Updown Counter, Observable Gauge). It depends on the stable \opentelemetry\_api\ package (version \~\> 1.4) and requires the experimental SDK to be active for metrics to be exported; otherwise, operations act as no-ops.

_apps/opentelemetry\_api\experimental · high confidence

The application now includes a new module, OpenTelemetryAPIExperimental, which serves as the entry point for the experimental Elixir metrics API. This change consolidates the metrics functionality into a dedicated experimental application, separating it from the stable API modules to allow for iterative development and testing of metrics features without impacting the core stable release.

_apps/opentelemetry\_api\experimental/lib · high confidence

This change introduces a new set of Elixir macros in the \open\_telemetry\_api\_experimental\ library to simplify the creation and recording of metrics. New modules (\Counter\, \Histogram\, \UpDownCounter\, \ObservableCounter\, \ObservableGauge\, \ObservableUpDownCounter\, and \Meter\) provide macro-based APIs for creating instruments (like counters and histograms) and recording measurements (via \add\ and \record\). These macros handle meter lookup and context passing, allowing developers to instrument applications with less boilerplate code while maintaining compatibility with the underlying OpenTelemetry C SDK.

_apps/opentelemetry\_api\_experimental/lib/open\telemetry · high confidence

A new \opentelemetry\_experimental\ application (version 0.6.0) has been introduced to host unstable OpenTelemetry signals. This module provides the implementation for the experimental metrics API and SDK, including aggregation strategies (sum, last value, explicit histogram, and drop) and metric readers. It also includes OTLP exporters for logs and metrics, allowing users to export telemetry data via gRPC or HTTP/Protobuf, and introduces a \otel\_log\_handler\ to bridge Erlang/OTP logging with OpenTelemetry.

_apps/opentelemetry\experimental/src · high confidence

The \OpenTelemetry\ module has been added to the API library, providing a central interface for tracing operations. It exposes type definitions for spans, traces, links, and events, along with helper functions to create these structures (such as \link/\ and \event/\) and manage tracers via \get\_tracer/1\ and \get\_tracer/3\. This module serves as the primary entry point for building span components and handling timestamp conversions within the Elixir OpenTelemetry implementation.

_apps/opentelemetry\api/lib · high confidence

The Zipkin exporter for OpenTelemetry Erlang/Elixir has been moved into the main repository as a standalone application. This change includes the necessary build configuration (rebar.config) with dependencies on opentelemetry and opentelemetry\_api, the Zipkin v2 protobuf definitions, and documentation. Users can now configure the exporter via the batch processor to send traces to a Zipkin endpoint using the v2 API with protobuf content type.

_apps/opentelemetry\zipkin · high confidence

The library now exposes a new \OpenTelemetry.SemConv.Schemas\ module containing constants for schema URLs ranging from v1.27.0 to v1.40.0, enabling users to reference specific semantic convention versions. Additionally, the \OpenTelemetry.SemConv\ module introduces a \stability\_opt\_in/0\ function that reads the \OTEL\_SEMCONV\_STABILITY\_OPT\_IN\ environment variable to configure stability opt-ins, such as HTTP stability settings, allowing users to control which experimental or incubating features are enabled.

_apps/opentelemetry\_semantic\conventions/lib · high confidence

The application now uses a centralized configuration structure, introducing environment-specific config files (dev, test) and a dedicated OpenTelemetry collector configuration (otel-collector-config.yaml). The collector is set up to receive OTLP traces, metrics, and logs via gRPC and HTTP, exporting traces to Zipkin and Jaeger, while metrics and logs are exported to a debug handler. The application's OpenTelemetry settings are defined in bench.config and sys.config, configuring the batch processor and logger handlers.

config · high confidence

The Erlang semantic conventions library now includes new header files defining schema URLs for versions 1.27.0 through 1.40.0, while the existing macro definitions for logs, resources, and traces are marked as deprecated with a warning to migrate to version 1.27.0 or later. Users relying on these macros should prepare for their removal in a future release by updating their code to use the newer semantic convention standards.

_apps/opentelemetry\_semantic\conventions/include · high confidence

The \open\_telemetry\ library in the \opentelemetry\_semantic\_conventions\ app has restructured its semantic convention modules (Logs, Resource, Trace) to use functions instead of macros. These modules are now explicitly marked as deprecated with warnings advising users to migrate to semantic conventions version 1.27.0 or later. The current implementations reference schema version 1.13.0 and provide specific attribute constants (e.g., \db.system\, \cloud.provider\, \aws.ecs.container.arn\) that will be removed in a future release.

_apps/opentelemetry\_semantic\_conventions/lib/open\telemetry · high confidence

The Erlang semantic conventions generator has been reorganized to use a new template structure, introducing a shared \common.j2\ module for utility macros (such as \attr\_name\, \file\_name\, and \to\_atom\) and separating the generation of attribute headers (\semantic\_attributes.hrl.j2\) and metric headers (\semantic\_metrics.hrl.j2\). The \weaver.yaml\ configuration has been updated to apply specific filters for stability (stable vs. incubating), exclude certain namespaces (e.g., android, ios, jvm), and handle name collisions using acronym expansion and underscore replacement, ensuring generated Erlang headers correctly map semantic conventions to Erlang atoms and types.

_apps/opentelemetry\_semantic\conventions/templates/registry/erlang · high confidence

The OpenTelemetry Erlang API has been updated to version 1.5.0. This release introduces support for the B3 single propagation format alongside existing B3 multi-header and W3C TraceContext propagators, allowing users to configure B3 single-header propagation for distributed tracing. It also adds a \record\_exception\ function to the API for capturing exception details within spans, and implements W3C Trace Context Level 2 tracestate key grammar validation to ensure compliance with the latest specification. Additionally, baggage handling now supports explicit context arguments and metadata, and the API enforces W3C Baggage limits on the extract path to prevent oversized baggage from being processed.

_apps/opentelemetry\api/src · high confidence

The OpenTelemetry SDK has been updated to version 1.7.0, introducing a performance improvement by precomputing hex encodings of SpanID and TraceID. The release also includes updated documentation covering configuration options for samplers, propagators, and resource detectors, along with a new changelog file to track changes. The SDK now depends on the OpenTelemetry API version 1.5.0.

apps/opentelemetry · high confidence

The \opentelemetry\ application has been updated to version 1.7.0, introducing a new \otel\_configuration\ module that centralizes the merging of application environment variables with OS environment variables. A key behavioral change is the support for the \OTEL\_SDK\_DISABLED\ environment variable (mapped to \sdk\_disabled\ in the config), which allows users to skip SDK initialization steps during app bootup while still setting up global text map propagators. The release also includes a comprehensive cleanup of the batch processor, resource detection, and exporter initialization logic, alongside various fixes to span limits, processor timeouts, and configuration precedence.

apps/opentelemetry/src · high confidence

The incubating attribute definitions in apps/opentelemetry\_semantic\conventions/include/incubating/attributes have been updated to align with OpenTelemetry semantic conventions v1.40.0. This release introduces new attribute macros for application, artifact, AWS, Azure, browser, Cassandra, CI/CD, cloud, CloudEvents, Cloud Foundry, code, container, CPU, CPython, database, deployment, destination, and device telemetry. It also includes deprecation notices for legacy attribute names (such as db.cassandra.\ and container.cpu.state) and adds new platform values for cloud providers like Alibaba Cloud, Hetzner, Oracle, Tencent Cloud, and Vultr.

_apps/opentelemetry\_semantic\conventions/include/incubating/attributes · high confidence

The API header files have been updated to reflect OpenTelemetry specification changes, primarily replacing the 'InstrumentationLibrary' concept with 'InstrumentationScope' (including the addition of a schema\_url field) and standardizing naming conventions such as using lowercase for span kinds and status codes. The span context record now includes fields for tracestate and hex-encoded IDs, and the tracer macros have been adjusted to support new behaviors like setting status via just a code, adding a with\_span macro, and ensuring the current span context is properly updated when a span ends.

_apps/opentelemetry\api/include · high confidence

The Erlang metrics header files in the incubating directory have been updated to align with OpenTelemetry semantic conventions v1.40.0. This update introduces new metrics definitions for Azure Cosmos DB, CI/CD pipelines, CPython garbage collection, DNS lookups, GenAI operations, MCP sessions, and NFS operations. It also adds comprehensive metrics for Kubernetes resources (containers, deployments, jobs, HPAs) and OpenShift cluster quotas. Several existing metrics have been deprecated in favor of new naming conventions (e.g., \db.client.connections.\\ replaced by \db.client.connection.\\) or removed entirely (e.g., RPC request/response sizes), and some units have changed (e.g., connection times from milliseconds to seconds).

(repo-wide) · high confidence

The OpenTelemetry SDK's internal data structures have been updated to match the current specification. The span record now includes an \instrumentation\_scope\ field (replacing the previous \InstrumentationLibrary\) and a \parent\_span\_is\_remote\ boolean to indicate if the parent context came from a remote process. New \span\_limits\ records define configurable constraints for attribute counts, value lengths, and event/link counts. Additionally, a new \otel\_sampler.hrl\ header introduces standard sampling decision constants (\drop\, \record\_only\, \record\_and\_sample\), and span link and event records have been standardized to include trace state and specific attribute handling.

apps/opentelemetry/include · high confidence

Added AttributesSampler test support module; Added Elixir test suite for OpenTelemetry metrics and tracing; Added Elixir tests for metrics API instrument creation; Added comprehensive test coverage for OpenTelemetry SDK components; Added comprehensive test suites for metrics, logs, and OTLP exporters; Added comprehensive tests for OTLP exporter configuration and endpoint parsing; Added test coverage for Zipkin exporter serialization; Added tests for semantic conventions registry and stability opt-in behavior; Expanded test coverage for OpenTelemetry API propagation and context features; Initial test coverage for semantic conventions.

The project now supports building and managing dependencies via Mix alongside the existing Rebar3 tooling. New \mix.exs\ and \mix.lock\ files have been added for the \opentelemetry\_api\, \opentelemetry\_api\_experimental\, and \opentelemetry\_semantic\_conventions\ applications, as well as a top-level \mix.exs\ for running tests. This enables developers to use standard Mix commands for dependency resolution, documentation generation (using \ex\_doc\), and static analysis (using \dialyxir\), while maintaining compatibility with the Rebar3-based build system.

(dependencies) · high confidence

The OpenTelemetry OTLP exporter has been updated to version 1.11.0. This release includes regenerated protocol buffer modules for traces, metrics, and logs, along with updated gRPC service client modules. The core exporter module now delegates to specific trace, metrics, and logs OTLP implementations, supporting configuration via application environment, OS environment variables, or direct option maps for endpoints, headers, protocol selection (gRPC or HTTP protobuf), and gzip compression.

_apps/opentelemetry\exporter/src · high confidence

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

• CAI 80 → 79 (-0.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 (new)
• Architecture 98 → 98 (+0.3)
• Maturity 73 → 72 (-0.8)
• Readiness 79 → 79 (+0.0)
• Security 90 → 87 (-3.2)

• Change coupling: otel_aggregation_drop.erl ↔ otel_aggregation_histogram_explicit.erl (apps/opentelemetry_experimental/src/otel_aggregation_drop.erl)
• Change coupling: otel_aggregation_drop.erl ↔ otel_aggregation_last_value.erl (apps/opentelemetry_experimental/src/otel_aggregation_drop.erl)
• Change coupling: otel_aggregation_drop.erl ↔ otel_aggregation_sum.erl (apps/opentelemetry_experimental/src/otel_aggregation_drop.erl)
• Change coupling: otel_aggregation_drop.erl ↔ otel_meter_server.erl (apps/opentelemetry_experimental/src/otel_aggregation_drop.erl)
• Change coupling: otel_aggregation_drop.erl ↔ otel_metric_reader.erl (apps/opentelemetry_experimental/src/otel_aggregation_drop.erl)
• Change coupling: otel_batch_processor.erl ↔ otel_simple_processor.erl (apps/opentelemetry/src/otel_batch_processor.erl)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Further orphaned files (smaller)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Test reliability not included
• complexity unreadable for .erl, .exs, .hrl — churn × complexity hotspots could not be measured

• Change-coupling hub: otel_aggregation_drop.erl → otel_aggregation_histogram_explicit.erl, otel_aggregation_last_value.erl, otel_aggregation_sum.erl, otel_meter_server.erl, otel_metric_reader.erl (apps/opentelemetry_experimental/src/otel_aggregation_drop.erl)
• Coverage not measured — no coverage collector is wired up
• Dependency hygiene PARTLY measured — Mix pinning read, dependency currency not (Hex registry unreachable)
• FileTooLong: semantic_conventions/trace.ex (apps/opentelemetry_semantic_conventions/lib/open_telemetry/semantic_conventions/trace.ex)
• HackComment (apps/opentelemetry/src/otel_span_sweeper.erl)
• HackComment (apps/opentelemetry/test/opentelemetry_SUITE.erl)
• HackComment (apps/opentelemetry/test/opentelemetry_SUITE.erl)
• HackComment (apps/opentelemetry/test/opentelemetry_SUITE.erl)
• HackComment (apps/opentelemetry/test/opentelemetry_SUITE.erl)
• HackComment (apps/opentelemetry/test/opentelemetry_SUITE.erl)
• High IaC: WD-COMPOSE-0003 (docker-compose.yml)
• High IaC: WD-COMPOSE-0003 (docker-compose.yml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Job token omits the contents scope its checkout needs
• Off-boarding risk: anonymized user #1
• TodoComment (apps/opentelemetry/src/opentelemetry_app.erl)
• …and 36 more

• 15 commits — 9 feature/other, 6 fixes

• .github/workflows — 3 commits
• apps/opentelemetry — 3 commits
• apps/opentelemetry_experimental — 3 commits
• apps/opentelemetry_api — 2 commits
• apps/opentelemetry_exporter — 2 commits
• (root) — 1 commit
• apps/opentelemetry_api_experimental — 1 commit

• fix: fix(api): enforce W3C Baggage limits on the extract path (#1031)
• fix: fix(experimental): keep otel_log_handler exporting after an idle interval (#1005)
• fix: fix(exporter): encode log record body as string instead of int array (#952)
• fix: fix(opentelemetry): shut exporter down in processor terminate (#987)
• fix: fix: decode hex trace and span ids in OTLP log records (#1001)
• fix: fix: processor-level config takes precedence over top-level settings (#984)
• change: Use shared OSSF Scorecard workflow (#1030)
• change: chore(deps): update jaegertracing/jaeger docker tag to v2.21.0 (#1025)
• change: chore: bump exporter to 1.11.0 (#1029)
• change: chore: cleanup eqwalizer changes to remove dynamic_cast/1 calls (#1036)
• change: chore: experimental bumps and changelog (#1033)
• change: chore: mainly fixup ci (#1035)
• change: chore: unbreak os_environment_precedence (#1041)
• change: chore: update to latest otel protos (#951)
• change: ci: add shared zizmor security scanning workflow (#1028)

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

open-telemetry/opentelemetry-erlang 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.