product trace source should generate two-character case-insensitive hexadecimal string and be able to parse masks of at least 32 bits to ensure forward compatibility

Author: jandro996

dd-trace-core/src/main/java/datadog/trace/core/propagation/ptags/PTagsCodec.java

@@ -230,11 +230,17 @@ private static boolean validateTraceId(TagValue value) {
   }
 
   private static boolean validateTraceSourceTagValue(TagValue value) {
-    // Ensure the string is not null, has a length of 2, and matches the hex pattern
-    return value != null
-        && value.length() == 2
-        && isHexDigit(value.charAt(0))
-        && isHexDigit(value.charAt(1));
+    // Ensure the string is not null and has a length between 2 and 8
+    if (value == null || value.length() < 2 || value.length() > 8) {
+      return false;
+    }
+    for (int i = 0; i < value.length(); i++) {
+      // Ensure each character is a valid hex digit
+      if (!isHexDigitCaseInsensitive(value.charAt(i))) {
+        return false;
+      }
+    }
+    return true;
   }
 
   protected static boolean isDigit(char c) {
@@ -244,4 +250,8 @@ protected static boolean isDigit(char c) {
   protected static boolean isHexDigit(char c) {
     return c >= 'a' && c <= 'f' || isDigit(c);
   }
+
+  protected static boolean isHexDigitCaseInsensitive(char c) {
+    return isHexDigit(c) || c >= 'A' && c <= 'F';
+  }
 }

dd-trace-core/src/test/groovy/datadog/trace/core/propagation/DatadogPropagationTagsTest.groovy

@@ -154,16 +154,19 @@ class DatadogPropagationTagsTest extends DDCoreSpecification {
     propagationTags.createTagMap() == tags
 
     where:
-    originalTagSet | product                  | expectedHeaderValue | tags
+    originalTagSet      | product                  | expectedHeaderValue | tags
     // keep the existing dm tag as is
-    ""             | ProductTraceSource.ASM   | "_dd.p.ts=02"       | ["_dd.p.ts": "02"]
-    "_dd.p.ts=00"  | ProductTraceSource.ASM   | "_dd.p.ts=02"       | ["_dd.p.ts": "02"]
-    "_dd.p.ts=02"  | ProductTraceSource.DBM   | "_dd.p.ts=12"       | ["_dd.p.ts": "12"]
+    ""                  | ProductTraceSource.ASM   | "_dd.p.ts=02"       | ["_dd.p.ts": "02"]
+    "_dd.p.ts=00"       | ProductTraceSource.ASM   | "_dd.p.ts=02"       | ["_dd.p.ts": "02"]
+    "_dd.p.ts=FFC00000" | ProductTraceSource.ASM   | "_dd.p.ts=02"       | ["_dd.p.ts": "02"]
+    "_dd.p.ts=02"       | ProductTraceSource.DBM   | "_dd.p.ts=12"       | ["_dd.p.ts": "12"]
     //Invalid input
-    "_dd.p.ts="    | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
-    "_dd.p.ts=0"   | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
-    "_dd.p.ts=GG"  | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
-    "_dd.p.ts=foo" | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
+    "_dd.p.ts="         | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
+    "_dd.p.ts=0"        | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
+    "_dd.p.ts=0G"       | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
+    "_dd.p.ts=GG"       | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
+    "_dd.p.ts=foo"      | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
+    "_dd.p.ts=000000002" | ProductTraceSource.UNSET | null                | ["_dd.propagation_error": "decoding_error"]
   }
 
   def extractionLimitExceeded() {

dd-trace-core/src/test/groovy/datadog/trace/core/propagation/W3CPropagationTagsTest.groovy

@@ -311,7 +311,7 @@ class W3CPropagationTagsTest extends DDCoreSpecification {
     propagationTags.createTagMap() == tags
 
     where:
-    headerValue                       | priority                      | mechanism                           | origin  | expectedHeaderValue                                   | tags
+    headerValue                       | priority                      | mechanism                           | origin  | expectedHeaderValue                | tags
     'dd=s:0;o:some;t.dm:934086a686-4' | PrioritySampling.SAMPLER_KEEP | SamplingMechanism.DEFAULT           | "other" | 'dd=s:0;o:other;t.dm:934086a686-4' | ['_dd.p.dm': '934086a686-4']
     'dd=s:0;o:some;x:unknown'         | PrioritySampling.USER_KEEP    | SamplingMechanism.LOCAL_USER_RULE   | "same"  | 'dd=s:2;o:same;t.dm:-3;x:unknown'  | ['_dd.p.dm': '-3']
     'dd=s:0;o:some;x:unknown'         | PrioritySampling.USER_DROP    | SamplingMechanism.MANUAL            | null    | 'dd=s:-1;x:unknown'                | [:]
@@ -339,9 +339,11 @@ class W3CPropagationTagsTest extends DDCoreSpecification {
     propagationTags.createTagMap() == tags
 
     where:
-    headerValue            | product       | expectedHeaderValue    | tags
+    headerValue            | product                | expectedHeaderValue    | tags
     'dd=x:unknown'         | ProductTraceSource.ASM | 'dd=t.ts:02;x:unknown' | ['_dd.p.ts': '02']
     'dd=t.ts:02;x:unknown' | ProductTraceSource.DBM | 'dd=t.ts:12;x:unknown' | ['_dd.p.ts': '12']
+    "dd=t.ts:00"           | ProductTraceSource.ASM | 'dd=t.ts:02'           | ["_dd.p.ts": "02"]
+    "dd=t.ts:FFC00000"     | ProductTraceSource.ASM | 'dd=t.ts:02'           | ["_dd.p.ts": "02"]
   }
 
   static private String toLcAlpha(String cs) {

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

@@ -1,5 +1,18 @@
 package datadog.trace.api;
 
+/**
+ * Represents a bitfield-based trace source for tracking product propagation tags.
+ *
+ * <p>The bitfield is encoded as an **8-bit hexadecimal mask** (ranging from `00` to `FF`), where
+ * each bit corresponds to a specific product. This class provides utility methods for updating,
+ * checking, and parsing these product bitfields.
+ *
+ * <ul>
+ *   <li>MUST use a two-character, case-insensitive hexadecimal string (e.g., "00" to "FF").
+ *   <li>MUST support parsing masks of at least 32 bits to ensure forward compatibility.
+ *   <li>Each bit corresponds to a specific product:
+ * </ul>
+ */
 public class ProductTraceSource {
 
   public static final int UNSET = 0;
@@ -10,26 +23,38 @@ public class ProductTraceSource {
   public static final int DJM = 0x08;
   public static final int DBM = 0x10;
 
-  // Update (set) the bitfield for a specific product
+  /** Updates the bitfield by setting the bit corresponding to a specific product. */
   public static int updateProduct(int bitfield, int product) {
     return bitfield |= product; // Set the bit for the given product
   }
 
-  // Check if the bitfield is marked for a specific product
+  /** Checks if the bitfield is marked for a specific product. */
   public static boolean isProductMarked(final int bitfield, int product) {
     return (bitfield & product) != 0; // Check if the bit is set
   }
 
-  // Get the current bitfield as a hexadecimal string
+  /**
+   * Converts the current bitfield to a two-character hexadecimal string.
+   *
+   * <p>This method ensures the output follows the **00 to FF** format, padding with leading zeros
+   * if necessary.
+   */
   public static String getBitfieldHex(final int bitfield) {
-    return String.format("%02x", bitfield); // Convert to 2-character hex
+    String hex = Integer.toHexString(bitfield & 0xFF);
+    return hex.length() == 1 ? "0" + hex : hex; // Ensure two characters
   }
 
-  // Parse a hexadecimal string back to an integer
+  /**
+   * Parses a hexadecimal string back into an integer bitfield.
+   *
+   * <p>This method allows for **at least 32-bit parsing**, ensuring forward compatibility with
+   * potential future expansions.
+   */
   public static int parseBitfieldHex(final String hexString) {
     if (hexString == null || hexString.isEmpty()) {
       return 0; // Return 0 if the string is empty
     }
-    return Integer.parseInt(hexString, 16); // Parse the string as a base-16 number
+    // Need to support unsigned parsing
+    return (int) Long.parseUnsignedLong(hexString, 16); // Parse the string as a base-16 number
   }
 }