typelevel/otel4s

This system is a Scala-native implementation of the OpenTelemetry API, providing type-safe, idiomatic interfaces for distributed tracing, metrics, and logging. It features a unified entry point for telemetry components and leverages Scala 3 macros for performance optimization and ergonomic attribute handling. The library includes a dedicated bridge module that integrates with the OpenTelemetry Java SDK, enabling seamless context propagation and data conversion between Scala and Java environments. Additionally, it offers comprehensive test kits and auto-generated semantic convention definitions to facilitate reliable instrumentation and verification.

27 changes.

This period established the otel4s project foundation, featuring a multi-module architecture, unified entry points, and comprehensive core APIs for tracing, metrics, and context management. It introduced the OtelJava integration module to bridge with the OpenTelemetry Java SDK, supported by extensive testing, benchmarks, and build infrastructure modernization.

21 changes.

This period focused on significantly enhancing the testing infrastructure by introducing a comprehensive, expectation-based testkit for the oteljava module, covering metrics, traces, and general telemetry. Concurrently, the project updated its semantic conventions to align with OpenTelemetry versions 1.42.0 and 1.44.0, including the generation of stable and experimental metric specifications. Additional features included support for complex attribute conversions in the Java bridge and the addition of CPU starvation metrics for Cats Effect runtimes.

11 changes.

This period focused on implementing the core OpenTelemetry Logs API and its Java bridge, enabling structured logging with severity levels and test kit support. Concurrently, the codebase unified InstrumentMeta handling across metrics and traces using cats.mtl.LiftValue and expanded Scala 3 macro support for attributes and instrumentation.

Users can now register CPU starvation metrics for Cats Effect I/O runtimes via the new \IORuntimeMetrics\ object. This change introduces three observable metrics—\cats.effect.runtime.cpu.starvation.count\, \cats.effect.runtime.cpu.starvation.clock.drift.current\, and \cats.effect.runtime.cpu.starvation.clock.drift.max\—allowing users to monitor CPU starvation events and clock drift within their applications.

instrumentation/metrics/shared · high confidence

The \oteljava/context-storage\ module now provides a \ContextStorage\ implementation backed by \cats.effect.IOLocal\, allowing OpenTelemetry context to be propagated via Scala's fiber-local storage. This change introduces \IOLocalContextStorage\ and its SPI provider, enabling users to use \IOLocalContextStorage.localProvider\ for consistent context handling across Scala and Java APIs. Additionally, the implementation includes support for instrumentation via the OpenTelemetry Java Agent, which can provide the underlying \IOLocal\ instance to ensure context propagation works correctly when the agent is active.

oteljava/context-storage · high confidence

The oteljava module now includes \JavaPropagatorWrappers\ and \PropagatorConverters\ to bridge OpenTelemetry Java and Scala context propagation APIs. Users can convert between Java \TextMapPropagator\/\TextMapGetter\ and their Scala counterparts using \asScala\ and \asJava\ extension methods, with wrappers ensuring that round-trip conversions return the original objects. The implementation also adds meaningful \toString\ methods to the propagator wrappers for better debugging.

oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava/context/propagation · high confidence

Introduces the \otel4s-oteljava-logs\ module, providing a bridge that connects otel4s logging APIs to the Java OpenTelemetry SDK. This includes implementations for \Logs\, \LoggerProvider\, \Logger\, and \LogRecordBuilder\, enabling users to configure loggers with version and schema URLs, set timestamps, severity, body, and attributes, and emit log records that are forwarded to the underlying Java \LogsBridge\. The implementation supports complex attributes, exception handling, and dynamic instrument enablement checks.

oteljava/logs · high confidence

This change introduces the \BaggageConverters\ object, which provides extension methods (\toJava\ and \toScala\) to seamlessly convert between Scala \Baggage\ types and Java OpenTelemetry \Baggage\ types without using wrappers. It also adds \BaggageManagerImpl\, a concrete implementation of the \BaggageManager\ trait that bridges the Scala API to the underlying Java OpenTelemetry context, enabling features like retrieving current baggage, managing local scope, and accessing specific baggage entries.

oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava/baggage · high confidence

