Release 8.14.2 (#2888)

buenaflor · denrase · getsentry-bot · web-flow · commit 972ad54f2f00 · 2025-04-24T13:00:24.000+02:00
* Fix: Improve platform memory collection on windows/linux (#2798) * deps: bump Android from `7.22.1` to `7.22.4` (#2810) * update android deps * Update CHANGELOG.md * Fix adding runtime to contexts (#2813) * Fix CHANGELOG formatting * release: 8.14.1 * fix: `options.diagnosticLevel` not affecting logs (#2856) * v9: Set log level to `warning` by default (#2836) * update * update test * update init native sdk test * Update CHANGELOG * Add additional test * Update CHANGELOG * Update CHANGELOG * Update * Update * Fix test * Fix test * Fix analyze * Remove prod scheme * Update mocks * Update mocks * Improve performance of frames tracking (#2854) * Improve performance * Update tests * Improve performance * Formatting * Separate function * Remove separate function * Update * Improve frames tracking performance * update naming * Update * update * update * Edge case * Update mocks * formatting * Improvements * Analyze * Update mocks * Update mocks * Clean up `getSpan()` log (#2865) * Remove unnecessary log and document the behaviour * Typo * Typo * Add CHANGELOG entry * release: 8.14.2 * Update * Update --------- Co-authored-by: Denis Andrašec <denrase@gmail.com> Co-authored-by: getsentry-bot <bot@sentry.io> Co-authored-by: getsentry-bot <bot@getsentry.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -67,6 +67,17 @@ await SentryFlutter.init(
   - [changelog](https://github.com/dart-lang/native/blob/main/pkgs/jni/CHANGELOG.md#0141)
   - [diff](https://github.com/dart-lang/native/compare/jnigen-v0.14.0..jnigen-v0.14.1)
 
+## 8.14.2
+
+### Improvements
+
+- Improve performance of frames tracking ([#2854](https://github.com/getsentry/sentry-dart/pull/2854))
+- Clean up `getSpan()` log ([#2865](https://github.com/getsentry/sentry-dart/pull/2865))
+
+### Fixes
+
+- `options.diagnosticLevel` not affecting logs ([#2856](https://github.com/getsentry/sentry-dart/pull/2856))
+
 ## 9.0.0-alpha.2
 
 ### Features
diff --git a/dart/lib/src/hub.dart b/dart/lib/src/hub.dart
@@ -507,12 +507,7 @@ class Hub {
         SentryLevel.warning,
         "Instance is disabled and this 'getSpan' call is a no-op.",
       );
-    } else if (!_options.isTracingEnabled()) {
-      _options.logger(
-        SentryLevel.info,
-        "Tracing is disabled and this 'getSpan' returns null.",
-      );
-    } else {
+    } else if (_options.isTracingEnabled()) {
       final item = _peek();
 
       span = item.scope.span;
diff --git a/dart/lib/src/sentry.dart b/dart/lib/src/sentry.dart
@@ -362,6 +362,7 @@ class Sentry {
       );
 
   /// Gets the current active transaction or span bound to the scope.
+  /// Returns `null` if performance is disabled in the options.
   static ISentrySpan? getSpan() => _hub.getSpan();
 
   static Future<void> addFeatureFlag(String name, dynamic value) async {
diff --git a/dart/test/sentry_test.dart b/dart/test/sentry_test.dart
@@ -1,3 +1,5 @@
+// ignore_for_file: deprecated_member_use_from_same_package
+
 import 'dart:async';
 import 'dart:isolate';
 
diff --git a/flutter/lib/src/binding_wrapper.dart b/flutter/lib/src/binding_wrapper.dart
@@ -73,37 +73,50 @@ typedef FrameTimingCallback = void Function(
     DateTime startTimestamp, DateTime endTimestamp);
 
 mixin SentryWidgetsBindingMixin on WidgetsBinding {
-  DateTime? _startTimestamp;
-  FrameTimingCallback? _frameTimingCallback;
-  ClockProvider? _clock;
-
-  SentryOptions get _options => Sentry.currentHub.options;
+  FrameTimingCallback? _onDelayedFrame;
+  FrameTimingCallback? get onDelayedFrame => _onDelayedFrame;
+  Duration? _expectedFrameDuration;
+  Duration? get expectedFrameDuration => _expectedFrameDuration;
+  bool _isTrackingActive = false;
+  SentryOptions? _options;
+  SentryOptions? get options => _options;
+  final Stopwatch _stopwatch = Stopwatch();
 
   @internal
-  void registerFramesTracking(
-      FrameTimingCallback callback, ClockProvider clock) {
-    _frameTimingCallback ??= callback;
-    _clock ??= clock;
+  void initializeFramesTracking(FrameTimingCallback onDelayedFrame,
+      SentryOptions options, Duration expectedFrameDuration) {
+    _onDelayedFrame ??= onDelayedFrame;
+    _options ??= options;
+    _expectedFrameDuration ??= expectedFrameDuration;
+  }
+
+  void resumeTrackingFrames() {
+    _isTrackingActive = true;
   }
 
-  @visibleForTesting
-  bool isFramesTrackingInitialized() {
-    return _frameTimingCallback != null && _clock != null;
+  void pauseTrackingFrames() {
+    // Stopwatch could continue running if we pause tracking in between a frame
+    _stopwatch.stop();
+    _stopwatch.reset();
+    _isTrackingActive = false;
   }
 
   @internal
   void removeFramesTracking() {
-    _frameTimingCallback = null;
-    _clock = null;
+    _onDelayedFrame = null;
+    _expectedFrameDuration = null;
+    _options = null;
   }
 
   @override
   void handleBeginFrame(Duration? rawTimeStamp) {
-    try {
-      _startTimestamp = _clock?.call();
-    } catch (_) {
-      if (_options.automatedTestMode) {
-        rethrow;
+    if (_isTrackingActive) {
+      try {
+        _stopwatch.start();
+      } catch (_) {
+        if (_options?.automatedTestMode == true) {
+          rethrow;
+        }
       }
     }
 
@@ -114,15 +127,25 @@ mixin SentryWidgetsBindingMixin on WidgetsBinding {
   void handleDrawFrame() {
     super.handleDrawFrame();
 
+    if (!_isTrackingActive) {
+      return;
+    }
+    final expectedFrameDuration = _expectedFrameDuration;
+    final options = _options;
     try {
-      final endTimestamp = _clock?.call();
-      if (_startTimestamp != null &&
-          endTimestamp != null &&
-          _startTimestamp!.isBefore(endTimestamp)) {
-        _frameTimingCallback?.call(_startTimestamp!, endTimestamp);
+      _stopwatch.stop();
+      if (options != null &&
+          expectedFrameDuration != null &&
+          _stopwatch.elapsedMilliseconds >
+              expectedFrameDuration.inMilliseconds) {
+        final endTimestamp = options.clock();
+        final startTimestamp = endTimestamp
+            .subtract(Duration(milliseconds: _stopwatch.elapsedMilliseconds));
+        _onDelayedFrame?.call(startTimestamp, endTimestamp);
       }
+      _stopwatch.reset();
     } catch (_) {
-      if (_options.automatedTestMode) {
+      if (_options?.automatedTestMode == true) {
         rethrow;
       }
     }
diff --git a/flutter/lib/src/frames_tracking/sentry_delayed_frames_tracker.dart b/flutter/lib/src/frames_tracking/sentry_delayed_frames_tracker.dart
@@ -3,6 +3,7 @@
 import 'dart:math';
 
 import 'package:meta/meta.dart';
+
 import '../../sentry_flutter.dart';
 
 /// This is just an upper limit, ensuring that the buffer does not grow
@@ -35,22 +36,13 @@ class SentryDelayedFramesTracker {
   /// Since startFrame and endFrame is always called sequentially by Flutter we
   /// don't need a SplayTree
   final List<SentryFrameTiming> _delayedFrames = [];
+  @visibleForTesting
+  List<SentryFrameTiming> get delayedFrames => _delayedFrames.toList();
   final SentryFlutterOptions _options;
   final Duration _expectedFrameDuration;
+  DateTime? _oldestFrameEndTimestamp;
   @visibleForTesting
   DateTime? get oldestFrameEndTimestamp => _oldestFrameEndTimestamp;
-  DateTime? _oldestFrameEndTimestamp;
-  bool _isTrackingActive = false;
-
-  /// Resumes the collecting of frames.
-  void resume() {
-    _isTrackingActive = true;
-  }
-
-  /// Pauses the collecting of frames.
-  void pause() {
-    _isTrackingActive = false;
-  }
 
   /// Retrieves the frames the intersect with the provided [startTimestamp] and [endTimestamp].
   @visibleForTesting
@@ -80,27 +72,27 @@ class SentryDelayedFramesTracker {
     }).toList(growable: false);
   }
 
+  /// Records the start and end time of a delayed frame.
+  ///
+  /// [startTimestamp] The time when the delayed frame rendering started.
+  /// [endTimestamp] The time when the delayed frame rendering ended.
   @pragma('vm:prefer-inline')
-  void addFrame(DateTime startTimestamp, DateTime endTimestamp) {
-    if (!_isTrackingActive || !_options.enableFramesTracking) {
+  void addDelayedFrame(DateTime startTimestamp, DateTime endTimestamp) {
+    if (!_options.enableFramesTracking) {
       return;
     }
     if (startTimestamp.isAfter(endTimestamp)) {
       return;
     }
     if (_delayedFrames.length > maxDelayedFramesBuffer) {
-      // buffer is full, we stop collecting frames until all active spans have
-      // finished processing
-      pause();
+      _options.logger(SentryLevel.debug,
+          'Frame tracking buffer is full, stopping frame collection until all active spans have finished processing');
       return;
     }
-    final duration = endTimestamp.difference(startTimestamp);
-    if (duration > _expectedFrameDuration) {
-      final frameTiming = SentryFrameTiming(
-          startTimestamp: startTimestamp, endTimestamp: endTimestamp);
-      _delayedFrames.add(frameTiming);
-      _oldestFrameEndTimestamp ??= endTimestamp;
-    }
+    final frameTiming = SentryFrameTiming(
+        startTimestamp: startTimestamp, endTimestamp: endTimestamp);
+    _delayedFrames.add(frameTiming);
+    _oldestFrameEndTimestamp ??= endTimestamp;
   }
 
   void removeIrrelevantFrames(DateTime spanStartTimestamp) {
@@ -227,15 +219,8 @@ class SentryDelayedFramesTracker {
   /// Clears the state of the tracker.
   void clear() {
     _delayedFrames.clear();
-    pause();
     _oldestFrameEndTimestamp = null;
   }
-
-  @visibleForTesting
-  List<SentryFrameTiming> get delayedFrames => _delayedFrames.toList();
-
-  @visibleForTesting
-  bool get isTrackingActive => _isTrackingActive;
 }
 
 /// Frame timing that represents an approximation of the frame's build duration.
diff --git a/flutter/lib/src/frames_tracking/span_frame_metrics_collector.dart b/flutter/lib/src/frames_tracking/span_frame_metrics_collector.dart
@@ -1,17 +1,26 @@
 // ignore_for_file: invalid_use_of_internal_member
 
 import 'package:meta/meta.dart';
+
 import '../../sentry_flutter.dart';
 import 'sentry_delayed_frames_tracker.dart';
 
 /// Collects frames from [SentryDelayedFramesTracker], calculates the metrics
 /// and attaches them to spans.
 @internal
 class SpanFrameMetricsCollector implements PerformanceContinuousCollector {
-  SpanFrameMetricsCollector(this._options, this._frameTracker);
+  SpanFrameMetricsCollector(
+    this._options,
+    this._frameTracker, {
+    required void Function() resumeFrameTracking,
+    required void Function() pauseFrameTracking,
+  })  : _resumeFrameTracking = resumeFrameTracking,
+        _pauseFrameTracking = pauseFrameTracking;
 
   final SentryFlutterOptions _options;
   final SentryDelayedFramesTracker _frameTracker;
+  final void Function() _resumeFrameTracking;
+  final void Function() _pauseFrameTracking;
 
   /// Stores the spans that are actively being tracked.
   /// After the frames are calculated and stored in the span the span is removed from this list.
@@ -26,7 +35,7 @@ class SpanFrameMetricsCollector implements PerformanceContinuousCollector {
       }
 
       activeSpans.add(span);
-      _frameTracker.resume();
+      _resumeFrameTracking();
     });
   }
 
@@ -69,6 +78,7 @@ class SpanFrameMetricsCollector implements PerformanceContinuousCollector {
 
   @override
   void clear() {
+    _pauseFrameTracking();
     _frameTracker.clear();
     activeSpans.clear();
     // we don't need to clear the expected frame duration as that realistically
diff --git a/flutter/lib/src/integrations/frames_tracking_integration.dart b/flutter/lib/src/integrations/frames_tracking_integration.dart
@@ -1,5 +1,7 @@
 // ignore_for_file: invalid_use_of_internal_member
 
+import 'dart:core';
+
 import '../../sentry_flutter.dart';
 import '../binding_wrapper.dart';
 import '../frames_tracking/sentry_delayed_frames_tracker.dart';
@@ -9,6 +11,7 @@ import '../native/sentry_native_binding.dart';
 class FramesTrackingIntegration implements Integration<SentryFlutterOptions> {
   FramesTrackingIntegration(this._native);
 
+  static const integrationName = 'FramesTracking';
   final SentryNativeBinding _native;
   SentryFlutterOptions? _options;
   PerformanceCollector? _collector;
@@ -45,13 +48,15 @@ class FramesTrackingIntegration implements Integration<SentryFlutterOptions> {
     // Everything valid, we can initialize now
     final framesTracker =
         SentryDelayedFramesTracker(options, expectedFrameDuration);
-    widgetsBinding.registerFramesTracking(
-        framesTracker.addFrame, options.clock);
-    final collector = SpanFrameMetricsCollector(options, framesTracker);
+    widgetsBinding.initializeFramesTracking(
+        framesTracker.addDelayedFrame, options, expectedFrameDuration);
+    final collector = SpanFrameMetricsCollector(options, framesTracker,
+        resumeFrameTracking: () => widgetsBinding.resumeTrackingFrames(),
+        pauseFrameTracking: () => widgetsBinding.pauseTrackingFrames());
     options.addPerformanceCollector(collector);
     _collector = collector;
 
-    options.sdk.addIntegration('framesTrackingIntegration');
+    options.sdk.addIntegration(integrationName);
     options.logger(SentryLevel.debug,
         '$FramesTrackingIntegration successfully initialized with an expected frame duration of ${expectedFrameDuration.inMilliseconds}ms');
   }
diff --git a/flutter/test/frame_tracking/frames_tracking_integration_test.dart b/flutter/test/frame_tracking/frames_tracking_integration_test.dart
@@ -53,9 +53,15 @@ void main() {
     await integration.call(Hub(options), options);
   }
 
+  bool isFramesTrackingInitialized(SentryWidgetsBindingMixin binding) {
+    return binding.options != null &&
+        binding.onDelayedFrame != null &&
+        binding.expectedFrameDuration != null;
+  }
+
   void assertInitFailure() {
     if (widgetsBinding != null) {
-      expect(widgetsBinding!.isFramesTrackingInitialized(), isFalse);
+      expect(isFramesTrackingInitialized(widgetsBinding!), isFalse);
     }
     expect(options.performanceCollectors, isEmpty);
   }
@@ -74,18 +80,19 @@ void main() {
   test('adds integration to SDK list', () async {
     await fromWorkingState(options);
 
-    expect(options.sdk.integrations, contains('framesTrackingIntegration'));
+    expect(options.sdk.integrations,
+        contains(FramesTrackingIntegration.integrationName));
   });
 
   test('properly cleans up resources on close', () async {
     await fromWorkingState(options);
 
-    expect(widgetsBinding!.isFramesTrackingInitialized(), isTrue);
+    expect(isFramesTrackingInitialized(widgetsBinding!), isTrue);
     expect(options.performanceCollectors, isNotEmpty);
 
     integration.close();
 
-    expect(widgetsBinding!.isFramesTrackingInitialized(), isFalse);
+    expect(isFramesTrackingInitialized(widgetsBinding!), isFalse);
     expect(options.performanceCollectors, isEmpty);
   });
 
diff --git a/flutter/test/frame_tracking/sentry_delayed_frames_tracker_test.dart b/flutter/test/frame_tracking/sentry_delayed_frames_tracker_test.dart
diff --git a/flutter/test/frame_tracking/span_frame_metrics_collector_test.dart b/flutter/test/frame_tracking/span_frame_metrics_collector_test.dart
diff --git a/flutter/test/mocks.mocks.dart b/flutter/test/mocks.mocks.dart
diff --git a/flutter/test/sentry_widgets_binding_mixin_test.dart b/flutter/test/sentry_widgets_binding_mixin_test.dart

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// ignore_for_file: deprecated_member_use_from_same_package`
	`2`	`+`
`1`	`3`	`import 'dart:async';`
`2`	`4`	`import 'dart:isolate';`
`3`	`5`