Out of the box instrumentation
Out of the box instrumentation is available for several frameworks:
| Feature | Property | Default |
|---|---|---|
| JDBC | otel.instrumentation.jdbc.enabled | true |
| Logback | otel.instrumentation.logback-appender.enabled | true |
| Logback MDC | otel.instrumentation.logback-mdc.enabled | true |
| Spring Web | otel.instrumentation.spring-web.enabled | true |
| Spring Web MVC | otel.instrumentation.spring-webmvc.enabled | true |
| Spring WebFlux | otel.instrumentation.spring-webflux.enabled | true |
| Kafka | otel.instrumentation.kafka.enabled | true |
| MongoDB | otel.instrumentation.mongo.enabled | true |
| Micrometer | otel.instrumentation.micrometer.enabled | false |
| R2DBC (reactive JDBC) | otel.instrumentation.r2dbc.enabled | true |
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).
| Feature | Name | Default |
|---|---|---|
| JDBC | jdbc | enabled |
| Logback | logback_appender | enabled |
| Logback MDC | logback_mdc | enabled |
| Spring Web | spring_web | enabled |
| Spring Web MVC | spring_webmvc | enabled |
| Spring WebFlux | spring_webflux | enabled |
| Kafka | kafka | enabled |
| MongoDB | mongo | enabled |
| Micrometer | micrometer | disabled |
| R2DBC (reactive JDBC) | r2dbc | enabled |
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 :
| Property | Type | Default | Description |
|---|---|---|---|
experimental-log-attributes | Boolean | false | Enable the capture of experimental log attributes thread.name and thread.id. |
experimental.capture-code-attributes | Boolean | false | Enable the capture of [source code attributes][]. Note that capturing source code attributes at logging sites might add a performance overhead. |
experimental.capture-marker-attribute | Boolean | false | Enable the capture of Logback markers as attributes. |
experimental.capture-key-value-pair-attributes | Boolean | false | Enable the capture of Logback key value pairs as attributes. |
experimental.capture-logger-context-attributes | Boolean | false | Enable the capture of Logback logger context properties as attributes. |
experimental.capture-mdc-attributes | String | Comma 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: '*'
| Property | Type | Default | Description |
|---|---|---|---|
experimental_log_attributes/development | Boolean | false | Enable the capture of experimental log attributes thread.name and thread.id. |
capture_code_attributes/development | Boolean | false | Enable the capture of [source code attributes][]. Note that capturing source code attributes at logging sites might add a performance overhead. |
capture_marker_attribute/development | Boolean | false | Enable the capture of Logback markers as attributes. |
capture_key_value_pair_attributes/development | Boolean | false | Enable the capture of Logback key value pairs as attributes. |
capture_logger_context_attributes/development | Boolean | false | Enable the capture of Logback logger context properties as attributes. |
capture_mdc_attributes/development | String | Comma 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
Feedback
Was this page helpful?
Thank you. Your feedback is appreciated!
Please let us know how we can improve this page. Your feedback is appreciated!