New platform-specific implementation files have been added for the JavaScript and JVM/Native targets to expose Cats Effect I/O runtime metrics via OpenTelemetry. On the JVM/Native platform, the instrumentation now collects detailed Work-Stealing Thread Pool metrics, including compute activity, worker thread status, local queue depth, timer heap usage, and poller events, in addition to CPU starvation metrics. The JavaScript platform implementation focuses on CPU starvation metrics. Both platforms allow users to enable or disable specific metric categories and attach custom attributes through a structured configuration API.

instrumentation/metrics/js, instrumentation/metrics/jvm-native · high confidence

The testkit now includes \IOLocalTestContextStorage\, a test-compatible local context provider that allows users to test code relying on \IOLocalContextStorage\ when the global context storage is set to \SettableContextStorageProvider\. This component unwraps the underlying \IOLocalContextStorage\ from the settable provider, enabling proper context propagation in tests, and is accompanied by documentation and test coverage.

oteljava/context-storage-testkit · high confidence

The build system now generates a Scala metrics registry (SemanticMetrics.scala) and its configuration (weaver.yaml) for the otel4s semantic conventions. This generated code provides a centralized list of metric specifications, mapping OpenTelemetry semantic convention metrics to their corresponding Scala types (Gauge, Counter, UpDownCounter, Histogram) and handling attribute requirements (required, recommended, opt-in) and stability levels (stable, alpha, beta, etc.). The generation process allows filtering for stable-only or experimental metrics and excludes specific problematic metrics, ensuring the library's metrics API stays synchronized with the latest OpenTelemetry semantic convention schema.

buildscripts/semantic-convention/templates/registry/otel4s/metrics · high confidence

The oteljava logs-testkit module now provides a \LogsTestkit\ that captures log records in memory during tests, allowing you to assert on their content. You can build expectations for individual log records—checking body, severity, trace/span correlation, attributes, scope, resource, and timestamps—and verify them against the collected logs using helpers like \check\, \checkAll\, and \checkAllDistinct\. This replaces older in-memory variants and deprecated APIs, giving a structured, fluent API for testing logs emitted by your code.

oteljava/logs-testkit · high confidence

The oteljava/testkit module now provides the OtelJavaTestkit class, a unified in-memory backend for testing metrics, traces, and logs. Users can create a test instance via the builder pattern or the convenience inMemory method, which allows customization of the underlying SDK providers (SdkMeterProviderBuilder, SdkTracerProviderBuilder, SdkLoggerProviderBuilder) and text map propagators. The testkit exposes finished spans, metrics, and logs for verification, along with reset methods to clear state between tests.

oteljava/testkit · high confidence

The metrics module now provides a complete API for OpenTelemetry metrics, introducing synchronous instruments (Counter, UpDownCounter, Histogram, Gauge) and asynchronous instruments (ObservableCounter, ObservableGauge, ObservableUpDownCounter). Users can configure instruments via builders (e.g., setting units, descriptions, and explicit bucket boundaries for histograms) and record measurements with attributes. The API supports generic value types (Long and Double) via the MeasurementValue typeclass, allows lifting effects between contexts, and enables batch callbacks to observe multiple asynchronous instruments in a single callback.

core/metrics/src/main/scala/org/typelevel/otel4s/metrics · high confidence

This change introduces the foundational API for distributed tracing in the \core/trace\ module. It defines the \Span\ trait for manual and automatic lifecycle management, \SpanBuilder\ for configuring span attributes, links, and parent contexts, and \SpanOps\ for executing spans via resources or unmanaged starts. The \SpanContext\ is now a sealed trait with explicit \TraceId\ and \SpanId\ helpers, supporting \TraceFlags\ (including sampling and random-trace-id bits) and \TraceState\ (W3C-compliant key-value pairs). Scope propagation is handled by \TraceScope\, which uses \cats.mtl.Local\ to manage current span context across fibers, and \SpanFinalizer\ provides deferred updates for status, events, and attributes upon span completion.

core/trace/src/main/scala/org/typelevel/otel4s/trace · high confidence

This change adds the concrete OpenTelemetry Java backend for the tracing module, implementing the core trace interfaces (Tracer, SpanBuilder, Span, TracerProvider) by wrapping the Java OpenTelemetry SDK. It introduces new files such as SpanBackendImpl, SpanBuilderImpl, SpanRunner, and TracerImpl to handle span lifecycle, context propagation, and attribute conversion, effectively wiring the library's abstract trace API to the underlying Java implementation.

