Split sofarpc into sofarpc-5.0/sofarpc-5.14 modules, fix Triple+gRPC span hierarchy, add REST and Triple tests

Author: ValentinZakharov

dd-java-agent/instrumentation/sofarpc/sofarpc-5.0/build.gradle

@@ -15,6 +15,8 @@ dependencies {
   compileOnly group: "com.alipay.sofa", name: "sofa-rpc-all", version: "5.6.0"
 
   testImplementation group: "com.alipay.sofa", name: "sofa-rpc-all", version: "5.6.0"
+  // JAX-RS annotations required for the REST protocol test interface (@Path, @GET, etc.)
+  testImplementation group: "javax.ws.rs", name: "javax.ws.rs-api", version: "2.1.1"
 
   latestDepTestImplementation group: "com.alipay.sofa", name: "sofa-rpc-all", version: "+"
 }

dd-java-agent/instrumentation/sofarpc/sofarpc-5.0/src/main/java/datadog/trace/instrumentation/sofarpc/ProviderProxyInvokerInstrumentation.java

@@ -46,17 +46,21 @@ public static AgentScope enter(@Advice.Argument(0) SofaRequest request) {
       if (protocol == null) {
         return null;
       }
-      AgentSpan span;
-      if ("bolt".equals(protocol) || "h2c".equals(protocol)) {
-        // Bolt propagates Datadog trace headers via SofaRequest.requestProps — extract from there.
-        AgentSpanContext parentContext = extractContextAndGetSpanContext(request, GETTER);
-        span = startSpan(SOFA_RPC_SERVER, parentContext);
-      } else {
-        // For Triple and other protocols, trace context is propagated at the transport layer
-        // (e.g. gRPC Metadata). The transport instrumentation already activated the parent span,
-        // so startSpan without an explicit parent inherits it automatically.
-        span = startSpan(SOFA_RPC_SERVER);
+      // Prefer the parent context stored by transport-specific instrumentation (e.g.
+      // TripleServerInstrumentation reads it from gRPC Metadata). For Bolt and H2C the
+      // transport instrumentations only set the protocol, so parentContext is null here and
+      // we fall back to extracting from SofaRequest.requestProps as before.
+      AgentSpanContext parentContext = SofaRpcProtocolContext.getParentContext();
+      if (parentContext == null) {
+        parentContext = extractContextAndGetSpanContext(request, GETTER);
       }
+      // parentContext may be null for Triple+gRPC-enabled: TripleServerInstrumentation skips
+      // Metadata extraction when a grpc.server span is already active. In that case
+      // startSpan() without an explicit parent naturally attaches to the active grpc.server span.
+      AgentSpan span =
+          parentContext != null
+              ? startSpan(SOFA_RPC_SERVER, parentContext)
+              : startSpan(SOFA_RPC_SERVER);
       DECORATE.afterStart(span);
       DECORATE.onRequest(span, request);
       span.setTag("sofarpc.protocol", protocol);

dd-java-agent/instrumentation/sofarpc/sofarpc-5.0/src/main/java/datadog/trace/instrumentation/sofarpc/SofaRpcModule.java

@@ -31,7 +31,6 @@ public List<Instrumenter> typeInstrumentations() {
         new AbstractClusterInstrumentation(),
         new BoltServerProcessorInstrumentation(),
         new H2cServerTaskInstrumentation(),
-        new TripleServerInstrumentation(),
         new ProviderProxyInvokerInstrumentation());
   }
 }

dd-java-agent/instrumentation/sofarpc/sofarpc-5.0/src/main/java/datadog/trace/instrumentation/sofarpc/SofaRpcProtocolContext.java

@@ -1,21 +1,39 @@
 package datadog.trace.instrumentation.sofarpc;
 
-/** Thread-local carrier for the SOFA RPC transport protocol name. */
+import datadog.trace.bootstrap.instrumentation.api.AgentSpanContext;
+
+/**
+ * Thread-local carrier for the SOFA RPC transport protocol name and the propagated parent span
+ * context. The parent context is extracted by transport-specific instrumentation (e.g.
+ * TripleServerInstrumentation reads it from gRPC Metadata) so that ProviderProxyInvokerInstrumentation
+ * can start the server span with an explicit parent regardless of whether other instrumentation
+ * (e.g. gRPC) is enabled.
+ */
 public final class SofaRpcProtocolContext {
 
   private static final ThreadLocal<String> PROTOCOL = new ThreadLocal<>();
+  private static final ThreadLocal<AgentSpanContext> PARENT_CONTEXT = new ThreadLocal<>();
 
   private SofaRpcProtocolContext() {}
 
   public static void set(String protocol) {
     PROTOCOL.set(protocol);
   }
 
+  public static void setParentContext(AgentSpanContext parentContext) {
+    PARENT_CONTEXT.set(parentContext);
+  }
+
   public static String get() {
     return PROTOCOL.get();
   }
 
+  public static AgentSpanContext getParentContext() {
+    return PARENT_CONTEXT.get();
+  }
+
   public static void clear() {
     PROTOCOL.remove();
+    PARENT_CONTEXT.remove();
   }
 }

