Container hash tags propagation

dd-java-agent/instrumentation/jdbc/build.gradle

@@ -22,6 +22,7 @@ addTestSuiteExtendingForDir('latestDepJava11Test', 'latestDepTest', 'test')
 dependencies {
   compileOnly group: 'com.zaxxer', name: 'HikariCP', version: '2.4.0'
   testImplementation(testFixtures(project(':dd-java-agent:agent-iast')))
+  implementation project(':utils:container-utils')
 
   // jdbc unit testing
   testImplementation group: 'com.h2database', name: 'h2', version: '[1.3.168,1.3.169]'// first jdk 1.6 compatible

dd-java-agent/instrumentation/jdbc/src/jmh/java/datadog/trace/instrumentation/jdbc/SQLCommenterBenchmark.java

@@ -21,6 +21,7 @@ public class SQLCommenterBenchmark {
   private static final String parentService = "parent";
   private static final String env = "env";
   private static final String version = "version";
+  private static final String serviceHash = "service-hash";
   private static final boolean injectTrace = true;
 
   @Benchmark
@@ -36,6 +37,7 @@ public void testToComment() {
         null,
         env,
         version,
-        traceParent);
+        traceParent,
+        serviceHash);
   }
 }

dd-java-agent/instrumentation/jdbc/src/main/java/datadog/trace/instrumentation/jdbc/DBMCompatibleConnectionInstrumentation.java

@@ -125,7 +125,7 @@ public static String onEnter(
           dbService =
               traceConfig(activeSpan()).getServiceMapping().getOrDefault(dbService, dbService);
         }
