fix(core): Simplify TID header parsing error handling

Revert the non-throwing id parsing from #12739: DD64bTraceId.fromOrNull and
the LongStringUtils sentinel parser added public API, duplicated the decimal
parser, and diverged from DD128bTraceId and DDSpanId.

Keep the goal of keeping malformed headers out of telemetry by catching
NumberFormatException during Datadog context extraction and logging it with
EXCLUDE_TELEMETRY, without the stack trace.

Author: PerfectSlayer

dd-trace-api/src/main/java/datadog/trace/api/DD64bTraceId.java

@@ -46,26 +46,6 @@ public static DD64bTraceId from(String s) throws NumberFormatException {
     return DD64bTraceId.create(LongStringUtils.parseUnsignedLong(s), s);
   }
 
-  /**
-   * Like {@link #from(String)}, but returns {@code null} instead of throwing when the given {@code
-   * String} is not a plain decimal unsigned 64 bit id. Stricter than {@link #from(String)}: a
-   * leading {@code +} and non-ASCII digits are rejected.
-   *
-   * <p>Internal API for parsing untrusted input, such as propagation headers, on the request path.
-   * Not intended for use outside the tracer.
-   *
-   * @param s String of unsigned 64 bit id
-   * @return DDTraceId, or {@code null} if the {@code String} is not a valid id
-   */
-  public static DD64bTraceId fromOrNull(String s) {
-    int len = s == null ? 0 : s.length();
-    long id = LongStringUtils.parseUnsignedLongOrSentinel(s, 0, len, 0L);
-    if (id == 0L && !LongStringUtils.isUnsignedLongZero(s, 0, len)) {
-      return null;
-    }
-    return DD64bTraceId.create(id, s);
-  }
-
   /**
    * Create a new {@code DDTraceId} from the given {@code String} hex representation of the unsigned
    * 64 bit id.

dd-trace-api/src/main/java/datadog/trace/api/internal/util/LongStringUtils.java

@@ -73,93 +73,7 @@ private static int firstNonZeroCharacter(CharSequence s, int start) {
     return firstNonZero;
   }
 
-  /**
-   * Parse the decimal representation of the unsigned 64 bit long from the {@code String}.
-   *
-   * @param s String in decimal of unsigned 64-bits long.
-   * @return long
-   * @throws NumberFormatException
-   */
   public static long parseUnsignedLong(String s) throws NumberFormatException {
-    long result = parseUnsignedLongOrSentinel(s, 0, s == null ? 0 : s.length(), 0L);
-    if (result != 0L) {
-      return result;
-    }
-    // Zero is ambiguous with the invalid sentinel. Let the strict parser decide: it accepts input
-    // the non-throwing parser rejects (a leading '+', non-ASCII digits) and builds the exception.
-    return parseUnsignedLongStrict(s);
-  }
-
-  /**
-   * Parse the decimal representation of the unsigned 64 bit long from the {@code CharSequence}
-   * without throwing, for untrusted input such as propagation headers.
-   *
-   * <p>Accepts 1 to 20 ASCII digits only: no sign, no whitespace, no non-ASCII digits. An unsigned
-   * 64 bit value uses every bit, so no return value can mean "invalid" on its own. Callers pick an
-   * {@code ifInvalid} that is impossible or harmless for their use, e.g. {@code 0} for trace and
-   * span ids. With {@code 0} as {@code ifInvalid}, {@link #isUnsignedLongZero} tells a real zero
-   * apart from invalid input.
-   *
-   * @param s CharSequence containing the decimal digits
-   * @param start the start index of the decimal value
-   * @param len the length of the decimal value
-   * @param ifInvalid the value returned for null, empty, malformed or out of range input
-   * @return the parsed long, or {@code ifInvalid}
-   */
-  public static long parseUnsignedLongOrSentinel(
-      CharSequence s, int start, int len, long ifInvalid) {
-    if (s == null || len <= 0 || len > 20 || start < 0 || start + len > s.length()) {
-      return ifInvalid;
-    }
-    int end = start + len;
-    // Signed 64 bits holds any 18 digit number, so the first 18 digits cannot overflow
-    int fastEnd = Math.min(end, start + 18);
-    long result = 0;
-    int i = start;
-    for (; i < fastEnd; i++) {
-      int d = s.charAt(i) - '0';
-      if (d < 0 || d > 9) {
-        return ifInvalid;
-      }
-      result = result * 10 + d;
-    }
-    for (; i < end; i++) {
-      int d = s.charAt(i) - '0';
-      if (d < 0 || d > 9 || Long.compareUnsigned(result, MAX_FIRST_PART) > 0) {
-        return ifInvalid;
-      }
-      long scaled = result * 10;
-      result = scaled + d;
-      if (Long.compareUnsigned(result, scaled) < 0) {
-        return ifInvalid;
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Whether {@code s[start, start + len)} is a zero that {@link #parseUnsignedLongOrSentinel}
-   * accepts: 1 to 20 {@code '0'} characters. Callers that use {@code 0} as the invalid sentinel
-   * check this only when the parse returned {@code 0}.
-   *
-   * @param s CharSequence containing the decimal digits
-   * @param start the start index of the decimal value
-   * @param len the length of the decimal value
-   * @return true if the range parses to zero, false if it is zero-valued only as the sentinel
-   */
-  public static boolean isUnsignedLongZero(CharSequence s, int start, int len) {
-    if (s == null || len <= 0 || len > 20 || start < 0 || start + len > s.length()) {
-      return false;
-    }
-    for (int i = start, end = start + len; i < end; i++) {
-      if (s.charAt(i) != '0') {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private static long parseUnsignedLongStrict(String s) throws NumberFormatException {
     if (s == null) {
       throw new NumberFormatException("s can't be null");
     }

dd-trace-api/src/test/java/datadog/trace/api/DDTraceIdTest.java

@@ -2,7 +2,6 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -71,46 +70,6 @@ void failParsingIllegal64BitIdStringRepresentation(String stringId) {
     assertThrows(NumberFormatException.class, () -> DD64bTraceId.from(stringId));
   }
 
-  @TableTest({
-    "scenario          | stringId               | expectedId           ",
-    "zero              | '0'                    | DD64bTraceId.ZERO    ",
-    "one               | '1'                    | DD64bTraceId.ONE     ",
-    "max               | '18446744073709551615' | DD64bTraceId.MAX     ",
-    "long max          | '9223372036854775807'  | DD64bTraceId.LONG_MAX",
-    "long max plus one | '9223372036854775808'  | DD64bTraceId.LONG_MIN"
-  })
-  @ParameterizedTest(name = "fromOrNull parses valid 64-bit id String representation [{index}]")
-  void fromOrNullParsesValid64BitIdStringRepresentation(String stringId, DD64bTraceId expectedId) {
-    DD64bTraceId ddid = DD64bTraceId.fromOrNull(stringId);
-
-    assertEquals(expectedId, ddid);
-    assertEquals(stringId, ddid.toString());
-  }
-
-  @Test
-  void fromOrNullKeepsTheParsedStringForToString() {
-    String stringId = "1234567890";
-
-    assertSame(stringId, DD64bTraceId.fromOrNull(stringId).toString());
-  }
-
-  @ParameterizedTest(name = "fromOrNull returns null for illegal 64-bit id String [{index}]")
-  @NullSource
-  @ValueSource(
-      strings = {
-        "",
-        "-1",
-        "+1",
-        "18446744073709551616",
-        "18446744073709551625",
-        "184467440737095516150",
-        "18446744073709551a1",
-        "184467440737095511a"
-      })
-  void fromOrNullReturnsNullForIllegal64BitIdString(String stringId) {
-    assertNull(DD64bTraceId.fromOrNull(stringId));
-  }
-
   @TableTest({
     "scenario                    | hexId                  | expectedId           ",
     "zero                        | '0'                    | DD64bTraceId.ZERO    ",