Zipkin

https://github.com/openzipkin/zipkin
Admin
Zipkin is a distributed tracing system that helps gather timing data to troubleshoot latency...
Tokens:42,871
Snippets:385
Trust Score:9
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run example application with docker-compose-example.yml

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Starts the example application (frontend and backend) by overriding the base docker-compose.yml with docker-compose-example.yml. After startup, open http://localhost:8081/ to see the backend response, and view traces at http://localhost:9411/zipkin?serviceName=backend.

```bash
$ docker compose -f docker-compose.yml -f docker-compose-example.yml up
```

--------------------------------

### Run Zipkin with MySQL Storage

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Example command to start Zipkin using the legacy MySQL storage component with a custom user.

```bash
$ STORAGE_TYPE=mysql MYSQL_USER=root java -jar zipkin.jar
```

--------------------------------

### Start Eureka-backed Zipkin with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Runs `docker compose -f docker-compose.yml -f docker-compose-eureka.yml up` to start Zipkin and Eureka, registering Zipkin's endpoint for service discovery by example services.

```bash
$ docker compose -f docker-compose.yml -f docker-compose-eureka.yml up
```

--------------------------------

### Install and run Zipkin via Homebrew

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Installs Zipkin with Homebrew and shows how to run it in the foreground or as a background service.

```bash
brew install zipkin
# to run in foreground
zipkin
# to run in background
brew services start zipkin
```

--------------------------------

### Start Kafka-backed Zipkin with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Run this command to start the Zipkin and Kafka containers using the docker-compose-kafka.yml file.

```bash
$ docker compose -f docker-compose-kafka.yml up
```

--------------------------------

### Run Zipkin with Kafka in Docker

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts a Kafka container and then runs the Zipkin server, which reads the KAFKA_BOOTSTRAP_SERVERS environment variable. The example uses docker-machine to get the host IP.

```bash
$ export KAFKA_BOOTSTRAP_SERVERS=$(docker-machine ip `docker-machine active`)
# Run Kafka in the background
$ docker run -d -p 9092:9092 \
    --env ADVERTISED_HOST=$KAFKA_BOOTSTRAP_SERVERS \
    --env AUTO_CREATE_TOPICS=true \
    spotify/kafka
# Start the zipkin server, which reads $KAFKA_BOOTSTRAP_SERVERS
$ java -jar zipkin.jar
```

--------------------------------

### Start NGINX UI proxy with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Run this command to start the NGINX UI proxy configuration. It uses docker compose overrides to add an NGINX container and sets ZIPKIN_UI_BASEPATH to '/admin/zipkin', making the UI accessible at http://localhost/admin/zipkin/.

```bash
$ docker compose -f docker-compose.yml -f docker-compose-uiproxy.yml up
```

--------------------------------

### Start MySQL-backed Zipkin with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Runs `docker compose -f docker-compose-mysql.yml up` to start Zipkin, MySQL, and the dependencies cron job in separate containers.

```bash
$ docker compose -f docker-compose-mysql.yml up
```

--------------------------------

### Start Zipkin with Cassandra

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Starts Zipkin, Cassandra, and the zipkin-dependencies cron job using the docker-compose-cassandra.yml file. The dependencies container runs every hour.

```bash
$ docker compose -f docker-compose-cassandra.yml up
```

--------------------------------

### Start Elasticsearch-backed Zipkin with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Run this command to start the Zipkin, Elasticsearch, and dependencies containers using the docker-compose-elasticsearch.yml file.

```bash
$ docker compose -f docker-compose-elasticsearch.yml up
```

--------------------------------

### Start RabbitMQ-backed Zipkin with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Runs `docker compose -f docker-compose-rabbitmq.yml up` to start Zipkin and RabbitMQ in separate containers, collecting traces via RabbitMQ in addition to HTTP.

```bash
$ docker compose -f docker-compose-rabbitmq.yml up
```

--------------------------------

### Download and run Zipkin server with curl and java

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Fetches the latest released Zipkin server jar using the quickstart script and runs it with Java. Requires JRE 17+.

```bash
curl -sSL https://zipkin.io/quickstart.sh | bash -s
java -jar zipkin.jar
```

--------------------------------

### Start Zipkin with zipkin.ui.basepath for reverse proxy

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-lens/README.md

Starts Zipkin with the UI basepath set to /admin/zipkin so the reverse proxy works. Use this command when running the jar directly.

```bash
java -jar zipkin.jar --zipkin.ui.basepath=/admin/zipkin
```

--------------------------------

### Start Pulsar-backed Zipkin with docker compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Runs `docker compose -f docker-compose-pulsar.yml up` to start Zipkin and Pulsar in separate containers, collecting traces via Pulsar in addition to HTTP.

```bash
$ docker compose -f docker-compose-pulsar.yml up
```

--------------------------------

### Quick-start: download and run Zipkin Server

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Downloads the latest released server as a self-contained executable jar and runs it. Requires minimum JRE 8. After starting, browse to http://localhost:9411/zipkin to find traces.

```bash
$ curl -sSL https://zipkin.io/quickstart.sh | bash -s
$ java -jar zipkin.jar
```

--------------------------------

### Run Zipkin with Kafka bootstrap servers

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts the Zipkin server with the Kafka collector enabled by setting KAFKA_BOOTSTRAP_SERVERS. The command uses a line continuation for readability.

