Skip to content
CAI
Software that uses CAICheck a score

zio/zio-telemetry

56.7

Adequate · 7 November 2026

4.3k

lines of production code

Scala

with JavaScript

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add OpenTelemetry instrumentation example for ZIO HTTP

The opentelemetry-instrumentation-example module now includes a complete runnable example demonstrating how to integrate OpenTelemetry tracing with a ZIO HTTP application. This example provides a server and client setup, configuring the application to use zio-http for HTTP handling and wiring in OpenTelemetry tracing aspects to capture spans and events on the health endpoint, along with the necessary configuration files (application.conf, logback.xml) to support the demo.

opentelemetry-instrumentation-example · high confidence

Add OpenTelemetry metrics and logging support to the example application

The example application now includes full OpenTelemetry observability by adding MeterProvider and LoggerProvider components alongside the existing TracerProvider. Users can now export metrics and logs to stdout, Seq, or Fluent Bit in addition to traces, with all providers configured to use the updated ServiceAttributes for resource identification.

opentelemetry-example/src/main/scala/zio/telemetry/opentelemetry/example/otel · high confidence

Add OpenTracing example with Jaeger integration

The opentracing-example module now provides a complete distributed tracing demo using OpenTracing and Jaeger. It includes a proxy service and a backend service, configured via application.conf, which communicate over HTTP while propagating tracing context. The example demonstrates how to inject and extract span headers, set span tags, and manage baggage items, with traces reported to a Jaeger collector.

opentracing-example · high confidence

Add ZIO OpenTelemetry logging demo app

A new Scala CLI application (ZioLoggingApp.scala) demonstrates integrating ZIO logging with OpenTelemetry. It configures an OpenTelemetry SDK to export trace and log records to stdout in OTLP JSON format, and sets up ZIO logging to automatically include span and trace IDs in console output, allowing users to correlate log messages with distributed traces.

scala-cli/opentelemetry-zio-logging · high confidence

Add ZIO Telemetry microsite documentation

A new documentation microsite has been added for ZIO Telemetry, built using Docusaurus. This introduces a public-facing website featuring a landing page, navigation structure, and footer with links to GitHub, Discord, and Scaladoc. The site is configured to host documentation for OpenTelemetry, OpenTracing, and OpenCensus integrations, and includes custom styling and static assets.

website · high confidence

Add ZIO integration for OpenTelemetry Baggage

This change introduces a new \Baggage\ module within the OpenTelemetry ZIO integration, allowing users to manage distributed context baggage using ZIO effects. The implementation provides a \Baggage\ trait and a \live\ ZLayer for dependency injection, exposing methods to extract and inject baggage via carriers, as well as get, set, and remove individual baggage entries. It includes support for baggage metadata and an optional feature to automatically inject ZIO log annotations into the baggage when the \logAnnotated\ flag is enabled. The module relies on the W3C Baggage Propagator by default and integrates with the existing \ContextStorage\ to manage the underlying OpenTelemetry context.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry/baggage · high confidence

Add example HTTP proxy and backend services with OpenTelemetry integration

The example application now includes a complete HTTP proxy and backend service setup to demonstrate distributed tracing, baggage propagation, and metrics. The proxy service exposes a /statuses endpoint that injects trace context and baggage into outgoing requests, while the backend service handles /status requests by extracting this context, recording events, setting attributes, and incrementing a status request counter. Both services are wired with ZIO layers for configuration, tracing, baggage, and metrics, providing a concrete reference for implementing OpenTelemetry in ZIO HTTP applications.

opentelemetry-example/src/main/scala/zio/telemetry/opentelemetry/example/http · high confidence

Added Scala helpers for OpenTelemetry Attributes

A new \Attributes\ object has been added to the common module, providing Scala-friendly factory methods to build \io.opentelemetry.api.common.Attributes\. It includes an \empty\ method and \apply\ overloads that accept one to six key-value pairs, simplifying the creation of attribute sets for metrics and traces.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry/common · high confidence

Direct trace and span ID access in ZIO logging formats

