openzipkin/zipkin

This system is a distributed tracing platform, specifically the Zipkin server and its associated libraries, designed to collect, store, and visualize trace data from various sources. It supports ingesting spans via Kafka, RabbitMQ, ActiveMQ, Pulsar, and Scribe, and persists them in backends like Elasticsearch, OpenSearch, Cassandra, and MySQL. The system provides a modernized server interface with a redesigned UI, health checks, and self-tracing capabilities, all built on a refactored architecture using Armeria and Spring Boot 3.

39 changes.

This period focused on implementing the v2 storage API across backends like Elasticsearch, Cassandra, and MySQL, while migrating the server infrastructure to Armeria and Spring Boot 3. The work also introduced new core domain models, collector components, and a modernized frontend, supported by extensive test coverage.

26 changes.

This period focused on consolidating the Zipkin server's architecture by introducing Spring Boot autoconfiguration for various storage backends and collectors, such as Cassandra, Elasticsearch, Kafka, and RabbitMQ. The work also included significant improvements to test coverage, adding comprehensive integration and benchmark tests for these new configurations and existing components.

15 changes.

This period focused on standardizing the project's build, deployment, and testing environments through the introduction of portable shell scripts and Docker-based test images. Key additions included support for multi-architecture builds, GPG signing, and new integration test containers for Elasticsearch, OpenSearch, Cassandra, ActiveMQ, and Eureka, alongside a new JUnit 5 testing module and Pulsar collector.

Users can now collect Zipkin spans from an ActiveMQ 5.x queue. The new ActiveMQCollector, ActiveMQSpanConsumer, and LazyInit classes enable consuming encoded binary messages from a configurable JMS queue, with support for setting the queue name and concurrency level.

zipkin-collector/activemq/src/main · high confidence

Users can now configure Zipkin to collect spans from an ActiveMQ queue. This change introduces new configuration properties (url, queue, concurrency, username, password, etc.) and an auto-configuration class that wires up the ActiveMQ collector when the necessary dependencies are present and the URL is set.

zipkin-server/src/main/java/zipkin2/server/internal/activemq · high confidence

Introduces a new multi-stage Dockerfile for building the Zipkin and Zipkin-slim images, utilizing the latest Java base container (25.0.2\_p10) and optimizing image size by removing unused platform-specific libraries. Additionally, adds a new test image for Elasticsearch 9.x, including its Dockerfile, configuration, and README, enabling integration testing with the latest Elasticsearch version.

docker · high confidence

A new Docker image, zipkin-elasticsearch8, has been added to provide an Elasticsearch 8.19.13 environment for integration testing. The image is built on OpenJDK 25 and includes a startup script and configuration files to support the Elasticsearch 8.x storage backend. This addition enables testing against the latest 8.x version of Elasticsearch, replacing older test image configurations.

docker/test-images/zipkin-elasticsearch8 · high confidence

Added new example assets for Prometheus, including a shell script that configures a Prometheus datasource and imports a dashboard into Grafana, and a Prometheus configuration file that sets up scraping for both Prometheus and Zipkin services.

docker/examples/prometheus · high confidence

Zipkin now supports collecting spans from Apache Pulsar. This new collector consumes encoded binary messages from a Pulsar topic (defaulting to 'zipkin'), supporting JSON, Thrift, and Proto3 encodings. Users can configure the Pulsar client and consumer via builder options for service URL, subscription name, and concurrency. The implementation includes lazy initialization of the Pulsar client and handles message processing with metrics and error handling for malformed data.

zipkin-collector/pulsar · high confidence

A new Docker test image for Eureka Server is introduced to support Zipkin's service discovery integration tests. The image runs on OpenJDK 25, exposes port 8761, and includes a custom BASIC authentication filter that requires the EUREKA\_USERNAME and EUREKA\_PASSWORD environment variables to secure the /eureka endpoints.

docker/test-images/zipkin-eureka · high confidence

The Zipkin test image for Elasticsearch 8 now includes default configuration files (elasticsearch.yml and log4j2.properties) to ensure the test environment runs correctly. These files configure the cluster as a single-node instance, disable security and monitoring features to reduce overhead, and set logging levels to suppress noisy AWS SDK warnings, providing a stable and predictable environment for running tests against Elasticsearch 8.

