fix: span ids not re-generating for headers created from scope

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Span ids not re-generating for headers created from scope ([#3051](https://github.com/getsentry/sentry-dart/pull/3051))
 - `ScreenshotIntegration` not being added for web ([#3055](https://github.com/getsentry/sentry-dart/pull/3055))
 
 ### Enhancements

dart/lib/sentry.dart

@@ -53,8 +53,6 @@ export 'src/type_check_hint.dart';
 // ignore: invalid_export_of_internal_element
 export 'src/utils.dart';
 // ignore: invalid_export_of_internal_element
-export 'src/utils/add_tracing_headers_to_http_request.dart';
-// ignore: invalid_export_of_internal_element
 export 'src/utils/http_header_utils.dart';
 // ignore: invalid_export_of_internal_element
 export 'src/utils/http_sanitizer.dart';

dart/lib/src/http_client/tracing_client.dart

@@ -5,7 +5,6 @@ import '../hub_adapter.dart';
 import '../protocol.dart';
 import '../sentry_trace_origins.dart';
 import '../tracing.dart';
-import '../utils/add_tracing_headers_to_http_request.dart';
 import '../utils/http_sanitizer.dart';
 import '../utils/tracing_utils.dart';
 

dart/lib/src/propagation_context.dart

@@ -1,17 +1,12 @@
 import 'package:meta/meta.dart';
 
-import 'protocol.dart';
-import 'sentry_baggage.dart';
+import '../sentry.dart';
 
 @internal
 class PropagationContext {
   /// Either represents the incoming `traceId` or the `traceId` generated by the current SDK, if there was no incoming trace.
   SentryId traceId = SentryId.newId();
 
-  /// A span ID that should be used for the `trace` context of various event type, when performance is disabled or when there is no active span.
-  /// If this value is undefined on the propagation context, the SDK will generate a random span ID for `trace` contexts and trace propagation.
-  final SpanId spanId = SpanId.newId();
-
   /// The dynamic sampling context.
   SentryBaggage? baggage;
 
@@ -20,5 +15,6 @@ class PropagationContext {
       baggage != null ? SentryBaggageHeader.fromBaggage(baggage!) : null;
 
   /// Sentry trace header to attach to http headers.
-  SentryTraceHeader toSentryTrace() => SentryTraceHeader(traceId, spanId);
+  SentryTraceHeader toSentryTrace() =>
+      generateSentryTraceHeader(traceId: traceId);
 }

dart/lib/src/protocol/sentry_span.dart

@@ -213,9 +213,9 @@ class SentrySpan extends ISentrySpan {
   Map<String, dynamic> get data => _data;
 
   @override
-  SentryTraceHeader toSentryTrace() => SentryTraceHeader(
-        _context.traceId,
-        _context.spanId,
+  SentryTraceHeader toSentryTrace() => generateSentryTraceHeader(
+        traceId: _context.traceId,
+        spanId: _context.spanId,
         sampled: samplingDecision?.sampled,
       );
 

dart/lib/src/protocol/sentry_trace_context.dart

@@ -119,7 +119,7 @@ class SentryTraceContext {
       PropagationContext propagationContext) {
     return SentryTraceContext(
         traceId: propagationContext.traceId,
-        spanId: propagationContext.spanId,
+        spanId: SpanId.newId(),
         operation: 'default',
         replayId: propagationContext.baggage?.getReplayId());
   }

dart/lib/src/utils/tracing_utils.dart

@@ -1,5 +1,33 @@
 import '../../sentry.dart';
 
+SentryTraceHeader generateSentryTraceHeader(
+    {SentryId? traceId, SpanId? spanId, bool? sampled}) {
+  traceId ??= SentryId.newId();
+  spanId ??= SpanId.newId();
+  return SentryTraceHeader(traceId, spanId, sampled: sampled);
+}
+
+void addTracingHeadersToHttpHeader(Map<String, dynamic> headers, Hub hub,
+    {ISentrySpan? span}) {
+  if (span != null) {
+    addSentryTraceHeaderFromSpan(span, headers);
+    addBaggageHeaderFromSpan(
+      span,
+      headers,
+      log: hub.options.log,
+    );
+  } else {
+    addSentryTraceHeaderFromScope(hub.scope, headers);
+    addBaggageHeaderFromScope(hub.scope, headers, log: hub.options.log);
+  }
+}
+
+void addSentryTraceHeaderFromScope(Scope scope, Map<String, dynamic> headers) {
+  final propagationContext = scope.propagationContext;
+  final traceHeader = propagationContext.toSentryTrace();
+  headers[traceHeader.name] = traceHeader.value;
+}
+
 void addSentryTraceHeaderFromSpan(
     ISentrySpan span, Map<String, dynamic> headers) {
   final traceHeader = span.toSentryTrace();
@@ -11,6 +39,17 @@ void addSentryTraceHeader(
   headers[traceHeader.name] = traceHeader.value;
 }
 
+void addBaggageHeaderFromScope(
+  Scope scope,
+  Map<String, dynamic> headers, {
+  SdkLogCallback? log,
+}) {
+  final baggageHeader = scope.propagationContext.toBaggageHeader();
+  if (baggageHeader != null) {
+    addBaggageHeader(baggageHeader, headers, log: log);
+  }
+}
+
 void addBaggageHeaderFromSpan(
   ISentrySpan span,
   Map<String, dynamic> headers, {

dart/test/http_client/tracing_client_test.dart

@@ -160,13 +160,38 @@ void main() {
       final response = await sut.get(requestUri);
 
       final baggageHeader = propagationContext.toBaggageHeader();
-      final sentryTraceHeader = propagationContext.toSentryTrace();
 
       expect(propagationContext.toBaggageHeader(), isNotNull);
       expect(
           response.request!.headers[baggageHeader!.name], baggageHeader.value);
-      expect(response.request!.headers[sentryTraceHeader.name],
-          sentryTraceHeader.value);
+
+      final traceHeader = SentryTraceHeader.fromTraceHeader(
+        response.request!.headers['sentry-trace'] as String,
+      );
+      expect(traceHeader.traceId, propagationContext.traceId);
+      // can't check span id as it is always generated new
+    });
+
+    test(
+        'tracing header from propagation context should generate new span ids for new events',
+        () async {
+      fixture._hub.options.tracesSampleRate = null;
+      fixture._hub.options.tracesSampler = null;
+      final sut = fixture.getSut(
+        client: fixture.getClient(statusCode: 200, reason: 'OK'),
+      );
+      final propagationContext = fixture._hub.scope.propagationContext;
+      propagationContext.baggage = SentryBaggage({'foo': 'bar'});
+
+      final response1 = await sut.get(requestUri);
+      final response2 = await sut.get(requestUri);
+
+      final traceHeader1 = SentryTraceHeader.fromTraceHeader(
+          response1.request!.headers['sentry-trace']!);
+      final traceHeader2 = SentryTraceHeader.fromTraceHeader(
+          response2.request!.headers['sentry-trace']!);
+
+      expect(traceHeader1.spanId, isNot(traceHeader2.spanId));
     });
 
     test(

dart/test/scope_test.dart

@@ -463,13 +463,34 @@ void main() {
           true);
     });
 
-    test('apply trace context to event', () async {
+    test('apply trace context to event with active span', () async {
       final event = SentryEvent();
       final scope = Scope(defaultTestOptions())..span = fixture.sentryTracer;
 
       final updatedEvent = await scope.applyToEvent(event, Hint());
 
-      expect(updatedEvent?.contexts['trace'] is SentryTraceContext, true);
+      expect(updatedEvent?.contexts['trace'] is SentryTraceContext, isTrue);
+    });
+
+    test('apply trace context to event with propagation context', () async {
+      final event = SentryEvent();
+      final event2 = SentryEvent();
+      final scope = Scope(defaultTestOptions());
+
+      final updatedEvent = await scope.applyToEvent(event, Hint());
+
+      final traceContext =
+          updatedEvent?.contexts['trace'] as SentryTraceContext;
+      final spanId1 = traceContext.spanId;
+      expect(traceContext.traceId, scope.propagationContext.traceId);
+
+      final updatedEvent2 = await scope.applyToEvent(event2, Hint());
+      final traceContext2 =
+          updatedEvent2?.contexts['trace'] as SentryTraceContext;
+      final spanId2 = traceContext2.spanId;
+
+      // trace contexts from the scope should always re-generate span ids
+      expect(spanId1, isNot(spanId2));
     });
 
     test('should not apply the scope properties when event already has it ',

dart/test/sentry_client_test.dart

@@ -647,8 +647,7 @@ void main() {
       expect(fixture.transport.envelopes.length, 1);
       expect(
           scopePropagationContext.traceId, sentryEvent.contexts.trace!.traceId);
-      expect(
-          scopePropagationContext.spanId, sentryEvent.contexts.trace!.spanId);
+      // not checking for span id as it should be a new generated random span id
     });
 
     test('keeps existing trace context if already present', () async {
@@ -680,8 +679,6 @@ void main() {
       expect(spanContext.spanId, isNot(sentryEvent.contexts.trace!.spanId));
       expect(propagationContext.traceId,
           isNot(sentryEvent.contexts.trace!.traceId));
-      expect(
-          propagationContext.spanId, isNot(sentryEvent.contexts.trace!.spanId));
     });
 
     test(

dart/test/sentry_trace_context_test.dart

@@ -1,4 +1,5 @@
 import 'package:sentry/sentry.dart';
+import 'package:sentry/src/propagation_context.dart';
 import 'package:test/test.dart';
 
 import 'mocks.dart';
@@ -48,6 +49,20 @@ void main() {
         traceContext.replayId.toString(), '00000000000000000000000000000004');
     expect(traceContext.data, {'key': 'value'});
   });
+
+  test('fromPropagationContext creates valid SentryTraceContext', () {
+    final propagationContext = PropagationContext();
+
+    final traceContext1 =
+        SentryTraceContext.fromPropagationContext(propagationContext);
+    final traceContext2 =
+        SentryTraceContext.fromPropagationContext(propagationContext);
+
+    expect(traceContext1.traceId, propagationContext.traceId);
+    expect(traceContext1.traceId, traceContext1.traceId);
+    // the span id is always generated new when creating a trace context from scope
+    expect(traceContext1.spanId, isNot(traceContext2.spanId));
+  });
 }
 
 class Fixture {