oteljava/trace/src/main · high confidence

This release adds the \semconv/metrics/stable\ module, providing auto-generated, stable semantic metric specifications for HTTP client/server, database client operations, and JVM telemetry. The module introduces core model types (\MetricSpec\, \AttributeSpec\, \Stability\, \Requirement\) and concrete metric definitions (e.g., \http.client.request.duration\, \db.client.operation.duration\, \jvm.class.count\) that include required attributes and stability markers. Companion test suites verify that all generated specs and their attributes are marked as stable, ensuring these conventions are ready for production use.

semconv/metrics/stable · high confidence

The library now exposes a single \Otel4s\[F\]\ entry point that aggregates access to all telemetry capabilities, including the tracer, meter, and logger providers, as well as context propagation and baggage management. This centralizes the API surface, allowing users to obtain a fully configured telemetry instance with a unified context type and implicit local context support, simplifying initialization and usage across tracing, metrics, and logging.

core/all · high confidence

Adds a new context bridge module that wraps the Java OpenTelemetry context, providing a \Context\ trait and implementation to integrate with the Java SDK. This includes context keys, a root context, and type aliases for \Ask\ and \Local\ effects to enable context propagation within the Java-based tracing infrastructure.

oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava/context · high confidence

This change adds the core logging infrastructure to the \core/logs\ module, introducing \LoggerProvider\, \Logger\, \LoggerBuilder\, and \LogRecordBuilder\ to align with the OpenTelemetry logging specification. Users can now create named loggers with optional version and schema metadata, and build log records with timestamps, event names, attributes, and exception details. The update also introduces a \Severity\ enum with 24 levels (Trace through Fatal) that map to OpenTelemetry numerical values, and an \InstrumentMeta\ system that allows checking if logging is enabled for specific contexts and severity levels.

core/logs · high confidence

Added the \oteljava\ module, providing an \OtelJava\ implementation that bridges otel4s with the Java OpenTelemetry SDK. This allows users to create isolated, auto-configured SDK instances via \OtelJava.autoConfigured\, access the global Java OpenTelemetry instance via \OtelJava.global\, or wrap existing Java SDK instances using \OtelJava.resource\ or \OtelJava.fromJOpenTelemetry\. The module also includes a \noop\ implementation for testing and exposes underlying Java components like \JOpenTelemetry\, \MeterProvider\, \TracerProvider\, and \LoggerProvider\.

oteljava/all/src/main · high confidence

The examples directory now includes several new demonstration programs: ContextStorageExample shows how to use IOLocalContextStorage with LocalProvider; HistogramBucketsExample demonstrates configuring explicit bucket boundaries for histograms; ObservableExample illustrates creating an ObservableCounter backed by an MBean; KleisliExample shows tracing with Kleisli\[IO, Context, \*\]; TraceExample provides a full tracing workflow with user database and service client mocks; and TracingExample demonstrates span linking and context propagation using B3 headers. These examples cover key otel4s-oteljava features including context management, metric customization, and advanced tracing patterns.

examples · high confidence

The \oteljava/common-testkit\ module now provides a fluent, expectation-driven API for verifying telemetry data in tests. It introduces \AttributesExpectation\ to validate attribute sets (supporting exact, subset, and custom predicate checks), \InstrumentationScopeExpectation\ to verify scope name, version, schema URL, and attributes, and \TelemetryResourceExpectation\ to validate resource attributes and schema URL. These expectations are backed by a shared \ExpectationChecks\ utility that aggregates failures into structured, human-readable mismatch reports, and a \MaximumMatching\ algorithm that handles complex collection matching to improve assertion clarity when multiple items are involved.

oteljava/common-testkit · high confidence

The oteljava metrics-testkit now provides a structured, expectation-based API for verifying emitted metrics in tests. Instead of manually inspecting raw OpenTelemetry data, users can build partial expectations for metric names, kinds (gauges, sums, histograms, summaries), values, attributes, and point-set constraints (existence, cardinality, exact matches). The new \MetricsTestkit\ builder creates an in-memory backend, and \MetricExpectations\ helpers like \checkAll\ and \checkAllDistinct\ return structured mismatch details with human-readable clues, making test failures easier to diagnose.

