feat: monitor for new metric values via sampling and notifications

Sentry.xcodeproj/xcshareddata/xcschemes/Sentry.xcscheme

@@ -67,9 +67,6 @@
                <Test
                   Identifier = "SentryFileIOTrackingIntegrationTests/test_DataConsistency_readUrl_disabled()">
                </Test>
-               <Test
-                  Identifier = "SentryNSErrorTests/testSerializeWithUnderlyingNSException_disabled()">
-               </Test>
                <Test
                   Identifier = "SentryNetworkTrackerIntegrationTests/testGetRequest_SpanCreatedAndBaggageHeaderAdded_disabled()">
                </Test>

Sources/Sentry/SentryProfiler.mm

@@ -45,6 +45,10 @@
 const int kSentryProfilerFrequencyHz = 101;
 NSString *const kTestStringConst = @"test";
 
+NSString *const kSentryProfilerSerializationKeySlowFrameRenders = @"slow_frame_renders";
+NSString *const kSentryProfilerSerializationKeyFrozenFrameRenders = @"frozen_frame_renders";
+NSString *const kSentryProfilerSerializationKeyFrameRates = @"screen_frame_rates";
+
 using namespace sentry::profiling;
 
 NSString *
@@ -154,6 +158,9 @@
 SentryNSProcessInfoWrapper *_gCurrentProcessInfoWrapper;
 SentrySystemWrapper *_gCurrentSystemWrapper;
 SentryNSTimerWrapper *_gCurrentTimerWrapper;
+#    if SENTRY_HAS_UIKIT
+SentryFramesTracker *_gCurrentFramesTracker;
+#    endif // SENTRY_HAS_UIKIT
 
 NSString *
 profilerTruncationReasonName(SentryProfilerTruncationReason reason)
@@ -170,28 +177,42 @@
 
 #    if SENTRY_HAS_UIKIT
 NSArray *
-processFrameRenders(SentryFrameInfoTimeSeries *frameInfo, uint64_t start, uint64_t duration)
+processFrameRenders(
+    SentryFrameInfoTimeSeries *frameInfo, uint64_t profileStart, uint64_t profileDuration)
 {
     auto relativeFrameInfo = [NSMutableArray array];
     [frameInfo enumerateObjectsUsingBlock:^(
         NSDictionary<NSString *, NSNumber *> *_Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
-        const auto begin = timeIntervalToNanoseconds(obj[@"start_timestamp"].doubleValue);
-        if (begin < start) {
+        const auto frameRenderStart
+            = timeIntervalToNanoseconds(obj[@"start_timestamp"].doubleValue);
+
+#        if defined(TEST) || defined(TESTCI)
+        // we don't currently validate the timestamps in tests, and the mock doesn't provide
+        // realistic ones, so they'd fail the checks below. just write them directly into the data
+        // structure so we can count *how many* were recorded
+        [relativeFrameInfo addObject:@{
+            @"elapsed_since_start_ns" : @(frameRenderStart),
+            @"value" : @(frameRenderStart),
+        }];
+        return;
+#        else // if not testing, ie, development or production
+        if (frameRenderStart < profileStart) {
             return;
         }
-        const auto end = timeIntervalToNanoseconds(obj[@"end_timestamp"].doubleValue);
-        const auto relativeEnd = getDurationNs(start, end);
-        if (relativeEnd > duration) {
+        const auto frameRenderEnd = timeIntervalToNanoseconds(obj[@"end_timestamp"].doubleValue);
+        const auto frameRenderEndRelativeToProfileStart = getDurationNs(profileStart, frameRenderEnd);
+        if (frameRenderEndRelativeToProfileStart > profileDuration) {
             SENTRY_LOG_DEBUG(@"The last slow/frozen frame extended past the end of the profile, "
                              @"will not report it.");
             return;
         }
-        const auto relativeStart = getDurationNs(start, begin);
-        const auto frameDuration = relativeEnd - relativeStart;
+        const auto frameRenderStartRelativeToProfileStartNs = getDurationNs(profileStart, frameRenderStart);
+        const auto frameRenderDurationNs = frameRenderEndRelativeToProfileStart - frameRenderStartRelativeToProfileStartNs;
         [relativeFrameInfo addObject:@{
-            @"elapsed_since_start_ns" : @(relativeStart),
-            @"value" : @(frameDuration),
+            @"elapsed_since_start_ns" : @(frameRenderStartRelativeToProfileStartNs),
+            @"value" : @(frameRenderDurationNs),
         }];
+#        endif // defined(TEST) || defined(TESTCI)
     }];
     return relativeFrameInfo;
 }
@@ -284,7 +305,7 @@ + (void)startForSpanID:(SentrySpanId *)spanID
             return;
         }
 #    if SENTRY_HAS_UIKIT
-        [SentryFramesTracker.sharedInstance resetProfilingTimestamps];
+        [_gCurrentFramesTracker resetProfilingTimestamps];
 #    endif // SENTRY_HAS_UIKIT
         [_gCurrentProfiler start];
         _gCurrentProfiler->_timeoutTimer =
@@ -383,6 +404,14 @@ + (void)useTimerWrapper:(SentryNSTimerWrapper *)timerWrapper
     _gCurrentTimerWrapper = timerWrapper;
 }
 
