### Quick-start Zipkin Server using Bash

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

This snippet provides the fastest way to get Zipkin Server running. It uses `curl` to fetch the quickstart script and then `java -jar` to execute the downloaded `zipkin.jar`. Once started, the server is accessible via `http://localhost:9411/zipkin`.

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

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

### Start Zipkin with Eureka Service Registration Example

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

Example command to start the Zipkin server with Eureka service registration enabled, specifying the Eureka service URL.

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

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

### Start Zipkin with Example Frontend/Backend Application

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

This command extends the Docker Compose configuration to include 'frontend' and 'backend' example services, demonstrating trace collection through an application.

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

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

### Example Usage for Kafka Collector

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

Provides a command-line example for starting the Zipkin JAR with the `KAFKA_BOOTSTRAP_SERVERS` environment variable configured to connect to Kafka.

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

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

### Run Zipkin with RabbitMQ for Trace Collection

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

Deploys Zipkin alongside a RabbitMQ instance for collecting traces. This setup starts `zipkin` and `zipkin-rabbitmq` containers. Requires configuring the RabbitMQ sender with the appropriate host.

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

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

### Start Zipkin with Pulsar Integration

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

This command starts Zipkin and Zipkin-Pulsar containers using the `docker-compose-pulsar.yml` file, enabling trace collection from Pulsar.

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

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

### Start Zipkin with Eureka Service Discovery

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

This command starts Zipkin and Zipkin-Eureka containers, allowing Zipkin to register its endpoint with Eureka for service discovery by example services.

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

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

### Run Zipkin with Kafka for Trace Collection

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

Deploys Zipkin alongside a Kafka instance for collecting traces. This setup starts `zipkin` and `zipkin-kafka` containers. Requires configuring the Kafka sender with the appropriate bootstrap servers, considering Docker network specifics.

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

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

### Run Zipkin with ActiveMQ for Trace Collection

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

Deploys Zipkin alongside an ActiveMQ instance for collecting traces. This setup starts `zipkin` and `zipkin-activemq` containers. Requires configuring the ActiveMQ sender with the appropriate broker URL.

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

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

### Start Zipkin UI Proxy with Base Path Configuration

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

This command starts an NGINX container to proxy the Zipkin UI, demonstrating the `ZIPKIN_UI_BASEPATH` variable by making the UI accessible at `/admin/zipkin`.

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

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

### Start Zipkin with Default Docker Compose

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

Initiates the Zipkin server using Docker Compose, storing traces in memory. Options are provided to use the last released or master branch version of Zipkin.

```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
```

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

### Start Zipkin with Prometheus and Grafana Monitoring

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

This command starts Prometheus configured to scrape Zipkin metrics and Grafana with a pre-configured Zipkin dashboard, enabling monitoring and visualization.

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

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

### Run Zipkin with Elasticsearch for Trace Storage

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

Configures Zipkin to store traces in Elasticsearch, including a scheduled job for dependency graph generation. This setup starts Zipkin, Elasticsearch, and Zipkin Dependencies containers.

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

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

### Running Zipkin with Cassandra Storage and Request Logging

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

Shows an example command to start Zipkin using Cassandra storage and enable debug-level logging for the Cassandra driver, which can be useful for troubleshooting queries.

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

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

### Quick-start Zipkin Server via cURL and Java JAR

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

Demonstrates the fastest way to get started with Zipkin by downloading and running the latest self-contained executable JAR. Requires JRE 17+.

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

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

### Start Zipkin UI with NGINX Proxy

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

This command starts an NGINX container to host the Zipkin UI on port 80, providing a skeleton for proxy configurations like authentication or SSL termination.

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

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

### Run Zipkin with Kafka in Docker

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

Provides a detailed example of setting up Kafka in a Docker container and then starting the Zipkin server to consume spans from it, using environment variables for configuration.

```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
```

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

### Run Zipkin with Cassandra for Trace Storage

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

Sets up Zipkin to persist traces in Cassandra, including a scheduled job for dependency graph generation. This configuration starts Zipkin, Cassandra, and Zipkin Dependencies containers.

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

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

### Connect Zipkin to Elasticsearch Example

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