docker/test-images/zipkin-elasticsearch8/config · high confidence

Users can now use the new \zipkin-junit5\ module to run a local Zipkin server during JUnit 5 tests. The module provides a \ZipkinExtension\ that emulates the Zipkin HTTP collector (v1 and v2 APIs), allowing tests to POST spans and verify behavior, including simulated HTTP failures and gzip compression support.

zipkin-junit5 · high confidence

A new Docker image for testing Zipkin with OpenSearch 2.x storage is introduced. The image bundles OpenSearch 2.19.5 on an Alpine-based Java 21 runtime, exposing port 9200 and configuring the environment for integration testing, including health checks and JVM options.

(repo-wide) · high confidence

A new shell script, build-bin/gpg/configure\_gpg, was added to prepare the GPG environment for signing JAR files during Maven deployment to Sonatype. The script sets up non-interactive GPG execution and imports the signing key using the GPG\_SIGNING\_KEY and GPG\_PASSPHRASE environment variables.

build-bin/gpg · medium confidence

Introduced new data models for the legacy Zipkin v1 format, including V1Span, V1Annotation, and V1BinaryAnnotation, alongside converters (V1SpanConverter and V2SpanConverter) to facilitate migration and parsing of older data formats. These classes are marked as deprecated in favor of the modern Span model, but provide necessary support for legacy storage and data interpretation.

zipkin/src/main/java/zipkin2/v1 · high confidence