```bash
$ KAFKA_BOOTSTRAP_SERVERS=127.0.0.1:9092 \
    java -jar zipkin.jar
```

--------------------------------

### ElasticsearchStorage usage example

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Shows how to build an ElasticsearchStorage instance, prepare a trace query, execute it synchronously, and close the storage. The comment notes that building the storage does not create network connections.

```java
// this won't create network connections
storage = ElasticsearchStorage.newBuilder()
                              .hosts(asList("http://myelastic:9200")).build();

// prepare a call
traceCall = storage.spanStore().getTrace("d3d200866a77cc59");

// execute it synchronously or asynchronously
trace = traceCall.execute();

// clean up any sessions, etc
storage.close();
```

--------------------------------

### Download and run Zipkin Slim with curl and java

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Fetches the slim build of Zipkin server and runs it. The slim build is smaller, starts faster, and supports in-memory and Elasticsearch storage only.

```bash
curl -sSL https://zipkin.io/quickstart.sh | bash -s io.zipkin:zipkin-server:LATEST:slim zipkin.jar
java -jar zipkin.jar
```

--------------------------------

### Start default Zipkin Docker Compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Starts the default Zipkin configuration using the last released version. Use TAG=master to run the last built version. Traces are stored in memory and the web UI is available at $(docker ip):9411.

```bash
# To use the last released version of zipkin
$ docker compose up
# To use the last built version of zipkin
$ TAG=master docker compose up
```

--------------------------------

### Example output of trace query

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/mysql-v1/README.md

Shows example output from the trace query, including 128-bit trace IDs. The trace_id can be copied into zipkin's UI for troubleshooting.

```text
+----------------------------------+------------------+------------------+------+--------------------------+
| trace_id                         | parent_id        | span_id          | name | timestamp                |
+----------------------------------+------------------+------------------+------+--------------------------+
| abbd9f5da49e5848aa4b729ff2bc90a3 | NULL             | aa4b729ff2bc90a3 | get  | 2017-04-19 12:43:00.9830 |
| abbd9f5da49e5848aa4b729ff2bc90a3 | aa4b729ff2bc90a3 | 7888a4aef81f074d | get  | 2017-04-19 12:43:01.1960 |
| 11b98d7107dac980                 | 11b98d7107dac980 | bc33c2d5ad25bf89 | get  | 2017-04-19 12:42:45.4240 |
| 11b98d7107dac980                 | NULL             | 11b98d7107dac980 | get  | 2017-04-19 12:42:45.0680 |
+----------------------------------+------------------+------------------+------+--------------------------+
```

--------------------------------

### Start Zipkin with Eureka Service URL

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Use this command to start Zipkin with Eureka service registration enabled. Set EUREKA_SERVICE_URL to a valid v2 endpoint of the Eureka REST API. The example uses http://localhost:8761/eureka/v2.

```bash
$ EUREKA_SERVICE_URL=http://localhost:8761/eureka/v2 java -jar zipkin.jar
```

--------------------------------

### Start Zipkin with ActiveMQ

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Starts Zipkin and the ActiveMQ container using the docker-compose-activemq.yml file. Configure the ActiveMQ sender with a brokerUrl of failover:tcp://localhost:61616 or a non-local hostname if in Docker.

```bash
$ docker compose -f docker-compose-activemq.yml up
```

--------------------------------

### Run Zipkin with multiple Kafka bootstrap servers

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Sets the KAFKA_BOOTSTRAP_SERVERS environment variable to a comma-separated list of brokers and starts the Zipkin server.

```bash
$ KAFKA_BOOTSTRAP_SERVERS=broker1.local:9092,broker2.local:9092 \
    java -jar zipkin.jar
```

--------------------------------

### Maven test output showing skipped tests

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/cassandra/README.md

Example output from running tests when Cassandra is not running, showing that tests are silently skipped. This behavior is intentional to avoid burdening developers with installing and running all storage options.

```text
Results :

Tests run: 62, Failures: 0, Errors: 0, Skipped: 48
```

--------------------------------

### Apply the schema with mysql commands

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/mysql-v1/README.md

Commands to set the innodb_file_format to Barracuda and install the schema and indexes. The first two commands verify the format, and the last two create the database and load the schema.

```bash
# Barracuda supports compression (In AWS RDS, this must be assigned in a parameter group)
$ mysql -uroot -e "SET GLOBAL innodb_file_format=Barracuda"
# This command should work even in RDS, and return "Barracuda"
$ mysql -uroot -e "show global variables like 'innodb_file_format'"

# install the schema and indexes
$ mysql -uroot -e "create database if not exists zipkin"
$ mysql -uroot -Dzipkin < zipkin-storage/mysql-v1/src/main/resources/mysql.sql
```

--------------------------------

### Run in-memory Zipkin server with Docker

Source: https://github.com/openzipkin/zipkin/blob/master/docker/README.md

Starts a Zipkin server in a Docker container with the slim image, exposing the UI on port 9411. The image is mirrored as ghcr.io/openzipkin/zipkin-slim.

```bash
# Note: this is mirrored as ghcr.io/openzipkin/zipkin-slim
$ docker run -d -p 9411:9411 openzipkin/zipkin-slim
```

--------------------------------

### Send a single span to the zipkin topic using kafka-console-producer

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-collector/kafka/README.md

Example command to send a JSON-encoded list of spans to the 'zipkin' topic using the Kafka console producer. The message must start with '[' (decimal 91) and contain a list of spans in JSON format.

