PR feedback

Author: jack-berg

api/all/src/main/java/io/opentelemetry/api/baggage/propagation/Parser.java

@@ -47,6 +47,9 @@ private enum State {
 
   int parseInto(BaggageBuilder baggageBuilder) {
     for (int i = 0, n = baggageHeader.length(); i < n; i++) {
+      if (entriesAdded >= maxEntries) {
+        break;
+      }
       char current = baggageHeader.charAt(i);
 
       if (skipToNext) {

api/all/src/main/java/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagator.java

@@ -155,19 +155,30 @@ private static <C> Context extractMulti(
         continue;
       }
 
+      int remainingBytes = MAX_BAGGAGE_BYTES - totalBytes;
       totalBytes += header.length();
-      if (totalBytes > MAX_BAGGAGE_BYTES || totalEntries >= MAX_BAGGAGE_ENTRIES) {
+
+      if (totalEntries >= MAX_BAGGAGE_ENTRIES) {
         LOGGER.fine("Baggage header exceeded W3C limits, dropping remaining entries");
         break;
       }
 
+      String headerToParse =
+          totalBytes > MAX_BAGGAGE_BYTES ? header.substring(0, remainingBytes) : header;
+
       try {
-        int added = extractEntries(header, baggageBuilder, MAX_BAGGAGE_ENTRIES - totalEntries);
+        int added =
+            extractEntries(headerToParse, baggageBuilder, MAX_BAGGAGE_ENTRIES - totalEntries);
         extracted = true;
         totalEntries += added;
       } catch (RuntimeException expected) {
         // invalid baggage header, continue
       }
+
+      if (totalBytes > MAX_BAGGAGE_BYTES) {
+        LOGGER.fine("Baggage header exceeded W3C limits, dropping remaining entries");
+        break;
+      }
     }
 
     return extracted ? context.with(baggageBuilder.build()) : context;

api/all/src/test/java/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagatorTest.java

@@ -649,21 +649,32 @@ private static String baggageHeader(int start, int count) {
   @Test
   void extract_limit_maxBytes_exceedsLimit() {
     W3CBaggagePropagator propagator = W3CBaggagePropagator.getInstance();
-    // Single header over 8192 bytes — should not be extracted
-    char[] chars = new char[8192];
-    Arrays.fill(chars, 'v');
-    String header = "k=" + new String(chars);
+    // Single header over 8192 bytes — truncated to the byte limit; the entry within budget is
+    // extracted with a truncated value
+    String header = "k=" + fillChars('v', 8192); // 8194 bytes; truncated to 8192 → k=<8190 v's>
     Context result = propagator.extract(Context.root(), ImmutableMap.of("baggage", header), getter);
-    assertThat(Baggage.fromContext(result)).isEqualTo(Baggage.empty());
+    assertThat(Baggage.fromContext(result).getEntryValue("k")).isEqualTo(fillChars('v', 8190));
+  }
+
+  @Test
+  void extract_limit_maxBytes_partialHeader() {
+    W3CBaggagePropagator propagator = W3CBaggagePropagator.getInstance();
+    // A header where the first entry is complete within the byte budget but the second entry's
+    // key is cut off by the truncation — only the first entry is extracted.
+    // "k1=" (3) + 8186 'v's + "," (1) + "k2=v2" (5) = 8195 bytes;
+    // truncated to 8192 → "k1=<8186 v's>,k2" (k2's "=" is beyond the budget)
+    String header = "k1=" + fillChars('v', 8186) + ",k2=v2";
+    Context result = propagator.extract(Context.root(), ImmutableMap.of("baggage", header), getter);
+    Baggage baggage = Baggage.fromContext(result);
+    assertThat(baggage.getEntryValue("k1")).isEqualTo(fillChars('v', 8186));
+    assertThat(baggage.getEntryValue("k2")).isNull();
   }
 
   @Test
   void extract_limit_maxBytes_acrossMultipleHeaders() {
     W3CBaggagePropagator propagator = W3CBaggagePropagator.getInstance();
     // First header just under 8192 bytes is extracted; second header pushes total over the limit
-    char[] almostMaxChars = new char[8189];
-    Arrays.fill(almostMaxChars, 'v');
-    String almostMax = "k=" + new String(almostMaxChars); // "k=vvv..."
+    String almostMax = "k=" + fillChars('v', 8189); // "k=vvv..."
     String second = "k2=v2";
     Context result =
         propagator.extract(
@@ -690,10 +701,7 @@ void inject_limit_maxEntries() {
   void inject_limit_maxBytes() {
     W3CBaggagePropagator propagator = W3CBaggagePropagator.getInstance();
     // One entry whose encoded form alone exceeds the byte limit — should produce empty header
-    char[] longValueChars = new char[8192];
-    Arrays.fill(longValueChars, 'v');
-    String longValue = new String(longValueChars);
-    Baggage baggage = Baggage.builder().put("k", longValue).build();
+    Baggage baggage = Baggage.builder().put("k", fillChars('v', 8192)).build();
     Map<String, String> carrier = new HashMap<>();
     propagator.inject(Context.root().with(baggage), carrier, Map::put);
     assertThat(carrier).doesNotContainKey("baggage");
@@ -703,15 +711,19 @@ void inject_limit_maxBytes() {
   void inject_limit_maxBytes_metadata() {
     // Value alone fits easily (k=v is 3 bytes), but k=v;{metadata} exceeds 8192 bytes.
     // Verifies that metadata length is included in the byte limit check.
-    char[] metaChars = new char[8190];
-    Arrays.fill(metaChars, 'x');
     Baggage baggage =
-        Baggage.builder().put("k", "v", BaggageEntryMetadata.create(new String(metaChars))).build();
+        Baggage.builder().put("k", "v", BaggageEntryMetadata.create(fillChars('x', 8190))).build();
     Map<String, String> carrier = new HashMap<>();
     W3CBaggagePropagator.getInstance().inject(Context.root().with(baggage), carrier, Map::put);
     assertThat(carrier).doesNotContainKey("baggage");
   }
 
+  private static String fillChars(char c, int count) {
+    char[] chars = new char[count];
+    Arrays.fill(chars, c);
+    return new String(chars);
+  }
+
   @Test
   void toString_Valid() {
     assertThat(W3CBaggagePropagator.getInstance().toString()).isEqualTo("W3CBaggagePropagator");