Out of the box instrumentation

Out of the box instrumentation is available for several frameworks:

FeaturePropertyDefault
JDBCotel.instrumentation.jdbc.enabledtrue
Logbackotel.instrumentation.logback-appender.enabledtrue
Logback MDCotel.instrumentation.logback-mdc.enabledtrue
Spring Webotel.instrumentation.spring-web.enabledtrue
Spring Web MVCotel.instrumentation.spring-webmvc.enabledtrue
Spring WebFluxotel.instrumentation.spring-webflux.enabledtrue
Kafkaotel.instrumentation.kafka.enabledtrue
MongoDBotel.instrumentation.mongo.enabledtrue
Micrometerotel.instrumentation.micrometer.enabledfalse
R2DBC (reactive JDBC)otel.instrumentation.r2dbc.enabledtrue

To disable a specific instrumentation:

otel:
  instrumentation:
    logback-appender:
      enabled: false

In declarative configuration, instrumentation enable/disable uses centralized lists under otel.distribution.spring_starter.instrumentation. The instrumentation name uses _ (snake_case), not - (kebab-case).

FeatureNameDefault
JDBCjdbcenabled
Logbacklogback_appenderenabled
Logback MDClogback_mdcenabled
Spring Webspring_webenabled
Spring Web MVCspring_webmvcenabled
Spring WebFluxspring_webfluxenabled
Kafkakafkaenabled
MongoDBmongoenabled
Micrometermicrometerdisabled
R2DBC (reactive JDBC)r2dbcenabled

To disable a specific instrumentation:

otel:
  distribution:
    spring_starter:
      instrumentation:
        disabled:
          - logback_appender

Turn on instrumentations selectively

To use only specific instrumentations, turn off all the instrumentations first and then turn on instrumentations one by one:

otel:
  instrumentation:
    common:
      default-enabled: false
    jdbc:
      enabled: true

In declarative configuration, set default_enabled to false and list the instrumentations you want in enabled:

otel:
  distribution:
    spring_starter:
      instrumentation:
        default_enabled: false
        enabled:
          - jdbc

Common instrumentation configuration

Common properties for all database instrumentations:

Enables the DB statement sanitization for all database instrumentations:

otel:
  instrumentation:
    common:
      db-statement-sanitizer:
        enabled: true # default: true

Enables the DB statement sanitization for all database instrumentations:

otel:
  instrumentation/development:
    java:
      common:
        database:
          statement_sanitizer:
            enabled: true

JDBC Instrumentation

Enables the DB statement sanitization for JDBC:

otel:
  instrumentation:
    jdbc:
      statement-sanitizer:
        enabled: true # default: true

Enables the DB statement sanitization for JDBC:

otel:
  instrumentation/development:
    java:
      jdbc:
        statement_sanitizer:
          enabled: true

Logback

You can enable experimental features with system properties to capture attributes :

PropertyTypeDefaultDescription
experimental-log-attributesBooleanfalseEnable the capture of experimental log attributes thread.name and thread.id.
experimental.capture-code-attributesBooleanfalseEnable the capture of [source code attributes][]. Note that capturing source code attributes at logging sites might add a performance overhead.
experimental.capture-marker-attributeBooleanfalseEnable the capture of Logback markers as attributes.
experimental.capture-key-value-pair-attributesBooleanfalseEnable the capture of Logback key value pairs as attributes.
experimental.capture-logger-context-attributesBooleanfalseEnable the capture of Logback logger context properties as attributes.
experimental.capture-mdc-attributesStringComma separated list of MDC attributes to capture. Use the wildcard character * to capture all attributes.
otel:
  instrumentation:
    logback-appender:
      experimental-log-attributes: false
      experimental:
        capture-code-attributes: false
        capture-marker-attribute: false
        capture-key-value-pair-attributes: false
        capture-logger-context-attributes: false
        capture-mdc-attributes: '*'
PropertyTypeDefaultDescription
experimental_log_attributes/developmentBooleanfalseEnable the capture of experimental log attributes thread.name and thread.id.
capture_code_attributes/developmentBooleanfalseEnable the capture of [source code attributes][]. Note that capturing source code attributes at logging sites might add a performance overhead.
capture_marker_attribute/developmentBooleanfalseEnable the capture of Logback markers as attributes.
capture_key_value_pair_attributes/developmentBooleanfalseEnable the capture of Logback key value pairs as attributes.
capture_logger_context_attributes/developmentBooleanfalseEnable the capture of Logback logger context properties as attributes.
capture_mdc_attributes/developmentStringComma separated list of MDC attributes to capture. Use the wildcard character * to capture all attributes.
otel:
  instrumentation/development:
    java:
      logback_appender:
        experimental_log_attributes/development: false
        capture_code_attributes/development: false
        capture_marker_attribute/development: false
        capture_key_value_pair_attributes/development: false
        capture_logger_context_attributes/development: false
        capture_mdc_attributes/development: '*'