This example demonstrates how to start Zipkin with Elasticsearch as the storage backend, specifying the Elasticsearch host. It uses the `STORAGE_TYPE` and `ES_HOSTS` environment variables.

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

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

### Run Zipkin with MySQL for Trace Storage

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

Sets up Zipkin to persist traces in MySQL, including a scheduled job for dependency graph generation. This configuration starts Zipkin, MySQL, and Zipkin Dependencies containers.

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

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

### Start Zipkin JAR with UI Base Path

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

This command demonstrates how to start the Zipkin JAR file, specifying a custom UI base path using the --zipkin.ui.basepath parameter. This is essential for Zipkin Lens to correctly resolve assets when running behind a reverse proxy.

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

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

### Install and Run Zipkin Server with Homebrew

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

Instructions for installing and running the Zipkin server using Homebrew, a package manager for macOS and Linux. Includes options for foreground and background execution.

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

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

### Example Usage for ActiveMQ Collector

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

Demonstrates how to run the Zipkin JAR with the `ACTIVEMQ_URL` environment variable set to connect to an ActiveMQ broker.

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

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

### Build Zipkin Benchmarks with Maven

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

This command builds the Zipkin benchmark module using Maven. It skips test execution and installs the module.

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

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

### Initialize and Use Zipkin StorageComponent in Java

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

Demonstrates how to initialize an ElasticsearchStorage component, prepare a trace query, execute it synchronously, and properly close the storage. This example illustrates basic interaction with a Zipkin storage component.

```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();
```

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

### Running Zipkin with Default In-Memory Storage

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

Provides the basic command to start the Zipkin server, which defaults to using in-memory storage if no other storage type is specified.

```Bash
$ java -jar zipkin.jar
```

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

### Run Zipkin UI Standalone Against Remote Server

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

This command runs the Zipkin UI in a standalone Docker container, configured to connect to a remote Zipkin server by setting the `ZIPKIN_BASE_URL` environment variable.

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

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

### Manually Run Zipkin Cassandra Dependencies Job

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

Executes the Zipkin dependency graph generation job for Cassandra manually. This is useful for immediate dependency graph updates before the scheduled task runs.

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

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

### Start Zipkin Server with RabbitMQ Address

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

Command to start the Zipkin server, configuring it to connect to a local RabbitMQ instance. The `RABBIT_ADDRESSES` environment variable is set to `localhost` to specify the RabbitMQ host.

```Bash
RABBIT_ADDRESSES=localhost java -jar zipkin.jar
```

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

### Example JSON Span Array

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

A sample JSON array representing a list of Zipkin spans. This example can be saved to a file like `sample-spans.json` and used for local testing by publishing it to RabbitMQ.

```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"}}]
```

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

### Enable HTTP Logging for Elasticsearch API Requests Example

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

This example shows how to enable basic HTTP logging for Elasticsearch/OpenSearch API requests when running Zipkin. It utilizes the `ES_HTTP_LOGGING` environment variable to control the verbosity of logs.

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

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

### Adjust Zipkin Server Logging Level via Command Line

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

Zipkin Server logs to the console at INFO level by default. This example shows how to enable more verbose debug logging for all `zipkin2` categories by passing the `--logging.level.zipkin2=DEBUG` argument when starting the `zipkin.jar`.

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

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

### Running Zipkin with Increased In-Memory Spans

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

Demonstrates how to start Zipkin with a higher `MEM_MAX_SPANS` limit and an increased JVM heap size to accommodate more spans in memory, useful for testing larger datasets.

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

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

### Manually Run Zipkin Elasticsearch Dependencies Job

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

Executes the Zipkin dependency graph generation job for Elasticsearch manually. This is useful for immediate dependency graph updates before the scheduled task runs.

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

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

### Enable Pulsar Collector with Service URL

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

Shows a basic example of enabling the Pulsar collector by setting the PULSAR_SERVICE_URL environment variable when running the Zipkin JAR.

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

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

### Enable RabbitMQ Collector with Addresses

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

Shows a basic example of enabling the RabbitMQ collector by setting the RABBIT_ADDRESSES environment variable when running the Zipkin JAR.

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

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