+#    if SENTRY_HAS_UIKIT
++ (void)useFramesTracker:(SentryFramesTracker *)framesTracker
+{
+    std::lock_guard<std::mutex> l(_gProfilerLock);
+    _gCurrentFramesTracker = framesTracker;
+}
+#    endif // SENTRY_HAS_UIKIT
+
 #    pragma mark - Private
 
 + (void)captureEnvelopeIfFinished:(SentryProfiler *)profiler spanID:(SentrySpanId *)spanID
@@ -431,8 +460,8 @@ + (void)stopProfilerForReason:(SentryProfilerTruncationReason)reason
     [_gCurrentProfiler stop];
     _gCurrentProfiler->_truncationReason = reason;
 #    if SENTRY_HAS_UIKIT
-    _gCurrentProfiler->_frameInfo = SentryFramesTracker.sharedInstance.currentFrames;
-    [SentryFramesTracker.sharedInstance resetProfilingTimestamps];
+    _gCurrentProfiler->_frameInfo = _gCurrentFramesTracker.currentFrames;
+    [_gCurrentFramesTracker resetProfilingTimestamps];
 #    endif // SENTRY_HAS_UIKIT
     _gCurrentProfiler = nil;
 }
@@ -644,19 +673,21 @@ - (void)captureEnvelope
     const auto slowTimestamps
         = processFrameRenders(_frameInfo.slowFrameTimestamps, _startTimestamp, profileDuration);
     if (slowTimestamps.count > 0) {
-        metrics[@"slow_frame_renders"] = @{ @"unit" : @"nanosecond", @"values" : slowTimestamps };
+        metrics[kSentryProfilerSerializationKeySlowFrameRenders] =
+            @{ @"unit" : @"nanosecond", @"values" : slowTimestamps };
     }
 
     const auto frozenTimestamps
         = processFrameRenders(_frameInfo.frozenFrameTimestamps, _startTimestamp, profileDuration);
     if (frozenTimestamps.count > 0) {
-        metrics[@"frozen_frame_renders"] =
+        metrics[kSentryProfilerSerializationKeyFrozenFrameRenders] =
             @{ @"unit" : @"nanosecond", @"values" : frozenTimestamps };
     }
 
     const auto frameRates = processFrameRates(_frameInfo.frameRateTimestamps, _startTimestamp);
     if (frameRates.count > 0) {
-        metrics[@"screen_frame_rates"] = @{ @"unit" : @"hz", @"values" : frameRates };
+        metrics[kSentryProfilerSerializationKeyFrameRates] =
+            @{ @"unit" : @"hz", @"values" : frameRates };
     }
 #    endif // SENTRY_HAS_UIKIT
 

Sources/Sentry/include/SentryProfiler.h

