Merge branch 'master' into mhlidd/create_breaking_changes_flag

Author: mhlidd

.circleci/config.continue.yml.j2

@@ -36,7 +36,7 @@ instrumentation_modules: &instrumentation_modules "dd-java-agent/instrumentation
 debugger_modules: &debugger_modules "dd-java-agent/agent-debugger|dd-java-agent/agent-bootstrap|dd-java-agent/agent-builder|internal-api|communication|dd-trace-core"
 profiling_modules: &profiling_modules "dd-java-agent/agent-profiling"
 
-default_system_tests_commit: &default_system_tests_commit 590162e1f5223cbbcd2876fdb820837cb13a85e1
+default_system_tests_commit: &default_system_tests_commit 5aee0ed598fd984344cf0da0048b27bdb2eb4da1
 
 parameters:
   nightly:

dd-trace-core/src/main/java/datadog/trace/core/baggage/BaggagePropagator.java

@@ -1,16 +1,17 @@
 package datadog.trace.core.baggage;
 
+import static java.util.Collections.emptyMap;
+
 import datadog.context.Context;
 import datadog.context.propagation.CarrierSetter;
 import datadog.context.propagation.CarrierVisitor;
 import datadog.context.propagation.Propagator;
 import datadog.trace.api.Config;
-import datadog.trace.bootstrap.instrumentation.api.BaggageContext;
-import datadog.trace.core.util.EscapedData;
+import datadog.trace.bootstrap.instrumentation.api.Baggage;
 import datadog.trace.core.util.PercentEscaper;
+import datadog.trace.core.util.PercentEscaper.Escaped;
 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.BiConsumer;