### Example: Sending JSON Spans to Zipkin Kafka Topic

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

Demonstrates how to use the `kafka-console-producer.sh` utility to send a list of JSON-encoded spans to the 'zipkin' Kafka topic. The example shows a single span with `traceId`, `name`, `id`, `timestamp`, `duration`, `localEndpoint`, and `tags`.

```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"}}]
```

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

### Mapping Properties to Environment Variables

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

Explains the convention for mapping Zipkin properties to environment variables by converting them to upper-underscore case. This allows for external configuration, for example, setting UI query limits via Docker environment variables.

```APIDOC
ZIPKIN_UI_QUERY_LIMIT: Maps to $.queryLimit in /config.json. Example: ZIPKIN_UI_QUERY_LIMIT=100
```

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

### Run Zipkin Lens in Development Mode

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

Starts the Zipkin Lens application in development mode, making it accessible via http://localhost:3000. API requests are proxied to http://localhost:9411 by default, which can be changed using the API_BASE environment variable. The page reloads on edits, and lint errors are displayed in the console.

```npm
npm start
API_BASE=http://tracing.company.com npm start
```

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

### Run Zipkin Docker Container with UI Base Path

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

This Docker command starts the openzipkin/zipkin container, mapping port 9411 and setting the ZIPKIN_UI_BASEPATH environment variable. This allows the Dockerized Zipkin instance to operate correctly when accessed via a reverse proxy with a custom context root.

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

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

### Run In-Memory Zipkin Server with Docker

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

This command demonstrates how to quickly start an in-memory Zipkin server using the 'openzipkin/zipkin-slim' Docker image. It runs the server in detached mode and maps the container's port 9411 to the host's port 9411, making the Zipkin UI accessible.

```bash
$ docker run -d -p 9411:9411 openzipkin/zipkin-slim
```

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

### Prometheus Scrape Configuration for Zipkin Metrics

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

This YAML snippet provides an example Prometheus configuration to scrape metrics from the Zipkin server's `/prometheus` endpoint. It defines a 'zipkin' job, sets a 5-second scrape interval, and includes `metric_relabel_configs` to transform raw metrics into more user-friendly `http_requests_total` with `status` and `path` labels.

```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__
```

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

### Add Zipkin Helm Repository

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

This command adds the official Zipkin Helm chart repository to your Helm configuration. Once added, you can use Helm to install and manage Zipkin deployments on Kubernetes clusters.

```Shell
helm repo add zipkin https://zipkin.io/zipkin-helm
```

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

### Adjust Virtual Memory for OpenSearch Host Setup

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

OpenSearch requires specific virtual memory settings to prevent crashes. These commands adjust the 'vm.max_map_count' kernel setting for different Docker environments: direct host, docker-machine/Docker Toolbox/Boot2Docker, and colima.

```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"
```

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

### In-Memory Storage Configuration

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

Details Zipkin's In-Memory Storage component, which holds all data in memory and purges older data based on a span limit. It is primarily used for testing and quick setup without external dependencies.

```APIDOC
STORAGE_TYPE: Set to 'mem' or unset to use in-memory storage.
MEM_MAX_SPANS: Integer. Oldest traces (and their spans) will be purged first when this limit is exceeded. Default: 500000.
```

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

### API Query Sharding for Trace by Service X Indexing

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

This section illustrates how a complex trace query is broken down into simpler shards for efficient indexing. It shows an example API request and its corresponding query shards, which are then intersected to find distinct trace IDs.

```APIDOC
GET /api/v2/traces?serviceName=tweetiebird%remoteService=s3

Breaks down into two query shards:
* (service=tweetiebird, span=)
* (service=tweetiebird, remote_service=s3)
```

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

### Analyze Trace ID Tokenization in Elasticsearch

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

Demonstrates how to use the Elasticsearch `_analyze` endpoint to inspect how trace IDs are tokenized. This example shows how a 128-bit trace ID is tokenized to also match its 64-bit truncated version, facilitating mixed-length trace ID lookups during migration.

