typelevel/otel4s
67.7
Adequate · 7 November 2026
21.4k
lines of production code
Scala
primary language
4
measurements over time
What this system is
Features
Add BaggageManager implementation and converters for OpenTelemetry Java
This change introduces the \BaggageManager\ implementation for the oteljava backend, enabling users to read, write, and scope baggage data within the OpenTelemetry Java context. It includes \BaggageManagerImpl\ which bridges the Scala \BaggageManager\ API to the underlying Java \Baggage\ context, and \BaggageConverters\ which provide extension methods to seamlessly convert between Scala and Java \Baggage\ objects. This allows existing code using the generic \BaggageManager\ interface to function correctly with the Java SDK backend.
oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava/baggage · high confidence
Add Cats Effect IO runtime metrics instrumentation
Users can now register CPU starvation metrics for the Cats Effect IO runtime via the new \IORuntimeMetrics\ object. This adds 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 monitoring of CPU starvation events and clock drift.
instrumentation/metrics/shared · high confidence
Add IOLocal-based context storage with Java Agent support
Users can now use an OpenTelemetry context storage implementation backed by cats-effect's IOLocal, which keeps Scala context propagation in sync with the Java ContextStorage. This change introduces the IOLocalContextStorage and its SPI provider (registered via META-INF/services), allowing seamless mixing of Java and Scala context operations. It also includes support for instrumentation via the OTeL Java Agent, which can provide the underlying IOLocal instance.
oteljava/context-storage · high confidence
Add IOLocalTestContextStorage for Cats Effect IOLocal usage
The testkit now includes \IOLocalTestContextStorage\, a test-compatible local context provider designed for code that relies on \IOLocalContextStorage\. This new component allows tests to properly unwrap the \SettableContextStorageProvider\ when using Cats Effect's \IO\, ensuring that context propagation works correctly in test environments where \IOLocalContextStorage\ would otherwise fail. A corresponding test suite verifies that the provider successfully detects and utilizes the underlying \IOLocalContextStorage\ instance.
oteljava/context-storage-testkit · high confidence
Add Java-to-Scala propagator conversion utilities
This change introduces the \oteljava\ module's context propagation bridge, providing \asScala\ and \asJava\ extension methods to convert between Scala \TextMapGetter\, \TextMapPropagator\, and \ContextPropagators\ and their Java OpenTelemetry counterparts. Users can now seamlessly interoperate with Java OpenTelemetry libraries by wrapping Java propagators in Scala types (and vice versa) using identity-preserving wrappers that avoid double-wrapping when converting back and forth.
oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava/context/propagation · high confidence
Add oteljava logs bridge module
Introduces the \otel4s-oteljava-logs\ module, providing a bridge that maps otel4s logging APIs to the Java OpenTelemetry SDK. This includes implementations for \LoggerProvider\, \Logger\, and \LogRecordBuilder\, enabling users to configure loggers with version and schema URLs, set timestamps, severity, body, and attributes, and emit logs. The module supports complex attributes via \AnyValue\ conversion, allows attaching exceptions with automatic attribute generation, and ensures log records are emitted with the correct OpenTelemetry context scope.
oteljava/logs · high confidence
Add platform-specific I/O runtime metrics instrumentation for JS and JVM/Native
New platform-specific implementation files for \IORuntimeMetricsPlatform\ have been added to the JS and JVM/Native instrumentation modules. These files introduce the ability to register and collect metrics from the Cats Effect I/O runtime, specifically tracking CPU starvation events on JavaScript and a broader set of work-stealing thread pool metrics (including compute, worker thread, local queue, timer heap, and poller metrics) on JVM and Native platforms. Users can now configure and enable these metrics via the \IORuntimeMetrics.Config\ API to gain visibility into runtime performance characteristics.
instrumentation/metrics/js, instrumentation/metrics/jvm-native · high confidence
Add stable semantic conventions for HTTP, Database, and JVM metrics
This change introduces the stable semantic conventions for HTTP, Database, and JVM metrics, providing auto-generated metric specifications and attribute definitions. Users can now access structured metric specs for HTTP client/server requests, database client operations, and JVM telemetry (such as class counts, CPU utilization, and memory usage) via the \semconv/metrics/stable\ package, along with corresponding stability and requirement metadata for attributes.
semconv/metrics/stable · high confidence
Added semantic convention metrics test generation
The build script now generates automated test suites for OpenTelemetry semantic conventions in the otel4s metrics registry. A new Jinja2 template creates a test class that verifies all metric specs and their attributes are marked as stable, while the associated weaver configuration excludes specific namespaces (e.g., ios, aspnetcore) and attributes (e.g., exception.escaped) from this stability check.
buildscripts/semantic-convention/templates/registry/otel4s/metrics-tests · high confidence
Introduce OtelJavaTestkit for in-memory OpenTelemetry testing
The oteljava/testkit module now provides a unified OtelJavaTestkit that aggregates in-memory backends for metrics, traces, and logs. Users can create a test instance via the new builder pattern or the inMemory factory method, which allows customizing the underlying SDK providers (SdkMeterProviderBuilder, SdkTracerProviderBuilder, SdkLoggerProviderBuilder) and configuring text map propagators. The testkit exposes methods to retrieve finished spans, metrics, and log records, as well as reset them, enabling verification of telemetry data emitted by application code without requiring external exporters.
oteljava/testkit · high confidence
Introduce core tracing API with managed and manual span lifecycles
The \core/trace\ module now provides the foundational OpenTelemetry tracing API, introducing key types such as \Tracer\, \Span\, \SpanBuilder\, \SpanContext\, and \TraceScope\. Users can create spans with either a fully managed lifecycle via \SpanOps.resource\ (automatically ending on finalization) or a manual lifecycle via \SpanOps.startUnmanaged\ (requiring explicit \end\ calls). The API supports context propagation through \TraceScope\, allows setting span status and attributes, and includes utilities for handling parent-child relationships and root spans. This change establishes the core interface for instrumentation, replacing previous ad-hoc implementations with a structured, type-safe API aligned with OpenTelemetry standards.
core/trace/src/main/scala/org/typelevel/otel4s/trace · high confidence
Introduce new core metrics API with typed instruments and batch callbacks
The metrics module now provides a redesigned, type-safe API for OpenTelemetry metrics. Synchronous instruments (Counter, UpDownCounter, Histogram, Gauge) and asynchronous instruments (ObservableCounter, ObservableGauge, ObservableUpDownCounter) are now generic over their measurement value type (Long or Double), requiring explicit type parameters. The Histogram builder supports explicit bucket boundaries via the new BucketBoundaries type. A new BatchCallback mechanism allows a single callback to observe measurements across multiple asynchronous instruments simultaneously. The Meter API is split into Synchronous and full Meter traits to support effect lifting, and MeterProvider now exposes a direct apply method for convenient retrieval.
core/metrics/src/main/scala/org/typelevel/otel4s/metrics · high confidence
Introduce oteljava trace backend implementation
This change adds the concrete OpenTelemetry Java backend for the tracing module, implementing the core trace interfaces (Tracer, SpanBuilder, Span, TracerProvider) via the io.opentelemetry Java SDK. It introduces new files in oteljava/trace/src/main to handle span lifecycle management, context propagation, and trace scope, effectively wiring the library's public trace API to the underlying Java OpenTelemetry implementation.
oteljava/trace/src/main · high confidence
Introduce unified Otel4s entry point for telemetry components
A new \Otel4s\ sealed trait has been added to serve as the central entry point for the library, consolidating access to the tracer, meter, and logger providers, context propagators, and baggage management. This change provides a single, unified API surface for users to initialize and interact with OpenTelemetry features, replacing the need to manage individual provider instances separately.
core/all · high confidence
Introduces OpenTelemetry Java context bridge
Adds the \oteljava.context\ package, providing a \Context\ trait that wraps the underlying Java OpenTelemetry context and exposes standard operations like \get\, \updated\, and \root\. This change also defines type aliases for \Ask\ and \Local\ effects within the package object, enabling the library to integrate with the Cats MTL ecosystem for context propagation in the Java backend.
oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava/context · high confidence
Introduces the core OpenTelemetry logging API components
Adds the foundational types for the OpenTelemetry logs module, including \LoggerProvider\, \Logger\, \LoggerBuilder\, and \LogRecordBuilder\ to construct and emit log records. Introduces the \Severity\ enum with 24 levels (TRACE through FATAL) aligned with the OpenTelemetry specification, and \InstrumentMeta\ to manage instrumentation enablement checks. The \LogRecordBuilder\ supports setting timestamps, context, severity, event names, bodies, attributes, and exceptions before emitting. All components include no-op implementations and support effect lifting via \cats.mtl.LiftValue\.
core/logs · high confidence
New Logs Testkit for verifying emitted log records
The oteljava logs-testkit now provides a \LogsTestkit\ component 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, and resource—and verify them against collected logs using helpers like \check\, \checkAll\, and \checkAllDistinct\. This enables precise validation of logging behavior in your application code.
oteljava/logs-testkit · high confidence
New OtelJava integration module with auto-configuration and global access
This change introduces the \oteljava\ module, providing a bridge between the otel4s Scala API and the Java OpenTelemetry SDK. Users can now create an isolated, auto-configured SDK instance via \OtelJava.autoConfigured()\, access the global Java OpenTelemetry instance through \OtelJava.global()\, or wrap an existing Java SDK using \OtelJava.resource()\ or \OtelJava.fromJOpenTelemetry()\. The module also includes a \noop\ implementation for testing and exposes underlying metrics, traces, logs, and baggage managers.
oteljava/all/src/main · high confidence
New examples for tracing, metrics, and context propagation
Added seven new example files in the \examples\ module to demonstrate otel4s capabilities: \TraceExample\ shows a full user-service workflow with spans and events; \TracingExample\ demonstrates span linking and the \SpanOps.Res\ extractor; \ContextStorageExample\ illustrates using \IOLocalContextStorage\ to bridge Java ThreadLocal context with otel4s; \KleisliExample\ shows tracing with \Kleisli\[IO, Context, \*\]\ via \LocalContext\; \HistogramBucketsExample\ configures explicit bucket boundaries for histograms using \ExplicitBucketHistogramOptions\; \ObservableExample\ records an observable counter from a JMX MBean; and \PekkoHttpExample\ integrates tracing with Pekko HTTP, including \@WithSpan\ annotations and context propagation.
examples · high confidence
New expectation-based testkit utilities for OpenTelemetry Java
The \oteljava/common-testkit\ module now includes a suite of new Scala utilities to simplify testing OpenTelemetry Java components. This adds \AttributesExpectation\ for verifying attribute sets (exact, subset, or custom predicates), \InstrumentationScopeExpectation\ for checking scope name, version, schema URL, and attributes, and \TelemetryResourceExpectation\ for validating resource attributes and schema URLs. Supporting infrastructure includes \ExpectationChecks\ and \CollectionExpectationChecks\ for combining and formatting mismatch results, \FlatExpectationMatching\ for list-based assertions, and \MaximumMatching\ for resolving ambiguous matches. A \Conversions\ helper bridges OpenTelemetry Java's \CompletableResultCode\ to Cats Effect \Async\, and comprehensive Munit test suites are provided for all new components.
oteljava/common-testkit · high confidence
New metrics testkit with expectation-based assertions
The oteljava metrics-testkit now provides a builder-based API for creating an in-memory metrics backend and a fluent expectation system for verifying emitted metrics. Users can construct expectations for metric names, types (gauges, sums, histograms, summaries), values, attributes, and point-set constraints (existence, cardinality, exact matches) using builders like \MetricExpectation.gauge\, \sum\, or \histogram\. These expectations are validated against collected metrics via \MetricExpectations.checkAll\ or \checkAllDistinct\, which return structured mismatch details including clues and specific failure reasons (e.g., type mismatches, missing points, attribute mismatches) to aid debugging.
oteljava/metrics-testkit · high confidence
New template for generating OpenTelemetry semantic convention metrics
Added a new Jinja2 template (SemanticMetrics.scala.j2) and its configuration (weaver.yaml) to the build scripts, enabling the automatic generation of Scala objects for OpenTelemetry semantic convention metrics. This generator creates metric specifications including instrument types (Gauge, Counter, etc.), stability levels (stable, alpha, etc.), and attribute requirements, supporting both stable and experimental metric sets via a configurable flag.
buildscripts/semantic-convention/templates/registry/otel4s/metrics · high confidence
New trace expectation API for the oteljava testkit
The oteljava trace-testkit now provides a comprehensive set of expectation types for verifying emitted traces. Users can assert on individual spans, events, and links using \SpanExpectation\, \EventExpectation\, and \LinkExpectation\, which support matching on names, timestamps, attributes, and span contexts. Collection-level assertions are available via \SpanSetExpectation\, \EventSetExpectation\, and \LinkSetExpectation\, allowing checks like \exists\, \forall\, \contains\, and \exactly\. The \SpanExpectations\ helper object simplifies verifying lists of collected spans with methods like \checkAll\ and \checkAllDistinct\, providing structured mismatch messages to aid debugging.
oteljava/trace-testkit · high confidence
Project initialization and repository configuration
The repository has been initialized with the otel4s project, including a README describing the OpenTelemetry implementation for Scala, an Apache 2.0 LICENSE, and a NOTICE file. Repository configuration files have been added to support development workflows: .scalafmt.conf sets the formatting version to 3.11.5 with a 120-column limit; .scalafix.conf enables specific linting rules; .scala-steward.conf configures dependency updates; .mergify.yml automates PR labeling; and .gitattributes marks generated semantic convention files. Additionally, Nix development environment support is provided via flake.nix and flake.lock, and a .jvmopts file configures JVM memory settings.
(repo-wide) · high confidence
Support for complex and AnyValue attributes in OpenTelemetry Java bridge
The oteljava bridge now supports complex attribute types, including nested sequences, maps, and the generic AnyValue type, by introducing new \AnyValueConverters\ and \AttributeConverters\ utilities. These additions allow users to seamlessly convert between Scala's richer attribute model (including \AnyValue\, \SeqValue\, and \MapValue\) and the Java OpenTelemetry SDK's \Value\ and \Attributes\ structures, ensuring that complex telemetry data is preserved during interop.
oteljava/common/src/main/scala/org/typelevel/otel4s/oteljava · high confidence
Behavioural changes
Redesigned attribute and baggage APIs with new core types
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
Refactored InstrumentMeta to use cats.mtl.LiftValue for context lifting
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
Refactored OpenTelemetry Java metrics implementation with generic builders and batch callbacks
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
Refactored otel4s semantic convention generation to use a single template
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
Regenerate experimental metrics semantic conventions
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
Regenerated experimental semantic conventions to OpenTelemetry 1.42.0
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
Scala 2 tracing API now uses macros for lazy evaluation and performance
The Scala 2 implementation of the tracing API (SpanBuilder, Span, and Tracer) has been updated to use macros for methods like addAttribute, addLink, and span creation. This change ensures that arguments are evaluated lazily, meaning attributes and links are only processed if the span is actually sampled, improving performance. It also introduces new capabilities such as adding links to spans and recording exceptions, while renaming the status type from Status to StatusCode.
core/trace/src/main/scala-2 · high confidence
Scala 3 macros for metrics instruments now use \`Attributes\` and \`ExitCase\`
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
Scala 3 tracing implementation uses macros for lazy evaluation and improved ergonomics
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
Unified InstrumentMeta for Tracer and SpanBuilder
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
Updated semantic conventions to version 1.44.0
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
Test coverage
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.
Dependencies
Build infrastructure upgrades and new automation plugins
The build system has been significantly upgraded: sbt is updated from 1.6.2 to 1.13.0, and the sbt-typelevel plugin suite (including site, mergify, and scalafix) is upgraded from 0.4.9 to 0.8.7. Several new build plugins are added, including sbt-scalajs (1.22.0), sbt-scala-native (0.5.12), sbt-buildinfo, sbt-jmh, and sbt-javaagent. Additionally, two new sbt plugins are introduced: \DockerComposeEnvPlugin\, which provides tasks to start and stop local Docker Compose environments for integration testing, and \SemanticConventionsGenerator\, which automates the generation of OpenTelemetry semantic convention code and tests using the \otel/weaver\ Docker image.
project · high confidence
Major dependency upgrades and project restructuring
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
Housekeeping
Added Apache License 2.0 text for Scala components
The repository now includes a dedicated license file (licenses/LICENSE\_scala) 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 and compliance purposes.
licenses · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 68 → 68 (-0.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 73 → 73 (-0.0)
- Architecture 92 → 92 (+0.0)
- Maturity 59 → 63 (+3.4)
- Readiness 75 → 73 (-1.1)
- Security 79 → 65 (-13.5)
- Performance 84 → 100 (+15.6)
Resolved (4)
- Off-boarding risk: anonymized user #1
- Outdated: com.outr:scribe_2.13
- Outdated: org.http4s:http4s-client_2.13
- Outdated: org.http4s:http4s-dsl_2.13
New (2)
- Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
- Off-boarding risk: anonymized user #1
Changes since last survey
- 16 commits — 16 feature/other, 0 fixes
By area
- (repo) — 8 commits
- (root) — 6 commits
- project/build.properties — 1 commit
- semconv/experimental — 1 commit
Notable commits
- change: Merge pull request #1363 from typelevel/update/opentelemetry-instrumentation-annotations-2.33.0
- change: Merge pull request #1364 from typelevel/update/opentelemetry-javaagent-2.33.0
- change: Merge pull request #1365 from typelevel/update/opentelemetry-instrumentation-annotations-2.33.1
- change: Merge pull request #1366 from typelevel/update/opentelemetry-javaagent-2.33.1
- change: Merge pull request #1367 from typelevel/update/sbt-1.13.1
- change: Merge pull request #1368 from typelevel/update/flake-lock
- change: Merge pull request #1369 from typelevel/update/scala3-library-3.3.9
- change: Merge pull request #1370 from iRevive/update/semconv
- change: Update opentelemetry-instrumentation-annotations to 2.33.0
- change: Update opentelemetry-instrumentation-annotations to 2.33.1
- change: Update opentelemetry-javaagent to 2.33.0
- change: Update opentelemetry-javaagent to 2.33.1
- change: Update sbt, scripted-plugin to 1.13.1
- change: Update scala3-library, ... to 3.3.9
- change: Update semantic conventions to 1.45.0
- change: flake.lock: Update
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 93886efac918033d8b9ab6a750689eddf009175b — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-5f8314471808.