Voici des informations sur la configuration des sources de données OpenTelemetry (OTEL) (telles que les bibliothèques d'instrumentation et le collecteur OpenTelemetry) afin de télécharger des données de surveillance (mesures et traces) vers 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 la trace distribuée et le téléchargement des traces vers Application Performance Monitoring.

Pour utiliser le traceur Jaeger afin de télécharger des traces d'une application Java vers Application Performance Monitoring, vous devez configurer le client Java Jaeger de sorte qu'il soit compatible Zipkin (rapport au format v2 Zipkin) 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 générateur de rapports Zipkin 2 à l'interface du générateur de rapports Jaeger et convertir les étendues Jaeger au format Zipkin v2 encodé JSON. Veillez à indiquer l'URL du collecteur Application Performance Monitoring pour télécharger les étendues vers Application Performance Monitoring, 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. Inscrivez B3TextMapCodec afin d'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 de 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();
    
   /* .... */

   Si le traceur Jaeger est créé à l'aide de la configuration d'environnement (Configuration.fromEnv()), la définition de la variable d'environnement JAEGER_PROPAGATION sur b3c définit le mode de propagation du contexte Zipkin (B3) sans modification du code.

Voici des informations sur les modifications à apporter au code d'une application Node.js qui utilise le client Zipkin pour la trace distribuée et le téléchargement des traces vers Application Performance Monitoring.

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

1. Veillez à avoir apporté les modifications nécessaires pour générer des rapports sur les étendues au format Zipkin v2 encodé JSON.

   Pour plus d'informations sur le format Zipkin v2, reportez-vous à la section Zipkin 2.

2. Ajoutez l'URL du collecteur Application Performance Monitoring pour télécharger les étendues vers Application Performance Monitoring, ainsi que le nom de votre service ou application.
3. Désactivez la fonctionnalité Zipkin de jointure des étendues, si elle est activée. La spécification OpenTracing n'autorise pas le partage des ID d'étendue entre les étendues d'une même trace. Cette fonctionnalité doit donc être désactivée.

Exemple avec Node.js

Voici un exemple de code d'initialisation du traceur Zipkin (les modifications détaillées dans la procédure sont en 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 collecteur Application Performance Monitoring est requise lors de la configuration des traceurs open source pour assurer la communication avec le service Application Performance Monitoring. Cette rubrique fournit des détails sur le format de l'URL du collecteur APM.

L'URL du collecteur Application Performance Monitoring se présente au format suivant :

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

Obtenez la valeur <dataUploadEndpoint> à partir de la page de 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

Configurez la propagation du contexte pour que les informations de contexte de trace soient propagées dans le format approprié et ajoutez-les à des en-têtes de demande HTTP. Le contexte de trace permet d'établir une corrélation entre les étendues issues de plusieurs microservices, mais appartenant à la même transaction (trace) et identifiées par un ID de trace commun.

Agent/traceur APM

L'agent ou 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 est lancé, l'agent ou le traceur Java APM tente de lui ajouter des en-têtes HTTP, qui peuvent ensuite être lus à l'autre extrémité pour faciliter la connexion des étendues.

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 définissant la propriété sur leur nom :

Définissez le type de propagation approprié pour permettre à vos différents traceurs d'oeuvrer ensemble à la formation une trace complète.

OpenTelemetry, Zipkin et Jaeger