```bash
# the output below shows which tokens will match on the trace id supplied.
$ curl -s 'localhost:9200/zipkin*span-2017-08-22/_analyze' -d '{
      "text": "48485a3953bb61246b221d5bc9e6496c",
      "analyzer": "traceId_analyzer"
  }'|jq '.tokens|.[]|.token'
  "48485a3953bb61246b221d5bc9e6496c"
  "6b221d5bc9e6496c"
```

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

### Adjust Kernel Virtual Memory for Elasticsearch Host Setup

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

Commands to adjust the `vm.max_map_count` kernel setting, which is critical for Elasticsearch's stability and performance. This adjustment is necessary whether Docker is running directly on the host, via `docker-machine`, or `colima`.

```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"
```

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

### API Query for Trace by Service and Span Name Indexing

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

This section illustrates the index rows generated for a span with a name and duration. It provides multiple API query examples demonstrating how to search traces using `serviceName`, `spanName`, and duration parameters (`minDuration`, `maxDuration`), noting the millisecond resolution for duration queries.

```APIDOC
Example index rows:
1. service=service1, span=get, trace_id=1, ts=timestamp_millis, duration=200
2. service=service1, span=, trace_id=1, ts=timestamp_millis, duration=200

Corresponding API queries:
1. GET /api/v2/traces?serviceName=service1&spanName=get
2. GET /api/v2/traces?serviceName=service1&spanName=get&minDuration=200000
3. GET /api/v2/traces?serviceName=service1&minDuration=200000
4. GET /api/v2/traces?spanName=get
5. GET /api/v2/traces?maxDuration=199500
```

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

### API Query for Trace by Service and Remote Service Indexing

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

This snippet demonstrates the index row format generated when a span accesses a remote service. It also provides API examples for querying traces specifically using the `remoteServiceName` parameter, highlighting its use case.

```APIDOC
Example index row:
* service=service1, span=remote_service, ts=timestamp_millis, trace_id=1

Corresponding API queries:
1. GET /api/v2/traces?serviceName=tweetiebird&remoteServiceName=s3
2. GET /api/v2/traces?serviceName=tweetiebird&maxDuration=199500&remoteServiceName=s3
```

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

### Build and Run Zipkin Server from Source

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

This snippet provides commands to build the Zipkin server locally using Maven and then run the compiled JAR files. It includes options for running both the standard and slim server executables.

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

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

### Encode Zipkin Trace Span Data in Java

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

An example demonstrating the manual construction and JSON V2 encoding of a Zipkin Span object using the core library. While possible, it's generally recommended to use higher-level tracing libraries like Brave for instrumentation.

```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);
```

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

### Elasticsearch/OpenSearch Automatic Index Creation Configuration

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

Details Zipkin's behavior regarding automatic index creation in Elasticsearch/OpenSearch. By default, these systems allow automatic index creation, but local installations might be configured to disallow it. This snippet shows the cluster setting to verify this configuration.

```APIDOC
action.auto_create_index: false
```

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

### Run Zipkin Slim Server via cURL and Java JAR

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

Illustrates how to download and run the 'slim' build of Zipkin, which is optimized for size and startup speed, supporting in-memory and Elasticsearch storage.

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

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

### Build zipkin-cassandra Docker Image

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

This bash command demonstrates how to build the `openzipkin/zipkin-cassandra:test` Docker image. It specifies the Dockerfile path and uses a custom build script. This command should be executed from the top-level directory of the repository.

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

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

### Build Zipkin Kafka Docker Test Image

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

Command to build the `openzipkin/zipkin-kafka:test` Docker image from the repository's top-level directory, specifying the Dockerfile path.

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

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

### Build zipkin-uiproxy Docker Test Image

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

Command to build the `openzipkin/zipkin-uiproxy:test` Docker image. This command should be executed from the top-level directory of the repository, specifying the Dockerfile path for the proxy.

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

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

### Build and Run Zipkin Server from Source

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

Instructions to compile and run the Zipkin server from a checked-out source. This process involves building the project with Maven, skipping tests, and then executing the generated JAR file. JDK 17+ is required for compilation.

```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
```

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

### Quick-start Zipkin Server via Docker Container

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