@@ -25,8 +25,12 @@ typedef NS_ENUM(NSUInteger, SentryProfilerTruncationReason) {
 
 NS_ASSUME_NONNULL_BEGIN
 
-FOUNDATION_EXPORT const int kSentryProfilerFrequencyHz;
-FOUNDATION_EXPORT NSString *const kTestStringConst;
+SENTRY_EXTERN const int kSentryProfilerFrequencyHz;
+SENTRY_EXTERN NSString *const kTestStringConst;
+
+SENTRY_EXTERN NSString *const kSentryProfilerSerializationKeySlowFrameRenders;
+SENTRY_EXTERN NSString *const kSentryProfilerSerializationKeyFrozenFrameRenders;
+SENTRY_EXTERN NSString *const kSentryProfilerSerializationKeyFrameRates;
 
 SENTRY_EXTERN_C_BEGIN
 

Tests/SentryTests/Helper/SentryProfiler+SwiftTest.h

@@ -23,6 +23,10 @@ SentryProfiler ()
 
 + (void)useTimerWrapper:(SentryNSTimerWrapper *)timerWrapper NS_SWIFT_NAME(useTimerWrapper(_:));
 
+#    if SENTRY_HAS_UIKIT
++ (void)useFramesTracker:(SentryFramesTracker *)framesTracker NS_SWIFT_NAME(useFramesTracker(_:));
+#    endif // SENTRY_HAS_UIKIT
+
 @end
 
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED

Tests/SentryTests/Integrations/Performance/FramesTracking/SentryFramesTrackerTests.swift

@@ -5,17 +5,15 @@ class SentryFramesTrackerTests: XCTestCase {
 
     private class Fixture {
 
-        var displayLinkWrapper: TestDiplayLinkWrapper
+        var displayLinkWrapper: TestDisplayLinkWrapper
         var queue: DispatchQueue
 
         init() {
-            displayLinkWrapper = TestDiplayLinkWrapper()
+            displayLinkWrapper = TestDisplayLinkWrapper()
             queue = DispatchQueue(label: "SentryFramesTrackerTests", qos: .background, attributes: [.concurrent])
         }
 
-        lazy var sut: SentryFramesTracker = {
-            return SentryFramesTracker(displayLinkWrapper: displayLinkWrapper)
-        }()
+        lazy var sut: SentryFramesTracker = SentryFramesTracker(displayLinkWrapper: displayLinkWrapper)
     }
 
     private var fixture: Fixture!

Tests/SentryTests/Integrations/Performance/FramesTracking/SentryFramesTrackingIntegrationTests.swift

@@ -5,7 +5,7 @@ class SentryFramesTrackingIntegrationTests: XCTestCase {
 
     private class Fixture {
         let options = Options()
-        let displayLink = TestDiplayLinkWrapper()
+        let displayLink = TestDisplayLinkWrapper()
 
         init() {
             options.dsn = TestConstants.dsnAsString(username: "SentryFramesTrackingIntegrationTests")

Tests/SentryTests/Integrations/Performance/FramesTracking/TestDisplayLinkWrapper.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
-class TestDiplayLinkWrapper: SentryDisplayLinkWrapper {
+class TestDisplayLinkWrapper: SentryDisplayLinkWrapper {
 
     var target: AnyObject!
     var selector: Selector!

Tests/SentryTests/Performance/SentryTracerTests.swift

@@ -38,7 +38,7 @@ class SentryTracerTests: XCTestCase {
         let idleTimeout: TimeInterval = 1.0
 
 #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
-        var displayLinkWrapper: TestDiplayLinkWrapper
+        var displayLinkWrapper: TestDisplayLinkWrapper
 #endif
 
         init() {
@@ -58,7 +58,7 @@ class SentryTracerTests: XCTestCase {
             CurrentDate.setCurrentDateProvider(currentDateProvider)
 
 #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
-            displayLinkWrapper = TestDiplayLinkWrapper()
+            displayLinkWrapper = TestDisplayLinkWrapper()
 
             SentryFramesTracker.sharedInstance().setDisplayLinkWrapper(displayLinkWrapper)
             SentryFramesTracker.sharedInstance().start()

Tests/SentryTests/PrivateSentrySDKOnlyTests.swift

@@ -127,7 +127,7 @@ class PrivateSentrySDKOnlyTests: XCTestCase {
 
     func testGetFrames() {
         let tracker = SentryFramesTracker.sharedInstance()
-        let displayLink = TestDiplayLinkWrapper()
+        let displayLink = TestDisplayLinkWrapper()
 
         tracker.setDisplayLinkWrapper(displayLink)
         tracker.start()

Tests/SentryTests/Profiling/SentryProfilerSwiftTests.swift

@@ -23,10 +23,16 @@ class SentryProfilerSwiftTests: XCTestCase {
         let message = "some message"
         let transactionName = "Some Transaction"
         let transactionOperation = "Some Operation"
+
         lazy var systemWrapper = TestSentrySystemWrapper()
         lazy var processInfoWrapper = TestSentryNSProcessInfoWrapper()
         lazy var timerWrapper = TestSentryNSTimerWrapper()
 
+#if !os(macOS)
+        lazy var displayLinkWrapper = TestDisplayLinkWrapper()
+        lazy var framesTracker = SentryFramesTracker(displayLinkWrapper: displayLinkWrapper)
+#endif
+
         func newTransaction() -> Span {
             hub.startTransaction(name: transactionName, operation: transactionOperation)
         }
@@ -45,7 +51,7 @@ class SentryProfilerSwiftTests: XCTestCase {
         super.tearDown()
         clearTestState()
         SentryTracer.resetAppStartMeasurementRead()
-#if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#if !os(macOS)
         SentryFramesTracker.sharedInstance().resetFrames()
         SentryFramesTracker.sharedInstance().stop()
 #endif
@@ -58,6 +64,9 @@ class SentryProfilerSwiftTests: XCTestCase {
         SentryProfiler.useSystemWrapper(fixture.systemWrapper)
         SentryProfiler.useProcessInfoWrapper(fixture.processInfoWrapper)
         SentryProfiler.useTimerWrapper(fixture.timerWrapper)
+#if !os(macOS)
+        SentryProfiler.useFramesTracker(fixture.framesTracker)
+#endif
 
         // mock cpu usage
         let cpuUsages = [12.4, 63.5, 1.4, 4.6]
@@ -76,13 +85,30 @@ class SentryProfilerSwiftTests: XCTestCase {
             self.fixture.timerWrapper.fire()
         }
 
+#if !os(macOS)
+        // gather mock GPU frame render timestamps
+        fixture.framesTracker.start()
+        fixture.displayLinkWrapper.call() // call once directly to capture previous frame timestamp for comparison with later ones
+        fixture.displayLinkWrapper.slowFrame()
+        fixture.displayLinkWrapper.normalFrame()
+        fixture.displayLinkWrapper.almostFrozenFrame()
+        fixture.displayLinkWrapper.normalFrame()
+        fixture.displayLinkWrapper.frozenFrame()
+        fixture.framesTracker.stop()
+#endif
+
+        // mock errors gathering cpu usage and memory footprint to ensure they don't add more information to the payload
+        fixture.systemWrapper.overrides.cpuUsageError = NSError(domain: "test-error", code: 0)
+        fixture.systemWrapper.overrides.memoryFootprintError = NSError(domain: "test-error", code: 1)
+        self.fixture.timerWrapper.fire()
+
         // finish profile
         let exp = expectation(description: "Receives profile payload")
         DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
             span.finish()
 
             do {
-                try self.assertMetricsPayload(expectedCPUUsages: cpuUsages, cpuReadings: 2)
+                try self.assertMetricsPayload(expectedCPUUsages: cpuUsages, usageReadings: 2, expectedMemoryFootprint: memoryFootprint, expectedSlowFrameCount: 2, expectedFrozenFrameCount: 1, expectedFrameRateCount: 1)
                 exp.fulfill()
             } catch {
                 XCTFail("Encountered error: \(error)")
@@ -241,8 +267,8 @@ private extension SentryProfilerSwiftTests {
         case noEnvelopeCaptured
         case noProfileEnvelopeItem
         case malformedMetricValueEntry
-        case noCPUUsageEvents
-        case noCPUUsageReported
+        case noMetricsReported
+        case noMetricValuesFound
     }
 
     func getProfileData() throws -> Data {
@@ -290,7 +316,7 @@ private extension SentryProfilerSwiftTests {
         self.assertValidProfileData(data: profileData, transactionEnvironment: transactionEnvironment, numberOfTransactions: numberOfTransactions, shouldTimeout: shouldTimeOut)
     }
 
-    func assertMetricsPayload(expectedCPUUsages: [Double], cpuReadings: Int) throws {
+    func assertMetricsPayload(expectedCPUUsages: [Double], usageReadings: Int, expectedMemoryFootprint: SentryRAMBytes, expectedSlowFrameCount: Int, expectedFrozenFrameCount: Int, expectedFrameRateCount: Int) throws {
         let profileData = try self.getProfileData()
         guard let profile = try JSONSerialization.jsonObject(with: profileData) as? [String: Any] else {
             throw TestError.unexpectedProfileDeserializationType
@@ -301,18 +327,32 @@ private extension SentryProfilerSwiftTests {
 
         for (i, expectedUsage) in expectedCPUUsages.enumerated() {
             let key = NSString(format: kSentryMetricProfilerSerializationKeyCPUUsageFormat as NSString, i) as String
-            guard let cpuUsage = measurements[key] as? [String: Any] else {
-                throw TestError.noCPUUsageEvents
-            }
-            guard let values = cpuUsage["values"] as? [[String: Any]] else {
-                throw TestError.malformedMetricValueEntry
-            }
-            XCTAssertEqual(values.count, cpuReadings)
-            guard let firstReport = values[0]["value"] as? Double else {
-                throw TestError.noCPUUsageReported
-            }
+            try assertMetricValue(measurements: measurements, key: key, numberOfReadings: usageReadings, expectedValue: expectedUsage)
+        }
+
+        try assertMetricValue(measurements: measurements, key: kSentryMetricProfilerSerializationKeyMemoryFootprint, numberOfReadings: usageReadings, expectedValue: expectedMemoryFootprint)
 
-            XCTAssertEqual(firstReport, expectedUsage)
+#if !os(macOS)
+        let dummyValue: UInt64? = nil
+        try assertMetricValue(measurements: measurements, key: kSentryProfilerSerializationKeySlowFrameRenders, numberOfReadings: expectedSlowFrameCount, expectedValue: dummyValue)
+        try assertMetricValue(measurements: measurements, key: kSentryProfilerSerializationKeyFrozenFrameRenders, numberOfReadings: expectedFrozenFrameCount, expectedValue: dummyValue)
+        try assertMetricValue(measurements: measurements, key: kSentryProfilerSerializationKeyFrameRates, numberOfReadings: expectedFrameRateCount, expectedValue: dummyValue)
+#endif
+    }
+
+    func assertMetricValue<T: Equatable>(measurements: [String: Any], key: String, numberOfReadings: Int, expectedValue: T?) throws {
+        guard let metricContainer = measurements[key] as? [String: Any] else {
+            throw TestError.noMetricsReported
+        }
+        guard let values = metricContainer["values"] as? [[String: Any]] else {
+            throw TestError.malformedMetricValueEntry
+        }
+        XCTAssertEqual(values.count, numberOfReadings, "Wrong number of values under \(key)")
+        if let expectedValue = expectedValue {
+            guard let memoryFootprintValue = values[0]["value"] as? T else {
+                throw TestError.noMetricValuesFound
+            }
+            XCTAssertEqual(memoryFootprintValue, expectedValue, "Wrong value for \(key)")
         }
     }
 

Tests/SentryTests/Protocol/SentryNSErrorTests.swift

@@ -27,7 +27,7 @@ class SentryNSErrorTests: XCTestCase {
         XCTAssertEqual(actualUnderlyingError.domain, inputUnderlyingError.domain)
     }
 
-    func testSerializeWithUnderlyingNSException_disabled() {
+    func testSerializeWithUnderlyingNSException() {
         let inputExceptionName = NSExceptionName.decimalNumberDivideByZeroException
         let inputExceptionReason = "test exception reason"
         let inputUnderlyingException = NSException(name: inputExceptionName, reason: inputExceptionReason, userInfo: ["some userinfo key": "some userinfo value"])
@@ -42,4 +42,15 @@ class SentryNSErrorTests: XCTestCase {
         XCTAssertEqual(actualDescription, "\(inputDescription) (\(inputExceptionReason))")
     }
 
+    func testWithKernelError() {
+        let inputKernelErrorCode = KERN_NOT_RECEIVER
+        let inputDescription = "some test kernel error"
+        let actualError = NSErrorFromSentryErrorWithKernelError(SentryError.unknownError, inputDescription, inputKernelErrorCode)
+
+        guard let actualDescription = actualError?.localizedDescription else {
+            XCTFail("Expected a localizedDescription in the resulting error")
+            return
+        }
+        XCTAssertEqual(actualDescription, "\(inputDescription) (The task in question does not hold receive rights for the port argument.)")
+    }
 }