```bash
$ kafka-console-producer.sh --broker-list $ADVERTISED_HOST:9092 --topic zipkin
[{"traceId":"1","name":"bang","id":"2","timestamp":1470150004071068,"duration":1,"localEndpoint":{"serviceName":"flintstones"},"tags":{"lc":"bamm-bamm"}}]
```

--------------------------------

### Run Zipkin UI with docker-compose-ui.yml

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Starts the NGINX-based UI container by overriding the base docker-compose.yml with docker-compose-ui.yml. This container can serve as a skeleton for proxy configuration (authentication, CORS, SSL).

```bash
$ docker compose -f docker-compose.yml -f docker-compose-ui.yml up
```

--------------------------------

### Run Zipkin with Cassandra and Request Logging

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts Zipkin with Cassandra storage and enables request logging at DEBUG level to show query values. Requires STORAGE_TYPE=cassandra3 and a running Cassandra cluster.

```bash
$ STORAGE_TYPE=cassandra3 java -jar zipkin.jar \
--logging.level.com.datastax.oss.driver.internal.core.tracker.RequestLogger=DEBUG
```

--------------------------------

### Send a span to the zipkin queue using curl

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-collector/activemq/README.md

Use this curl command to send a JSON list of spans to the ActiveMQ queue named 'zipkin'. The message body must start with '[' (decimal 91) to be valid JSON. The example sends a single span with traceId '1', name 'bang', and id '2'.

```bash
$ curl -u admin:admin -X POST -s localhost:8161/api/message/zipkin?type=queue \
    -H "Content-Type: application/json" \
    -d '[{"traceId":"1","name":"bang","id":"2","timestamp":1470150004071068,"duration":1,"localEndpoint":{"serviceName":"flintstones"},"tags":{"lc":"bamm-bamm"}}]'
```

--------------------------------

### Enable debug logging for zipkin categories

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Start the Zipkin server with the `--logging.level.zipkin2=DEBUG` flag to enable debug logging for all Zipkin categories. Useful for troubleshooting.

```bash
java -jar zipkin.jar --logging.level.zipkin2=DEBUG
```

--------------------------------

### Configure SSL for Elasticsearch or OpenSearch

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Use JAVA_OPTS to pass JSSE properties for custom SSL configurations like self-signed certificates when starting the Zipkin jar.

```bash
$ JAVA_OPTS='-Djavax.net.ssl.keyStore=keystore.p12 -Djavax.net.ssl.keyStorePassword=keypassword -Djavax.net.ssl.keyStoreType=PKCS12 -Djavax.net.ssl.trustStore=truststore.p12 -Djavax.net.ssl.trustStorePassword=trustpassword -Djavax.net.ssl.trustStoreType=PKCS12'
$ STORAGE_TYPE=elasticsearch java $JAVA_OPTS -jar zipkin.jar
```

--------------------------------

### Host setup for OpenSearch virtual memory

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-opensearch2/README.md

Adjusts vm.max_map_count to 262144 for OpenSearch. Includes commands for host machine, docker-machine, and colima environments.

```bash
# If docker is running on your host machine, adjust the kernel setting directly
$ sudo sysctl -w vm.max_map_count=262144

# If using docker-machine/Docker Toolbox/Boot2Docker, remotely adjust the same
$ docker-machine ssh default "sudo sysctl -w vm.max_map_count=262144"

# If using colima, it is similar as well
$ colima ssh "sudo sysctl -w vm.max_map_count=262144"
```

--------------------------------

### Run Zipkin server via Docker

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Starts the Zipkin server in a Docker container, mapping port 9411. The image is also mirrored as ghcr.io/openzipkin/zipkin.

```bash
# Note: this is mirrored as ghcr.io/openzipkin/zipkin
docker run -d -p 9411:9411 openzipkin/zipkin
```

--------------------------------

### Run Zipkin with In-Memory Storage

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts the Zipkin server with the default in-memory storage. This storage purges older data when the span limit is exceeded and is intended for testing or quick startup, not high workloads.

```bash
$ java -jar zipkin.jar
```

--------------------------------

### Run Zipkin with Pulsar service URL

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts the Zipkin server with the Pulsar collector enabled by setting the PULSAR_SERVICE_URL environment variable. The command uses a line continuation for readability.

```bash
$ PULSAR_SERVICE_URL=pulsar://localhost:6650 \
    java -jar zipkin.jar
```

--------------------------------

### Create and encode a span with SpanBytesEncoder.JSON_V2

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Shows how to record a span against a local endpoint and encode it as JSON using SpanBytesEncoder.JSON_V2. The example uses a service name 'tweetie' and IP '192.168.0.1'. Note that this is just an example; typically you'd use an existing tracing library like Brave.

```java
// All data are recorded against the same endpoint, associated with your service graph
localEndpoint = Endpoint.newBuilder().serviceName("tweetie").ip("192.168.0.1").build()
span = Span.newBuilder()
    .traceId("d3d200866a77cc59")
    .id("d3d200866a77cc59")
    .name("targz")
    .localEndpoint(localEndpoint)
    .timestamp(epochMicros())
    .duration(durationInMicros)
    .putTag("compression.level", "9");

// Now, you can encode it as json
bytes = SpanBytesEncoder.JSON_V2.encode(span);
```

--------------------------------

### Sample spans JSON

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-collector/rabbitmq/README.md