Shows how to launch the Zipkin server as a Docker container, making it accessible on port 9411. This provides an isolated and easy-to-deploy environment.

```bash
docker run -d -p 9411:9411 openzipkin/zipkin
```

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

### Build and Run zipkin-eureka Docker Image

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

Commands to build the `openzipkin/zipkin-eureka:test` Docker image from the repository's top-level and then run it, mapping port 8761 and removing the container on 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
```

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

### Override Kafka Consumer Property auto.offset.reset

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

Demonstrates how to override a specific Kafka consumer property, auto.offset.reset, by prefixing it with zipkin.collector.kafka.overrides. and passing it as a Java system property when starting the Zipkin JAR.

```bash
$ KAFKA_BOOTSTRAP_SERVERS=127.0.0.1:9092 \
    java -Dzipkin.collector.kafka.overrides.auto.offset.reset=latest -jar zipkin.jar
```

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

### GitHub Actions Workflow for Project Testing

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

This YAML configuration defines a GitHub Actions workflow named 'test.yml' for running project tests. It triggers on pushes to the 'master' branch (excluding tagged commits and documentation-only changes) and on pull requests targeting 'master' (also excluding documentation-only changes). The workflow checks out the repository and then executes `build-bin/configure_test` and `build-bin/test` scripts to set up the environment and run tests.

```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
```

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

### Build zipkin-mysql Docker image

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

Command to build the `openzipkin/zipkin-mysql:test` Docker image from the repository's top-level directory, using a specific Dockerfile.

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

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

### Build openzipkin/zipkin-elasticsearch8:test Docker Image

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

Instructions to build the `openzipkin/zipkin-elasticsearch8:test` Docker image. This command should be run from the top-level directory of the repository and specifies the Dockerfile location for the build process.

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

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

### Build Zipkin Lens for Production

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

Builds the Zipkin Lens application for production, optimizing React bundling and performance. The optimized assets are placed into the 'build' folder.

```npm
npm run build
```

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

### Create Custom Elasticsearch Ingest Pipeline

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

Provides an example of defining an Elasticsearch ingest pipeline named `zipkin`. This pipeline adds a `collector_timestamp_millis` field to documents, capturing the ingestion timestamp, which can be utilized by Zipkin for custom processing.

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

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

### Build zipkin-ui Docker Image

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

This command builds the `openzipkin/zipkin-ui:test` Docker image from the top-level of the repository, specifying the Dockerfile location.

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

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

### Test Snapshot Deployment with Manual Credentials

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

Provides a bash command to perform a manual snapshot deployment, allowing validation of SONATYPE_USER and SONATYPE_PASSWORD credentials by passing them as environment variables, along with GPG_PASSPHRASE.

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

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

### Build Standard Zipkin Docker Image

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

Command to build the standard 'openzipkin/zipkin:test' Docker image from the top-level repository directory.

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

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

### Run Integration Tests for Zipkin MySQL Storage Component

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

This command executes integration tests for the `zipkin-storage-mysql-v1` module using Maven, specifically targeting the `clean verify` goals. Tests are conditionally run against a Docker-managed MySQL container, and may be silently skipped if Docker is not available.

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

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

### Set Environment Variable for Docker Container Link

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

Example of setting the ES_HOSTS environment variable when using Docker's deprecated container links to connect to an Elasticsearch container named 'storage'. This method is no longer supported by OpenZipkin.

```bash
ES_HOSTS=http://$STORAGE_PORT_9200_TCP_ADDR:9200
```

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

### Build Zipkin RabbitMQ Test Docker Image

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

This command builds the `openzipkin/zipkin-rabbitmq:test` Docker image from the specified Dockerfile. It uses a custom build script `build-bin/docker/docker_build` to automate the build process.

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

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

### Send JSON Spans to Zipkin ActiveMQ Queue with cURL

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

Demonstrates sending a list of a single span, encoded in JSON, to the 'zipkin' queue on an ActiveMQ 5.x instance using `curl`. The example includes basic authentication and sets the `Content-Type` header to `application/json`.

```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"}}]'
```

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

### Run Zipkin Benchmarks JAR

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

This command executes the compiled JMH benchmarks directly from the generated JAR file.

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

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

### Configure Virtual Memory for Elasticsearch Docker

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

Elasticsearch requires a high `vm.max_map_count` kernel setting to prevent crashes, especially when running in Docker. These commands demonstrate how to adjust this setting for direct Docker host installations, 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
```

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

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

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

