Managed Service for OpenTelemetry:Reporte de datos de aplicaciones Java mediante Jaeger

Requisitos previos

Contexto

Para reportar los datos de una aplicación Java a la consola de Managed Service for OpenTelemetry mediante Jaeger, primero debe instrumentar la aplicación. Esta instrumentación se configura de forma manual o bien mediante diversos complementos existentes para automatizarla. Este tema describe los tres métodos de instrumentación siguientes:

• Instrumentación manual

• Instrumentación mediante un componente de Spring Cloud

• Instrumentación mediante un componente de gRPC

Instrumentar una aplicación Java

Antes de usar Jaeger para enviar los datos de una aplicación Java a Managed Service for OpenTelemetry, debe instrumentar la aplicación. En este ejemplo, la aplicación se instrumenta de forma manual.

1. Descargue el proyecto de demostración. Acceda al directorio manualDemo y ejecute el programa según las instrucciones del archivo README.md.

2. Agregue la siguiente dependencia de los clientes de Jaeger al archivo pom.xml:

   <dependency>
       <groupId>io.jaegertracing</groupId>
       <artifactId>jaeger-client</artifactId>
       <version>0.31.0</version>
   </dependency>

3. Configure los parámetros de inicialización y cree un tracer.

   Un tracer permite crear spans para registrar el tiempo de las operaciones distribuidas. También transmite datos entre servidores en modo de paso directo mediante los métodos Extract o Inject, o bien especifica el span actual. Asimismo, el tracer contiene datos como el endpoint utilizado para reportar información, la dirección IP local, la tasa de muestreo y el nombre del servicio. Ajuste la tasa de muestreo para reducir la sobrecarga generada por el reporte de datos.

   Nota

   Reemplace <endpoint> por el endpoint que obtuvo en la sección "Requisitos previos" de este tema.

   // Replace manualDemo with your application name.
   io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("manualDemo");
   io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
   // Replace <endpoint> with the endpoint that you obtained in the "Prerequisites" section of this topic. 
   sender.withEndpoint("<endpoint>");
   config.withSampler(new io.jaegertracing.Configuration.SamplerConfiguration().withType("const").withParam(1));
   config.withReporter(new io.jaegertracing.Configuration.ReporterConfiguration().withSender(sender).withMaxQueueSize(10000));
   // Set resource tags, such as the application version and deployment environment.
   Map<String, String> map = new HashMap<>();
   map.put("service.version", "1.0.0");
   map.put("deployment.environment", "test");
   config.withTracerTags(map);
   GlobalTracer.register(config.getTracer());

4. Registre los datos de la solicitud.

   Tracer tracer = GlobalTracer.get();
   // Create a span. 
   Span span = tracer.buildSpan("parentSpan").withTag("myTag", "spanFirst").start();
   tracer.scopeManager().activate(span, false);
   tracer.activeSpan().setTag("methodName", "testTracing");
   // The business logic. 
   secondBiz();
   span.finish();

5. Opcional. Ejecute el código anterior para crear un span raíz que registre la operación principal de una solicitud. Si desea registrar las operaciones previas y posteriores de una solicitud, especifique la información de contexto.

   Tracer tracer = GlobalTracer.get();
   Span parentspan = tracer.activeSpan();
   Tracer.SpanBuilder spanBuilder = tracer.buildSpan("childSpan").withTag("myTag", "spanSecond");
   if (parentspan !=null) {
       spanBuilder.asChildOf(parentspan).start();
   }
   Span childSpan = spanBuilder.start();
   Scope scope = tracer.scopeManager().activate(childSpan); // The statement is executed once when the request starts.
   // The business logic.  The buildSpan function can be executed multiple times.
   childSpan.finish();
   tracer.activeSpan().setTag("methodName", "testCall");
   
   // The statement is executed once when the request ends.
   scope.close();

6. Opcional. Para solucionar problemas de manera eficiente, agregue etiquetas personalizadas a un span. Por ejemplo, añada una etiqueta personalizada para comprobar si ocurre un error o para registrar el valor devuelto por una solicitud.

   tracer.activeSpan().setTag("methodName", "testCall");

7. En un sistema distribuido, las solicitudes de llamada a procedimiento remoto (RPC) se envían junto con los datos de traza. Estos datos contienen los valores de los parámetros TraceId, ParentSpanId, SpanId y Sampled. Llame al método Extract o Inject para transmitir los datos de traza en los encabezados de las solicitudes HTTP. La siguiente figura muestra todo el proceso.

   

   1. Llame al método Inject en el cliente para especificar la información de contexto.

      private void attachTraceInfo(Tracer tracer, Span span, final Request request) {
              tracer.inject(span.context(), Format.Builtin.TEXT_MAP, new TextMap() {
                  @Override
                  public void put(String key, String value) {
                      request.setHeader(key, value);
                  }
                  @Override
                  public Iterator<Map.Entry<String, String>> iterator() {
                      throw new UnsupportedOperationException("TextMapInjectAdapter should only be used with Tracer.inject()");
                  }
              });
          }

   2. Llame al método Extract en el servidor para extraer la información de contexto.

      protected Span extractTraceInfo(Request request, Tracer tracer) {
          Tracer.SpanBuilder spanBuilder = tracer.buildSpan("/api/xtrace/test03");
          try {
              SpanContext spanContext = tracer.extract(Format.Builtin.TEXT_MAP, new TextMapExtractAdapter(request.getAttachments()));
              if (spanContext !=null) {
                  spanBuilder.asChildOf(spanContext);
              }
          } catch (Exception e) {
              spanBuilder.withTag("Error", "extract from request fail, error msg:" + e.getMessage());
          }
          return spanBuilder.start();
      }
                                      