dd-java-agent/instrumentation/sofarpc/sofarpc-5.0/src/main/java/datadog/trace/instrumentation/sofarpc/TripleServerInstrumentation.java

@@ -0,0 +1,125 @@
+package datadog.trace.instrumentation.sofarpc
+
+import com.alipay.sofa.rpc.bootstrap.ProviderBootstrap
+import com.alipay.sofa.rpc.config.ApplicationConfig
+import com.alipay.sofa.rpc.config.ConsumerConfig
+import com.alipay.sofa.rpc.config.ProviderConfig
+import com.alipay.sofa.rpc.config.ServerConfig
+import datadog.trace.agent.test.InstrumentationSpecification
+import datadog.trace.bootstrap.instrumentation.api.Tags
+import spock.lang.Shared
+
+import javax.ws.rs.GET
+import javax.ws.rs.Path
+import javax.ws.rs.PathParam
+import javax.ws.rs.Produces
+import javax.ws.rs.core.MediaType
+
+import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
+import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
+
+/**
+ * Tests SOFA RPC REST protocol instrumentation.
+ *
+ * REST works out-of-the-box via dd-trace-java's Apache HttpClient and HTTP server
+ * instrumentation.  Our SOFA RPC instrumentation contributes the sofarpc.request[client]
+ * span (from AbstractClusterInstrumentation).  There is no sofarpc.request[server] span
+ * because no transport-level instrumentation sets SofaRpcProtocolContext for REST — the
+ * server side is covered by JAX-RS / HTTP server instrumentation instead.
+ */
+class SofaRpcRestTest extends InstrumentationSpecification {
+
+  @Shared
+  int port = 12205
+
+  @Shared
+  ProviderBootstrap restProviderBootstrap
+
+  @Shared
+  GreeterService greeterService
+
+  def setupSpec() {
+    ServerConfig serverConfig =
+      new ServerConfig()
+        .setProtocol("rest")
+        .setHost("127.0.0.1")
+        .setPort(port)
+
+    ProviderConfig<GreeterService> providerConfig =
+      new ProviderConfig<GreeterService>()
+        .setApplication(new ApplicationConfig().setAppName("test-server"))
+        .setInterfaceId(GreeterService.name)
+        .setRef(new GreeterServiceImpl())
+        .setServer(serverConfig)
+        .setRegister(false)
+
+    restProviderBootstrap = providerConfig.export()
+
+    greeterService =
+      new ConsumerConfig<GreeterService>()
+        .setApplication(new ApplicationConfig().setAppName("test-client"))
+        .setInterfaceId(GreeterService.name)
+        .setDirectUrl("rest://127.0.0.1:${port}")
+        .setProtocol("rest")
+        .setRegister(false)
+        .setSubscribe(false)
+        .refer()
+  }
+
+  def cleanupSpec() {
+    restProviderBootstrap?.unExport()
+  }
+
+  def "client span created for REST call"() {
+    setup:
+    String serviceUniqueName = GreeterService.name + ":1.0"
+
+    when:
+    String reply = runUnderTrace("caller") { greeterService.sayHello("World") }
+
+    then:
+    reply == "Hello, World"
+
+    and:
+    // REST is instrumented by Apache HttpClient (client) + HTTP server (server) integrations.
+    // Our SOFA RPC instrumentation adds sofarpc.request[client] on top.  No server-side
+    // SofaRpcProtocolContext is set for REST, so ProviderProxyInvoker produces no sofarpc span.
+    // Only the client-side trace is collected here.
+    assertTraces(1) {
+      trace(2) {
+        basicSpan(it, "caller")
+        span {
+          operationName "sofarpc.request"
+          resourceName "${serviceUniqueName}/sayHello"
+          spanType "rpc"
+          errored false
+          childOf span(0)
+          tags {
+            "$Tags.RPC_SERVICE" serviceUniqueName
+            "rpc.system" "sofarpc"
+            "sofarpc.protocol" "rest"
+            "component" "sofarpc-client"
+            "span.kind" "client"
+            peerServiceFrom(Tags.RPC_SERVICE)
+            defaultTags()
+          }
+        }
+      }
+    }
+  }
+
+  @Path("/greeter")
+  interface GreeterService {
+    @GET
+    @Path("/hello/{name}")
+    @Produces(MediaType.TEXT_PLAIN)
+    String sayHello(@PathParam("name") String name)
+  }
+
+  static class GreeterServiceImpl implements GreeterService {
+    @Override
+    String sayHello(String name) {
+      return "Hello, ${name}"
+    }
+  }
+}

dd-java-agent/instrumentation/sofarpc/sofarpc-5.0/src/test/groovy/datadog/trace/instrumentation/sofarpc/SofaRpcRestTest.groovy