Alternatively, you can enable these features by adding the OpenTelemetry Logback appender in your logback.xml or logback-spring.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>
    <appender name="OpenTelemetry"
        class="io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender">
        <captureExperimentalAttributes>false</captureExperimentalAttributes>
        <captureCodeAttributes>true</captureCodeAttributes>
        <captureMarkerAttribute>true</captureMarkerAttribute>
        <captureKeyValuePairAttributes>true</captureKeyValuePairAttributes>
        <captureLoggerContext>true</captureLoggerContext>
        <captureMdcAttributes>*</captureMdcAttributes>
    </appender>
    <root level="INFO">
        <appender-ref ref="console"/>
        <appender-ref ref="OpenTelemetry"/>
    </root>
</configuration>

Spring Web Autoconfiguration

Provides autoconfiguration for the RestTemplate trace interceptor defined in opentelemetry-spring-web-3.1. This autoconfiguration instruments all requests sent using Spring RestTemplate beans by applying a RestTemplate bean post processor. This feature is supported for spring web versions 3.1+. To learn more about the OpenTelemetry RestTemplate interceptor, see opentelemetry-spring-web-3.1.

The following ways of creating a RestTemplate are supported:

package otel;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

  @Bean
  public RestTemplate restTemplate() {
    return new RestTemplate();
  }
}
package otel;

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class RestTemplateController {

  private final RestTemplate restTemplate;

  public RestTemplateController(RestTemplateBuilder restTemplateBuilder) {
    restTemplate = restTemplateBuilder.rootUri("http://localhost:8080").build();
  }
}

The following ways of creating a RestClient are supported:

package otel;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestClient;

@Configuration
public class RestClientConfig {

  @Bean
  public RestClient restClient() {
    return RestClient.create();
  }
}
package otel;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestClient;

@RestController
public class RestClientController {

  private final RestClient restClient;

  public RestClientController(RestClient.Builder restClientBuilder) {
    restClient = restClientBuilder.baseUrl("http://localhost:8080").build();
  }
}

As it’s possible with the Java agent, you can configure the capture of the following entities:

Spring Web MVC Autoconfiguration

This feature autoconfigures instrumentation for Spring WebMVC controllers by adding a telemetry producing servlet Filter bean to the application context. The filter decorates the request execution with a server span, propagating the incoming tracing context if received in the HTTP request. To learn more about the OpenTelemetry Spring WebMVC instrumentation, see the opentelemetry-spring-webmvc-5.3 instrumentation library.

As it’s possible with the Java agent, you can configure the capture of the following entities:

Spring WebFlux Autoconfiguration

Provides autoconfigurations for the OpenTelemetry WebClient ExchangeFilter defined in opentelemetry-spring-webflux-5.3. This autoconfiguration instruments all outgoing HTTP requests sent using Spring’s WebClient and WebClient Builder beans by applying a bean post processor. This feature is supported for spring webflux versions 5.0+. For details, see opentelemetry-spring-webflux-5.3.

The following ways of creating a WebClient are supported:

package otel;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

  @Bean
  public WebClient webClient() {
    return WebClient.create();
  }
}
package otel;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.reactive.function.client.WebClient;

@RestController
public class WebClientController {

  private final WebClient webClient;

  public WebClientController(WebClient.Builder webClientBuilder) {
    webClient = webClientBuilder.baseUrl("http://localhost:8080").build();
  }
}

Kafka Instrumentation

Provides autoconfiguration for the Kafka client instrumentation.

Enables the capture of experimental span attributes for Kafka:

otel:
  instrumentation:
    kafka:
      experimental-span-attributes: false # default: false

Enables the capture of experimental span attributes for Kafka:

otel:
  instrumentation/development:
    java:
      kafka:
        experimental_span_attributes/development: false

Micrometer Instrumentation

Provides autoconfiguration for the Micrometer to OpenTelemetry bridge.

MongoDB Instrumentation

Provides autoconfiguration for the MongoDB client instrumentation.

Enables the DB statement sanitization for MongoDB:

otel:
  instrumentation:
    mongo:
      statement-sanitizer:
        enabled: true # default: true

Enables the DB statement sanitization for MongoDB:

otel:
  instrumentation/development:
    java:
      mongo:
        statement_sanitizer:
          enabled: true

R2DBC Instrumentation

Provides autoconfiguration for the OpenTelemetry R2DBC instrumentation.

Enables the DB statement sanitization for R2DBC:

otel:
  instrumentation:
    r2dbc:
      statement-sanitizer:
        enabled: true # default: true

Enables the DB statement sanitization for R2DBC:

otel:
  instrumentation/development:
    java:
      r2dbc:
        statement_sanitizer:
          enabled: true