Voici des informations sur la configuration des sources de données OpenTelemetry (OTEL) (telles que les bibliothèques d'instrumentation et le collecteur OpenTelemetry) pour charger les données de surveillance (mesures et traces) dans Application Performance Monitoring.

const opentelemetry = require("@opentelemetry/sdk-node");
const {
 getNodeAutoInstrumentations,
} = require("@opentelemetry/auto-instrumentations-node");
const {
 OTLPTraceExporter,
} = require("@opentelemetry/exporter-trace-otlp-http");

  const sdk = new opentelemetry.NodeSDK({
traceExporter: new OTLPTraceExporter({
  url: "https://aaabbbb.example.us-phoenix-1.oci.oraclecloud.com/20200101/opentelemetry/private/v1/traces",
  headers: {"Authorization": "dataKey AAAAABBBBBCCCC"},
 }),

  instrumentations: [getNodeAutoInstrumentations()]
});

 sdk.start()
(base) [ssirajud@ssirajud node_with_opentelemetry]$

export OTEL_TRACES_EXPORTER=otlp
export OTEL_SERVICE_NAME=my-service
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_TRACES_HEADERS="authorization=dataKey 1111aaaabbbccc"
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://aaabbbb.example.us-phoenix-1.oci.oraclecloud.com/20200101/opentelemetry/private/v1/traces/
export OTEL_METRICS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=https://aaabbbb.example.us-phoenix-1.oci.oraclecloud.com/20200101/opentelemetry/v1/metrics
export OTEL_EXPORTER_OTLP_METRICS_HEADERS="authorization=dataKey 1111aaaabbbccc"
export OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=http/protobuf

receivers:
  otlp:
    protocols:
      http:

exporters:
  logging:
    verbosity: detailed
  otlphttp:
    endpoint: https://aaaaXXXX.apm-agt.us-ashburn-1.oci.oraclecloud.com/20200101/opentelemetry/private/v1/traces/
    headers:
      Authorization: "dataKey XXX"

processors:
  batch:

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp]
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp]

Voici des informations sur les modifications à apporter au code d'une application Java qui utilise le client Jaeger pour le traçage réparti. Utilisez-le ensuite pour charger les traces dans le service de surveillance de la performance des applications.

Pour utiliser le traceur Jaeger pour charger des traces d'une application Java dans Application Performance Monitoring, vous devez configurer le client Java Jaeger pour la compatibilité Zipkin (rapport au format Zipkin v2) et ajouter l'URL du collecteur Application Performance Monitoring. Pour ce faire, vous devez apporter les modifications suivantes au code de votre service :

1. En plus des dépendances requises du client Jaeger, ajoutez les dépendances suivantes au fichier pom.xml.

   <dependency>
       <groupId>io.zipkin.reporter2</groupId>
       <artifactId>zipkin-sender-urlconnection</artifactId>
       <version>2.15.0</version>
   </dependency>
   <dependency>
       <groupId>io.jaegertracing</groupId>
       <artifactId>jaeger-zipkin</artifactId>
       <version>1.3.2</version>
   </dependency>

2. Utilisez ZipkinV2Reporter pour adapter un programme de rapport Zipkin 2 à l'interface du programme de rapport Jaeger et convertir les intervalles Jaeger au format Zipkin v2 encodé en JSON. Assurez-vous d'indiquer l'URL du programme de collecte APM pour charger les intervalles dans le service de surveillance de la performance des applications, ainsi que le nom de votre service ou application.

   import io.jaegertracing.Configuration;
   import io.jaegertracing.zipkin.ZipkinV2Reporter;
   import zipkin2.reporter.AsyncReporter;
   import zipkin2.reporter.urlconnection.URLConnectionSender;
    
   /* .... */
    
   ZipkinV2Reporter reporter = new ZipkinV2Reporter(AsyncReporter.create(URLConnectionSender.create("<Application Performance Monitoring collector URL>")));
   JaegerTracer tracer = Configuration
       .fromEnv("<service-name>")
       .getTracerBuilder()
       .withReporter(reporter)
       .withSampler(new ConstSampler(true))
       .build();
    
   /* .... */