oteljava/metrics-testkit · high confidence

The oteljava trace-testkit now provides a comprehensive, fluent API for asserting on exported OpenTelemetry data. Users can define granular expectations for individual spans, events, and links—including checks on names, timestamps, attributes, span contexts, and sampling status—and combine them into set-level assertions (e.g., exists, forall, exactly, count). The testkit returns structured mismatch details to help diagnose failures, enabling precise verification of trace behavior in tests.

oteljava/trace-testkit · high confidence

The repository has been initialized with the otel4s project, including the Apache 2.0 license, README, and a NOTICE file. Development tooling is configured with scalafmt (version 3.11.5, 120-column width), scalafix rules, and Scala Steward settings for semantic convention regeneration. The Nix flake has been updated to use \typelevel-nix\ overlays and enable Scala Native support with specific libraries. Additionally, Mergify is configured to automatically label pull requests based on the module they touch (core, oteljava, semconv, metrics, tracing, logs).

(repo-wide) · high confidence

The oteljava bridge now supports complex attribute types, including arrays and nested structures, by introducing \AnyValueConverters\ and \AttributeConverters\. These new utilities enable bidirectional conversion between Scala \AnyValue\ types (strings, booleans, longs, doubles, byte arrays, sequences, and maps) and their Java OpenTelemetry counterparts, as well as converting Scala \AttributeKey\ and \Attributes\ objects to and from Java \AttributeKey\ and \Attributes\. This allows users to pass and receive rich, structured attribute data when interacting with the underlying OpenTelemetry Java SDK.

oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava · high confidence

The core tracing API in \core/trace\ is now implemented using Scala 2 macros to preserve laziness and optimize performance. \SpanBuilder\ and \Span\ methods (such as \addAttribute\, \addLink\, and \addEvent\) are backed by macros that skip execution when the span is disabled or when varargs attributes are empty. The \Tracer\ provides new \span\ and \rootSpan\ convenience methods that automatically build and finalize spans, while \SpanBuilder\ now supports \addLink\ for linking spans across traces and \withFinalizationStrategy\ for customizing error/cancellation recording.

core/trace/src/main/scala-2 · high confidence

The build system has been significantly modernized: sbt is upgraded from 1.6.2 to 1.13.0, and the sbt-typelevel plugin suite is updated to 0.8.7, introducing new plugins for Mergify and Scalafix. Additional build tooling includes sbt-scalajs (1.22.0), sbt-scala-native (0.5.12), sbt-buildinfo (0.13.2), sbt-jmh (0.4.8), and sbt-javaagent (0.2.0). Two new sbt plugins are introduced: DockerComposeEnvPlugin, which adds tasks to automatically start and stop Docker Compose environments for integration tests, and SemanticConventionsGenerator, which automates the generation of OpenTelemetry semantic convention code and tests using the otel/weaver Docker image.

project · high confidence

The core attribute and baggage APIs have been redesigned to improve type safety and ergonomics. Attributes are now built using a new \AttributeKey\ system with a \KeySelect\ mechanism for type-safe key creation, and a new \AnyValue\ type supports complex nested structures (maps, sequences, primitives) as defined by the OpenTelemetry spec. The \Attributes\ collection now provides improved factory methods and \Make\ instances for easier construction. Additionally, a new \Baggage\ API and \BaggageManager\ have been introduced to manage context baggage, including support for local scope modification and lifting to other effect types.

core/common/src/main · high confidence

The \InstrumentMeta\ trait in the metrics module has been refactored to replace the previous \KindTransformer\ mechanism with \cats.mtl.LiftValue\. This change updates how instrument metadata is lifted between different effect contexts (e.g., from \F\ to \G\), providing a more standard and flexible approach for context transformation within the metrics system. The implementation now relies on \LiftValue\ for the \liftTo\ method, and internal factory methods have been renamed to \dynamic\, \enabled\, and \disabled\ to reflect their specific behaviors.

core/metrics/src/main/scala/org/typelevel/otel4s/metrics/meta · high confidence