New Docker images for testing the Zipkin UI are now available. The \zipkin-ui\ image serves the static UI files directly via NGINX, while the \zipkin-uiproxy\ image acts as a reverse proxy for the UI. Both images are built on Alpine Linux 3.23.3 and use Java 25.0.2\_p10 for the build process. The \zipkin-ui\ image proxies requests to the Zipkin backend at \ZIPKIN\_BASE\_URL\ (defaulting to http://zipkin:9411), and the \zipkin-uiproxy\ image proxies the UI under a configurable \ZIPKIN\_UI\_BASEPATH\ (defaulting to /zipkin).

docker/test-images/zipkin-ui · high confidence

The Zipkin core library now includes a RATIONALE.md document explaining design decisions such as the zero-dependency policy, Java 8 baseline, and field visibility conventions. Additionally, a bnd.bnd file is added to configure OSGi packaging, explicitly excluding the embedded Gson stream package and exporting internal packages.

zipkin · high confidence

Introduces the \RabbitMQCollector\ class, enabling Zipkin to consume span data from a RabbitMQ queue. The implementation supports configuring connection addresses, queue names, and concurrency levels, and includes a health check that validates the RabbitMQ connection status.

zipkin-collector/rabbitmq/src/main · high confidence

Introduces new Spring Boot autoconfiguration classes (ZipkinCassandra3StorageConfiguration and ZipkinCassandra3StorageProperties) that enable Cassandra 3 storage via the 'cassandra3' storage type. This change inlines the Cassandra autoconfiguration, allowing users to configure Cassandra storage through standard Spring Boot properties (e.g., zipkin.storage.cassandra3.\*) without manual bean setup.

zipkin-server/src/main/java/zipkin2/server/internal/cassandra3 · high confidence

The Kafka collector is now configured via Spring Boot's autoconfiguration mechanism. A new \ZipkinKafkaCollectorConfiguration\ class registers the \KafkaCollector\ bean and binds properties under \zipkin.collector.kafka\ (including \bootstrap-servers\, \group-id\, \topic\, \streams\, and \overrides\). The collector is only activated when the \bootstrap-servers\ property is set and the \enabled\ flag is not false, allowing users to enable or disable the Kafka collector through standard Spring Boot configuration.

zipkin-server/src/main/java/zipkin2/server/internal/kafka · high confidence

Introduces new internal health check endpoints at /actuator/health and /health that report the status of each Zipkin component. The implementation uses Armeria to serve JSON responses indicating UP or DOWN status for each component, allowing users to monitor the health of the underlying storage and other dependencies.

zipkin-server/src/main/java/zipkin2/server/internal/health · high confidence

The Zipkin library introduces several new internal classes to support trace and dependency processing. \AggregateCall\ enables combining multiple asynchronous calls into a single result. \DependencyLinker\ and \Dependencies\ provide the logic for parsing span trees into dependency links for the web UI. Additionally, \Proto3Codec\ and related classes (\Proto3Fields\, \Proto3SpanWriter\) handle the serialization and deserialization of spans in the proto3 format, while \FilterTraces\ allows for filtering trace lists based on query requests. These changes consolidate internal logic for handling trace data and network protocols.

zipkin/src/main/java/zipkin2/internal · high confidence

A new Spring Boot auto-configuration class, ZipkinScribeCollectorConfiguration, has been added to support collecting traces via the Scribe protocol. This feature is disabled by default and can be enabled by setting the property zipkin.collector.scribe.enabled to true. When enabled, the server will listen on port 9410 (configurable) to receive Scribe logs, decoding each entry as a single span for asynchronous storage.

zipkin-server/src/main/java/zipkin2/server/internal/scribe · high confidence

The repository now includes the foundational files for building and maintaining the project. This includes the Apache 2.0 license, a Maven wrapper (mvnw) for consistent builds, and configuration files (.editorconfig, .gitattributes, .gitignore, .dockerignore) to standardize line endings and file handling. Additionally, a Maven settings file (.settings.xml) is added to configure deployment credentials for Sonatype and GitHub, and a RELEASE.md document is provided to guide the release process.

(repo-wide) · high confidence

The server now supports self-tracing, allowing the Zipkin server to trace its own internal operations. This is enabled via the \zipkin.self-tracing\ configuration properties (e.g., \zipkin.self-tracing.enabled\), which control sampling rates and trace retention. The implementation introduces \SelfTracingProperties\ for configuration, \ZipkinSelfTracingConfiguration\ to wire up the Brave tracing infrastructure, and \TracingStorageComponent\ to wrap storage components with tracing spans. This allows users to monitor the performance and behavior of the Zipkin server itself.

zipkin-server/src/main/java/zipkin2/server/internal/brave · high confidence

The server now includes a startup banner displaying the Zipkin version and Git commit hash, and exposes this information via the /info endpoint. This is achieved by adding an info.json resource file containing the version and commit placeholders, and a zipkin.txt file for the ASCII art banner, ensuring users can easily identify the running build.

zipkin-server/src/main/resources · high confidence

The Elasticsearch storage component now supports OpenSearch alongside Elasticsearch. This is achieved by introducing a shared \BaseVersion\ abstract class and specific \ElasticsearchVersion\ and \OpensearchVersion\ classes to handle version detection and comparison. The codebase now includes \OpensearchSpecificTemplates\ and \OpensearchVersion\ to manage OpenSearch-specific index templates and behavior, while \ElasticsearchSpecificTemplates\ and \ElasticsearchVersion\ continue to handle Elasticsearch-specific logic. This allows the storage plugin to detect and interact with either backend based on the \distribution\ field in the server's version response.

zipkin-storage/elasticsearch/src/main/java/zipkin2/elasticsearch · high confidence

The Elasticsearch storage component now supports loading username and password from a file, allowing credentials to be updated at runtime without restarting the service. Additionally, the component now supports configuring custom SSL keystores and truststores for secure connections, and enables health-checking of Elasticsearch endpoints to ensure only healthy nodes are used for requests.

zipkin-server/src/main/java/zipkin2/server/internal/elasticsearch · high confidence

Zipkin now supports automatic service registration with Eureka. A new configuration class wires the Armeria EurekaUpdatingListener, allowing the server to register itself with a Eureka server. Users can configure the Eureka service URL (including embedded credentials for basic auth) and override the app name, instance ID, and hostname via the zipkin.discovery.eureka properties.

zipkin-server/src/main/java/zipkin2/server/internal/eureka · high confidence

The Elasticsearch storage module introduces new internal classes to handle v2 storage operations, including \BulkCallBuilder\ for constructing and sending bulk HTTP requests with backpressure support, \BulkIndexWriter\ for serializing spans and autocomplete entries to JSON, \IndexNameFormatter\ for managing index naming conventions across Elasticsearch versions, \Internal\ as a facade for internal APIs, and \JsonReaders\/\JsonSerializers\ for efficient JSON parsing and generation.

zipkin-storage/elasticsearch/src/main/java/zipkin2/elasticsearch/internal · high confidence

Adds a new Docker image for running Cassandra 4.x with Zipkin's schema for integration testing. The image is built on OpenJDK 21 (JRE 21.0.10\_p7) and includes a custom install script that downloads and configures Cassandra 4.1.10, along with supporting scripts (start-cassandra, install.sh) and a README. This provides a dedicated, self-contained environment for testing Zipkin's Cassandra storage backend.

docker/test-images/zipkin-cassandra · high confidence

The \build-bin\ directory now contains a set of portable shell scripts and configuration files that standardize how the project is tested, linted, and deployed. This includes scripts for configuring and running tests (\test\, \configure\_test\), running linters (\lint\, \configure\_lint\), and managing deployments (\deploy\, \configure\_deploy\). The addition of these scripts allows for consistent CI/CD operations across different providers, supporting features like offline dependency caching for non-AMD64 architectures and automated Javadoc publishing to GitHub Pages.

build-bin · high confidence

The build system now uses a new set of shell scripts in the build-bin/docker directory to standardize Docker image building, pushing, and health checking. The new scripts handle multi-architecture builds (amd64, arm64, s390x, ppc64le) and implement a common healthcheck mechanism that supports both HTTP and TCP probes, improving reliability and consistency across the project's containerized builds.

build-bin/docker · high confidence

Adds the foundational classes for the Zipkin collector subsystem: the \Collector\ class handles span acceptance, decoding, and scheduling for storage; the \CollectorComponent\ abstracts the server-side transport lifecycle; the \CollectorMetrics\ interface and \InMemoryCollectorMetrics\ implementation provide counters for messages, bytes, and spans; and the \CollectorSampler\ class implements probabilistic trace sampling. These changes enable the system to receive, process, and store trace data with observable metrics.

zipkin-collector/core/src/main · high confidence

Added new classes in the \zipkin2.elasticsearch.internal.client\ package (\Aggregation\, \HttpCall\, \SearchCallFactory\, \SearchRequest\, and \SearchResultConverter\) to handle HTTP communication with Elasticsearch. These classes encapsulate request building, execution, and response parsing, supporting the migration from OkHttp to Armeria for the Elasticsearch storage component.

zipkin-storage/elasticsearch/src/main/java/zipkin2/elasticsearch/internal/client · high confidence

The storage package now defines new interfaces for accessing traces (Traces, SpanStore, ServiceAndSpanNames, AutocompleteTags) and a concrete InMemoryStorage implementation that supports configurable strict trace IDs, search toggling, and autocomplete keys. A ForwardingStorageComponent wrapper is also added to facilitate storage decoration or throttling.

zipkin/src/main/java/zipkin2/storage · high confidence

The zipkin2 package now includes new core domain classes—Annotation, Call, Callback, CheckResult, Component, DependencyLink, Endpoint, and Span—along with a SpanBytesDecoderDetector for format detection. These classes provide the foundational data structures and an asynchronous call interface for handling remote requests, replacing older v1 representations and enabling more efficient, modern Java-based tracing workflows.

zipkin/src/main/java/zipkin2 · high confidence

Adds a new internal throttle module that limits concurrent storage requests and buffers excess calls in a bounded queue to protect the storage engine from being overwhelmed. The change introduces configuration properties (enabled, min/max concurrency, queue size) and associated metrics (requests, succeeded, dropped, ignored, in-flight, queue size) to monitor and control the flow of storage operations.

zipkin-server/src/main/java/zipkin2/server/internal/throttle · high confidence

A new SQL schema file (mysql.sql) is added to the zipkin-storage/mysql-v1 module, defining the database tables (zipkin\_spans, zipkin\_annotations, zipkin\_dependencies) and their indexes required for MySQL-based trace storage. This provides the underlying data structure for storing and querying Zipkin span and annotation data in MySQL v1.

zipkin-storage/mysql-v1/src/main/resources · high confidence

Added a suite of shell scripts in the build-bin/maven directory to standardize Maven operations. The new scripts include maven\_build for running Maven goals, maven\_build\_or\_unjar for on-demand snapshot builds, maven\_deploy for deploying to Sonatype, maven\_go\_offline for resolving dependencies, maven\_opts for architecture-specific JVM options, maven\_release for managing release tags, and maven\_unjar for extracting artifacts. These scripts replace ad-hoc Maven invocations with a consistent, reusable build interface.

build-bin/maven · high confidence

The Zipkin library introduces new \BytesDecoder\ and \BytesEncoder\ interfaces in the \zipkin2.codec\ package, providing a standardized way to serialize and deserialize spans and dependency links. Specific implementations are added for JSON (v1, v2), Thrift, and Protocol Buffers (proto3) formats, enabling more efficient and flexible encoding/decoding of trace data.

zipkin/src/main/java/zipkin2/codec · high confidence

A new Docker image, zipkin-activemq, has been added to support ActiveMQ Classic integration testing. The image is built on OpenJDK (defaulting to version 25.0.2\_p10) and Alpine Linux, packaging ActiveMQ version 6.1.8. It includes a healthcheck script and entrypoint to manage the ActiveMQ process, exposing ports 1883, 5672, 8161, 61613, 61614, and 61616 for testing purposes.

docker/test-images/zipkin-activemq · high confidence

The Zipkin Lens interface has been redesigned with a new header bar containing a trace ID search, a JSON trace uploader, and a support link. Users can now switch between light and dark themes using a new theme selector, and change the display language via a new language selector. The header also includes navigation links to the search and dependencies pages, with the dependencies page being conditionally displayed based on configuration. The layout and navigation have been updated to use React Router for client-side navigation, and the application now supports internationalization with translations for English, Spanish, French, and Chinese.

zipkin-lens/src · high confidence

The Zipkin server now displays a custom startup banner that includes the Zipkin version and hash, and replaces the previous ASCII art with a new logo. This change improves the visual identity and provides immediate version feedback upon server startup.

zipkin-server/src/main/java/zipkin2/server/internal/banner · medium confidence

The Zipkin UI is now served directly by the Zipkin server via new internal configuration classes (ZipkinUiConfiguration, ZipkinUiProperties, CompressionProperties). This change introduces a dedicated Spring Boot configuration that serves the 'lens' UI assets, handles the /zipkin base path, and exposes UI settings (such as search, lookback, and dependency visualization options) through the zipkin.ui configuration properties.

zipkin-server/src/main/java/zipkin2/server/internal/ui · high confidence

The Kafka collector is ported to the v2 CollectorComponent interface, introducing a dedicated health check that verifies cluster connectivity without crashing the process on failure. The implementation also adds robust error handling in the polling loop, ensuring that unexpected exceptions do not terminate the consumer thread, and includes configuration options for topics, bootstrap servers, and consumer groups.

zipkin-collector/kafka/src/main · high confidence

The Zipkin server implementation has been refactored to use the Armeria framework and Spring Boot 3, replacing the previous Spring MVC-based server. This migration introduces a new internal configuration structure, including dedicated components for HTTP and gRPC collectors, health checks, and metrics. Users will see improved performance and modernized infrastructure, with the server now relying on Armeria for HTTP and gRPC endpoints and Spring Boot 3 for auto-configuration and actuator integration.

zipkin-server/src/main/java/zipkin2/server/internal · high confidence

The MySQL storage configuration has been inlined into the zipkin-server module, making the Spring Boot actuator dependency optional. This change allows for a slim build of the Zipkin server that does not include MySQL storage support, reducing the footprint for users who do not need MySQL integration.

zipkin-server/src/main/java/zipkin2/server/internal/mysql · high confidence

Zipkin's Prometheus metrics are now managed through a dedicated configuration class (ZipkinPrometheusMetricsConfiguration) that allows users to customize the metric name and bind standard JVM/system metrics. The metrics controller (ZipkinMetricsController) is now a separate component, enabling more flexible metric collection for API endpoints and reducing coupling with the main server logic.

zipkin-server/src/main/java/zipkin2/server/internal/prometheus · high confidence

The RabbitMQ collector configuration is now provided directly by the Zipkin server via new internal classes (ZipkinRabbitMQCollectorConfiguration and ZipkinRabbitMQCollectorProperties). This change consolidates the RabbitMQ collector setup, making it possible to produce a slim build by removing the need for separate auto-configuration modules. Users can now configure RabbitMQ collection through standard Spring Boot properties (zipkin.collector.rabbitmq.\*) without relying on external auto-configuration beans.

zipkin-server/src/main/java/zipkin2/server/internal/rabbitmq · medium confidence

The Cassandra storage module has been refactored to implement the v2 storage API, introducing new classes such as CassandraSpanConsumer, CassandraSpanStore, and CassandraAutocompleteTags to handle span ingestion, querying, and autocomplete features. This change aligns the Cassandra backend with the updated Zipkin storage interfaces, ensuring compatibility with the broader v2 storage model while maintaining existing functionality for trace storage and search.

zipkin-storage/cassandra/src/main · high confidence

The MySQL v1 storage implementation has been refactored to use the v2 storage model, including support for autocomplete tags, disabling search, and handling 128-bit trace IDs. The changes include new classes for managing database connections, executing queries, and converting spans. The implementation also supports pre-aggregated dependencies and error counts.

zipkin-storage/mysql-v1/src/main/java/zipkin2/storage/mysql/v1 · high confidence

The MySQL storage implementation for Zipkin now uses newly generated jOOQ model classes (DefaultCatalog, Indexes, Keys, Tables, and table/Schema wrappers) to represent the zipkin database schema. These generated classes provide type-safe access to the zipkin\_annotations, zipkin\_spans, and zipkin\_dependencies tables, ensuring the Java layer stays synchronized with the database structure.

zipkin-storage/mysql-v1/src/main/java/zipkin2/storage/mysql/v1/internal · high confidence

The Scribe collector now uses a new Netty-based server (NettyScribeServer) and handler (ScribeInboundHandler) to process incoming Scribe logs, replacing the previous implementation. This change introduces a blocking executor for delegating span collection, ensuring that the collector's accept method is invoked on a dedicated thread pool, which improves handling of synchronous span consumers.

zipkin-collector/scribe/src/main · high confidence

The Maven wrapper configuration has been updated to use version 3.3.4 of the wrapper tooling, which downloads and uses Apache Maven 3.9.14 for builds. This ensures that the project's build environment is aligned with the latest stable Maven release, providing updated build capabilities and potential security fixes.

.mvn · high confidence

The Zipkin Lens frontend has been migrated from Create React App to Vite, introducing TypeScript support and updated build tooling. This change improves the development experience and build performance while maintaining compatibility with the existing API and resource paths.

zipkin-lens · medium confidence

The Zipkin server application entry point has been refactored to disable Spring Boot's auto-configuration by default, which reduces startup time and clutter. Users must now explicitly configure modules, such as storage backends, via properties (e.g., \zipkin.internal.module...\) rather than relying on automatic detection. The startup process also explicitly bridges Java Util Logging to SLF4J and uses a custom banner.

zipkin-server/src/main/java/zipkin · medium confidence

Added Cassandra stress test profiles and test schema; Added JMH benchmarks for Zipkin components; Added benchmark and interop tests for Zipkin internal components; Added benchmark test resources and configuration; Added benchmark tests for JSON, Protobuf, and Wire span decoders; Added integrated server benchmarks for Zipkin storage backends; Added integration and unit tests for the RabbitMQ collector; Added integration tests for the Kafka collector; Added test configuration for SLF4J logging; Added test configuration for Scribe collector; Added test configuration for logging; Added test resources for MySQL v1 storage; Added tests for Cassandra storage call wrappers; Added tests for Elasticsearch and OpenSearch storage components; Added tests for MySQL v1 storage implementation; Added tests for collector property overrides and server integration scenarios; Added tests for collector sampling and span processing; Added unit and integration tests for the Cassandra storage component; Added unit tests for Elasticsearch client HTTP and search call components; Added unit tests for Elasticsearch storage internals; Added unit tests for internal Cassandra storage utilities; Adds integration and unit tests for the Scribe collector; Adds new storage integration test suite for Zipkin; Adds unit tests for Zipkin core model and codec classes; Migrate Elasticsearch integration tests to JUnit 5.

The project now includes a new 'benchmarks' module for running JMH performance tests, alongside a 'docker/test-images/zipkin-eureka' module to provide a test Eureka server. These additions support internal development and testing workflows rather than providing new user-facing capabilities.

(dependencies) · high confidence

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

• CAI 47 → 50 (+3.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 83 → 83 (+0.3)
• Architecture 100 → 99 (-0.8)
• Maturity 62 → 60 (-1.5)
• Readiness 36 → 42 (+5.9)
• Security 63 → 73 (+10.6)
• Accessibility 43 → 43 (+0.0)

• (anonymous) (cognitive 21) (zipkin-lens/src/zipkin/span-row.js)
• (anonymous) (cyclomatic 21) (zipkin-lens/src/zipkin/span-row.js)
• 1.fromJson (cyclomatic 18) (benchmarks/src/test/java/zipkin2/codec/MoshiSpanDecoder.java)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (zipkin-lens/package-lock.json)
• Critical CVE: [GHSA redacted] (zipkin-lens/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (zipkin/src/main/java/zipkin2/internal/V1SpanWriter.java)
• Duplicated block (10 lines × 2) (zipkin/src/main/java/zipkin2/internal/V1SpanWriter.java)
• Duplicated block (10 lines × 3) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• Duplicated block (11 lines × 2) (zipkin-storage/elasticsearch/src/main/java/zipkin2/elasticsearch/ElasticsearchSpecificTemplates.java)
• Duplicated block (11 lines × 2) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• Duplicated block (11 lines × 2) (zipkin-tests/src/main/java/zipkin2/storage/ITSpanStore.java)
• Duplicated block (12 lines × 2) (zipkin-storage/mysql-v1/src/main/java/zipkin2/storage/mysql/v1/HasRemoteServiceName.java)
• Duplicated block (12 lines × 2) (zipkin/src/main/java/zipkin2/internal/V1JsonSpanReader.java)
• Duplicated block (16 lines × 2) (zipkin-storage/mysql-v1/src/main/java/zipkin2/storage/mysql/v1/HasErrorCount.java)
• Duplicated block (5 lines × 2) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• Duplicated block (5 lines × 2) (zipkin-tests/src/main/java/zipkin2/storage/ITSpanStore.java)
• Duplicated block (5 lines × 3) (zipkin-tests/src/main/java/zipkin2/storage/ITSpanStore.java)
• Duplicated block (6 lines × 2) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• …and 65 more

• ClassTooLong: Span (zipkin/src/main/java/zipkin2/Span.java)
• Coverage not measured — JavaScript/TypeScript suite
• CriterionBox.CriterionBox (cognitive 67) (zipkin-lens/src/components/DiscoverPage/SearchBar/CriterionBox.tsx)
• CriterionBox.CriterionBox (cyclomatic 62) (zipkin-lens/src/components/DiscoverPage/SearchBar/CriterionBox.tsx)
• Critical CVE: [GHSA redacted] (zipkin-lens/package-lock.json)
• Critical CVE: [GHSA redacted] (zipkin-lens/package-lock.json)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• DependencyLinker.putTrace (cognitive 75) (zipkin-lens/src/zipkin/dependency-linker.js)
• DependencyLinker.putTrace (cyclomatic 40) (zipkin-lens/src/zipkin/dependency-linker.js)
• DiscoverPageContent.useQueryParams (cognitive 28) (zipkin-lens/src/components/DiscoverPage/DiscoverPageContent.tsx)
• DiscoverPageContent.useQueryParams (cyclomatic 27) (zipkin-lens/src/components/DiscoverPage/DiscoverPageContent.tsx)
• Duplicated block (10 lines × 2) (zipkin/src/main/java/zipkin2/internal/V1SpanWriter.java)
• Duplicated block (10 lines × 2) (zipkin/src/main/java/zipkin2/internal/V1SpanWriter.java)
• Duplicated block (10–11 lines × 8) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• Duplicated block (10–12 lines × 2) (zipkin-storage/cassandra/src/main/java/zipkin2/storage/cassandra/SelectFromSpan.java)
• Duplicated block (11 lines × 2) (zipkin-storage/elasticsearch/src/main/java/zipkin2/elasticsearch/ElasticsearchSpecificTemplates.java)
• Duplicated block (12 lines × 2) (zipkin-storage/mysql-v1/src/main/java/zipkin2/storage/mysql/v1/HasRemoteServiceName.java)
• Duplicated block (12–17 lines × 6) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• Duplicated block (15 lines × 2) (zipkin-tests/src/main/java/zipkin2/storage/ITDependencies.java)
• Duplicated block (16 lines × 2) (zipkin-storage/mysql-v1/src/main/java/zipkin2/storage/mysql/v1/HasErrorCount.java)
• …and 152 more

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

openzipkin/zipkin 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.