### Configure Multiple Kafka Bootstrap Servers

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

Shows how to specify multiple Kafka bootstrap servers by comma-separating their addresses in the KAFKA_BOOTSTRAP_SERVERS environment variable.

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

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

### Configure Zipkin Server with TLS/SSL

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

This snippet demonstrates how to enable TLS/SSL for the Zipkin server. It includes commands to generate a PKCS12 keystore using `keytool` and then run the Zipkin JAR with SSL-related Armeria properties, specifying the keystore, password, alias, and enabling HTTPS on port 9411.

```bash
# assuming you generate the key like this
keytool -genkeypair -alias mysite -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore zipkin.p12 -validity 3650

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
```

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

### Zipkin Server API and UI Endpoints Overview

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

This section outlines the various endpoints exposed by the Zipkin Server, all accessible under the base URL `http://your_host:9411`. It covers the UI, configuration, API versions (v1 and v2), health checks, instance information, and metrics endpoints, including a Prometheus-specific one.

```APIDOC
Base URL: http://your_host:9411
Endpoints:
/ - UI (../zipkin-lens)
/config.json - Configuration for the UI
/api/v2 - API (https://zipkin.io/zipkin-api/#/)
/health - Returns 200 status if OK
/info - Provides the version of the running instance
/metrics - Includes collector metrics broken down by transport type
/prometheus - Prometheus scrape endpoint

Legacy API:
/api/v1 - Still supported (https://zipkin.io/zipkin-api/#/)
Swagger UI definition: https://zipkin.io/zipkin-api/zipkin-api.yaml
```

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

### Run Zipkin Slim Server via Docker Container

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

Provides the command to run the 'slim' version of the Zipkin server as a Docker container, ideal for environments where a smaller footprint is desired.

```bash
docker run -d -p 9411:9411 openzipkin/zipkin-slim
```

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

### Push Git Tag for OpenZipkin Release

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

Demonstrates the command to create and push a semantic version tag (e.g., 'release-1.18.1') to trigger the CI/CD release pipeline for OpenZipkin.

```bash
git tag release-1.18.1 && git push origin release-1.18.1
```

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

### Build Slim Zipkin Docker Image

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

Command to build the 'openzipkin/zipkin-slim:test' Docker image by setting the DOCKER_TARGET environment variable before running the build script.

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

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

### Run Single Integration Test with Maven

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

This command demonstrates how to execute a specific integration test class and method using Maven, targeting the `zipkin-storage/cassandra` module. It cleans and verifies the project, allowing developers to test isolated changes without running all storage options.

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

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

### GitHub Actions Workflow for Project Deployment

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

This YAML configuration defines a GitHub Actions workflow named 'deploy.yml' for deploying project artifacts. It triggers on pushes to the 'master' branch (excluding tagged commits to prevent redundant deployments). The workflow runs on 'ubuntu-24.04', checks out the repository with a shallow fetch, and then executes `build-bin/configure_deploy` and `build-bin/deploy` scripts. It passes the branch or tag name (extracted from `GITHUB_REF`) as an argument to the deploy script and uses `GH_USER` and `GH_TOKEN` environment variables for authentication.

```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)
```

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

### Zipkin Top-Level Configuration Parameters

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

Describes the environment variables used to configure Zipkin, covering aspects like listen ports, API and UI enablement, query timeouts, logging, storage types, sampling rates, and autocomplete tag settings.

