Distributed tracing support with Micrometer and OpenTelemetry

README.adoc

@@ -315,6 +315,29 @@ image:./images/interceptors_003.png[]
 This started is *natively* supported by `spring-cloud-sleuth` project. +
 Please continue to https://docs.spring.io/spring-cloud-sleuth/docs/current/reference/html/integrations.html#sleuth-rpc-grpc-integration[sleuth grpc integration].
 
+=== Distributed tracing support (OpenTelemetry)
+
+OpenTelemetry distributed tracing can enabled by including:
+[source,groovy]
+----
+implementation 'io.opentelemetry:opentelemetry-exporter-otlp:[version]'
+implementation 'io.micrometer:micrometer-tracing-bridge-otel:[version]'
+----
+
+Enable tracing for client by adding `TracingClientInterceptor` to `ManagedChannelBuilder`:
+[source,java]
+----
+ManagedChannelBuilder.forAddress(host, port)
+ ...
+.intercept(TracingClientInterceptor())
+.build()
+----
+
+Add tracing interceptor `TracingServerInterceptor` for your `GRpcService`:
+[source,java]
+----
+@GRpcService(interceptors = {LogInterceptor.class, TracingServerInterceptor.class })
+----
 
 === GRPC server metrics (Micrometer.io integration)
 

grpc-client-spring-boot-starter/build.gradle

@@ -114,6 +114,8 @@ signing {
 
 dependencies {
     api "io.grpc:grpc-api:${grpcVersion}"
+    compileOnly 'io.opentelemetry:opentelemetry-exporter-otlp:1.29.0'
+    compileOnly 'io.micrometer:micrometer-tracing-bridge-otel:1.1.4'
 }
 compileJava.dependsOn(processResources)
 

grpc-client-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/tracing/TracingClientInterceptor.java

@@ -0,0 +1,33 @@
+package org.lognet.springboot.grpc.tracing;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ForwardingClientCall;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.TraceId;
+
+public class TracingClientInterceptor implements ClientInterceptor {
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+
+        return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+            @Override
+            public void start(ClientCall.Listener<RespT> responseListener, Metadata headers) {
+                Span currentSpan = Span.current();
+                String traceId = currentSpan.getSpanContext().getTraceId();
+                String spanId = currentSpan.getSpanContext().getSpanId();
+
+                if (!traceId.equals(TraceId.getInvalid())) {
+                    headers.put(Metadata.Key.of("traceId", Metadata.ASCII_STRING_MARSHALLER), traceId);
+                    headers.put(Metadata.Key.of("spanId", Metadata.ASCII_STRING_MARSHALLER), spanId);
+                }
+                super.start(responseListener, headers);
+            }
+        };
+    }
+}

grpc-spring-boot-starter/build.gradle

@@ -286,6 +286,8 @@ dependencies {
     compileOnly "org.springframework.boot:spring-boot-starter-actuator"
     compileOnly "org.springframework.boot:spring-boot-starter-validation"
     compileOnly 'org.springframework.cloud:spring-cloud-starter-consul-discovery'
+    compileOnly 'io.opentelemetry:opentelemetry-exporter-otlp:1.29.0'
+    compileOnly 'io.micrometer:micrometer-tracing-bridge-otel:1.1.4'
 
 
     testImplementation "javax.annotation:javax.annotation-api:1.3.2"

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/autoconfigure/tracing/OtelConfiguration.java

@@ -0,0 +1,42 @@
+package org.lognet.springboot.grpc.autoconfigure.tracing;
+
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
+import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporterBuilder;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
+import org.lognet.springboot.grpc.tracing.TracingServerInterceptor;
+import org.springframework.boot.actuate.autoconfigure.tracing.otlp.OtlpProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@EnableConfigurationProperties(OtlpProperties.class)
+public class OtelConfiguration {
+
+    @Bean
+    public OtlpGrpcSpanExporter otlpExporter(OtlpProperties properties) {
+        OtlpGrpcSpanExporterBuilder builder = OtlpGrpcSpanExporter.builder().setEndpoint(properties.getEndpoint());
+        return builder.build();
+    }
+
+    @Bean
+    public Tracer tracer(OtlpGrpcSpanExporter otlpExporter) {
+        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
+                .addSpanProcessor(BatchSpanProcessor.builder(otlpExporter).build())
+                .build();
+
+        OpenTelemetrySdk openTelemetry = OpenTelemetrySdk.builder()
+                .setTracerProvider(tracerProvider)
+                .buildAndRegisterGlobal();
+
+        return openTelemetry.getTracerProvider().get("grpc-spring-boot-starter");
+    }
+
+    @Bean
+    public TracingServerInterceptor tracingServerInterceptor(Tracer tracer) {
+        return new TracingServerInterceptor(tracer);
+    }
+}

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/log/LogInterceptor.java

@@ -0,0 +1,22 @@
+package org.lognet.springboot.grpc.log;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+@Component
+public class LogInterceptor implements ServerInterceptor {
+
+    private final Logger logger = LoggerFactory.getLogger(LogInterceptor.class);
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        logger.info(call.getMethodDescriptor().getFullMethodName());
+        return next.startCall(call, headers);
+    }
+}

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/tracing/TracingServerInterceptor.java

@@ -0,0 +1,52 @@
+package org.lognet.springboot.grpc.tracing;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanBuilder;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+
+public class TracingServerInterceptor implements ServerInterceptor {
+
+    private final Tracer tracer;
+
+    public TracingServerInterceptor(Tracer tracer) {
+        this.tracer = tracer;
+    }
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+
+        String traceId = headers.get(Metadata.Key.of("traceId", Metadata.ASCII_STRING_MARSHALLER));
+        String spanId = headers.get(Metadata.Key.of("spanId", Metadata.ASCII_STRING_MARSHALLER));
+
+        Context spanContext = createSpanContext(traceId, spanId);
+        SpanBuilder spanBuilder = tracer.spanBuilder("grpc-spring-boot-starter-span").setParent(spanContext);
+        Span span = spanBuilder.startSpan();
+        Context scopedContext = Context.current().with(span);
+
+        try (Scope scope = scopedContext.makeCurrent()) {
+            return next.startCall(call, headers);
+        } finally {
+            span.end();
+        }
+    }
+
+    private Context createSpanContext(String traceId, String spanId) {
+        SpanContext spanContext = SpanContext.createFromRemoteParent(
+                traceId != null ? traceId : "",
+                spanId != null ? spanId : "",
+                TraceFlags.getDefault(),
+                TraceState.getDefault()
+        );
+        return Context.current().with(Span.wrap(spanContext));
+    }
+}