The \oteljava/metrics\ module has been rewritten to use generic, type-safe builders for all metric instruments (Counter, UpDownCounter, Gauge, Histogram, and their observable variants), allowing them to work with both Long and Double measurement values via a unified \MeasurementValue\ type class. The implementation now supports synchronous Gauges and introduces a \batchCallback\ API for registering multiple observable measurements in a single callback, while also ensuring that metric recording operations correctly propagate the current OpenTelemetry context. Additionally, histogram builders now support explicit bucket boundaries, and instrument enablement is dynamically calculated at runtime.

oteljava/metrics · high confidence

The build script for generating otel4s semantic convention attributes has been consolidated into a single Jinja2 template (SemanticAttributes.scala.j2) and a corresponding weaver.yaml configuration. This change simplifies the generation process by replacing previous multi-file or fragmented approaches with one unified template that handles both standard attribute keys and their associated enum values. The configuration explicitly excludes certain namespaces (ios, aspnetcore, signalr, dotnet) and specific attributes (messaging.client\_id, exception.escaped), ensuring the generated Scala code aligns with the current OpenTelemetry semantic conventions (1.42.0) while maintaining stable-only generation by default.

buildscripts/semantic-convention/templates/registry/otel4s/attributes · high confidence

The experimental metrics semantic conventions in the \semconv/metrics/experimental\ package have been regenerated to align with OpenTelemetry semantic conventions version 1.42.0. This update introduces new metric specifications for Azure Cosmos DB, CI/CD pipelines, containers, CPU, CPython garbage collection, database connection pools, DNS, serverless functions (FaaS), and Generative AI operations. Several existing metrics, including CPU frequency/time/utilization and GenAI client operation duration, are now marked as deprecated in favor of their system-level or dedicated repository counterparts. The generated Scala objects provide the \MetricSpec\ definitions and factory methods required to create the corresponding OpenTelemetry instruments.

semconv/metrics/experimental · high confidence

The experimental semantic conventions in \semconv/experimental\ have been regenerated to align with OpenTelemetry semantic convention version 1.42.0. This update introduces new attribute definitions for Android (app state and OS API level), application metrics (crash IDs, jank, screen coordinates), software artifacts (attestations, hashes, PURLs), AWS services (Bedrock, DynamoDB, ECS, EKS), Azure services (Cosmos DB, resource groups), browser web vitals, Cassandra, and CI/CD pipelines. It also deprecates legacy attributes such as \android.state\ (replaced by \android.app.state\), \az.namespace\ (replaced by \azure.resource\_provider.namespace\), and client address/port (replaced by the standard \ClientAttributes\), ensuring the library stays current with upstream OpenTelemetry standards.

semconv/experimental · high confidence

The Scala 3 macro implementations for Counter, Gauge, Histogram, and UpDownCounter have been updated to align with the improved attribute API. Recording methods now accept \AttributeOrIterableOnce\ and internally convert them to \Attributes\, providing a more ergonomic user experience. Additionally, the \Histogram.recordDuration\ macro now supports building attributes based on \Resource.ExitCase\, allowing users to capture error or cancellation details in duration measurements.

core/metrics/src/main/scala-3 · high confidence

The Scala 3 tracing core now implements \SpanBuilder\, \Span\, and \Tracer\ operations via Scala 3 macros (in \SpanBuilderMacro\, \SpanMacro\, and \TracerMacro\). This change preserves laziness in the \SpanBuilder\ API, allowing attributes, links, and configuration to be evaluated only when the span is actually built. It also introduces ergonomic improvements such as varargs support for adding attributes and links, and ensures that adding empty varargs attributes is skipped to avoid unnecessary overhead. Users benefit from more efficient span construction and a cleaner API for associating attributes and links with spans and events.

core/trace/src/main/scala-3 · high confidence

The trace module now uses a shared InstrumentMeta trait for both Tracer and SpanBuilder, ensuring consistent metadata handling. This change introduces a dynamic factory method and replaces the previous KindTransformer approach with cats.mtl.LiftValue for context lifting, simplifying how instrumentation state is managed and transformed across different effect types.

core/trace/src/main/scala/org/typelevel/otel4s/trace/meta · high confidence

