Address PR feedback: fix locale bug, move ksr formatting to PropagationTags

- Use Locale.ROOT in String.format to prevent locale-sensitive decimal
  separators (e.g. comma in fr_FR) from corrupting x-datadog-tags
- Move formatKnuthSamplingRate() from DDSpan to PTagsFactory so
  propagation encoding logic stays in the propagation layer
- Change updateKnuthSamplingRate signature to accept double instead of
  pre-formatted String
- Use indexOf('.') instead of contains(".") for minor perf improvement
- Update test to exercise formatting through PropagationTags API

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bm1549

dd-trace-core/src/main/java/datadog/trace/core/DDSpan.java

@@ -650,34 +650,12 @@ public DDSpan setSamplingPriority(
           || samplingMechanism == SamplingMechanism.LOCAL_USER_RULE
           || samplingMechanism == SamplingMechanism.REMOTE_USER_RULE
           || samplingMechanism == SamplingMechanism.REMOTE_ADAPTIVE_RULE) {
-        context.getPropagationTags().updateKnuthSamplingRate(formatKnuthSamplingRate(sampleRate));
+        context.getPropagationTags().updateKnuthSamplingRate(sampleRate);
       }
     }
     return this;
   }
 
-  /**
-   * Formats the sampling rate for the _dd.p.ksr propagated tag. Uses up to 6 significant digits
-   * with no trailing zeros, matching the Go/Python reference implementations (%.6g format).
-   */
-  static String formatKnuthSamplingRate(double rate) {
-    // Use %.6g format: up to 6 significant digits, no trailing zeros
-    // This matches Go's strconv.FormatFloat(rate, 'g', 6, 64) and Python's f"{rate:.6g}"
-    String formatted = String.format("%.6g", rate);
-    // Remove trailing zeros after decimal point (avoid forbidden String#replaceAll)
-    if (formatted.contains(".")) {
-      int end = formatted.length();
-      while (end > 0 && formatted.charAt(end - 1) == '0') {
-        end--;
-      }
-      if (end > 0 && formatted.charAt(end - 1) == '.') {
-        end--;
-      }
-      formatted = formatted.substring(0, end);
-    }
-    return formatted;
-  }
-
   @Override
   public DDSpan setSpanSamplingPriority(double rate, int limit) {
     context.setSpanSamplingPriority(rate, limit);

dd-trace-core/src/main/java/datadog/trace/core/propagation/PropagationTags.java

@@ -132,11 +132,13 @@ public interface Factory {
 
   /**
    * Updates the Knuth sampling rate (_dd.p.ksr) propagated tag. This records the sampling rate that
-   * was applied when making an agent-based or rule-based sampling decision.
+   * was applied when making an agent-based or rule-based sampling decision. The rate is formatted
+   * with up to 6 significant digits and no trailing zeros, matching the Go/Python reference
+   * implementations (%.6g format).
    *
-   * @param rate the formatted sampling rate string (up to 6 significant digits, no trailing zeros)
+   * @param rate the sampling rate value
    */
-  public abstract void updateKnuthSamplingRate(String rate);
+  public abstract void updateKnuthSamplingRate(double rate);
 
   public HashMap<String, String> createTagMap() {
     HashMap<String, String> result = new HashMap<>();

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

@@ -17,6 +17,7 @@
 import java.util.Collections;
 import java.util.EnumMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
@@ -270,15 +271,32 @@ public String getDebugPropagation() {
     }
 
     @Override
-    public void updateKnuthSamplingRate(String rate) {
-      TagValue newValue = rate == null ? null : TagValue.from(rate);
-      if (!java.util.Objects.equals(knuthSamplingRateTagValue, newValue)) {
+    public void updateKnuthSamplingRate(double rate) {
+      TagValue newValue = TagValue.from(formatKnuthSamplingRate(rate));
+      if (!Objects.equals(knuthSamplingRateTagValue, newValue)) {
         clearCachedHeader(DATADOG);
         clearCachedHeader(W3C);
       }
       knuthSamplingRateTagValue = newValue;
     }
 
+    /** Formats a sampling rate with up to 6 significant digits and no trailing zeros. */
+    static String formatKnuthSamplingRate(double rate) {
+      String formatted = String.format(Locale.ROOT, "%.6g", rate);
+      int dotIndex = formatted.indexOf('.');
+      if (dotIndex >= 0) {
+        int end = formatted.length();
+        while (end > dotIndex + 1 && formatted.charAt(end - 1) == '0') {
+          end--;
+        }
+        if (formatted.charAt(end - 1) == '.') {
+          end--;
+        }
+        formatted = formatted.substring(0, end);
+      }
+      return formatted;
+    }
+
     TagValue getKnuthSamplingRateTagValue() {
       return knuthSamplingRateTagValue;
     }

dd-trace-core/src/test/groovy/datadog/trace/core/KnuthSamplingRateTest.groovy

@@ -5,6 +5,7 @@ import datadog.trace.common.sampling.RateByServiceTraceSampler
 import datadog.trace.common.sampling.Sampler
 import datadog.trace.common.writer.ListWriter
 import datadog.trace.common.writer.ddagent.DDAgentApi
+import datadog.trace.core.propagation.PropagationTags
 import datadog.trace.core.test.DDCoreSpecification
 
 import static datadog.trace.api.config.TracerConfig.TRACE_RATE_LIMIT
@@ -16,9 +17,16 @@ import static datadog.trace.api.sampling.PrioritySampling.SAMPLER_KEEP
 class KnuthSamplingRateTest extends DDCoreSpecification {
   static serializer = DDAgentApi.RESPONSE_ADAPTER
 
-  def "formatKnuthSamplingRate produces correct format"() {
-    expect:
-    DDSpan.formatKnuthSamplingRate(rate) == expected
+  def "updateKnuthSamplingRate formats rate correctly"() {
+    setup:
+    def pTags = PropagationTags.factory().empty()
+
+    when:
+    pTags.updateKnuthSamplingRate(rate)
+    def tagMap = pTags.createTagMap()
+
+    then:
+    tagMap.get('_dd.p.ksr') == expected
 
     where:
     rate       | expected