Integrate trace headers

src/Sentry/HubExtensions.cs

@@ -42,6 +42,27 @@ public static ITransaction StartTransaction(
             return transaction;
         }
 
+        /// <summary>
+        /// Starts a transaction from the specified trace header.
+        /// </summary>
+        public static ITransaction StartTransaction(
+            this IHub hub,
+            string name,
+            string operation,
+            SentryTraceHeader traceHeader)
+        {
+            var context = new TransactionContext(
+                // SpanId from the header becomes ParentSpanId on this transaction
+                traceHeader.SpanId,
+                traceHeader.TraceId,
+                name,
+                operation,
+                traceHeader.IsSampled
+            );
+
+            return hub.StartTransaction(context);
+        }
+
         /// <summary>
         /// Adds a breadcrumb to the current scope.
         /// </summary>

src/Sentry/Internal/Hub.cs

@@ -158,6 +158,7 @@ public ITransaction StartTransaction(
 
         public SentryTraceHeader? GetSentryTrace()
         {
+            // TODO:
             var (currentScope, _) = ScopeManager.GetCurrent();
             return currentScope.Transaction?.GetTraceHeader();
         }

src/Sentry/Protocol/SentryTraceHeader.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Net.Http;
 
 namespace Sentry.Protocol
 {
@@ -7,24 +8,59 @@ namespace Sentry.Protocol
     /// </summary>
     public class SentryTraceHeader
     {
-        private readonly SentryId _traceId;
-        private readonly SpanId _spanId;
-        private readonly bool? _isSampled;
+        private const string HeaderName = "sentry-trace";
+
+        /// <summary>
+        /// Trace ID.
+        /// </summary>
+        public SentryId TraceId { get; }
+
+        /// <summary>
+        /// Span ID.
+        /// </summary>
+        public SpanId SpanId { get; }
+
+        /// <summary>
+        /// Whether the trace is sampled.
+        /// </summary>
+        public bool? IsSampled { get; }
 
         /// <summary>
         /// Initializes an instance of <see cref="SentryTraceHeader"/>.
         /// </summary>
-        public SentryTraceHeader(SentryId traceId, SpanId spanId, bool? isSampled)
+        public SentryTraceHeader(SentryId traceId, SpanId spanSpanId, bool? isSampled)
         {
-            _traceId = traceId;
-            _spanId = spanId;
-            _isSampled = isSampled;
+            TraceId = traceId;
+            SpanId = spanSpanId;
+            IsSampled = isSampled;
+        }
+
+        /// <summary>
+        /// Injects trace information into the headers of the specified HTTP request.
+        /// </summary>
+        public void Inject(HttpRequestMessage request)
+        {
+            var headerValue = ToString();
+
+            request.Headers.Remove(HeaderName);
+            request.Headers.Add(HeaderName, headerValue);
+        }
+
+        /// <summary>
+        /// Injects trace information into the default headers of the specified HTTP client.
+        /// </summary>
+        public void Inject(HttpClient client)
+        {
+            var headerValue = ToString();
+
+            client.DefaultRequestHeaders.Remove(HeaderName);
+            client.DefaultRequestHeaders.Add(HeaderName, headerValue);
         }
 
         /// <inheritdoc />
-        public override string ToString() => _isSampled is {} isSampled
-            ? $"{_traceId}-{_spanId}-{(isSampled ? 1 : 0)}"
-            : $"{_traceId}-{_spanId}";
+        public override string ToString() => IsSampled is {} isSampled
+            ? $"{TraceId}-{SpanId}-{(isSampled ? 1 : 0)}"
+            : $"{TraceId}-{SpanId}";
 
         /// <summary>
         /// Parses <see cref="SentryTraceHeader"/> from string.

src/Sentry/Protocol/TransactionContext.cs

@@ -29,11 +29,12 @@ public TransactionContext(
         /// Initializes an instance of <see cref="TransactionContext"/>.
         /// </summary>
         public TransactionContext(
+            SpanId? parentSpanId,
+            SentryId traceId,
             string name,
             string operation,
-            string description,
             bool? isSampled)
-            : this(SpanId.Create(), null, SentryId.Create(), name, operation, description, null, isSampled)
+            : this(SpanId.Create(), parentSpanId, traceId, name, operation, "", null, isSampled)
         {
         }
 
@@ -44,7 +45,7 @@ public TransactionContext(
             string name,
             string operation,
             bool? isSampled)
-            : this(name, operation, "", isSampled)
+            : this(null, SentryId.Create(), name, operation, isSampled)
         {
         }
 

test/Sentry.Tests/HubTests.cs

@@ -162,6 +162,30 @@ public void StartTransaction_NameOpDescription_Works()
             transaction.Description.Should().Be("description");
         }
 
+        [Fact]
+        public void StartTransaction_FromTraceHeader_Works()
+        {
+            // Arrange
+            var hub = new Hub(new SentryOptions
+            {
+                Dsn = DsnSamples.ValidDsnWithSecret
+            });
+
+            var traceHeader = new SentryTraceHeader(
+                SentryId.Parse("75302ac48a024bde9a3b3734a82e36c8"),
+                SpanId.Parse("2000000000000000"),
+                true
+            );
+
+            // Act
+            var transaction = hub.StartTransaction("name", "operation", traceHeader);
+
+            // Assert
+            transaction.TraceId.Should().Be("75302ac48a024bde9a3b3734a82e36c8");
+            transaction.ParentSpanId.Should().Be(SpanId.Parse("2000000000000000"));
+            transaction.IsSampled.Should().BeTrue();
+        }
+
         [Fact]
         public void StartTransaction_StaticSampling_SampledIn()
         {

test/Sentry.Tests/Protocol/SentryTraceHeaderTests.cs

@@ -0,0 +1,96 @@
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Sentry.Protocol;
+using Sentry.Testing;
+using Xunit;
+
+namespace Sentry.Tests.Protocol
+{
+    public class SentryTraceHeaderTests
+    {
+        [Fact]
+        public void Parse_WithoutSampled_Works()
+        {
+            // Arrange
+            const string headerValue = "75302ac48a024bde9a3b3734a82e36c8-1000000000000000";
+
+            // Act
+            var header = SentryTraceHeader.Parse(headerValue);
+
+            // Assert
+            header.TraceId.Should().Be(SentryId.Parse("75302ac48a024bde9a3b3734a82e36c8"));
+            header.SpanId.Should().Be(SpanId.Parse("1000000000000000"));
+            header.IsSampled.Should().BeNull();
+        }
+
+        [Fact]
+        public void Parse_WithSampledTrue_Works()
+        {
+            // Arrange
+            const string headerValue = "75302ac48a024bde9a3b3734a82e36c8-1000000000000000-1";
+
+            // Act
+            var header = SentryTraceHeader.Parse(headerValue);
+
+            // Assert
+            header.TraceId.Should().Be(SentryId.Parse("75302ac48a024bde9a3b3734a82e36c8"));
+            header.SpanId.Should().Be(SpanId.Parse("1000000000000000"));
+            header.IsSampled.Should().BeTrue();
+        }
+
+        [Fact]
+        public void Parse_WithSampledFalse_Works()
+        {
+            // Arrange
+            const string headerValue = "75302ac48a024bde9a3b3734a82e36c8-1000000000000000-0";
+
+            // Act
+            var header = SentryTraceHeader.Parse(headerValue);
+
+            // Assert
+            header.TraceId.Should().Be(SentryId.Parse("75302ac48a024bde9a3b3734a82e36c8"));
+            header.SpanId.Should().Be(SpanId.Parse("1000000000000000"));
+            header.IsSampled.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Inject_ToHttpRequest_Works()
+        {
+            // Arrange
+            using var request = new HttpRequestMessage();
+            var header = SentryTraceHeader.Parse("75302ac48a024bde9a3b3734a82e36c8-1000000000000000-0");
+
+            // Act
+            header.Inject(request);
+
+            // Assert
+            request.Headers.Should().Contain(h =>
+                h.Key == "sentry-trace" &&
+                string.Concat(h.Value) == "75302ac48a024bde9a3b3734a82e36c8-1000000000000000-0"
+            );
+        }
+
+        [Fact]
+        public async Task Inject_ToHttpClient_Works()
+        {
+            // Arrange
+            using var handler = new FakeHttpClientHandler();
+            using var client = new HttpClient(handler);
+            var header = SentryTraceHeader.Parse("75302ac48a024bde9a3b3734a82e36c8-1000000000000000-0");
+
+            // Act
+            header.Inject(client);
+            await client.GetAsync("https://example.com");
+
+            using var request = handler.GetRequests().Single();
+
+            // Assert
+            request.Headers.Should().Contain(h =>
+                h.Key == "sentry-trace" &&
+                string.Concat(h.Value) == "75302ac48a024bde9a3b3734a82e36c8-1000000000000000-0"
+            );
+        }
+    }
+}