An example JSON array containing a single span that can be published to the RabbitMQ queue for collection.

```json
[{"traceId":"9032b04972e475c5","id":"9032b04972e475c5","kind":"SERVER","name":"get","timestamp":1505990621526000,"duration":612898,"localEndpoint":{"serviceName":"brave-webmvc-example","ipv4":"192.168.1.113"},"remoteEndpoint":{"serviceName":"","ipv4":"127.0.0.1","port":60149},"tags":{"error":"500 Internal Server Error","http.path":"/a"}}]
```

--------------------------------

### Run Zipkin with ActiveMQ URL

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts the Zipkin server with an ActiveMQ broker URL, enabling the ActiveMQ collector. The command sets the ACTIVEMQ_URL environment variable to connect to a broker at tcp://localhost:61616.

```bash
$ ACTIVEMQ_URL=tcp://localhost:61616 java -jar zipkin.jar
```

--------------------------------

### Start Zipkin server with RabbitMQ addresses

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-collector/rabbitmq/README.md

Runs the Zipkin server with the RabbitMQ addresses environment variable set to localhost, allowing the collector to connect to a locally running RabbitMQ instance on the default port.

```bash
$ RABBIT_ADDRESSES=localhost java -jar zipkin.jar
```

--------------------------------

### Run Zipkin with Increased MEM_MAX_SPANS

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Starts Zipkin with in-memory storage, doubling the default span limit to 1,000,000 and increasing the heap size to 1GB. Use this to reduce out-of-memory errors when storing more traces.

```bash
$ MEM_MAX_SPANS=1000000 java -Xmx1G -jar zipkin.jar
```

--------------------------------

### Test results when Docker is unavailable

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/mysql-v1/README.md

Shows the output when tests are skipped due to missing Docker. This behavior is intentional to avoid requiring storage installations for unrelated changes.

```text
Results :

Tests run: 49, Failures: 0, Errors: 0, Skipped: 48
```

--------------------------------

### Example Prometheus /prometheus configuration

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

YAML configuration for Prometheus to scrape Zipkin's `/prometheus` endpoint. It includes metric relabeling to extract status and path from metric names and rename to `http_requests_total`.

```yaml
- job_name: 'zipkin'
    scrape_interval: 5s
    metrics_path: '/prometheus'
    static_configs:
      - targets: ['localhost:9411']
    metric_relabel_configs:
      # Response code count
      - source_labels: [__name__]
        regex: '^status_(\d+)_(.*)$'
        replacement: '${1}'
        target_label: status
      - source_labels: [__name__]
        regex: '^status_(\d+)_(.*)$'
        replacement: '${2}'
        target_label: path
      - source_labels: [__name__]
        regex: '^status_(\d+)_(.*)$'
        replacement: 'http_requests_total'
        target_label: __name__
```

--------------------------------

### Create ingest pipeline for Zipkin

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/elasticsearch/README.md

Example of setting up an ingest pipeline that adds a collector_timestamp_millis field using the ingest timestamp. This pipeline should be created before configuring Zipkin to use it via ElasticsearchStorage.Builder.pipeline.

```json
PUT _ingest/pipeline/zipkin
{
  "description" : "add collector_timestamp_millis",
  "processors" : [
    {
      "set" : {
        "field": "collector_timestamp_millis",
        "value": "{{_ingest.timestamp}}"
      }
    }
  ]
}
```

--------------------------------

### CORS configuration: ZIPKIN_QUERY_ALLOWED_ORIGINS

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Sets the allowed origins for cross-origin requests to the /api/v2 endpoints. By default, all endpoints under /api/v2 allow cross-origin requests. This example allows requests from http://foo.bar.com.

```bash
ZIPKIN_QUERY_ALLOWED_ORIGINS=http://foo.bar.com
```

--------------------------------

### Post trace and open Zipkin UI

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-lens/testdata/README.md

Use curl to POST a JSON trace file to the Zipkin API, then open the UI with a lookback range to view the trace. Assumes Zipkin is started with QUERY_LOOKBACK=157784630000 to allow 5-year-old data.

```bash
$ curl -X POST -s localhost:9411/api/v2/spans -H'Content-Type: application/json' -d @yelp.json
$ open "http://localhost:9411/zipkin/?lookback=range&endTs=$(date +%s)000&startTs=0&limit=1"
```

--------------------------------

### Build and run Zipkin server from source

Source: https://github.com/openzipkin/zipkin/blob/master/README.md

Use these commands to build the Zipkin server from source and run it. JDK 17+ is required to compile the source. The first command builds the server and its dependencies, skipping tests; the second runs the server using the executable JAR.

```bash
# Build the server and also make its dependencies
$ ./mvnw -q --batch-mode -DskipTests --also-make -pl zipkin-server clean install
# Run the server
$ java -jar ./zipkin-server/target/zipkin-server-*exec.jar
```

--------------------------------

### Enable TLS/SSL on Zipkin Server with keytool and Java args

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Generates a PKCS12 keystore with keytool, then runs zipkin.jar with Armeria SSL flags to enable HTTPS on port 9411. The keystore password is passed as a command-line argument.

```bash
keytool -genkeypair -alias mysite -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore zipkin.p12 -validity 3650
```

