Using Helidon to set the global OpenTelemetry instance has these effects:

• Assigns the instance as the OpenTelemetry global instance.

• Creates a Helidon Tracer using the OpenTelemetry instance and makes that the Helidon global Tracer.

OpenTelemetry applies the defaults described in the next table.

Sections below describe how to set up the tracing signal configuration:

• Assigning attributes

• Associating Exporters and Processors

• Configuring Span Exporters

• Configuring Span Processors

• Configuring the Span Sampler

• Configuring the Span Limits

Configured attributes are key/value pairs that OpenTelemetry attaches to each tracing span. OpenTelemetry supports attributes of type String, long, double, and boolean. The configuration stricture groups attributes by type so Helidon knows precisely what type you intend for each attribute.

Ultimately, OpenTelemetry transmits the telemetry data it gathers to a backend system—​such as Grafana, Prometheus, Jaeger, or others—​where you can view and query the data. OpenTelemetry tracing first processes each data observation within the JVM and then exports the processed data to one or more backends. Each span processor uses one or more span exporters to transmit telemetry data.

You link processors and exporters in config selectively as follows:

• Name each exporter if you have more than one.

• List, for each processor, the names of exporters it should use. Omitting a processor’s list of exporter names causes the processor to use all configured exporters.

The following examples show increasingly-complicated scenarios:

• Default

• Minimal configuration

• Maximum flexibility

For many applications the default and minimal scenarios work well.

Default

telemetry:
  service: "inventory"
  tracing:
    sampler: "always_off"

Minimal configuration

telemetry:
  service: "inventory"
  tracing:
    sampler: "always_off"
    exporters:
      - type: zipkin
        compression: gzip
    processors:
      - type: batch
        max-queue-size: 50

Maximum flexibility

telemetry:
  service: "inventory"
  tracing:
    sampler: "always_off"
    exporters:
      - type: zipkin
        compression: gzip
        name: "compressed-zipkin"
      - endpoint: "http://collect.com:4317"
        name: "alternate-otlp""
    processors:
      - type: batch
        max-queue-size: 50
      - type: simple
        exporters: ["alternate-otlp"]

An OpenTelemetry span processor is one of the following types:

• simple - The processor sends each telemetry observation to its exporters for transmission as soon as it receives the observation.

• batch - The processor groups observations into batches and sends a batch at a time to its exporters for transmission.

In the table below only the type and exporters setting apply to simple span processors; the other settings are for batch processors.

Type: io.helidon.telemetry.otelconfig.BatchSpanProcessorConfig

Configuration options

OpenTelemetry supports many types of exporters, each with its own configurable settings. Helidon configuration supports several of the most popular exporters, listed in the table below.

If you need to use an exporter that is not in the table:

• Add a dependency on the OpenTelemetry artifact that contains that exporter type.

• Add application code that prepares the exporter instance.

• Prepare the Helidon OpenTelemetry builders programmatically and add your exporter instance to the builder.

<dependency>
  <groupId>io.opentelemetry</groupId>
  <artifactId>opentelemetry-exporter-otlp</artifactId>
</dependency>

<dependency>
  <groupId>io.opentelemetry</groupId>
  <artifactId>opentelemetry-exporter-zipkin</artifactId>
</dependency>

Configuring an OTLP Exporter

The OpenTelemetry documentation describes the defaults; see the "Properties for `otlp `span, metric, and log exporters" section there.

Configuring a Zipkin Exporter

The OpenTelemetry documentation describes the defaults; see the "Properties for Zipkin span exporters" section there.

OpenTelemetry offers different ways of sampling data—​deciding which tracing spans tp capture and send to the backend. The OpenTelemetry documentation describes sampling in more detail.

Helidon configuration supports the sampler implementations that reside in the opentelemetry-sdk as listed in the table below. Other samplers are in other components. If you need to use one of those:

• Add the relevant OpenTelemetry dependency to your project.

• Instantiate the span sample you need.

• Prepare the sampler and the OpenTelemetry-related builders programmatically and use your sampler to assign the sampler the OpenTelemetryTracer.Builder should use.

Type: io.helidon.telemetry.otelconfig.SamplerConfig

OpenTelemetry allows you to constrain certain aspects of the data it gathers in tracing spans. By assigning the settings in the table below, you can apply the span limits you want.

Type: io.helidon.telemetry.otelconfig.SpanLimitsConfig

The OpenTelemetry documentation describes the defaults; see the "Properties for span limits" section there.