Merge branch 'main' into set-commit-release-options

jamescrosswell · web-flow · commit bec337bf3aab · 2025-04-15T09:43:40.000+12:00
diff --git a/.github/actions/environment/action.yml b/.github/actions/environment/action.yml
@@ -60,7 +60,7 @@ runs:
       with:
         dotnet-version: |
           8.0.x
-          9.0.202
+          9.0.203
 
     - name: Install .NET Workloads
       shell: bash
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,11 @@
 
 - Prevent users from disabling AndroidEnableAssemblyCompression which leads to untrappable crash ([#4089](https://github.com/getsentry/sentry-dotnet/pull/4089))
 - Added a `SentrySetCommitReleaseOptions` build property that can be specified separately from `SentryReleaseOptions` ([#4109](https://github.com/getsentry/sentry-dotnet/pull/4109))
+- Fixed MSVCRT build warning on Windows ([#4111](https://github.com/getsentry/sentry-dotnet/pull/4111))
+
+### Features
+
+- If an incoming HTTP request has the `traceparent` header, it is now parsed and interpreted like the `sentry-trace` header. Outgoing requests now contain the `traceparent` header to facilitate integration with servesr that only support the [W3C Trace Context](https://www.w3.org/TR/trace-context/). ([#4084](https://github.com/getsentry/sentry-dotnet/pull/4084))
 
 ## 5.5.1
 
@@ -25,6 +30,12 @@
 - The `IScopeObserver` now has an `SetTrace` that allows observing changes to the scope's trace context. The SDK uses this to propagate the `trace ID` to `sentry-native`. This allows Sentry to connect errors coming from all layers of your application ([#4026](https://github.com/getsentry/sentry-dotnet/pull/4026))
 - Exception.HResult is now included in the mechanism data for all exceptions ([#4029](https://github.com/getsentry/sentry-dotnet/pull/4029))
 
+### Dependencies
+
+- Bump Native SDK from v0.8.2 to v0.8.3 [#4072](https://github.com/getsentry/sentry-dotnet/pull/4072))
+    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#083)
+    - [diff](https://github.com/getsentry/sentry-native/compare/0.8.2...0.8.3)
+
 ### Fixes
 
 - Fixed symbolication and source context for net9.0-android ([#4033](https://github.com/getsentry/sentry-dotnet/pull/4033))
@@ -36,7 +47,7 @@
 
 ### Dependencies
 
-- Bump Native SDK from v0.8.1 to v0.8.2 ([#4050](https://github.com/getsentry/sentry-dotnet/pull/4050))
+- Bump Native SDK from v0.8.1 to v0.8.2 ([#4050](https://github.com/getsentry/sentry-dotnet/pull/4050)
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#082)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.8.1...0.8.2)
 - Bump CLI from v2.42.2 to v2.43.0 ([#4036](https://github.com/getsentry/sentry-dotnet/pull/4036), [#4049](https://github.com/getsentry/sentry-dotnet/pull/4049), [#4060](https://github.com/getsentry/sentry-dotnet/pull/4060), [#4062](https://github.com/getsentry/sentry-dotnet/pull/4062))
@@ -118,6 +129,11 @@
 - .NET on iOS: Add experimental EnableAppHangTrackingV2 configuration flag to the options binding SDK ([#3877](https://github.com/getsentry/sentry-dotnet/pull/3877))
 - Added `SentryOptions.DisableSentryHttpMessageHandler`. Useful if you're using `OpenTelemetry.Instrumentation.Http` and ending up with duplicate spans. ([#3879](https://github.com/getsentry/sentry-dotnet/pull/3879))
 
+### Dependencies
+
+- Bump Native SDK from v0.7.17 to v0.7.18 ([#3891](https://github.com/getsentry/sentry-dotnet/pull/3891))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0718)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.7.17...0.7.18)
 ### Fixes
 
 - Prevent Native EXC_BAD_ACCESS signal errors from being captured when managed NullRefrenceExceptions occur ([#3909](https://github.com/getsentry/sentry-dotnet/pull/3909))
diff --git a/global.json b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "9.0.202",
+    "version": "9.0.203",
     "rollForward": "disable",
     "allowPrerelease": false
   }
diff --git a/modules/sentry-native b/modules/sentry-native
@@ -1 +1 @@
-Subproject commit 77dbf6a6006f0be24af30d056bdcac98a7bf5877
+Subproject commit 69f006a722ac1688ff3373acf0f7dcf0b067b56f
diff --git a/src/Sentry.AspNet/HttpContextExtensions.cs b/src/Sentry.AspNet/HttpContextExtensions.cs
@@ -33,6 +33,27 @@ public static class HttpContextExtensions
         }
     }
 
+    private static W3CTraceHeader? TryGetW3CTraceHeader(HttpContext context, SentryOptions? options)
+    {
+        var value = context.Request.Headers.Get(W3CTraceHeader.HttpHeaderName);
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+
+        options?.LogDebug("Received Sentry trace header '{0}'.", value);
+
+        try
+        {
+            return W3CTraceHeader.Parse(value);
+        }
+        catch (Exception ex)
+        {
+            options?.LogError(ex, "Invalid Sentry trace header '{0}'.", value);
+            return null;
+        }
+    }
+
     private static BaggageHeader? TryGetBaggageHeader(HttpContext context, SentryOptions? options)
     {
         var value = context.Request.Headers.Get(BaggageHeader.HttpHeaderName);
@@ -64,7 +85,10 @@ public static void StartOrContinueTrace(this HttpContext httpContext)
     {
         var options = SentrySdk.CurrentOptions;
 
+        // If both sentry-trace and traceparent headers are present, sentry-trace takes precedence.
+        // See: https://github.com/getsentry/team-sdks/issues/41
         var traceHeader = TryGetSentryTraceHeader(httpContext, options);
+        traceHeader ??= TryGetW3CTraceHeader(httpContext, options)?.SentryTraceHeader;
         var baggageHeader = TryGetBaggageHeader(httpContext, options);
 
         var method = httpContext.Request.HttpMethod;
diff --git a/src/Sentry.AspNetCore/Extensions/HttpContextExtensions.cs b/src/Sentry.AspNetCore/Extensions/HttpContextExtensions.cs
@@ -65,6 +65,27 @@ internal static class HttpContextExtensions
         }
     }
 
+    public static W3CTraceHeader? TryGetW3CTraceHeader(this HttpContext context, SentryOptions? options)
+    {
+        var value = context.Request.Headers.GetValueOrDefault(W3CTraceHeader.HttpHeaderName);
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+
+        options?.LogDebug("Received Sentry trace header '{0}'.", value);
+
+        try
+        {
+            return W3CTraceHeader.Parse(value!);
+        }
+        catch (Exception ex)
+        {
+            options?.LogError(ex, "Invalid Sentry trace header '{0}'.", value);
+            return null;
+        }
+    }
+
     public static BaggageHeader? TryGetBaggageHeader(this HttpContext context, SentryOptions? options)
     {
         var value = context.Request.Headers.GetValueOrDefault(BaggageHeader.HttpHeaderName);
diff --git a/src/Sentry.AspNetCore/SentryMiddleware.cs b/src/Sentry.AspNetCore/SentryMiddleware.cs
@@ -105,7 +105,10 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
                 context.Response.OnCompleted(() => hub.FlushAsync(_options.FlushTimeout));
             }
 
+            // If both sentry-trace and traceparent headers are present, sentry-trace takes precedence.
+            // See: https://github.com/getsentry/team-sdks/issues/41
             var traceHeader = context.TryGetSentryTraceHeader(_options);
+            traceHeader ??= context.TryGetW3CTraceHeader(_options)?.SentryTraceHeader;
             var baggageHeader = context.TryGetBaggageHeader(_options);
             var transactionContext = hub.ContinueTrace(traceHeader, baggageHeader);
 
diff --git a/src/Sentry.Azure.Functions.Worker/HttpRequestDataExtensions.cs b/src/Sentry.Azure.Functions.Worker/HttpRequestDataExtensions.cs
@@ -30,6 +30,31 @@ internal static class HttpRequestDataExtensions
         }
     }
 
+    public static W3CTraceHeader? TryGetW3CTraceHeader(this HttpRequestData context, IDiagnosticLogger? logger)
+    {
+        var traceHeaderValue = context.Headers.TryGetValues(W3CTraceHeader.HttpHeaderName, out var values)
+            ? values.FirstOrDefault()
+            : null;
+
+        if (traceHeaderValue is null)
+        {
+            logger?.LogDebug("Did not receive a Sentry trace header.");
+            return null;
+        }
+
+        logger?.LogDebug("Received Sentry trace header '{0}'.", traceHeaderValue);
+
+        try
+        {
+            return W3CTraceHeader.Parse(traceHeaderValue);
+        }
+        catch (Exception ex)
+        {
+            logger?.LogError(ex, "Invalid Sentry trace header '{0}'.", traceHeaderValue);
+            return null;
+        }
+    }
+
     public static BaggageHeader? TryGetBaggageHeader(this HttpRequestData context, IDiagnosticLogger? logger)
     {
         var baggageValue = context.Headers.TryGetValues(BaggageHeader.HttpHeaderName, out var value)
diff --git a/src/Sentry.Azure.Functions.Worker/SentryFunctionsWorkerMiddleware.cs b/src/Sentry.Azure.Functions.Worker/SentryFunctionsWorkerMiddleware.cs
@@ -123,7 +123,10 @@ private async Task<TransactionContext> StartOrContinueTraceAsync(FunctionContext
             TransactionNameCache.TryAdd(transactionNameKey, transactionName);
         }
 
+        // If both sentry-trace and traceparent headers are present, sentry-trace takes precedence.
+        // See: https://github.com/getsentry/team-sdks/issues/41
         var traceHeader = requestData.TryGetSentryTraceHeader(_logger);
+        traceHeader ??= requestData.TryGetW3CTraceHeader(_logger)?.SentryTraceHeader;
         var baggageHeader = requestData.TryGetBaggageHeader(_logger);
 
         return SentrySdk.ContinueTrace(traceHeader, baggageHeader, transactionName, Operation);
diff --git a/src/Sentry/Platforms/Native/buildTransitive/Sentry.Native.targets b/src/Sentry/Platforms/Native/buildTransitive/Sentry.Native.targets
@@ -18,6 +18,7 @@
     <NativeLibrary Include="$(MSBuildThisFileDirectory)..\sentry-native\win-x64\sentry-native.lib" />
     <NativeLibrary Include="dbghelp.lib" />
     <NativeLibrary Include="winhttp.lib" />
+    <NativeLibrary Include="Gdi32.lib" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(FrameworkSupportsNative)' == 'true' and '$(RuntimeIdentifier)' == 'linux-x64'">
diff --git a/src/Sentry/SentryMessageHandler.cs b/src/Sentry/SentryMessageHandler.cs
@@ -136,6 +136,7 @@ private void PropagateTraceHeaders(HttpRequestMessage request, string url)
         if (_options?.TracePropagationTargets.MatchesSubstringOrRegex(url) is true or null)
         {
             AddSentryTraceHeader(request);
+            AddW3CTraceHeader(request);
             AddBaggageHeader(request);
         }
     }
@@ -149,6 +150,15 @@ private void AddSentryTraceHeader(HttpRequestMessage request)
         }
     }
 
+    private void AddW3CTraceHeader(HttpRequestMessage request)
+    {
+        // Set trace header if it hasn't already been set
+        if (!request.Headers.Contains(W3CTraceHeader.HttpHeaderName) && _hub.GetTraceHeader() is { } traceHeader)
+        {
+            request.Headers.Add(W3CTraceHeader.HttpHeaderName, new W3CTraceHeader(traceHeader).ToString());
+        }
+    }
+
     private void AddBaggageHeader(HttpRequestMessage request)
     {
         var baggage = _hub.GetBaggage();
diff --git a/src/Sentry/SentryOptions.cs b/src/Sentry/SentryOptions.cs
@@ -952,7 +952,8 @@ public double? ProfilesSampleRate
     /// <summary>
     /// A customizable list of <see cref="StringOrRegex"/> objects, each containing either a
     /// substring or regular expression pattern that can be used to control which outgoing HTTP requests
-    /// will have the <c>sentry-trace</c> and <c>baggage</c> headers propagated, for purposes of distributed tracing.
+    /// will have the <c>sentry-trace</c>, <c>traceparent</c>, and <c>baggage</c> headers propagated,
+    /// for purposes of distributed tracing.
     /// The default value contains a single value of <c>.*</c>, which matches everything.
     /// To disable propagation completely, clear this collection or set it to an empty collection.
     /// </summary>
diff --git a/src/Sentry/W3CTraceHeader.cs b/src/Sentry/W3CTraceHeader.cs
@@ -0,0 +1,131 @@
+namespace Sentry;
+
+/// <summary>
+/// Extension methods for working with Sentry trace headers.
+/// </summary>
+internal class W3CTraceHeader
+{
+    private const string SupportedVersion = "00";
+
+    /// <summary>
+    /// The name of the W3C trace context header used for distributed tracing.
+    /// This field contains the value "traceparent" which is part of the W3C Trace Context specification.
+    /// </summary>
+    public const string HttpHeaderName = "traceparent";
+
+    /// <summary>
+    /// Represents the sampled trace flags value ("01") in W3C Trace Context specification.
+    /// This flag indicates that the trace is part of the sampling set and should be recorded.
+    /// </summary>
+    public const string TraceFlagsSampled = "01";
+
+    /// <summary>
+    /// Represents the unsampled trace flags value ("00") in W3C Trace Context specification.
+    /// This flag indicates that the trace is not part of the sampling set and should not be recorded.
+    /// </summary>
+    public const string TraceFlagsNotSampled = "00";
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="W3CTraceHeader"/> class from a Sentry trace header.
+    /// </summary>
+    /// <param name="source">The source Sentry trace header to create the W3C trace header from.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> is null.</exception>
+    public W3CTraceHeader(SentryTraceHeader source)
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source), "Source Sentry trace header cannot be null.");
+        }
+
+        SentryTraceHeader = source;
+    }
+
+    /// <summary>
+    /// Gets the Sentry trace header containing trace identification and sampling information.
+    /// </summary>
+    /// <value>
+    /// The Sentry trace header that contains the trace ID, span ID, and sampling decision.
+    /// </value>
+    public SentryTraceHeader SentryTraceHeader { get; }
+
+    /// <summary>
+    /// Parses a <see cref="SentryTraceHeader"/> from a string representation of the Sentry trace header.
+    /// </summary>
+    /// <param name="value">
+    /// A string containing the Sentry trace header, expected to follow the format "traceId-spanId-sampled",
+    /// where "sampled" is optional.
+    /// </param>
+    /// <returns>
+    /// A <see cref="SentryTraceHeader"/> object if parsing succeeds, or <c>null</c> if the input string is null, empty, or whitespace.
+    /// </returns>
+    /// <exception cref="FormatException">
+    /// Thrown if the input string does not contain a valid trace header format, specifically if it lacks required trace ID and span ID components.
+    /// </exception>
+    public static W3CTraceHeader? Parse(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+
+        var components = value.Split('-', StringSplitOptions.RemoveEmptyEntries);
+        if (components.Length < 4)
+        {
+            throw new FormatException($"Invalid W3C trace header: {value}.");
+        }
+
+        var version = components[0];
+        if (version != SupportedVersion)
+        {
+            throw new FormatException($"Invalid W3C trace header version: {version}.");
+        }
+
+        var traceId = SentryId.Parse(components[1]);
+        var spanId = SpanId.Parse(components[2]);
+        var isSampled = ConvertTraceFlagsToSampled(components[3]);
+
+        return new W3CTraceHeader(new SentryTraceHeader(traceId, spanId, isSampled));
+    }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        var traceFlags = ConvertSampledToTraceFlags(SentryTraceHeader.IsSampled);
+        return $"{SupportedVersion}-{SentryTraceHeader.TraceId}-{SentryTraceHeader.SpanId}-{traceFlags}";
+    }
+
+    private static string? ConvertSampledToTraceFlags(bool? isSampled) => (isSampled ?? false) ? TraceFlagsSampled : TraceFlagsNotSampled;
+
+    private static bool? ConvertTraceFlagsToSampled(string? traceFlags)
+    {
+        if (string.IsNullOrWhiteSpace(traceFlags) || traceFlags.Length != 2)
+        {
+            return null;
+        }
+
+        // In version 00 of the W3C Trace Context specification, the trace flags field is 2 hex digits.
+        // Only the first bit is used. We use string comparison first to avoid parsing the hex value in
+        // the bulk of all cases.
+        // See https://github.com/getsentry/sentry-dotnet/pull/4084#discussion_r2035771628
+        if (string.Equals(traceFlags, TraceFlagsSampled, StringComparison.Ordinal))
+        {
+            return true;
+        }
+        else if (string.Equals(traceFlags, TraceFlagsNotSampled, StringComparison.Ordinal))
+        {
+            return false;
+        }
+
+        // If the trace flags field is not "01" or "00", we try to parse it as a hex number.
+        // This is a fallback for cases where the trace flags field is not in the expected format.
+        if (!byte.TryParse(traceFlags, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out byte traceFlagsBytes))
+        {
+            // If it's not a valid hex number, we can't parse it.
+            return null;
+        }
+
+        // The first bit of the trace flags field indicates whether the trace is sampled.
+        // We use bitwise AND to check if the first bit is set.
+        return (traceFlagsBytes & 0x01) == 1;
+    }
+}
diff --git a/src/Sentry/buildTransitive/Sentry.targets b/src/Sentry/buildTransitive/Sentry.targets
@@ -15,6 +15,11 @@
     <Error Text="Android projects using Sentry cannot build using AndroidEnableAssemblyCompression = false due to a Microsoft issue.  Please follow https://github.com/dotnet/android/issues/9752" />
   </Target>
 
+  <ItemGroup Condition="$([System.OperatingSystem]::IsWindows())">
+    <!-- See: https://github.com/getsentry/sentry-dotnet/pull/4111 -->
+    <LinkerArg Include="/NODEFAULTLIB:MSVCRT" />
+  </ItemGroup>
+
   <Target Name="WriteSentryAttributes"
           Condition="$(Language) == 'VB' or $(Language) == 'C#' or $(Language) == 'F#'"
           BeforeTargets="BeforeCompile;CoreCompile"
diff --git a/test/Sentry.AspNetCore.Tests/SentryMiddlewareTests.cs b/test/Sentry.AspNetCore.Tests/SentryMiddlewareTests.cs
diff --git a/test/Sentry.Tests/SentryHttpMessageHandlerTests.cs b/test/Sentry.Tests/SentryHttpMessageHandlerTests.cs
diff --git a/test/Sentry.Tests/W3CTraceHeaderTests.cs b/test/Sentry.Tests/W3CTraceHeaderTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`		`- "version": "9.0.202",`
	`3`	`+ "version": "9.0.203",`
`4`	`4`	`"rollForward": "disable",`
`5`	`5`	`"allowPrerelease": false`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,10 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)`
`105`	`105`	`context.Response.OnCompleted(() => hub.FlushAsync(_options.FlushTimeout));`
`106`	`106`	`}`
`107`	`107`
	`108`	`+ // If both sentry-trace and traceparent headers are present, sentry-trace takes precedence.`
	`109`	`+ // See: https://github.com/getsentry/team-sdks/issues/41`
`108`	`110`	`var traceHeader = context.TryGetSentryTraceHeader(_options);`
	`111`	`+ traceHeader ??= context.TryGetW3CTraceHeader(_options)?.SentryTraceHeader;`
`109`	`112`	`var baggageHeader = context.TryGetBaggageHeader(_options);`
`110`	`113`	`var transactionContext = hub.ContinueTrace(traceHeader, baggageHeader);`
`111`	`114`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,10 @@ private async Task<TransactionContext> StartOrContinueTraceAsync(FunctionContext`
`123`	`123`	`TransactionNameCache.TryAdd(transactionNameKey, transactionName);`
`124`	`124`	`}`
`125`	`125`
	`126`	`+ // If both sentry-trace and traceparent headers are present, sentry-trace takes precedence.`
	`127`	`+ // See: https://github.com/getsentry/team-sdks/issues/41`
`126`	`128`	`var traceHeader = requestData.TryGetSentryTraceHeader(_logger);`
	`129`	`+ traceHeader ??= requestData.TryGetW3CTraceHeader(_logger)?.SentryTraceHeader;`
`127`	`130`	`var baggageHeader = requestData.TryGetBaggageHeader(_logger);`
`128`	`131`
`129`	`132`	`return SentrySdk.ContinueTrace(traceHeader, baggageHeader, transactionName, Operation);`