```bash
java -jar zipkin.jar --armeria.ssl.key-store=zipkin.p12 --armeria.ssl.key-store-type=PKCS12 --armeria.ssl.key-store-password=123123 --armeria.ssl.key-alias=mysite  --armeria.ssl.enabled=true --armeria.ports[0].port=9411 --armeria.ports[0].protocols[0]=https
```

--------------------------------

### Build openzipkin/zipkin-slim:test image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/README.md

Builds the slim distribution (openzipkin/zipkin-slim:test) by setting DOCKER_TARGET=zipkin-slim.

```bash
$ DOCKER_TARGET=zipkin-slim build-bin/docker/docker_build openzipkin/zipkin-slim:test
```

--------------------------------

### Build and run Zipkin Server locally with Maven

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Builds the zipkin-server module and its dependencies, then runs the executable JAR or the slim JAR from the target directory.

```bash
./mvnw -T1C -q --batch-mode -DskipTests --also-make -pl zipkin-server clean package
```

```bash
java -jar ./zipkin-server/target/zipkin-server-*exec.jar
```

```bash
java -jar ./zipkin-server/target/zipkin-server-*slim.jar
```

--------------------------------

### Build zipkin-ui Docker image with DOCKER_FILE and build-bin/docker/docker_build

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-ui/README.md

Use this command from the repository top-level to build the openzipkin/zipkin-ui:test image. It sets the DOCKER_FILE environment variable to the zipkin-ui Dockerfile and invokes the build script.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-ui/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-ui:test
```

--------------------------------

### Build zipkin-kafka Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-kafka/README.md

Builds the openzipkin/zipkin-kafka:test image from the top-level repository directory using the specified Dockerfile. Run this command from the repository root.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-kafka/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-kafka:test
```

--------------------------------

### Build zipkin-cassandra Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-cassandra/README.md

Builds the openzipkin/zipkin-cassandra:test image using the provided Dockerfile. Run from the top-level of the repository.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-cassandra/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-cassandra:test
```

--------------------------------

### Snapshot deploy with specified credentials

Source: https://github.com/openzipkin/zipkin/blob/master/RELEASE.md

Deploys a snapshot manually using CI-like credentials. Exports GPG_TTY, GPG_PASSPHRASE, SONATYPE_USER, and SONATYPE_PASSWORD, then runs the maven_deploy script. Useful for validating Sonatype credentials.

```bash
$ export GPG_TTY=$(tty) && GPG_PASSPHRASE=whackamole SONATYPE_USER=adrianmole SONATYPE_PASSWORD=ed6f20bde9123bbb2312b221 build-bin/build-bin/maven/maven_deploy
```

--------------------------------

### Build zipkin-uiproxy Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-uiproxy/README.md

Command to build the openzipkin/zipkin-uiproxy:test image from the top-level repository directory. Uses the Dockerfile at docker/test-images/zipkin-uiproxy/Dockerfile.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-uiproxy/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-uiproxy:test
```

--------------------------------

### Build openzipkin/zipkin:test image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/README.md

Builds the openzipkin/zipkin:test image from the top-level of the repository.

```bash
$ build-bin/docker/docker_build openzipkin/zipkin:test
```

--------------------------------

### Build zipkin-mysql Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-mysql/README.md

Builds the openzipkin/zipkin-mysql:test image from the top-level of the repository using the Dockerfile at docker/test-images/zipkin-mysql/Dockerfile.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-mysql/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-mysql:test
```

--------------------------------

### Build and run the zipkin-eureka Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-eureka/README.md

These commands build the `openzipkin/zipkin-eureka:test` image from the repository's Dockerfile and then run it, exposing port 8761. The build command requires setting `DOCKER_FILE` to the specific Dockerfile path. The run command uses `--rm` to remove the container after exit.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-eureka/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-eureka:test
$ docker run -p 8761:8761 --rm openzipkin/zipkin-eureka:test
```

--------------------------------

### Build and run JMH benchmarks

Source: https://github.com/openzipkin/zipkin/blob/master/benchmarks/README.md

Build the benchmarks with Maven, then run them with the JMH benchmark jar. The build command skips test execution.

```bash
$ ./mvnw install -pl benchmarks -am -Dmaven.test.skip.exec=true
```

```bash
$ java -jar benchmarks/target/benchmarks.jar
```

--------------------------------

### Build zipkin-pulsar Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-pulsar/README.md

Run this command from the top-level of the repository to build the openzipkin/zipkin-pulsar:test image. The DOCKER_FILE environment variable points to the Dockerfile for the zipkin-pulsar test image.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-pulsar/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-pulsar:test
```

--------------------------------

### Publish sample spans using amqp-publish

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-collector/rabbitmq/README.md

Publishes the sample spans JSON to the 'zipkin' queue using the amqp-publish CLI from an AMQP package like rabbitmq-c-utils or simple-amqp-client.

```bash
$ amqp-publish -r zipkin < sample-spans.json
```

--------------------------------

### Run integration tests with Maven

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/mysql-v1/README.md

Runs the integration tests for the zipkin-storage-mysql-v1 module. Tests are skipped if Docker is not available.

```bash
$ ./mvnw clean verify -pl :zipkin-storage-mysql-v1
```

--------------------------------

### Build zipkin-activemq test image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-activemq/README.md

Builds the openzipkin/zipkin-activemq:test image from the top-level repository directory using the provided Dockerfile. The JAVA_OPTS environment variable can be set to change settings such as heap size for ActiveMQ.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-activemq/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-activemq:test
```

--------------------------------