3. Enregistrez B3TextMapCodec pour utiliser la propagation B3, qui est une spécification pour l'en-tête b3. Ces en-têtes sont utilisés pour la propagation du contexte de trace au-delà des limites du service.

   import io.jaegertracing.Configuration;
   import io.jaegertracing.internal.propagation.B3TextMapCodec;
   import io.opentracing.propagation.Format;
    
   /* .... */
    
   B3TextMapCodec b3Codec = new B3TextMapCodec.Builder().build();       
   JaegerTracer tracer = Configuration
       .fromEnv("<service-name>")
       .getTracerBuilder()
       .registerInjector(Format.Builtin.HTTP_HEADERS, b3Codec)
       .registerExtractor(Format.Builtin.HTTP_HEADERS, b3Codec)
       .build();
    
   /* .... */

   Notez que si le traceur Jaeger est créé à l'aide de la configuration d'environnement (Configuration.fromEnv()), le réglage de la variable d'environnement JAEGER_PROPAGATION à b3c définit le mode de propagation de contexte Zipkin (B3) sans modification de code.

Voici des informations sur les modifications à apporter au code d'une application Node.js qui utilise le client Zipkin pour le traçage réparti. Utilisez-le ensuite pour charger les traces dans le service de surveillance de la performance des applications.

Pour ce faire, apportez les modifications suivantes au code d'initialisation du traceur Zipkin :

1. Assurez-vous d'avoir apporté les modifications nécessaires pour que le rapport sur les intervalles soit dans le format Zipkin v2 encodé en JSON.

   Pour plus d'informations sur le format Zipkin v2, voir Zipkin 2.

2. Ajoutez l'URL du programme de collecte APM, pour charger les intervalles dans le service de surveillance de la performance des applications, ainsi que le nom de votre service ou application.
3. Désactivez la fonction Zipkin de jointure d'intervalles (span joining) si elle est activée. La spécification OpenTracing n'autorise pas le partage d'ID intervalle entre différents intervalles dans la même trace et cette fonction doit être désactivée.

Exemple Node.js

Voici un exemple du code d'initialisation du traceur Zipkin et les modifications détaillées dans la procédure sont en caractères gras :

const {
  Tracer,
  BatchRecorder,
  jsonEncoder: {JSON_V2}
} = require('zipkin');
 
const CLSContext = require('zipkin-context-cls');
const {HttpLogger} = require('zipkin-transport-http');
 
// Setup the tracer
const tracer = new Tracer({
  ctxImpl: new CLSContext('zipkin'), // implicit in-process context
  recorder: new BatchRecorder({
    logger: new HttpLogger({
      endpoint: '<Application Performance Monitoring collector URL>', //Span collection endpoint URL setting
      jsonEncoder: JSON_V2 //Span format and encoding setting
    })
  }), // batched http recorder
  localServiceName: '<service-name>', // name of the application/service
  supportsJoin: false //Span join disable setting
});

L'URL du programme de collecte APM est requise lors de la configuration des traceurs à code source libre pour communiquer avec le service de surveillance de la performance des applications. Cette rubrique fournit des détails sur le format de l'URL du programme de collecte APM.

L'URL du programme de collecte APM a le format suivant :

<dataUploadEndpoint>/<API version>/observations/<observationType>?dataFormat=<dataFormat>&dataFormatVersion=<dataFormatVersion>&dataKey=<dataKey>

Obtenez la valeur <dataUploadEndpoint> à partir de la page des détails du domaine APM.

https://aaaabbbb.example.us-ashburn-1.oci.oraclecloud.com/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=11115Q7IGN

spring.zipkin.baseUrl =  https://aaaabbbb.example.us-ashburn-1.oci.oraclecloud.com
spring.zipkin.apiPath = /20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=11115Q7IGN

https://aaaabbbb.example.us-phoenix-1.oci.oraclecloud.com/20200101/observations/private-span?dataFormat=otlp-span&dataFormatVersion=1&dataKey=11112222UZ5

Configurer la propagation de contexte pour propager les informations de contexte de trace dans le format approprié et les ajouter à un ou plusieurs en-têtes de demande HTTP. Le contexte de trace permet de mettre en corrélation des intervalles provenant de différents microservices, mais appartenant à la même transaction (trace) et identifiés par un ID trace commun.

Agent/racteur APM

L'agent/le traceur Java APM peut être configuré pour fonctionner avec d'autres traceurs OpenTracing (tels que Jaeger et Zipkin) afin de former une trace complète.

Lorsqu'un appel HTTP se produit, l'agent/le traceur Java APM tente d'ajouter des en-têtes HTTP à l'appel, qui peuvent ensuite être lus à l'autre extrémité pour faciliter la connexion des intervalles.

Vous pouvez modifier ce format à l'aide de la propriété com.oracle.apm.agent.tracer.propagation.type du fichier AgentConfig.properties situé sous le répertoire oracle-apm-agent\config.

Vous pouvez utiliser les types de propagation suivants en affectant la propriété au nom :

Définissez le type de propagation approprié pour que vos différents traceurs puissent travailler ensemble afin de former une trace complète.

OpenTelemetry, Zipkin et Jaeger