Do not strip leading zeros from Trace and Span IDs

crossdock/Jaeger.Crossdock/Controllers/CrossdockController.cs

@@ -89,7 +89,7 @@ private ActionResult ResultFromCrossdock(CrossdockResult.Result result, string o
 
         private string ValidateTrace(Downstream target, TraceResponse resp, string service, int level, string traceID, bool sampled, string baggage)
         {
-            if (traceID != resp.Span.TraceId)
+            if (!EqualTraceIDs(traceID, resp.Span.TraceId))
             {
                 return $"Trace ID mismatch in S{level}({service}): expected {traceID}, received {resp.Span.TraceId}";
             }
@@ -119,6 +119,17 @@ private string ValidateTrace(Downstream target, TraceResponse resp, string servi
             return null;
         }
 
+        private bool EqualTraceIDs(string id1, string id2)
+        {
+            var len = Math.Max(id1.Length, id2.Length);
+            return PadTraceID(id1, len) == PadTraceID(id2, len);
+        }
+
+        private string PadTraceID(string id, int len)
+        {
+            return id.PadLeft(len, '0');
+        }
+
         private async Task<TraceResponse> StartTraceAsync(string host, StartTraceRequest request)
         {
             var url = $"http://{host}:{Constants.DEFAULT_SERVER_PORT_HTTP}/start_trace";

src/Jaeger.Core/SpanId.cs

@@ -28,7 +28,7 @@ public SpanId(TraceId traceId)
 
         public override string ToString()
         {
-            return Id.ToString("x");
+            return Id.ToString("x016");
         }
 
         public static implicit operator long(SpanId s)

src/Jaeger.Core/TraceId.cs

@@ -34,10 +34,10 @@ public override string ToString()
         {
             if (High == 0)
             {
-                return Low.ToString("x");
+                return Low.ToString("x016");
             }
 
-            return $"{High:x}{Low:x016}";
+            return $"{High:x016}{Low:x016}";
         }
 
         public static TraceId FromString(string from)

test/Jaeger.Core.Tests/SpanIdTests.cs

@@ -14,10 +14,24 @@ public SpanIdTests()
             _spanId = new SpanId(_spanIdValue);
         }
 
+        [Fact]
+        public void FromString_WithoutZeroes()
+        {
+            var spanId = SpanId.FromString("2a");
+            Assert.Equal("000000000000002a", _spanId.ToString());
+        }
+
+        [Fact]
+        public void FromString_WithZeroes()
+        {
+            var spanId = SpanId.FromString("000000000000002a");
+            Assert.Equal("000000000000002a", _spanId.ToString());
+        }
+
         [Fact]
         public void Field_ShouldReturnHexString()
         {
-            Assert.Equal("2a", _spanId.ToString());
+            Assert.Equal("000000000000002a", _spanId.ToString());
         }
 
         [Fact]

test/Jaeger.Core.Tests/TraceIdTests.cs

@@ -6,7 +6,7 @@ namespace Jaeger.Core.Tests
     public class TraceIdTests
     {
         [Fact]
-        public void TraceId_InitLow_ShouldSetHighToZero()
+        public void InitLow_ShouldSetHighToZero()
         {
             var traceId = new TraceId(42);
 
@@ -15,7 +15,7 @@ public void TraceId_InitLow_ShouldSetHighToZero()
         }
 
         [Fact]
-        public void TraceId_InitHighLow_ShouldSetHighAndLow()
+        public void InitHighLow_ShouldSetHighAndLow()
         {
             var traceId = new TraceId(42, 21);
 
@@ -24,45 +24,89 @@ public void TraceId_InitHighLow_ShouldSetHighAndLow()
         }
 
         [Fact]
-        public void TraceId_InitLow_ToString()
+        public void InitLow_ToString()
         {
             var traceId = new TraceId(10);
 
-            Assert.Equal("a", traceId.ToString());
+            Assert.Equal("000000000000000a", traceId.ToString());
         }
 
         [Fact]
-        public void TraceId_InitHighLow_ToString()
+        public void InitHighLow_ToString()
         {
             var traceId = new TraceId(16, 31);
 
-            Assert.Equal("10000000000000001f", traceId.ToString());
+            Assert.Equal("0000000000000010000000000000001f", traceId.ToString());
         }
 
         [Fact]
-        public void TraceId_FromString()
+        public void FromString_Empty()
         {
             var ex = Assert.Throws<Exception>(() => TraceId.FromString(""));
             Assert.Equal("Cannot parse Low TraceId from string: ", ex.Message);
+        }
+
+        [Fact]
+        public void FromString_64Bit_WithoutZeroes()
+        {
+            var traceId = TraceId.FromString("1");
+            Assert.Equal(0, traceId.High);
+            Assert.Equal(1, traceId.Low);
+        }
+
+        [Fact]
+        public void FromString_64Bit_WithZeroes()
+        {
+            var traceId = TraceId.FromString("0123456789abcdef");
+            Assert.Equal(0, traceId.High);
+            Assert.Equal(0x123456789abcdef, traceId.Low);
+        }
 
+        [Fact]
+        public void FromString_64Bit_LowMalformed()
+        {
+            var badLowTraceId = "fedcba_876543210";
+            var ex = Assert.Throws<Exception>(() => TraceId.FromString(badLowTraceId));
+            Assert.Equal("Cannot parse Low TraceId from string: fedcba_876543210", ex.Message);
+        }
+
+        [Fact]
+        public void FromString_MoreThan128Bit()
+        {
             var tooLongTraceId = "0123456789abcdef0123456789abcdef012";
-            ex = Assert.Throws<Exception>(() => TraceId.FromString(tooLongTraceId));
+            var ex = Assert.Throws<Exception>(() => TraceId.FromString(tooLongTraceId));
             Assert.Equal($"TraceId cannot be longer than 32 hex characters: {tooLongTraceId}", ex.Message);
+        }
 
+        [Fact]
+        public void FromString_128Bit_WithoutZeroes()
+        {
+            var traceId = TraceId.FromString("10000000000000001");
+            Assert.Equal("1", traceId.High.ToString());
+            Assert.Equal("1", traceId.Low.ToString());
+        }
+
+        [Fact]
+        public void FromString_128Bit_WithZeroes()
+        {
             var traceId = TraceId.FromString("0123456789abcdeffedcba9876543210");
             Assert.Equal("0123456789abcdef", traceId.High.ToString("x016"));
             Assert.Equal("fedcba9876543210", traceId.Low.ToString("x016"));
+        }
 
-            ex = Assert.Throws<Exception>(() => TraceId.FromString("01234_6789abcdeffedcba9876543210"));
+        [Fact]
+        public void FromString_128Bit_HighMalformed()
+        {
+            var ex = Assert.Throws<Exception>(() => TraceId.FromString("01234_6789abcdeffedcba9876543210"));
             Assert.Equal("Cannot parse High TraceId from string: 01234_6789abcdef", ex.Message);
+        }
 
+        [Fact]
+        public void FromString_128Bit_LowMalformed()
+        {
             var badLowTraceId = "0123456789abcdeffedcba_876543210";
-            ex = Assert.Throws<Exception>(() => TraceId.FromString(badLowTraceId));
+            var ex = Assert.Throws<Exception>(() => TraceId.FromString(badLowTraceId));
             Assert.Equal("Cannot parse Low TraceId from string: fedcba_876543210", ex.Message);
-
-            traceId = TraceId.FromString("10000000000000001");
-            Assert.Equal("1", traceId.High.ToString());
-            Assert.Equal("1", traceId.Low.ToString());
         }
     }
 }