-        if (dbInfo.getType().equals("sqlserver")) {
+        if (dbInfo.getType().equals("sqlserver")) { // TODO why it's decided here?
           sql =
               SQLCommenter.append(
                   sql, dbService, dbInfo.getType(), dbInfo.getHost(), dbInfo.getDb());

dd-java-agent/instrumentation/jdbc/src/main/java/datadog/trace/instrumentation/jdbc/SQLCommenter.java

@@ -2,7 +2,9 @@
 
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan;
 
+import datadog.common.container.ContainerInfo;
 import datadog.trace.api.Config;
+import datadog.trace.api.ServiceHash;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
 import datadog.trace.bootstrap.instrumentation.api.Tags;
 import java.io.UnsupportedEncodingException;
@@ -22,6 +24,7 @@ public class SQLCommenter {
   private static final String DD_PEER_SERVICE = "ddprs";
   private static final String DD_ENV = encode("dde");
   private static final String DD_VERSION = encode("ddpv");
+  private static final String DD_SERVICE_HASH = encode("ddsh");
   private static final String TRACEPARENT = encode("traceparent");
   private static final char EQUALS = '=';
   private static final char COMMA = ',';
@@ -117,6 +120,10 @@ public static String inject(
     final String parentService = config.getServiceName();
     final String env = config.getEnv();
     final String version = config.getVersion();
+    String containerTagsHash = ContainerInfo.get().getContainerTagsHash();
+    final String serviceHash =
+        Long.toString(ServiceHash.getBaseHash(parentService, env, containerTagsHash));
+    //        config.isDbDbmInjectServiceHash() ; // TODO && baseHash != null
     final int commentSize = capacity(traceParent, parentService, dbService, env, version);
     StringBuilder sb = new StringBuilder(sql.length() + commentSize);
     boolean commentAdded = false;
@@ -137,7 +144,8 @@ public static String inject(
               peerService,
               env,
               version,
-              traceParent);
+              traceParent,
+              serviceHash);
       sb.append(CLOSE_COMMENT);
     } else {
       sb.append(OPEN_COMMENT);
@@ -152,7 +160,8 @@ public static String inject(
               peerService,
               env,
               version,
-              traceParent);
+              traceParent,
+              serviceHash);
 
       sb.append(CLOSE_COMMENT);
       sb.append(SPACE);
@@ -226,9 +235,9 @@ protected static boolean toComment(
       final String peerService,
       final String env,
       final String version,
-      final String traceparent) {
+      final String traceparent,
+      final String serviceHash) {
     int emptySize = sb.length();
-
     append(sb, PARENT_SERVICE, parentService, false);
     append(sb, DATABASE_SERVICE, dbService, sb.length() > emptySize);
     append(sb, DD_HOSTNAME, hostname, sb.length() > emptySize);
@@ -241,6 +250,8 @@ protected static boolean toComment(
     if (injectTrace) {
       append(sb, TRACEPARENT, traceparent, sb.length() > emptySize);
     }
+    // TODO only if DB_DBM_INJECT_SERVICE_HASH_ENABLED
+    append(sb, DD_SERVICE_HASH, serviceHash, sb.length() > emptySize);
     return sb.length() > emptySize;
   }
 

dd-java-agent/instrumentation/jdbc/src/test/groovy/SQLCommenterTest.groovy

@@ -2,9 +2,7 @@ import datadog.trace.agent.test.AgentTestRunner
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan
 import datadog.trace.bootstrap.instrumentation.api.AgentTracer
 import datadog.trace.bootstrap.instrumentation.api.Tags
-
 import datadog.trace.instrumentation.jdbc.SQLCommenter
-
 import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
 
 class SQLCommenterTest extends AgentTestRunner {
@@ -30,25 +28,22 @@ class SQLCommenterTest extends AgentTestRunner {
     "   "             | ""
   }
 
-
   def "test encode Sql Comment"() {
     setup:
     injectSysConfig("dd.service", ddService)
     injectSysConfig("dd.env", ddEnv)
     injectSysConfig("dd.version", ddVersion)
 
     when:
-    String sqlWithComment = ""
+    String sqlWithComment
     if (injectTrace) {
       sqlWithComment = SQLCommenter.inject(query, dbService, dbType, host, dbName, traceParent, true, appendComment)
     } else if (appendComment) {
       sqlWithComment = SQLCommenter.append(query, dbService, dbType, host, dbName)
-    }
-    else {
+    } else {
       sqlWithComment = SQLCommenter.prepend(query, dbService, dbType, host, dbName)
     }
 
-
     then:
     sqlWithComment == expected
 

dd-trace-core/src/main/java/datadog/trace/core/datastreams/DefaultPathwayContext.java

@@ -7,9 +7,9 @@
 import com.datadoghq.sketch.ddsketch.encoding.ByteArrayInput;
 import com.datadoghq.sketch.ddsketch.encoding.GrowingByteArrayOutput;
 import com.datadoghq.sketch.ddsketch.encoding.VarEncodingHelper;
+import datadog.common.container.ContainerInfo;
 import datadog.context.propagation.CarrierVisitor;
-import datadog.trace.api.Config;
-import datadog.trace.api.ProcessTags;
+import datadog.trace.api.ServiceHash;
 import datadog.trace.api.WellKnownTags;
 import datadog.trace.api.datastreams.DataStreamsContext;
 import datadog.trace.api.datastreams.DataStreamsTags;
@@ -269,19 +269,7 @@ private static DefaultPathwayContext decode(
   }
 
   public static long getBaseHash(WellKnownTags wellKnownTags) {
-    StringBuilder builder = new StringBuilder();
-    builder.append(wellKnownTags.getService());
-    builder.append(wellKnownTags.getEnv());
-
-    String primaryTag = Config.get().getPrimaryTag();
-    if (primaryTag != null) {
-      builder.append(primaryTag);
-    }
-    CharSequence processTags = ProcessTags.getTagsForSerialization();
-    if (processTags != null) {
-      builder.append(processTags);
-    }
-    return FNV64Hash.generateHash(builder.toString(), FNV64Hash.Version.v1);
+    return ServiceHash.getBaseHash(wellKnownTags, ContainerInfo.get().getContainerTagsHash());
   }
 
   private long generatePathwayHash(long nodeHash, long parentHash) {

dd-trace-core/src/test/groovy/datadog/trace/core/datastreams/DefaultPathwayContextTest.groovy

@@ -1,5 +1,6 @@
 package datadog.trace.core.datastreams
 
+import datadog.common.container.ContainerInfo
 import datadog.communication.ddagent.DDAgentFeaturesDiscovery
 import datadog.trace.api.Config
 import datadog.trace.api.DDTraceId
@@ -481,6 +482,32 @@ class DefaultPathwayContextTest extends DDCoreSpecification {
     ProcessTags.reset()
   }
 
+  def "ContainerTagsHash used in hash calculation when enabled propagateTagsEnabled=#propagateTagsEnabled"() {
+    when:
+    injectSysConfig(EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED, propagateTagsEnabled.toString())
+    ProcessTags.reset()
+    ProcessTags.addTag("000", "first")
+    def firstBaseHash = DefaultPathwayContext.getBaseHash(wellKnownTags)
+
+    then:
+    ContainerInfo.get().setContainerTagsHash("<test-container-tags-hash>")
+    def secondBaseHash = DefaultPathwayContext.getBaseHash(wellKnownTags)
+
+    expect:
+    if (propagateTagsEnabled) {
+      assert secondBaseHash != firstBaseHash
+    } else {
+      assert secondBaseHash == firstBaseHash
+    }
+
+    cleanup:
+    injectSysConfig(EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED, "false")
+    ProcessTags.reset()
+
+    where:
+    propagateTagsEnabled << [true, false]
+  }
+
   def "Check context extractor decorator behavior"() {
     given:
     def sink = Mock(Sink)

internal-api/src/main/java/datadog/trace/api/ServiceHash.java

@@ -0,0 +1,47 @@
+package datadog.trace.api;
+
+import datadog.trace.util.FNV64Hash;
+
+public final class ServiceHash {
+
+  public static long getBaseHash(WellKnownTags wellKnownTags, String containerTagsHash) {
+    return getBaseHash(
+        wellKnownTags.getService(),
+        wellKnownTags.getEnv(),
+        Config.get().getPrimaryTag(),
+        ProcessTags.getTagsForSerialization(),
+        containerTagsHash);
+  }
+
+  public static long getBaseHash(
+      CharSequence serviceName, CharSequence env, String containerTagsHash) {
+    return getBaseHash(
+        serviceName,
+        env,
+        Config.get().getPrimaryTag(),
+        ProcessTags.getTagsForSerialization(),
+        containerTagsHash);
+  }
+
+  private static long getBaseHash(
+      CharSequence serviceName,
+      CharSequence env,
+      String primaryTag,
+      CharSequence processTags,
+      String containerTagsHash) {
+    StringBuilder builder = new StringBuilder();
+    builder.append(serviceName);
+    builder.append(env);
+
+    if (primaryTag != null) {
+      builder.append(primaryTag);
+    }
+    if (processTags != null) {
+      builder.append(processTags);
+      if (containerTagsHash != null && !containerTagsHash.isEmpty()) {
+        builder.append(containerTagsHash);
+      }
+    }
+    return FNV64Hash.generateHash(builder.toString(), FNV64Hash.Version.v1);
+  }
+}