split interop test, add spanPropagationServerInterceptor test

interop-testing/build.gradle

@@ -13,7 +13,6 @@ dependencies {
     implementation project(path: ':grpc-alts', configuration: 'shadow'),
             project(':grpc-auth'),
             project(':grpc-census'),
-            project(':grpc-opentelemetry'),
             project(':grpc-gcp-csm-observability'),
             project(':grpc-netty'),
             project(':grpc-okhttp'),

opentelemetry/build.gradle

@@ -7,6 +7,8 @@ plugins {
 
 description = 'gRPC: OpenTelemetry'
 
+test.testLogging.showStandardStreams(true)
+
 dependencies {
     api project(':grpc-api')
     implementation libraries.guava,
@@ -17,8 +19,11 @@ dependencies {
     testImplementation project(':grpc-testing'),
             project(':grpc-inprocess'),
             testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
             libraries.opentelemetry.sdk.testing,
-            libraries.assertj.core // opentelemetry.sdk.testing uses compileOnly for assertj
+            libraries.assertj.core
+    testImplementation project(path: ':grpc-api')
+    // opentelemetry.sdk.testing uses compileOnly for assertj
 
     annotationProcessor libraries.auto.value
 

opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcOpenTelemetry.java

@@ -37,6 +37,7 @@
 import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.api.metrics.Meter;
 import io.opentelemetry.api.metrics.MeterProvider;
+import io.opentelemetry.api.trace.Tracer;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -89,8 +90,8 @@ private GrpcOpenTelemetry(Builder builder) {
     this.optionalLabels = ImmutableList.copyOf(builder.optionalLabels);
     this.openTelemetryMetricsModule = new OpenTelemetryMetricsModule(
         STOPWATCH_SUPPLIER, resource, optionalLabels, builder.plugins);
-    this.openTelemetryTracingModule = new OpenTelemetryTracingModule(openTelemetrySdk);
     this.sink = new OpenTelemetryMetricSink(meter, enableMetrics, disableDefault, optionalLabels);
+    this.openTelemetryTracingModule = new OpenTelemetryTracingModule(openTelemetrySdk);
   }
 
   @VisibleForTesting
@@ -127,6 +128,11 @@ MetricSink getSink() {
     return sink;
   }
 
+  @VisibleForTesting
+  Tracer getTracer() {
+    return this.openTelemetryTracingModule.getTracer();
+  }
+
   /**
    * Registers GrpcOpenTelemetry globally, applying its configuration to all subsequently created
    * gRPC channels and servers.
@@ -154,9 +160,18 @@ public void configureChannelBuilder(ManagedChannelBuilder<?> builder) {
     InternalManagedChannelBuilder.addMetricSink(builder, sink);
     InternalManagedChannelBuilder.interceptWithTarget(
         builder, openTelemetryMetricsModule::getClientInterceptor);
+  }
+
+  void configTracingForChannel(ManagedChannelBuilder<?> builder) {
     builder.intercept(openTelemetryTracingModule.getClientInterceptor());
   }
 
+  void configureTracingForServer(ServerBuilder<?> serverBuilder) {
+    serverBuilder.addStreamTracerFactory(
+        openTelemetryTracingModule.getServerTracerFactory());
+    serverBuilder.intercept(openTelemetryTracingModule.getServerSpanPropagationInterceptor());
+  }
+
   /**
    * Configures the given {@link ServerBuilder} with OpenTelemetry metrics instrumentation.
    *

opentelemetry/src/main/java/io/grpc/opentelemetry/InternalGrpcOpenTelemetry.java

@@ -17,6 +17,8 @@
 package io.grpc.opentelemetry;
 
 import io.grpc.Internal;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ServerBuilder;
 
 /**
  * Internal accessor for {@link GrpcOpenTelemetry}.
@@ -29,4 +31,15 @@ public static void builderPlugin(
       GrpcOpenTelemetry.Builder builder, InternalOpenTelemetryPlugin plugin) {
     builder.plugin(plugin);
   }
+
+
+  public static void configTracingForChannelExperimental(
+      ManagedChannelBuilder<?> builder, GrpcOpenTelemetry grpcOpenTelemetry) {
+    grpcOpenTelemetry.configTracingForChannel(builder);
+  }
+
+  public static void configChannelBuilderExperimental(
+      ServerBuilder<?> builder, GrpcOpenTelemetry grpcOpenTelemetry) {
+    grpcOpenTelemetry.configureTracingForServer(builder);
+  }
 }

opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryTracingModule.java

@@ -18,6 +18,7 @@
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.internal.GrpcUtil.IMPLEMENTATION_VERSION;
 
 import com.google.common.annotations.VisibleForTesting;
 import io.grpc.Attributes;
@@ -35,6 +36,7 @@
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
 import io.grpc.ServerStreamTracer;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
 import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.api.common.AttributesBuilder;
 import io.opentelemetry.api.trace.Span;
@@ -55,8 +57,7 @@ final class OpenTelemetryTracingModule {
   private static final Logger logger = Logger.getLogger(OpenTelemetryTracingModule.class.getName());
 
   @VisibleForTesting
-  static final String OTEL_TRACING_SCOPE_NAME = "grpc-java";
-  private final io.grpc.Context.Key<Span> otelSpan = io.grpc.Context.key("opentelemetry-span-key");
+  final io.grpc.Context.Key<Span> otelSpan = io.grpc.Context.key("opentelemetry-span-key");
   @Nullable
   private static final AtomicIntegerFieldUpdater<CallAttemptsTracerFactory> callEndedUpdater;
   @Nullable
@@ -94,10 +95,18 @@ final class OpenTelemetryTracingModule {
   private final ServerTracerFactory serverTracerFactory = new ServerTracerFactory();
 
   OpenTelemetryTracingModule(OpenTelemetry openTelemetry) {
-    this.otelTracer = checkNotNull(openTelemetry.getTracer(OTEL_TRACING_SCOPE_NAME), "otelTracer");
+    this.otelTracer = checkNotNull(openTelemetry.getTracerProvider(), "tracerProvider")
+        .tracerBuilder(OpenTelemetryConstants.INSTRUMENTATION_SCOPE)
+        .setInstrumentationVersion(IMPLEMENTATION_VERSION)
+        .build();
     this.contextPropagators = checkNotNull(openTelemetry.getPropagators(), "contextPropagators");
   }
 
+  @VisibleForTesting
+  Tracer getTracer() {
+    return otelTracer;
+  }
+
   /**
    * Creates a {@link CallAttemptsTracerFactory} for a new call.
    */
@@ -321,52 +330,53 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, Re
             + "tracing must be set.");
         return next.startCall(call, headers);
       }
-      try (Scope scope = Context.current().with(span).makeCurrent()) {
-        return new AttachSpanServerCallListener<>(next.startCall(call, headers), span);
+      Context serverCallContext = Context.current().with(span);
+      try (Scope scope = serverCallContext.makeCurrent()) {
+        return new ContextServerCallListener<>(next.startCall(call, headers), serverCallContext);
       }
     }
   }
 
-  private static class AttachSpanServerCallListener<ReqT> extends
+  private static class ContextServerCallListener<ReqT> extends
       ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT> {
-    private final Span span;
+    private final Context context;
 
-    protected AttachSpanServerCallListener(ServerCall.Listener<ReqT> delegate, Span span) {
+    protected ContextServerCallListener(ServerCall.Listener<ReqT> delegate, Context context) {
       super(delegate);
-      this.span = checkNotNull(span, "span");
+      this.context = checkNotNull(context, "context");
     }
 
     @Override
     public void onMessage(ReqT message) {
-      try (Scope scope = Context.current().with(span).makeCurrent()) {
+      try (Scope scope = context.makeCurrent()) {
         delegate().onMessage(message);
       }
     }
 
     @Override
     public void onHalfClose() {
-      try (Scope scope = Context.current().with(span).makeCurrent()) {
+      try (Scope scope = context.makeCurrent()) {
         delegate().onHalfClose();
       }
     }
 
     @Override
     public void onCancel() {
-      try (Scope scope = Context.current().with(span).makeCurrent()) {
+      try (Scope scope = context.makeCurrent()) {
         delegate().onCancel();
       }
     }
 
     @Override
     public void onComplete() {
-      try (Scope scope = Context.current().with(span).makeCurrent()) {
+      try (Scope scope = context.makeCurrent()) {
         delegate().onComplete();
       }
     }
 
     @Override
     public void onReady() {
-      try (Scope scope = Context.current().with(span).makeCurrent()) {
+      try (Scope scope = context.makeCurrent()) {
         delegate().onReady();
       }
     }

opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcOpenTelemetryTest.java

@@ -25,6 +25,7 @@
 import io.opentelemetry.sdk.OpenTelemetrySdk;
 import io.opentelemetry.sdk.metrics.SdkMeterProvider;
 import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -35,6 +36,7 @@ public class GrpcOpenTelemetryTest {
   private final InMemoryMetricReader inMemoryMetricReader = InMemoryMetricReader.create();
   private final SdkMeterProvider meterProvider =
       SdkMeterProvider.builder().registerMetricReader(inMemoryMetricReader).build();
+  private final SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build();
   private final OpenTelemetry noopOpenTelemetry = OpenTelemetry.noop();
 
   @Test
@@ -56,6 +58,21 @@ public void build() {
     assertThat(openTelemetryModule.getOptionalLabels()).isEqualTo(ImmutableList.of("version"));
   }
 
+  @Test
+  public void buildTracer() {
+    OpenTelemetrySdk sdk =
+        OpenTelemetrySdk.builder().setTracerProvider(tracerProvider).build();
+
+    GrpcOpenTelemetry openTelemetryModule = GrpcOpenTelemetry.newBuilder()
+        .sdk(sdk).build();
+
+    assertThat(openTelemetryModule.getOpenTelemetryInstance()).isSameInstanceAs(sdk);
+    assertThat(openTelemetryModule.getTracer()).isSameInstanceAs(
+        tracerProvider.tracerBuilder("grpc-java")
+            .setInstrumentationVersion(GrpcUtil.IMPLEMENTATION_VERSION)
+            .build());
+  }
+
   @Test
   public void builderDefaults() {
     GrpcOpenTelemetry module = GrpcOpenTelemetry.newBuilder().build();
@@ -73,6 +90,13 @@ public void builderDefaults() {
     assertThat(module.getEnableMetrics()).isEmpty();
     assertThat(module.getOptionalLabels()).isEmpty();
     assertThat(module.getSink()).isInstanceOf(MetricSink.class);
+
+    assertThat(module.getTracer()).isSameInstanceAs(noopOpenTelemetry
+        .getTracerProvider()
+        .tracerBuilder("grpc-java")
+        .setInstrumentationVersion(GrpcUtil.IMPLEMENTATION_VERSION)
+        .build()
+    );
   }
 
   @Test