Users can now directly include trace and span identifiers in their ZIO log output via the new \LogFormats\ trait. This change introduces \traceId\ and \spanId\ log formats, along with corresponding \traceIdLabel\ and \spanIdLabel\ helpers, allowing logs to automatically display OpenTelemetry context when available. The implementation retrieves the current span context from the ZIO fiber refs or native context storage to append these IDs to log messages.

opentelemetry-zio-logging · high confidence

Initial OpenTracing integration for ZIO

This change introduces the \zio-telemetry-opentracing\ module, providing ZIO-specific abstractions for OpenTracing. It adds a new \OpenTracing\ trait and companion object that expose methods for creating root spans, child spans, and propagating context via \spanFrom\. The implementation manages the current span via a \FiberRef\, handles error tagging and logging by extracting \Throwable\ from \Cause\, and supports baggage items. It also provides ZIO aspects (\root\, \span\, \spanFrom\) for declarative span creation and a \noop\ layer for testing without an active tracer.

opentracing/src/main · high confidence

Initial configuration for OpenTelemetry example application

The opentelemetry-example module now includes its own configuration files, defining the network endpoints for the application and the logging pipeline. The application.conf sets the proxy to listen on port 8080 and the backend on port 9000, while fluentbit.conf configures an OpenTelemetry input listener on port 4318 to forward logs to stdout.

opentelemetry-example/src/main/resources · high confidence

Initial project scaffolding and configuration

The repository has been initialized with essential configuration files, including a Contributor License Agreement (CLA), a README with installation instructions for ZIO Telemetry modules (OpenTelemetry, OpenTracing, OpenCensus), and build tooling configurations. This includes \.scalafmt.conf\ (version 3.11.5), \.scalafix.conf\ for code cleanup rules, \.mergify.yml\ for automated PR handling, and an sbt launcher script. These changes establish the foundational structure and development workflow for the project.

(repo-wide) · high confidence

Integration of ZIO Metrics with OpenTelemetry

This change introduces the internal infrastructure to bridge ZIO Metrics with OpenTelemetry. It adds an \InstrumentRegistry\ that maps ZIO metric keys to OpenTelemetry instruments (counters, histograms, gauges), an \OtelMetricListener\ that receives ZIO metric updates and forwards them to the registry, and an \Instrument\ builder that configures OpenTelemetry meters. Notably, the histogram builder filters out \Double.MaxValue\ boundaries (a ZIO default) to comply with OpenTelemetry's internal infinity representation, and the listener supports propagating ZIO log annotations as metric attributes when enabled.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry/metrics/internal · high confidence

Introduce OpenCensus tracing integration for ZIO

This change adds a new OpenCensus client module to the ZIO telemetry library, providing the core infrastructure for distributed tracing. It introduces a \Tracing\ trait with methods to create spans (\span\, \root\, \fromRemoteSpan\, \fromRootSpan\), inject context into carriers, and attach attributes, along with corresponding ZIO aspects for declarative tracing. The implementation includes an \ErrorMapper\ to convert ZIO errors into OpenCensus status codes and implicit conversions in \Attributes\ to easily map Scala primitives (Boolean, String, Long, Double) to OpenCensus attribute values.

opencensus/src/main · high confidence

New OpenTelemetry demo applications for Scala CLI

Added five new Scala CLI demo applications in the scala-cli/opentelemetry directory that showcase integration with zio-opentelemetry 3.1.20 and OpenTelemetry SDK 1.66.0. These examples demonstrate practical usage of distributed tracing (TracingApp), metrics with observable counters (MetricsApp), logging with OTLP JSON export (LoggingApp), baggage propagation (BaggageApp), and context propagation between upstream and downstream services (PropagatingApp). Each app configures its own OpenTelemetry SDK layer with specific exporters and demonstrates key features like span creation, attribute setting, log annotation correlation, and baggage injection/extraction.

scala-cli/opentelemetry · high confidence

New OpenTelemetry integration layer for ZIO

