@opentelemetry/exporter-zipkin

What is @opentelemetry/exporter-zipkin?

The @opentelemetry/exporter-zipkin package is designed for Node.js and web applications to export telemetry data to Zipkin, a distributed tracing system. It allows developers to monitor and troubleshoot their applications by collecting and reporting timing data needed to troubleshoot latency problems in microservice architectures. This package is part of the OpenTelemetry project, which provides a set of APIs, libraries, agents, and instrumentation to create and manage telemetry data (metrics, logs, and traces).

What are @opentelemetry/exporter-zipkin's main functionalities?

Exporting Traces to Zipkin

This code snippet demonstrates how to set up the ZipkinExporter with the OpenTelemetry Node.js SDK. It initializes a NodeTracerProvider, configures the ZipkinExporter with the service name and Zipkin server URL, and registers the exporter using a SimpleSpanProcessor.

{
  const { ZipkinExporter } = require('@opentelemetry/exporter-zipkin');
  const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
  const { NodeTracerProvider } = require('@opentelemetry/node');

  const provider = new NodeTracerProvider();
  const zipkinExporter = new ZipkinExporter({
    serviceName: 'your-service-name',
    url: 'http://localhost:9411/api/v2/spans'
  });
  provider.addSpanProcessor(new SimpleSpanProcessor(zipkinExporter));
  provider.register();
}

Other packages similar to @opentelemetry/exporter-zipkin

@opentelemetry/exporter-jaeger

Similar to the Zipkin exporter, the Jaeger exporter allows exporting traces to Jaeger, another open-source, end-to-end distributed tracing system. It provides functionality to send telemetry data to a Jaeger backend, facilitating the monitoring and troubleshooting of microservices-based distributed systems. The choice between Zipkin and Jaeger often depends on the specific needs of the project and the existing infrastructure.

@opentelemetry/exporter-prometheus

While not directly similar in terms of exporting traces, the Prometheus exporter is another telemetry data exporter that focuses on metrics. It allows exporting metrics data to a Prometheus monitoring system. This package is useful for users who are looking to monitor their application's performance and health through metrics rather than tracing data. It complements the functionality provided by the Zipkin exporter by offering a different aspect of telemetry data monitoring.

README

OpenTelemetry Zipkin Trace Exporter

OpenTelemetry Zipkin Trace Exporter allows the user to send collected traces to Zipkin.

Zipkin is a distributed tracing system. It helps gather timing data needed to troubleshoot latency problems in microservice architectures. It manages both the collection and lookup of this data.

Installation

npm install --save @opentelemetry/exporter-zipkin

Usage in Node and Browser

Install the exporter on your application and pass the options. serviceName is an optional string. If omitted, the exporter will first try to get the service name from the Resource. If no service name can be detected on the Resource, a fallback name of "OpenTelemetry Service" will be used.

const { ZipkinExporter } = require('@opentelemetry/exporter-zipkin');

// Add your zipkin url (`http://localhost:9411/api/v2/spans` is used as
// default) and application name to the Zipkin options.
// You can also define your custom headers which will be added automatically.
const options = {
  headers: {
    'my-header': 'header-value',
  },
  url: 'your-zipkin-url',
  // optional interceptor
  getExportRequestHeaders: () => {
    return {
      'my-header': 'header-value',
    }
  }
}
const exporter = new ZipkinExporter(options);

Now, register the exporter and start tracing.

const tracerProvider = new NodeTracerProvider({
  spanProcessors: [new BatchSpanProcessor(exporter)]
})

const tracer = traceProvider.getTracer('my-tracer')

You can use built-in SimpleSpanProcessor or BatchSpanProcessor or write your own.

• SimpleSpanProcessor: The implementation of SpanProcessor that passes ended span directly to the configured SpanExporter.
• BatchSpanProcessor: The implementation of the SpanProcessor that batches ended spans and pushes them to the configured SpanExporter. It is recommended to use this SpanProcessor for better performance and optimization.

Options

• getExportRequestHeaders - optional interceptor that allows adding new headers every time time the exporter is going to send spans. This is optional and can be used if headers are changing over time. This is a sync callback.

Viewing your traces

Please visit the Zipkin UI endpoint http://localhost:9411

Useful links

• For more information on OpenTelemetry, visit: https://opentelemetry.io/
• For more about OpenTelemetry JavaScript: https://github.com/open-telemetry/opentelemetry-js
• For Zipkin project at https://zipkin.io/
• For help or feedback on this project, join us in GitHub Discussions

License

Apache 2.0 - See LICENSE for more information.

Changelog

1.30.0

:rocket: (Enhancement)

• feat(sdk-metrics): PeriodicExportingMetricReader now flushes pending tasks at shutdown #5242

:bug: (Bug Fix)

• fix(sdk-trace-base): do not load OTEL_ env vars on module load, but when needed #5233
• fix(instrumentation-xhr, instrumentation-fetch): content length attributes no longer get removed with ignoreNetworkEvents: true being set #5229