Instrumentation prête à l'emploi

Une instrumentation prête à l’emploi par défaut est disponible pour plusieurs frameworks :

FonctionnalitéPropriétéValeur par défaut
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

Activer les instrumentations de manière sélective

Pour n’utiliser que des instrumentations spécifiques, désactivez d’abord toutes les instrumentations en définissant la propriété otel.instrumentation.common.default-enabled à false. Ensuite, activez les instrumentations une par une.

Par exemple, si vous souhaitez uniquement activer l’instrumentation JDBC, définissez otel.instrumentation.jdbc.enabled à true.

Configuration commune de l’instrumentation

Propriétés communes à toutes les instrumentations de base de données :

Propriété systèmeTypeDéfautDescription
otel.instrumentation.common.db-statement-sanitizer.enabledBooleantrueActive le nettoyage des instructions de base de données.

Instrumentation JDBC

Propriété systèmeTypeDéfautDescription
otel.instrumentation.jdbc.statement-sanitizer.enabledBooleantrueActive le nettoyage des instructions de base de données.

Logback

Vous pouvez activer des fonctionnalités expérimentales à l’aide des propriétés système pour capturer des attributs :

Propriété systèmeTypeDéfautDescription
otel.instrumentation.logback-appender.experimental-log-attributesBooleanfalseActive la capture des attributs de log expérimentaux thread.name et thread.id.
otel.instrumentation.logback-appender.experimental.capture-code-attributesBooleanfalseActive la capture des attributs de code source. Notez que la capture des attributs de code source sur les sites de journalisation peut ajouter une surcharge de performance.
otel.instrumentation.logback-appender.experimental.capture-marker-attributeBooleanfalseActive la capture des marqueurs Logback comme attributs.
otel.instrumentation.logback-appender.experimental.capture-key-value-pair-attributesBooleanfalseActive la capture des paires clé-valeur Logback comme attributs.
otel.instrumentation.logback-appender.experimental.capture-logger-context-attributesBooleanfalseActive la capture des propriétés de contexte du logger Logback comme attributs.
otel.instrumentation.logback-appender.experimental.capture-mdc-attributesStringListe séparée par des virgules des attributs MDC à capturer. Utilisez le caractère générique * pour capturer tous les attributs.

Par ailleurs, vous pouvez activer ces fonctionnalités en ajoutant l’appender Logback OpenTelemetry dans votre fichier logback.xml ou logback-spring.xml :

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

Autoconfiguration Spring Web

Fournit une autoconfiguration pour l’intercepteur de trace RestTemplate défini dans opentelemetry-spring-web-3.1. Cette autoconfiguration instrumente toutes les requêtes envoyées à l’aide des beans Spring RestTemplate en appliquant un post-processeur de bean RestTemplate. Cette fonctionnalité est supportée pour les versions de spring web 3.1+. Pour en savoir plus sur l’intercepteur RestTemplate OpenTelemetry, consultez opentelemetry-spring-web-3.1.

Les manières suivantes de créer un RestTemplate sont supportées :

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

Les manières suivantes de créer un RestClient sont supportées :

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

Comme il est possible avec l’agent Java, vous pouvez configurer la capture des entités suivantes :

Autoconfiguration Spring Web MVC

Cette fonctionnalité autoconfigure l’instrumentation pour les contrôleurs Spring WebMVC en ajoutant un bean filtre servlet produisant de la télémétrie au contexte de l’application. Le filtre décore l’exécution de la requête avec un span de serveur, propageant le contexte de traçage entrant s’il est reçu dans la requête HTTP. Pour en savoir plus sur l’instrumentation Spring WebMVC OpenTelemetry, consultez la bibliothèque d’instrumentation opentelemetry-spring-webmvc-5.3.

Comme il est possible avec l’agent Java, vous pouvez configurer la capture des entités suivantes :

Autoconfiguration Spring WebFlux

Fournit des autoconfigurations pour le filtre d’échange WebClient OpenTelemetry défini dans opentelemetry-spring-webflux-5.3. Cette autoconfiguration instrumente toutes les requêtes HTTP sortantes envoyées à l’aide des beans WebClient et WebClient Builder de Spring en appliquant un post-processeur de bean. Cette fonctionnalité est supportée pour les versions de spring webflux 5.0+. Pour plus de détails, consultez opentelemetry-spring-webflux-5.3.

Les manières suivantes de créer un WebClient sont supportées :

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

Instrumentation Kafka

Fournit une autoconfiguration pour l’instrumentation du client Kafka.

Propriété systèmeTypeDéfautDescription
otel.instrumentation.kafka.experimental-span-attributesBooleanfalseActive la capture des attributs de span expérimentaux.

Instrumentation Micrometer

Fournit une autoconfiguration pour le pont Micrometer vers OpenTelemetry.

Instrumentation MongoDB

Fournit une autoconfiguration pour l’instrumentation du client MongoDB.

Propriété systèmeTypeDéfautDescription
otel.instrumentation.mongo.statement-sanitizer.enabledBooleantrueActive le nettoyage des instructions de base de données.

Instrumentation R2DBC

Fournit une autoconfiguration pour l’instrumentation R2DBC OpenTelemetry.

Propriété systèmeTypeDéfautDescription
otel.instrumentation.r2dbc.statement-sanitizer.enabledBooleantrueActive le nettoyage des instructions de base de données.

Dernière modification August 4, 2025: [fr] Translation of Zero Code Java docs (#7389) (a409f82a)