The \zio-telemetry-opentelemetry\ module now provides a unified \OpenTelemetry\ object that serves as the entry point for tracing, metrics, logging, and baggage. Users can configure OpenTelemetry instances via \global\, \custom\, or \noop\ layers, and access specific capabilities through dedicated methods: \tracing\ for manual span instrumentation, \metrics\ for manual metric creation, \zioMetrics\ for seamless integration with ZIO runtime metrics, \logging\ to propagate ZIO log calls as OpenTelemetry log signals, and \baggage\ for contextual information passing. Context propagation is handled via \contextZIO\ (fiber-based) or \contextJVM\ (native) layers, allowing users to choose the appropriate storage mechanism based on their instrumentation setup.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry · high confidence

New ZIO-based OpenTelemetry metrics API

The \zio-telemetry-opentelemetry\ library now exposes a complete metrics API within the \zio.telemetry.opentelemetry.metrics\ package, providing ZIO-effect wrappers for OpenTelemetry instruments. Users can create and record measurements using \Counter\, \UpDownCounter\, and \Histogram\ instruments via the \Meter\ service, with support for observable (asynchronous) counters, up-down counters, and gauges. The implementation integrates with ZIO's context storage to automatically propagate context and supports logging ZIO log annotations as metric attributes.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry/metrics · high confidence

New backend and proxy example applications with OpenTelemetry integration

Added BackendApp and ProxyApp entry points that demonstrate the OpenTelemetry ZIO integration. The backend application configures and exposes metrics (including a custom observable counter and default JVM metrics) alongside tracing, logging, and baggage support, while the proxy application demonstrates tracing, logging, and baggage propagation using the zio-http client. Both apps are wired with ZIO dependency injection layers for configuration, HTTP servers, and OpenTelemetry SDKs.

opentelemetry-example/src/main/scala/zio/telemetry/opentelemetry/example · high confidence

New context propagation abstractions for OpenTelemetry integration

This change introduces three new components in the \zio.telemetry.opentelemetry.context\ package to manage OpenTelemetry context propagation within ZIO applications. \ContextStorage\ provides an abstraction layer for context storage, offering two implementations: a default \ZIOFiberRef\-based storage for standard ZIO usage and a \Native\ implementation backed by \java.lang.ThreadLocal\ for use with the OpenTelemetry Java instrumentation agent. Additionally, \IncomingContextCarrier\ and \OutgoingContextCarrier\ are added to handle the extraction and injection of context data (such as trace headers) from external processes, with default implementations provided for mutable string maps.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry/context · high confidence

New example applications and core OpenTelemetry tracing utilities

This release introduces new example applications for both OpenTelemetry and OpenTracing, each featuring HTTP endpoints that expose component health status via JSON responses. To support the OpenTelemetry implementation, the library adds core utilities including an Attribute helper for creating key-value pairs and a StatusMapper that allows users to map ZIO effect results to OpenTelemetry span status codes and error descriptions.

repository · high confidence

New logging support and refined tracing API

The library now includes a new \Logging\ module that integrates ZIO logging with OpenTelemetry, mapping ZIO log levels to OTEL severity and propagating annotations as span attributes. The \Tracing\ API has been refined to improve safety and usability: methods for retrieving the current context, span context, and span now carry an \Unsafe\ suffix to indicate they do not manage span lifecycle, and the \extractSpan\ method now supports span links and configurable status mappers.

opentelemetry/src/main/scala/zio/telemetry/opentelemetry/tracing · high confidence

Behavioural changes

Structured configuration for proxy and backend services

The example application now uses dedicated configuration case classes to manage connection details for its proxy and backend components. Users can now explicitly define the host and port for both the proxy and the backend service through a structured \AppConfig\ that aggregates \ProxyConfig\ and \BackendConfig\, replacing any previous flat or implicit configuration methods.

opentelemetry-example/src/main/scala/zio/telemetry/opentelemetry/example/config · high confidence

Test coverage

