Optimization of traceId serialization: do not allocate temporary buffer.

Author: AlexeyKuznetsov-DD

communication/src/main/java/datadog/communication/serialization/Writable.java

@@ -27,6 +27,8 @@ public interface Writable {
 
   void writeBinary(byte[] binary, int offset, int length);
 
+  void writeBinary(long hi, long lo);
+
   /**
    * Start a part of the message containing key-value pairs
    *

communication/src/main/java/datadog/communication/serialization/msgpack/MsgPackWriter.java

@@ -213,6 +213,13 @@ public void writeBinary(byte[] binary, int offset, int length) {
     buffer.put(binary, offset, length);
   }
 
+  @Override
+  public void writeBinary(long hi, long lo) {
+    writeBinaryHeader(16);
+    buffer.putLong(hi);
+    buffer.putLong(lo);
+  }
+
   @Override
   public void writeBinary(ByteBuffer binary) {
     ByteBuffer slice = binary.slice();

communication/src/test/java/datadog/communication/serialization/msgpack/MsgPackWriterTest.java

@@ -154,6 +154,28 @@ public void testWriteBinaryNoArgVariant() {
     writer.writeBinary("foobar".getBytes(UTF_8));
   }
 
+  @Test
+  public void testWriteBinaryLongPair() {
+    final long hi = 0x1122334455667788L;
+    final long lo = 0x99AABBCCDDEEFF00L;
+    final byte[] data = ByteBuffer.allocate(16).putLong(hi).putLong(lo).array();
+    MessageFormatter messageFormatter =
+        new MsgPackWriter(
+            newBuffer(
+                25,
+                (messageCount, buffy) -> {
+                  try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(buffy)) {
+                    int length = unpacker.unpackBinaryHeader();
+                    assertEquals(16, length);
+                    assertArrayEquals(data, unpacker.readPayload(length));
+                  } catch (IOException e) {
+                    fail(e.getMessage());
+                  }
+                }));
+    messageFormatter.format(data, (ignored, writable) -> writable.writeBinary(hi, lo));
+    messageFormatter.flush();
+  }
+
   @Test
   public void testWriteBinaryAsObject() {
     final byte[] data = new byte[] {1, 2, 3, 4};

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

@@ -1,7 +1,6 @@
 package datadog.trace.api;
 
 import datadog.trace.api.internal.util.LongStringUtils;
-import java.nio.ByteBuffer;
 
 /**
  * Class encapsulating the id used for TraceIds.
@@ -103,14 +102,4 @@ public static DDTraceId fromHex(String s) throws NumberFormatException {
    *     <code>0</code> for 64-bit {@link DDTraceId} only.
    */
   public abstract long toHighOrderLong();
-
-  /**
-   * @return High-order and low-order bits as bytes array.
-   */
-  public byte[] to128BitBytes() {
-    ByteBuffer buffer = ByteBuffer.allocate(16);
-    buffer.putLong(toHighOrderLong());
-    buffer.putLong(toLong());
-    return buffer.array();
-  }
 }

dd-trace-core/src/main/java/datadog/trace/common/writer/ddagent/TraceMapperV1.java

@@ -13,6 +13,7 @@
 import datadog.environment.JavaVirtualMachine;
 import datadog.trace.api.Config;
 import datadog.trace.api.DDTags;
+import datadog.trace.api.DDTraceId;
 import datadog.trace.api.ProcessTags;
 import datadog.trace.api.TagMap;
 import datadog.trace.api.sampling.SamplingMechanism;
@@ -97,7 +98,7 @@ public void map(List<? extends CoreSpan<?>> trace, Writable writable) {
     // spans = 4, a list of spans in this chunk
     encodeSpans(writable, 4, trace);
     // traceID = 6, the ID of the trace to which all spans in this chunk belong
-    encodeBytes(writable, 6, firstSpan.getTraceId().to128BitBytes());
+    encodeTraceId(writable, 6, firstSpan.getTraceId());
     // samplingMechanism = 7, uint32
     encodeInt(writable, 7, parseSamplingMechanism(firstSpanMeta.getTags()));
   }
@@ -184,7 +185,7 @@ private void encodeSpanLinks(
     for (AgentSpanLink link : links) {
       writable.startMap(5);
       // 1: the ID of the trace that this link targets
-      encodeBytes(writable, 1, link.traceId().to128BitBytes());
+      encodeTraceId(writable, 1, link.traceId());
       // 2: the ID of the span that this link targets, fixed64
       encodeLongUnsigned(writable, 2, link.spanId());
       // 3: a collection of attribute string key to value pairs on the link, map<uint32, AnyValue>
@@ -522,9 +523,9 @@ private void encodeString(Writable writable, int fieldId, CharSequence value) {
     writeStreamingString(writable, value);
   }
 
-  private void encodeBytes(Writable writable, int fieldId, byte[] value) {
+  private void encodeTraceId(Writable writable, int fieldId, DDTraceId traceId) {
     writable.writeInt(fieldId);
-    writable.writeBinary(value);
+    writable.writeBinary(traceId.toHighOrderLong(), traceId.toLong());
   }
 
   /** Writes a string using the streaming string table encoding. */

dd-trace-core/src/test/groovy/datadog/trace/common/writer/ddagent/TraceMapperV1PayloadTest.groovy

@@ -349,13 +349,13 @@ class TraceMapperV1PayloadTest extends DDSpecification {
 
     then:
     assertEquals(2, links.size())
-    assertArrayEquals(DDTraceId.fromHex("11223344556677889900aabbccddeeff").to128BitBytes(), links[0].traceId as byte[])
+    assertArrayEquals(traceIdBytes(DDTraceId.fromHex("11223344556677889900aabbccddeeff")), links[0].traceId as byte[])
     assertEquals(DDSpanId.fromHex("000000000000002a"), links[0].spanId)
     assertEquals("dd=s:1", links[0].tracestate)
     assertEquals(1L, links[0].flags)
     assertEquals(["link.kind": "follows_from", "context_headers": "tracecontext"], links[0].attributes)
 
-    assertArrayEquals(DDTraceId.fromHex("00000000000000000000000000000001").to128BitBytes(), links[1].traceId as byte[])
+    assertArrayEquals(traceIdBytes(DDTraceId.fromHex("00000000000000000000000000000001")), links[1].traceId as byte[])
     assertEquals(DDSpanId.fromHex("0000000000000002"), links[1].spanId)
     assertEquals("", links[1].tracestate)
     assertEquals(0L, links[1].flags)
@@ -846,10 +846,17 @@ class TraceMapperV1PayloadTest extends DDSpecification {
     assertEqualsWithNullAsEmpty(firstSpan.getOrigin(), origin)
     assertEquals(1, chunkAttributes.size())
     assertEqualsWithNullAsEmpty(firstSpan.getLocalRootSpan().getServiceName(), chunkAttributes.get("service"))
-    assertArrayEquals(firstSpan.getTraceId().to128BitBytes(), traceId)
+    assertArrayEquals(traceIdBytes(firstSpan.getTraceId()), traceId)
     assertEquals(expectedSamplingMechanism(firstSpan.getTags()), samplingMechanism)
   }
 
+  private static byte[] traceIdBytes(DDTraceId traceId) {
+    ByteBuffer.allocate(16)
+      .putLong(traceId.toHighOrderLong())
+      .putLong(traceId.toLong())
+      .array()
+  }
+
   private static List<TraceGenerator.PojoSpan> verifySpans(
     MessageUnpacker unpacker,
     List<TraceGenerator.PojoSpan> expectedTrace,