### Build the zipkin-elasticsearch9 test image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-elasticsearch9/README.md

Run this command from the top-level repository directory to build the openzipkin/zipkin-elasticsearch9:test image using the provided Dockerfile.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-elasticsearch9/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-elasticsearch9:test
```

--------------------------------

### Build command for openzipkin/zipkin-rabbitmq:test

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-rabbitmq/README.md

Run this command from the top-level repository directory to build the testing image. It uses the DOCKER_FILE environment variable to point to the Dockerfile and invokes the build script.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-rabbitmq/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-rabbitmq:test
```

--------------------------------

### Run openzipkin/zipkin with shell

Source: https://github.com/openzipkin/zipkin/blob/master/docker/README.md

Runs the openzipkin/zipkin image with a shell entrypoint to browse its contents. The image runs under a nologin user named 'zipkin' with home directory '/zipkin'.

```bash
$ docker run -it --rm --entrypoint /bin/sh openzipkin/zipkin
/zipkin $ ls
BOOT-INF  META-INF  org       run.sh
```

--------------------------------

### Publish sample spans using rabbitmqadmin

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-collector/rabbitmq/README.md

If the RabbitMQ management extension is enabled, publishes the sample spans JSON to the 'zipkin' queue via the default exchange using rabbitmqadmin.

```bash
$ rabbitmqadmin publish exchange=amq.default routing_key=zipkin < sample-spans.json
```

--------------------------------

### Run Zipkin with Kafka bootstrap servers as system property

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Specifies the Kafka bootstrap servers using the system property 'zipkin.collector.kafka.bootstrap-servers' instead of an environment variable.

```bash
$ java -Dzipkin.collector.kafka.bootstrap-servers=127.0.0.1:9092 \
    -jar zipkin.jar
```

--------------------------------

### Build zipkin-opensearch2 Docker image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-opensearch2/README.md

Builds the zipkin-opensearch2 testing image with the tag openzipkin/zipkin-opensearch2:test. Run from the top-level of the repository.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-opensearch2/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-opensearch2:test
```

--------------------------------

### Connect to Elasticsearch with STORAGE_TYPE and ES_HOSTS

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Runs Zipkin with Elasticsearch storage, connecting to the specified host. STORAGE_TYPE must be set to 'elasticsearch' and ES_HOSTS defaults to http://localhost:9200.

```bash
$ STORAGE_TYPE=elasticsearch ES_HOSTS=http://myhost:9200 java -jar zipkin.jar
```

--------------------------------

### Run zipkin-ui standalone with ZIPKIN_BASE_URL

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Runs the zipkin-ui container standalone, mapping port 80 and setting ZIPKIN_BASE_URL to point to a remote Zipkin server. Useful for hosting the UI separately from the Zipkin backend.

```bash
$ docker run -d -p 80:80 \
  -e ZIPKIN_BASE_URL=http://myfavoritezipkin:9411 \
  openzipkin/zipkin-ui
```

--------------------------------

### Build zipkin-elasticsearch8 test image

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-elasticsearch8/README.md

Builds the openzipkin/zipkin-elasticsearch8:test image from the top-level repository directory. Uses the DOCKER_FILE environment variable to specify the Dockerfile.

```bash
$ DOCKER_FILE=docker/test-images/zipkin-elasticsearch8/Dockerfile build-bin/docker/docker_build openzipkin/zipkin-elasticsearch8:test
```

--------------------------------

### Connect to MySQL with docker-machine

Source: https://github.com/openzipkin/zipkin/blob/master/docker/test-images/zipkin-mysql/README.md

Connects to the MySQL instance running in the zipkin-mysql container when using docker-machine, using the mysql client with the zipkin user and password.

```bash
$ mysql -h $(docker-machine ip) -u zipkin -pzipkin -D zipkin
```

--------------------------------

### Run Zipkin with alternate Kafka topic names

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Sets the Kafka bootstrap servers and overrides the default topic name with 'zapkin,zipken' using the system property 'zipkin.collector.kafka.topic'.

```bash
$ KAFKA_BOOTSTRAP_SERVERS=127.0.0.1:9092 \
    java -Dzipkin.collector.kafka.topic=zapkin,zipken -jar zipkin.jar
```

--------------------------------

### Run a single integration test with Maven

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/cassandra/README.md

Command to run a single integration test using the -Dit.test property, targeting the getTraces_duration test in ITCassandraStorage$ITSpanStore.

```bash
$ ./mvnw -Dit.test='ITCassandraStorage$ITSpanStore#getTraces_duration' -pl zipkin-storage/cassandra clean verify
```

--------------------------------

### Run zipkin-dependencies manually

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Runs the zipkin-dependencies container manually to generate the dependency graph before the hourly scheduled run. Uses the --no-deps and --entrypoint flags to override the default command.

```bash
$ docker compose -f docker-compose-cassandra.yml run --rm --no-deps --entrypoint start-zipkin-dependencies dependencies
```

--------------------------------

### Enable Elasticsearch API HTTP logging with ES_HTTP_LOGGING

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Runs Zipkin with Elasticsearch storage and logs API requests at BASIC level. ES_HTTP_LOGGING accepts BASIC, HEADERS, or BODY.

```bash
$ STORAGE_TYPE=elasticsearch ES_HTTP_LOGGING=BASIC java -jar zipkin.jar
```

--------------------------------

### Use production node version with nvm

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-lens/README.md

Run this command to switch to the same Node version used by the Maven build. This reduces the chance of pull request failures when npm test succeeds locally.

```bash
nvm use $(../mvnw help:evaluate -Dexpression=node.version -q -DforceStdout)
```

--------------------------------

### GitHub Actions deploy.yml for Zipkin deployment

Source: https://github.com/openzipkin/zipkin/blob/master/build-bin/README.md

A partial GitHub Actions workflow that deploys on pushes to master, ignoring tags to avoid redundant deployments. It uses the build-bin/configure_deploy and build-bin/deploy scripts, with environment variables GH_USER and GH_TOKEN from secrets.

```yaml
on:  # yamllint disable-line rule:truthy
  push:
    branches:
      - master
    # Don't deploy tags because the same commit for MAJOR.MINOR.PATCH is also
    # on master: Redundant deployment of a release version will fail uploading.
    tags-ignore:
      - '*'