@@ -20,7 +21,7 @@
 
 @ParametersAreNonnullByDefault
 public class BaggagePropagator implements Propagator {
-  private static final Logger log = LoggerFactory.getLogger(BaggagePropagator.class);
+  private static final Logger LOG = LoggerFactory.getLogger(BaggagePropagator.class);
   private static final PercentEscaper UTF_ESCAPER = PercentEscaper.create();
   static final String BAGGAGE_KEY = "baggage";
   private final Config config;
@@ -37,13 +38,13 @@ public BaggagePropagator(Config config) {
   public BaggagePropagator(boolean injectBaggage, boolean extractBaggage) {
     this.injectBaggage = injectBaggage;
     this.extractBaggage = extractBaggage;
-    config = Config.get();
+    this.config = Config.get();
   }
 
   @Override
   public <C> void inject(Context context, C carrier, CarrierSetter<C> setter) {
-    int maxItems = config.getTraceBaggageMaxItems();
-    int maxBytes = config.getTraceBaggageMaxBytes();
+    int maxItems = this.config.getTraceBaggageMaxItems();
+    int maxBytes = this.config.getTraceBaggageMaxBytes();
     //noinspection ConstantValue
     if (!this.injectBaggage
         || maxItems == 0
@@ -54,52 +55,52 @@ public <C> void inject(Context context, C carrier, CarrierSetter<C> setter) {
       return;
     }
 
-    BaggageContext baggageContext = BaggageContext.fromContext(context);
-    if (baggageContext == null) {
-      log.debug("BaggageContext instance is missing from the following context {}", context);
+    Baggage baggage = Baggage.fromContext(context);
+    if (baggage == null) {
+      LOG.debug("Baggage instance is missing from the following context {}", context);
       return;
     }
 
-    String baggageHeader = baggageContext.getW3cBaggageHeader();
-    if (baggageHeader != null) {
-      setter.set(carrier, BAGGAGE_KEY, baggageHeader);
+    String headerValue = baggage.getW3cHeader();
+    if (headerValue != null) {
+      setter.set(carrier, BAGGAGE_KEY, headerValue);
       return;
     }
 
-    int processedBaggage = 0;
+    int processedItems = 0;
     int currentBytes = 0;
     StringBuilder baggageText = new StringBuilder();
-    for (final Map.Entry<String, String> entry : baggageContext.asMap().entrySet()) {
+    for (final Map.Entry<String, String> entry : baggage.asMap().entrySet()) {
       // if there are already baggage items processed, add and allocate bytes for a comma
       int extraBytes = 1;
-      if (processedBaggage != 0) {
+      if (processedItems != 0) {
         baggageText.append(',');
         extraBytes++;
       }
 
-      EscapedData escapedKey = UTF_ESCAPER.escapeKey(entry.getKey());
-      EscapedData escapedVal = UTF_ESCAPER.escapeValue(entry.getValue());
+      Escaped escapedKey = UTF_ESCAPER.escapeKey(entry.getKey());
+      Escaped escapedVal = UTF_ESCAPER.escapeValue(entry.getValue());
 
-      baggageText.append(escapedKey.getData());
+      baggageText.append(escapedKey.data);
       baggageText.append('=');
-      baggageText.append(escapedVal.getData());
+      baggageText.append(escapedVal.data);
 
-      processedBaggage++;
+      processedItems++;
       // reached the max number of baggage items allowed
-      if (processedBaggage == maxItems) {
+      if (processedItems == maxItems) {
         break;
       }
       // Drop newest k/v pair if adding it leads to exceeding the limit
-      if (currentBytes + escapedKey.getSize() + escapedVal.getSize() + extraBytes > maxBytes) {
+      if (currentBytes + escapedKey.size + escapedVal.size + extraBytes > maxBytes) {
         baggageText.setLength(currentBytes);
         break;
       }
-      currentBytes += escapedKey.getSize() + escapedVal.getSize() + extraBytes;
+      currentBytes += escapedKey.size + escapedVal.size + extraBytes;
     }
 
-    String baggageString = baggageText.toString();
-    baggageContext.setW3cBaggageHeader(baggageString);
-    setter.set(carrier, BAGGAGE_KEY, baggageString);
+    headerValue = baggageText.toString();
+    baggage.setW3cHeader(headerValue);
+    setter.set(carrier, BAGGAGE_KEY, headerValue);
   }
 
   @Override
@@ -108,57 +109,52 @@ public <C> Context extract(Context context, C carrier, CarrierVisitor<C> visitor
     if (!this.extractBaggage || context == null || carrier == null || visitor == null) {
       return context;
     }
-    BaggageContextExtractor baggageContextExtractor = new BaggageContextExtractor();
-    visitor.forEachKeyValue(carrier, baggageContextExtractor);
-    BaggageContext extractedContext = baggageContextExtractor.extractedContext;
-    if (extractedContext == null) {
-      return context;
-    }
-    return extractedContext.storeInto(context);
+    BaggageExtractor baggageExtractor = new BaggageExtractor();
+    visitor.forEachKeyValue(carrier, baggageExtractor);
+    return baggageExtractor.extracted == null ? context : context.with(baggageExtractor.extracted);
   }
 
-  public static class BaggageContextExtractor implements BiConsumer<String, String> {
-    private BaggageContext extractedContext;
+  private static class BaggageExtractor implements BiConsumer<String, String> {
+    private static final char KEY_VALUE_SEPARATOR = '=';
+    private static final char PAIR_SEPARATOR = ',';
+    private Baggage extracted;
 
-    BaggageContextExtractor() {}
+    private BaggageExtractor() {}
 
     /** URL decode value */
     private String decode(final String value) {
       String decoded = value;
       try {
         decoded = URLDecoder.decode(value, "UTF-8");
       } catch (final UnsupportedEncodingException | IllegalArgumentException e) {
-        log.debug("Failed to decode {}", value);
+        LOG.debug("Failed to decode {}", value);
       }
       return decoded;
     }
 
     private Map<String, String> parseBaggageHeaders(String input) {
       Map<String, String> baggage = new HashMap<>();
-      char keyValueSeparator = '=';
-      char pairSeparator = ',';
       int start = 0;
-
-      int pairSeparatorInd = input.indexOf(pairSeparator);
+      int pairSeparatorInd = input.indexOf(PAIR_SEPARATOR);
       pairSeparatorInd = pairSeparatorInd == -1 ? input.length() : pairSeparatorInd;
-      int kvSeparatorInd = input.indexOf(keyValueSeparator);
+      int kvSeparatorInd = input.indexOf(KEY_VALUE_SEPARATOR);
       while (kvSeparatorInd != -1) {
         int end = pairSeparatorInd;
         if (kvSeparatorInd > end) {
-          log.debug(
+          LOG.debug(
               "Dropping baggage headers due to key with no value {}", input.substring(start, end));
-          return Collections.emptyMap();
+          return emptyMap();
         }
         String key = decode(input.substring(start, kvSeparatorInd).trim());
         String value = decode(input.substring(kvSeparatorInd + 1, end).trim());
         if (key.isEmpty() || value.isEmpty()) {
-          log.debug("Dropping baggage headers due to empty k/v {}:{}", key, value);
-          return Collections.emptyMap();
+          LOG.debug("Dropping baggage headers due to empty k/v {}:{}", key, value);
+          return emptyMap();
         }
         baggage.put(key, value);
 
-        kvSeparatorInd = input.indexOf(keyValueSeparator, pairSeparatorInd + 1);
-        pairSeparatorInd = input.indexOf(pairSeparator, pairSeparatorInd + 1);
+        kvSeparatorInd = input.indexOf(KEY_VALUE_SEPARATOR, pairSeparatorInd + 1);
+        pairSeparatorInd = input.indexOf(PAIR_SEPARATOR, pairSeparatorInd + 1);
         pairSeparatorInd = pairSeparatorInd == -1 ? input.length() : pairSeparatorInd;
         start = end + 1;
       }
@@ -168,10 +164,10 @@ private Map<String, String> parseBaggageHeaders(String input) {
     @Override
     public void accept(String key, String value) {
       // Only process tags that are relevant to baggage
-      if (key != null && key.equalsIgnoreCase(BAGGAGE_KEY)) {
+      if (BAGGAGE_KEY.equalsIgnoreCase(key)) {
         Map<String, String> baggage = parseBaggageHeaders(value);
         if (!baggage.isEmpty()) {
-          extractedContext = BaggageContext.create(baggage, value);
+          this.extracted = Baggage.create(baggage, value);
         }
       }
     }

dd-trace-core/src/main/java/datadog/trace/core/util/EscapedData.java

@@ -107,25 +107,24 @@ private static boolean[] createUnsafeOctets(String safeChars) {
     return octets;
   }
 
-  public EscapedData escapeKey(String s) {
+  public Escaped escapeKey(String s) {
     return escape(s, unsafeKeyOctets);
   }
 
-  public EscapedData escapeValue(String s) {
+  public Escaped escapeValue(String s) {
     return escape(s, unsafeValOctets);
   }
 
   /** Escape the provided String, using percent-style URL Encoding. */
-  public EscapedData escape(String s, boolean[] unsafeOctets) {
-    int size = 0;
+  public Escaped escape(String s, boolean[] unsafeOctets) {
     int slen = s.length();
     for (int index = 0; index < slen; index++) {
       char c = s.charAt(index);
       if (c > '~' || c <= ' ' || c <= unsafeOctets.length && unsafeOctets[c]) {
         return escapeSlow(s, index, unsafeOctets);
       }
     }
-    return new EscapedData(s, slen);
+    return new Escaped(s, slen);
   }
 
   /*
@@ -147,14 +146,14 @@ public EscapedData escape(String s, boolean[] unsafeOctets) {
    * @throws NullPointerException if {@code string} is null
    * @throws IllegalArgumentException if invalid surrogate characters are encountered
    */
-  private static EscapedData escapeSlow(String s, int index, boolean[] unsafeOctets) {
+  private static Escaped escapeSlow(String s, int index, boolean[] unsafeOctets) {
     int end = s.length();
 
     // Get a destination buffer and setup some loop variables.
     char[] dest = new char[1024]; // 1024 from the original guava source
     int destIndex = 0;
     int unescapedChunkStart = 0;
-    EscapedData data = new EscapedData("", index);
+    Escaped result = new Escaped("", index);
 
     while (index < end) {
       int cp = codePointAt(s, index, end);
@@ -164,7 +163,7 @@ private static EscapedData escapeSlow(String s, int index, boolean[] unsafeOctet
       // It is possible for this to return null because nextEscapeIndex() may
       // (for performance reasons) yield some false positives but it must never
       // give false negatives.
-      char[] escaped = escape(cp, data, unsafeOctets);
+      char[] escaped = escape(cp, result, unsafeOctets);
       int nextIndex = index + (Character.isSupplementaryCodePoint(cp) ? 2 : 1);
       if (escaped != null) {
         int charsSkipped = index - unescapedChunkStart;
@@ -202,10 +201,11 @@ private static EscapedData escapeSlow(String s, int index, boolean[] unsafeOctet
       s.getChars(unescapedChunkStart, end, dest, destIndex);
       destIndex = endIndex;
     }
-    data.addSize(charsSkipped); // Adding characters in-between characters that want to be encoded
+    // Adding characters in-between characters that want to be encoded
+    result.size += charsSkipped;
 
-    data.setData(new String(dest, 0, destIndex));
-    return data;
+    result.data = new String(dest, 0, destIndex);
+    return result;
   }
 
   private static int nextEscapeIndex(CharSequence csq, int index, int end, boolean[] unsafeOctets) {
@@ -221,7 +221,7 @@ private static int nextEscapeIndex(CharSequence csq, int index, int end, boolean
   /** Escapes the given Unicode code point in UTF-8. */
   @CheckForNull
   @SuppressWarnings("UngroupedOverloads")
-  private static char[] escape(int cp, EscapedData data, boolean[] unsafeOctets) {
+  private static char[] escape(int cp, Escaped escaped, boolean[] unsafeOctets) {
     // We should never get negative values here but if we do it will throw an
     // IndexOutOfBoundsException, so at least it will get spotted.
     if (cp < unsafeOctets.length && !unsafeOctets[cp]) {
@@ -233,7 +233,7 @@ private static char[] escape(int cp, EscapedData data, boolean[] unsafeOctets) {
       dest[0] = '%';
       dest[2] = UPPER_HEX_DIGITS[cp & 0xF];
       dest[1] = UPPER_HEX_DIGITS[cp >>> 4];
-      data.incrementSize();
+      escaped.size++;
       return dest;
     } else if (cp <= 0x7ff) {
       // Two byte UTF-8 characters [cp >= 0x80 && cp <= 0x7ff]
@@ -248,7 +248,7 @@ private static char[] escape(int cp, EscapedData data, boolean[] unsafeOctets) {
       dest[2] = UPPER_HEX_DIGITS[cp & 0xF];
       cp >>>= 4;
       dest[1] = UPPER_HEX_DIGITS[0xC | cp];
-      data.addSize(2);
+      escaped.size += 2;
       return dest;
     } else if (cp <= 0xffff) {
       // Three byte UTF-8 characters [cp >= 0x800 && cp <= 0xffff]
@@ -267,7 +267,7 @@ private static char[] escape(int cp, EscapedData data, boolean[] unsafeOctets) {
       dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
       cp >>>= 2;
       dest[2] = UPPER_HEX_DIGITS[cp];
-      data.addSize(3);
+      escaped.size += 3;
       return dest;
     } else if (cp <= 0x10ffff) {
       char[] dest = new char[12];
@@ -291,7 +291,7 @@ private static char[] escape(int cp, EscapedData data, boolean[] unsafeOctets) {
       dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
       cp >>>= 2;
       dest[2] = UPPER_HEX_DIGITS[cp & 0x7];
-      data.addSize(4);
+      escaped.size += 4;
       return dest;
     } else {
       // If this ever happens it is due to bug in UnicodeEscaper, not bad input.
@@ -386,4 +386,14 @@ private static char[] growBuffer(char[] dest, int index, int size) {
     }
     return copy;
   }
+
+  public static class Escaped {
+    public String data;
+    public int size;
+
+    public Escaped(String data, int size) {
+      this.data = data;
+      this.size = size;
+    }
+  }
 }