```APIDOC
Configuration Parameters:
  QUERY_PORT:
    Description: Listen port for the HTTP API and web UI
    Default: 9411
  QUERY_ENABLED:
    Description: 'false' disables the HTTP read endpoints under '/api/v2'. This also disables the UI, as it relies on the API. If your only goal is to restrict search, use 'SEARCH_ENABLED' instead. If your only goal is to disable the UI, use 'UI_ENABLED' instead.
    Default: true
  SEARCH_ENABLED:
    Description: 'false' disables searching in the query API and any indexing or post-processing in the collector to support search. This does not disable the entire UI, as trace by ID and dependency queries still operate. Disable this when you use another service (such as logs) to find trace IDs.
    Default: true
  UI_ENABLED:
    Description: 'false' disables the web UI, mounted at '/zipkin'.
    Default: true
  QUERY_TIMEOUT:
    Description: Sets the hard timeout for query requests. Accepts any duration string (e.g., 100ms). A value of 0 will disable the timeout completely.
    Default: 11s
  QUERY_LOG_LEVEL:
    Description: Log level written to the console
    Default: INFO
  QUERY_NAMES_MAX_AGE:
    Description: Controls the value of the 'max-age' header zipkin-server responds with on http requests for autocompleted values in the UI (service names for example).
    Default: 300 seconds
  QUERY_LOOKBACK:
    Description: How many milliseconds queries can look back from endTs
    Default: 24 hours (two daily buckets: one for today and one for yesterday)
  STORAGE_TYPE:
    Description: SpanStore implementation
    Values: mem, mysql, cassandra3, elasticsearch
  COLLECTOR_SAMPLE_RATE:
    Description: Percentage of traces to retain
    Default: 1.0 (always sample)
  AUTOCOMPLETE_KEYS:
    Description: list of span tag keys which will be returned by the '/api/v2/autocompleteTags' endpoint; Tag keys should be comma separated e.g. "instance_id,user_id,env"
  AUTOCOMPLETE_TTL:
    Description: How long in milliseconds to suppress calls to write the same autocomplete key/value pair.
    Default: 3600000 (1 hr)
```

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

### zipkin-uiproxy Docker Image Environment Variables

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

Configurable environment variables for the `zipkin-uiproxy` Docker image, defining its behavior and base URLs. These variables allow customization of the UI base path and the proxied Zipkin base URL.

```APIDOC
ZIPKIN_UI_BASEPATH:
  Description: The path this proxy serves the UI under.
  Default: /zipkin
ZIPKIN_BASE_URL:
  Description: The proxied zipkin base URL.
  Default: http://zipkin:9411
```

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

### YAML Configuration for Zipkin Internal Module Discovery

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

Demonstrates the YAML dictionary structure used by Zipkin for internal module discovery, providing a flexible alternative to Spring Boot's auto-configuration. This approach allows explicit loading of module dependencies.

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

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

### Build zipkin-opensearch2 Docker Image

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

This command builds the 'openzipkin/zipkin-opensearch2:test' Docker image. It should be executed from the top-level directory of the repository, specifying the Dockerfile path.

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

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

### Connect to zipkin-mysql with docker-machine

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

Command to connect to the `zipkin-mysql` instance running with docker-machine using the MySQL client, specifying the host IP, username, password, and database.

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

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

### Build zipkin-activemq Docker Image

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

This command builds the `openzipkin/zipkin-activemq:test` Docker image. It specifies the Dockerfile path and uses a custom build script to create the test image for ActiveMQ collector integration.

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

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

### Specify Kafka Bootstrap Servers via System Property

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

Illustrates an alternative method to specify Kafka bootstrap servers using a Java 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-pulsar Docker Image

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

This command builds the `openzipkin/zipkin-pulsar:test` Docker image. It specifies the Dockerfile path and uses a build script from the repository. This image is specifically designed for testing Pulsar collector integration.

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

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

### zipkin-cassandra Docker Image Environment Variables

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

This section details the environment variables that can be set to configure the `zipkin-cassandra` Docker image. These variables allow users to customize aspects like logging behavior.

```APIDOC
Environment Variables:
  LOGGING_LEVEL:
    Description: Root Log4J logging level sent to stdout.
    Default: "WARN"
```

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

### Apply Zipkin MySQL Schema and Configure Barracuda Format

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

These commands configure MySQL to use the Barracuda file format for InnoDB (required for compression in AWS RDS), create the `zipkin` database if it doesn't exist, and then apply the Zipkin schema and indexes from the provided SQL DDL file.

```bash
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
```