@@ -0,0 +1,47 @@
+muzzle {
+  pass {
+    group = "com.alipay.sofa"
+    module = "sofa-rpc-all"
+    versions = "[5.14.2,)"
+    assertInverse = true
+  }
+}
+
+apply from: "$rootDir/gradle/java.gradle"
+
+configurations.testRuntimeClasspath {
+  // Force the JRE variant of Guava so that java.time-based APIs (e.g.
+  // CacheBuilder.expireAfterWrite(Duration)) are available at test runtime.
+  // Without this, dependency resolution picks the android variant which lacks
+  // those overloads, causing NoSuchMethodError during SOFA RPC initialisation.
+  resolutionStrategy.force "com.google.guava:guava:32.1.3-jre"
+}
+
+addTestSuiteForDir('latestDepTest', 'test')
+
+dependencies {
+  compileOnly project(':dd-java-agent:instrumentation:sofarpc:sofarpc-5.0')
+  compileOnly group: "com.alipay.sofa", name: "sofa-rpc-all", version: "5.14.2"
+  // grpc-api provides io.grpc.Metadata used by TripleGrpcMetadataExtractAdapter.
+  compileOnly group: "io.grpc", name: "grpc-api", version: "1.53.0"
+
+  testImplementation project(':dd-java-agent:instrumentation:sofarpc:sofarpc-5.0')
+  // Required so that GrpcServerModule / GrpcClientModule are discovered via ServiceLoader
+  // in SofaRpcTripleWithGrpcForkedTest (the test framework loads InstrumenterModules from
+  // the test classpath, not from a shadow jar).
+  testImplementation project(':dd-java-agent:instrumentation:grpc-1.5')
+  testImplementation group: "com.alipay.sofa", name: "sofa-rpc-all", version: "5.14.2"
+  // sofa-rpc-all:5.14.2 was compiled against gRPC 1.53.0 and does not bundle its
+  // transitive dependencies — they must be declared explicitly at the matching version.
+  testImplementation group: "io.grpc", name: "grpc-netty", version: "1.53.0"
+  testImplementation group: "io.grpc", name: "grpc-core", version: "1.53.0"
+  testImplementation group: "io.grpc", name: "grpc-stub", version: "1.53.0"
+  testImplementation group: "com.google.protobuf", name: "protobuf-java", version: "3.25.3"
+  testImplementation group: "com.alibaba", name: "fastjson", version: "1.2.83"
+  // sofa-common-tools (transitive via sofa-rpc-all:5.14.2) uses Guava 28+ API
+  // (CacheBuilder.expireAfterWrite(Duration)); force the JRE variant — the android
+  // variant omits java.time-based overloads that are required at runtime.
+  testImplementation group: "com.google.guava", name: "guava", version: "32.1.3-jre"
+
+  latestDepTestImplementation group: "com.alipay.sofa", name: "sofa-rpc-all", version: "+"
+}

dd-java-agent/instrumentation/sofarpc/sofarpc-5.14/build.gradle

@@ -0,0 +1,27 @@
+package datadog.trace.instrumentation.sofarpc;
+
+import com.google.auto.service.AutoService;
+import datadog.trace.agent.tooling.Instrumenter;
+import datadog.trace.agent.tooling.InstrumenterModule;
+import java.util.Collections;
+import java.util.List;
+
+@AutoService(InstrumenterModule.class)
+public class SofaRpcTripleModule extends InstrumenterModule.Tracing {
+
+  public SofaRpcTripleModule() {
+    super("sofarpc");
+  }
+
+  @Override
+  public String[] helperClassNames() {
+    return new String[] {
+      packageName + ".TripleGrpcMetadataExtractAdapter",
+    };
+  }
+
+  @Override
+  public List<Instrumenter> typeInstrumentations() {
+    return Collections.singletonList(new TripleServerInstrumentation());
+  }
+}

dd-java-agent/instrumentation/sofarpc/sofarpc-5.14/src/main/java/datadog/trace/instrumentation/sofarpc/SofaRpcTripleModule.java

@@ -0,0 +1,32 @@
+package datadog.trace.instrumentation.sofarpc;
+
+import datadog.trace.bootstrap.instrumentation.api.AgentPropagation;
+import io.grpc.Metadata;
+
+/**
+ * Extracts Datadog propagation headers from gRPC {@link Metadata}.
+ *
+ * <p>Used by {@link TripleServerInstrumentation} to read the trace context that was injected by
+ * {@link AbstractClusterInstrumentation} into {@code SofaRequest.requestProps} on the client side
+ * and then serialised into gRPC Metadata by SOFA RPC's {@code TripleTracerAdapter.beforeSend()}.
+ *
+ * <p>Identical in structure to {@code GrpcExtractAdapter} in the grpc-1.5 instrumentation.
+ */
+public final class TripleGrpcMetadataExtractAdapter
+    implements AgentPropagation.ContextVisitor<Metadata> {
+
+  public static final TripleGrpcMetadataExtractAdapter GETTER =
+      new TripleGrpcMetadataExtractAdapter();
+
+  @Override
+  public void forEachKey(Metadata carrier, AgentPropagation.KeyClassifier classifier) {
+    for (String key : carrier.keys()) {
+      if (!key.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+        if (!classifier.accept(
+            key, carrier.get(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER)))) {
+          return;
+        }
+      }
+    }
+  }
+}