Instrumentar una aplicación Java con Spring Cloud

Para reportar los datos de una aplicación Java a la consola de Managed Service for OpenTelemetry mediante Jaeger, primero debe configurar la instrumentación. Este ejemplo utiliza componentes de Spring Cloud para dicho propósito. Spring Cloud ofrece instrumentación para los siguientes componentes:

• @Async, @Scheduled, Executors

• Feign, HystrixFeign

• Hystrix

• JDBC

• JMS

• Mongo

• RabbitMQ

• Redis

• RxJava

• Spring Messaging: las trazas se envían a través de canales de mensajes.

• Spring Web (RestControllers, RestTemplates, WebAsyncTask)

• Standard Logging: los registros se agregan al span actual.

• WebSocket STOMP

• Zuul

1. Abra el archivo pom.xml y agregue las dependencias JAR.

   <dependency>
      <groupId>io.opentracing.contrib</groupId>
     <artifactId>opentracing-spring-cloud-starter</artifactId>
     <version>0.5.8</version>
   </dependency>
   <dependency>
     <groupId>io.jaegertracing</groupId>
     <artifactId>jaeger-client</artifactId>
     <version>1.4.0</version>
   </dependency>

2. Agregue el bean Tracer de OpenTracing.

   Nota

   Reemplace <endpoint> por el endpoint que obtuvo en la sección "Requisitos previos" de este tema.

   @Bean
   public io.opentracing.Tracer tracer() {
       io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("springFrontend");
       io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
       sender.withEndpoint("<endpoint>");
       config.withSampler(new io.jaegertracing.Configuration.SamplerConfiguration().withType("const").withParam(1));
       config.withReporter(new io.jaegertracing.Configuration.ReporterConfiguration().withSender(sender).withMaxQueueSize(10000));
       return config.getTracer();
   }

Instrumentar una aplicación Java con gRPC

Para enviar los datos de una aplicación Java a la consola de Managed Service for OpenTelemetry mediante Jaeger, primero debe instrumentar la aplicación. Este ejemplo utiliza el componente gRPC para dicha tarea.

1. Abra el archivo pom.xml y agregue la dependencia JAR.

   <dependency>
       <groupId>io.opentracing.contrib</groupId>
       <artifactId>opentracing-grpc</artifactId>
       <version>0.2.3</version>
   </dependency>

2. En el servidor, inicialice el objeto Tracer, cree un ServerTracingInterceptor y agréguelo como interceptor del servidor.

   import io.opentracing.Tracer;
       public class YourServer {
           private int port;
           private Server server;
           private final Tracer tracer;
           private void start() throws IOException {
               ServerTracingInterceptor tracingInterceptor = new ServerTracingInterceptor(this.tracer);
               // If GlobalTracer is used: 
               // ServerTracingInterceptor tracingInterceptor = new ServerTracingInterceptor();
               server = ServerBuilder.forPort(port)
                   .addService(tracingInterceptor.intercept(someServiceDef))
                   .build()
                   .start();
           }
       }

3. En el cliente, inicialice el objeto Tracer, cree un ClientTracingInterceptor y agréguelo como interceptor del canal del cliente.

   import io.opentracing.Tracer;
       public class YourClient {
           private final ManagedChannel channel;
           private final GreeterGrpc.GreeterBlockingStub blockingStub;
           private final Tracer tracer;
           public YourClient(String host, int port) {
               channel = ManagedChannelBuilder.forAddress(host, port)
                   .usePlaintext(true)
                   .build();
               ClientTracingInterceptor tracingInterceptor = new ClientTracingInterceptor(this.tracer);
               // If GlobalTracer is used: 
               // ClientTracingInterceptor tracingInterceptor = new ClientTracingInterceptor();
               blockingStub = GreeterGrpc.newBlockingStub(tracingInterceptor.intercept(channel));
           }
       }
                           

Preguntas frecuentes

P: Mi programa de demostración se ejecuta sin errores, pero no aparecen datos en la consola. ¿Cuál podría ser el problema?

R: Depure el método io.jaegertracing.thrift.internal.senders.HttpSender.send(Process process, List<Span> spans) y compruebe el valor devuelto cuando se reportan los datos. Si se reporta un error 403, significa que la configuración del endpoint es incorrecta. Revísela y modifíquela.