jobs:
  deploy:
    runs-on: ubuntu-24.04  # newest available distribution, aka noble
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 1  # only needed to get the sha label
      - name: Deploy
        env:
          GH_USER: ${{ secrets.GH_USER }}
          GH_TOKEN: ${{ secrets.GH_TOKEN }}
        run: |  # GITHUB_REF = refs/heads/master or refs/tags/MAJOR.MINOR.PATCH
          build-bin/configure_deploy &&
          build-bin/deploy $(echo ${GITHUB_REF} | cut -d/ -f 3)
```

--------------------------------

### Manual release commands

Source: https://github.com/openzipkin/zipkin/blob/master/RELEASE.md

Commands to manually release OpenZipkin if CI is unavailable. Sets environment variables, creates the release tag, deploys it, and cleans up. Requires Sonatype to be up.

```bash
# First, set variable according to your personal credentials. These would normally be assigned as
# org secrets: https://github.com/organizations/openzipkin/settings/secrets/actions
export GPG_TTY=$(tty)
export GPG_PASSPHRASE=your_gpg_passphrase
export SONATYPE_USER=your_sonatype_account
export SONATYPE_PASSWORD=your_sonatype_password
release_version=xx-version-to-release-xx

# now from latest master, create the release. This creates and pushes the MAJOR.MINOR.PATCH tag
./build-bin/maven/maven_release release-${release_version}

# once this works, deploy the release
git checkout ${release_version}
./build-bin/deploy

# Finally, clean up
./mvnw release:clean
git checkout master
git reset HEAD --hard
```

--------------------------------

### Run Zipkin dependencies manually

Source: https://github.com/openzipkin/zipkin/blob/master/docker/examples/README.md

Run this command to manually trigger the zipkin-dependencies container to generate the dependency graph before the scheduled hourly run.

```bash
$ docker compose -f docker-compose-elasticsearch.yml run --rm --no-deps --entrypoint start-zipkin-dependencies dependencies
```

--------------------------------

### ZipkinExtension basic usage in JUnit5 test

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-junit5/README.md

Use this snippet to set up a Zipkin server for a micro-integration test. It creates the extension with @RegisterExtension, uses a TracedService pointing to the Zipkin HTTP URL with reporting mode FLUSH_EVERY, and verifies that a request with sampling disabled results in no additional spans being collected.

```java
@RegisterExtension
public ZipkinExtension zipkin = new ZipkinExtension();

// Pretend we have a traced system under test
TracedService service = new TracedService(zipkin.httpUrl(), ReportingMode.FLUSH_EVERY);

@Test
public void skipsReportingWhenNotSampled() throws IOException {
  zipkin.storeSpans(asList(rootSpan));

  // send a request to the instrumented server, telling it not to sample.
  client.addHeader("X-B3-TraceId", rootSpan.traceId)
        .addHeader("X-B3-SpanId", rootSpan.id)
        .addHeader("X-B3-Sampled", 0).get(service.httpUrl());

  // check that zipkin didn't receive any new data in that trace
  assertThat(zipkin.getTraces()).containsOnly(asList(rootSpan));
}
```

--------------------------------

### YAML map-based module configuration (supported)

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/RATIONALE.md

Shows the map-based YAML configuration that supports merging profiles. When both profiles are present, both modules are loaded into a Map<String, String> property.

```yaml
zipkin:
  internal:
    module:
      sqs: zipkin.module.collector.sqs.ZipkinSQSCollectorModule
```

```yaml
zipkin:
  internal:
    module:
      kinesis: zipkin.module.collector.kinesis.ZipkinKinesisCollectorModule
```

--------------------------------

### GitHub Actions test.yml for running tests

Source: https://github.com/openzipkin/zipkin/blob/master/build-bin/README.md

A partial GitHub Actions workflow that runs tests after configuring the build environment. It triggers on non-tagged pushes to master and pull requests targeting master, ignoring documentation-only changes and specific lint/config files. The job checks out the repository and runs 'build-bin/configure_test' followed by 'build-bin/test'.

```yaml
on:  # yamllint disable-line rule:truthy
  push:  # non-tagged pushes to master
    branches:
      - master
    tags-ignore:
      - '*'
    paths-ignore:
      - '**/*.md'
      - './build-bin/*lint'
      - ./build-bin/mlc_config.json
  pull_request:  # pull requests targeted at the master branch.
    branches:
      - master
    paths-ignore:
      - '**/*.md'
      - './build-bin/*lint'
      - ./build-bin/mlc_config.json