The stable semantic conventions have been regenerated to align with OpenTelemetry semantic conventions version 1.44.0. This update refreshes the \SchemaUrls\ object to include the new 1.44.0 schema URL and sets it as the current default, while also adding support for versions 1.36.0 and 1.37.0. The generated attribute definitions across modules such as HTTP, database, Kubernetes, and JVM have been updated to reflect the latest specification changes.

semconv/stable · high confidence

Add JMH benchmarks for core tracing and metrics components; Added Scala 3 test suites for attributes, metrics, and tracing macros; Added Scalacheck generators for OTel4s attributes and values; Added Scalacheck property-based testing generators for trace types; Added comprehensive test suites for core tracing components; Added property-based tests for core OTel4s types; Added test suites for OpenTelemetry Java metrics implementation; Added test suites for SpanBuilder and Tracer in oteljava module; Added test suites for metrics instruments and utilities; Added tests for AnyValue and Attribute converters; Added tests for Baggage and BaggageManager; Added tests for BaggageConverters and BaggageManagerImpl; Added tests for IORuntimeMetrics configuration and metric expectations; Added tests for InstrumentMeta enabled, disabled, and dynamic states; Added tests for OtelJava integration; Added tests for SpanContext conversion and TraceScope implementation; Added tests for VaultContext implementation; Added tests for context Key laws, Show instances, and LocalProvider resolution; Added tests for context propagation components; Added tests for context propagation converter wrappers; Auto-generated semantic convention metrics tests for otel4s.

This release upgrades core dependencies to OpenTelemetry 1.66.0, Cats Effect 3.7.1, FS2 3.14.0, and Scala 2.13.18/3.3.8, while bumping the base version to 1.1 and moving the organization to Typelevel. The build has been restructured into a multi-module architecture (core, oteljava, semconv, etc.) with new Mergify rules for automated PR labeling and a task to generate semantic conventions.

(dependencies) · high confidence

The repository now includes a dedicated \licenses/LICENSE\_scala\ file containing the full text of the Apache License, Version 2.0. This ensures that the licensing terms for Scala-based parts of the project are explicitly documented and available for redistribution compliance.

licenses · 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 70.

• Code Health 93
• Architecture 100
• Maturity 67
• Readiness 68
• Security 65

• 300 commits — 295 feature/other, 5 fixes

• (repo) — 148 commits
• (root) — 62 commits
• project/build.properties — 9 commits
• project/plugins.sbt — 9 commits
• docs/how-to-tracing — 8 commits
• docs/explanations — 7 commits
• docs/how-to-metrics — 6 commits
• docs/how-to-testkit — 6 commits
• core/trace — 5 commits
• oteljava/metrics-testkit — 5 commits
• core/logs — 3 commits
• docs/how-to-jvm-setup — 3 commits
• docs/oteljava — 3 commits
• semconv/experimental — 3 commits
• buildscripts/semantic-convention — 2 commits
• core/metrics — 2 commits
• oteljava/logs-testkit — 2 commits
• oteljava/trace-testkit — 2 commits
• semconv/metrics — 2 commits
• semconv/stable — 2 commits

• fix: Fix compilation issues
• fix: Merge pull request #1206 from iRevive/oteljava-log-attribute-fix
• fix: Merge pull request #1330 from iRevive/fix/cross-project-revert
• fix: Revert "Update sbt-scala-native-crossproject to 1.4.0"
• fix: semconv generator: fix block code template
• change: Add loggerProvider to the OtelJavaTestkit's toString
• change: Bump tlBaseVersion to 1.0
• change: Generate semantic conventions
• change: Generate semantic conventions
• change: Improve wording, tighten the context
• change: Merge branch 'main' into docs/stream-tracing
• change: Merge branch 'main' into docs/testkit/logs
• change: Merge branch 'main' into topic/baggage/lift-to
• change: Merge branch 'main' into update/munit-1.2.4
• change: Merge branch 'main' into update/munit-1.2.4
• change: Merge branch 'main' into update/munit-scalacheck-1.3.0
• change: Merge branch 'main' into update/munit-scalacheck-1.3.1
• change: Merge branch 'main' into update/opentelemetry-api-1.65.0
• change: Merge branch 'main' into update/opentelemetry-api-1.65.0
• change: Merge branch 'main' into update/opentelemetry-instrumentation-annotations-2.26.0
• …and 280 more

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

typelevel/otel4s 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.