explaingit

openzipkin/zipkin

17,431JavaAudience · ops devopsComplexity · 3/5Setup · easy

TLDR

Zipkin collects timing data from each service in a multi-service application so you can look up exactly where slowdowns or failures happened across the entire request chain.

Mindmap

mindmap
  root((Zipkin))
    What it does
      Distributed tracing
      Latency troubleshooting
      Dependency mapping
    Instrumentation
      HTTP transport
      Kafka transport
      gRPC RabbitMQ Pulsar
    Storage
      In-memory for dev
      Cassandra production
      Elasticsearch production
    Use Cases
      Find slow microservice
      Trace request path
      Service dependency map
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Trace a slow API request across multiple microservices to pinpoint which service is adding the most latency.

USE CASE 2

Set up a visual dependency diagram showing how traced requests flow between your services.

USE CASE 3

Store and query trace data long-term using Cassandra or Elasticsearch for production workloads.

USE CASE 4

Instrument a Java service to send span data to Zipkin over HTTP or Kafka.

Tech stack

JavaKafkaApache CassandraElasticsearchDockergRPCRabbitMQApache Pulsar

Getting it running

Difficulty · easy Time to first run · 5min

Quickest start is a single executable jar or Docker image, persistent storage requires Cassandra or Elasticsearch setup.

License not specified in the explanation.

In plain English

Zipkin is a distributed tracing system. In plain terms, when a single user action in a modern application is actually handled by several services talking to each other over the network, it can be hard to figure out where a delay or failure happened. Zipkin collects the timing information from each step and lets you look it up afterwards, so you can troubleshoot latency problems in that kind of service architecture. The way it works has two halves. Each application has to be instrumented, meaning it uses a tracing library to report data to Zipkin about the work it does. The most common ways to ship that data are HTTP and Kafka, with other transports like Apache ActiveMQ, gRPC, RabbitMQ, and Apache Pulsar also supported. On the receiving side, the Zipkin server stores the spans and serves a web UI on port 9411 where you can paste a trace ID from a log to jump straight to it, or query by service, operation name, tags, or duration. The UI also shows a dependency diagram of how traced requests flow between applications. Storage can be in-memory for development, or persistent through Apache Cassandra or Elasticsearch for real workloads. A smaller slim build is available that keeps in-memory and Elasticsearch storage but drops messaging transports. Someone would use this when they run a multi-service system and need to see where requests are spending their time. The quickest setup, per the README, is to download a single self-contained executable jar and run it, or launch the openzipkin/zipkin Docker image. The stack is Java, the server requires JRE 17 or higher, while the core library targets Java 8. The full README is longer than what was provided.

Copy-paste prompts

Prompt 1
Show me how to instrument a Java microservice to send trace spans to a local Zipkin server over HTTP.
Prompt 2
How do I set up Zipkin with Kafka transport and Elasticsearch storage for a production multi-service environment?
Prompt 3
Walk me through querying Zipkin's web UI to find the slowest operation in a trace ID I pulled from my logs.
Prompt 4
How do I run the Zipkin Docker image and hook it up to my Spring Boot services?
Prompt 5
What is the quickest way to get Zipkin running locally to start tracing my services today?
Open on GitHub → Explain another repo

← openzipkin on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.