jobs:
  test:
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
      - name: Test
        run: |
          build-bin/configure_test
          build-bin/test
```

--------------------------------

### Run Zipkin Docker container with ZIPKIN_UI_BASEPATH

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-lens/README.md

Runs the Zipkin Docker container with the ZIPKIN_UI_BASEPATH environment variable set to /admin/zipkin, exposing port 9411. Use this when running via Docker.

```bash
docker run -e ZIPKIN_UI_BASEPATH=/admin/zipkin -p 9411:9411 openzipkin/zipkin
```

--------------------------------

### YAML module discovery entry

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/RATIONALE.md

Shows the YAML structure for registering a module under the 'zipkin.internal.module' path. This map-based approach is used instead of auto-configuration to avoid performance impact and allow combining values.

```yaml
zipkin:
  internal:
    module:
      sqs: zipkin.module.collector.sqs.ZipkinSQSCollectorModule
```

--------------------------------

### Set debug logging in docker-compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/README.md

Adds debug logging for the zipkin2 package by setting the command in a docker-compose file.

```yaml
    command: --logging.level.zipkin2=DEBUG
```

--------------------------------

### Query trace data from MySQL

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-storage/mysql-v1/README.md

SQL query to retrieve trace spans from the last 5 minutes, formatting IDs as hex and timestamps as dates. Useful for debugging zipkin data.

```sql
SELECT lower(concat(CASE trace_id_high
                        WHEN '0' THEN ''
                        ELSE hex(trace_id_high)
                    END,hex(trace_id))) AS trace_id,
       lower(hex(parent_id)) as parent_id,
       lower(hex(id)) as span_id,
       name,
       from_unixtime(start_ts/1000000) as timestamp
FROM zipkin_spans
where (start_ts/1000000) > UNIX_TIMESTAMP(now()) - 5 * 60;
```

--------------------------------

### Apache HTTP Server reverse proxy configuration for Zipkin Lens

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-lens/README.md

Configures Apache as a reverse proxy for a Zipkin instance running on the same host, mapping the /admin/zipkin path to http://localhost:9411/zipkin. Requires mod_proxy and mod_proxy_http modules.

```apache
LoadModule proxy_module lib/httpd/modules/mod_proxy.so
LoadModule proxy_http_module lib/httpd/modules/mod_proxy_http.so

ProxyPass "/admin/zipkin"  "http://localhost:9411/zipkin"
ProxyPassReverse "/admin/zipkin"  "http://localhost:9411/zipkin"
```

--------------------------------

### Simulate HTTP 400 failure with ZipkinExtension

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-junit5/README.md

Use this snippet to simulate a server-side error and verify your instrumentation does not retry on HTTP 400. It enqueues a failure response with status 400, records and flushes a span, then asserts that only one HTTP request was made.

```java
@Test
public void doesntAttemptToRetryOn400() throws IOException {
  zipkin.enqueueFailure(sendErrorResponse(400, "Invalid Format"));

  reporter.record(span);
  reporter.flush();

  // check that we didn't retry on 400
  assertThat(zipkin.httpRequestCount()).isEqualTo(1);
}
```

--------------------------------

### Set JAVA_OPTS in docker-compose

Source: https://github.com/openzipkin/zipkin/blob/master/docker/README.md

Configures the Java heap size and exit on out-of-memory error via the JAVA_OPTS environment variable in a docker-compose file.

```yaml
    environment:
      - JAVA_OPTS=-Xms128m -Xmx128m -XX:+ExitOnOutOfMemoryError
```

--------------------------------

### GitHub Actions lint.yml for running linters

Source: https://github.com/openzipkin/zipkin/blob/master/build-bin/README.md

Partial GitHub Actions workflow that runs linters after configuring them, but only on relevant event conditions. The 'on:' section limits execution to non-tagged pushes to master and pull requests targeting master, with path filters for Markdown and workflow files. The job 'lint' runs on ubuntu-24.04 and skips commits made by the release plugin.

```yaml
---
on:  # yamllint disable-line rule:truthy
  push:  # non-tagged pushes to master
    branches:
      - master
    tags-ignore:
      - '*'
    paths:
      - '**/*.md'
      - '.github/workflows/*.yml'
      - './build-bin/*lint'
      - ./build-bin/mlc_config.json
  pull_request:  # pull requests targeted at the master branch.
    branches:
      - master
    paths:
      - '**/*.md'
      - '.github/workflows/*.yml'
      - './build-bin/*lint'
      - ./build-bin/mlc_config.json

jobs:
  lint:
    name: Lint
    runs-on: ubuntu-24.04  # newest available distribution, aka noble
    # skip commits made by the release plugin
    if: "!contains(github.event.head_commit.message, 'maven-release-plugin')"
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
      - name: Lint
        run: |
          build-bin/configure_lint
          build-bin/lint

```

--------------------------------

### Set Pulsar client property via system property

Source: https://github.com/openzipkin/zipkin/blob/master/zipkin-server/README.md

Sets the Pulsar client property 'numIoThreads' by prefixing it with 'zipkin.collector.pulsar.client-props' and passing it as a system property. The PULSAR_SERVICE_URL is also set.

```bash
$ PULSAR_SERVICE_URL=pulsar://localhost:6650 \
    java -Dzipkin.collector.pulsar.client-props.numIoThreads=20 -jar zipkin.jar
```
Tokens:
Raw