Added comprehensive tests for ZIO OpenTracing integration; Added test for Attributes apply method resolution; Added tests for OpenCensus tracing integration; Added tests for OpenTelemetry logging integration; Added tests for ZIO OpenTelemetry baggage operations and log annotation integration; Added tests for ZIO OpenTelemetry tracing aspects.

Dependencies

117 commits updating dependencies (3 manifests)

A dependency / build maintenance change in (dependencies) — 117 commits (2 fixs), 3 files.

(dependencies) · medium confidence · unverified

Project build infrastructure and dependency definitions for v3.0.0-RC1

The project's build configuration has been established with SBT 1.13.0 and a suite of plugins including zio-sbt (0.8.5), sbt-scoverage (2.4.4), sbt-mdoc (2.9.2), and sbt-mima-plugin (1.2.1). Core library dependencies are defined for ZIO (2.1.26), OpenTelemetry (1.66.0), OpenCensus (0.31.1), and OpenTracing (0.33.0), alongside example dependencies for Jaeger, Zipkin, and sttp. Binary compatibility is configured via MiMa to compare against version 3.0.0-RC1, with specific filters excluding issues in the opentelemetry, opentracing, and opencensus modules.

project · 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 67 → 57 (-10.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 72 → 72 (+0.0)
  • Architecture 95 → 95 (+0.0)
  • Maturity 59 → 62 (+2.9)
  • Readiness 78 → 60 (-18.8)
  • Security 67 → 45 (-21.9)
  • Performance 100 → 100 (+0.0)

Resolved (17)

  • Further orphaned files (smaller)
  • Orphaned file (opencensus/src/main/scala/zio/telemetry/opencensus/Tracing.scala)
  • Orphaned file (opentelemetry-example/src/main/scala/zio/telemetry/opentelemetry/example/otel/LoggerProvider.scala)
  • Orphaned file (opentelemetry-example/src/main/scala/zio/telemetry/opentelemetry/example/otel/TracerProvider.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/OpenTelemetry.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/baggage/Baggage.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/common/Attributes.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/context/ContextStorage.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/logging/Logging.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/metrics/Meter.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/metrics/UpDownCounter.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/metrics/internal/Instrument.scala)
  • Orphaned file (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/tracing/StatusMapper.scala)
  • Orphaned file (opentracing/src/main/scala/zio/telemetry/opentracing/OpenTracing.scala)
  • Orphaned knowledge (opentelemetry/src/main/scala/zio/telemetry/opentelemetry/tracing/Tracing.scala)
  • Outdated: io.zipkin.reporter2:zipkin-reporter
  • Outdated: io.zipkin.reporter2:zipkin-sender-okhttp3

New (1)

  • Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)

Changes since last survey

  • 13 commits — 13 feature/other, 0 fixes

By area

  • (root) — 5 commits
  • .github/workflows — 4 commits
  • scala-cli/opentelemetry — 3 commits
  • project/build.properties — 1 commit

Notable commits

  • change: Update README.md (#1269)
  • change: Update README.md (#1272)
  • change: Update opentelemetry-api, ... to 1.68.0 (#1280)
  • change: Update opentelemetry-semconv to 1.45.0 (#1277)
  • change: Update sbt to 2.0.12 (#1275)
  • change: Update sbt, scripted-plugin to 1.13.1 (#1274)
  • change: Update zio-opentelemetry, ... to 3.1.21 (#1270)
  • change: Update zio-sbt-ci, zio-sbt-ecosystem, ... to 0.8.7 (#1276)
  • change: build(deps): bump actions/setup-java from 6.0.1 to 6.1.0 (#1265)
  • change: build(deps): bump coursier/cache-action from 8.1.1 to 8.2.0 (#1266)
  • change: build(deps): bump sbt/setup-sbt from 1.5.7 to 1.5.12 (#1267)
  • change: build(deps): bump scala-steward-org/scala-steward-action from 2.96.0 to 2.97.0 (#1268)
  • change: ci: update README only for series/2.x releases (#1273)

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

zio/zio-telemetry 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 8d9480c52855adcf0a795e4315b8348a89935fad — 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-110e4fee044f.