SentryTimeToDisplayTracker.m

#import "SentryTimeToDisplayTracker.h"

#if SENTRY_HAS_UIKIT

#    import "SentryInternalDefines.h"
#    import "SentryLogC.h"
#    import "SentryProfilingConditionals.h"
#    import "SentrySDK+Private.h"
#    import "SentrySpanContext.h"
#    import "SentrySpanId.h"
#    import "SentrySpanOperation.h"
#    import "SentrySwift.h"
#    import "SentryTraceOrigin.h"
#    import "SentryTracer.h"

#    import <UIKit/UIKit.h>

#    if SENTRY_TARGET_PROFILING_SUPPORTED
#        import "SentryLaunchProfiling.h"
#        import "SentryProfiler+Private.h"
#    endif // SENTRY_TARGET_PROFILING_SUPPORTED

@interface SentryTimeToDisplayTracker () <SentryFramesTrackerListener>

@property (nonatomic, weak) id<SentrySpan> initialDisplaySpan;
@property (nonatomic, weak) id<SentrySpan> fullDisplaySpan;
@property (nonatomic, strong, readonly) SentryDispatchQueueWrapper *dispatchQueueWrapper;

@end

@implementation SentryTimeToDisplayTracker {
    BOOL _waitForFullDisplay;
    BOOL _initialDisplayReported;
    BOOL _fullyDisplayedReported;
    NSString *_name;
}

- (instancetype)initWithName:(NSString *)name
          waitForFullDisplay:(BOOL)waitForFullDisplay
        dispatchQueueWrapper:(SentryDispatchQueueWrapper *)dispatchQueueWrapper
{
    if (self = [super init]) {
        _name = name;
        _waitForFullDisplay = waitForFullDisplay;
        _dispatchQueueWrapper = dispatchQueueWrapper;
        _initialDisplayReported = NO;
        _fullyDisplayedReported = NO;
    }
    return self;
}

- (BOOL)startForTracer:(SentryTracer *)tracer
{
    if (SentryDependencyContainer.sharedInstance.framesTracker.isRunning == NO) {
        SENTRY_LOG_DEBUG(@"Skipping TTID/TTFD spans, because can't report them correctly when the "
                         @"frames tracker isn't running.");
        return NO;
    }

    SENTRY_LOG_DEBUG(@"Starting initial display span");
    self.initialDisplaySpan =
        [tracer startChildWithOperation:SentrySpanOperationUiLoadInitialDisplay
                            description:[NSString stringWithFormat:@"%@ initial display", _name]];
    self.initialDisplaySpan.origin = SentryTraceOriginAutoUITimeToDisplay;

    if (self.waitForFullDisplay) {
        SENTRY_LOG_DEBUG(@"Starting full display span");
        self.fullDisplaySpan =
            [tracer startChildWithOperation:SentrySpanOperationUiLoadFullDisplay
                                description:[NSString stringWithFormat:@"%@ full display", _name]];
        self.fullDisplaySpan.origin = SentryTraceOriginManualUITimeToDisplay;

        // By concept TTID and TTFD spans should have the same beginning,
        // which also should be the same of the transaction starting.
        self.fullDisplaySpan.startTimestamp = tracer.startTimestamp;
    }

    self.initialDisplaySpan.startTimestamp = tracer.startTimestamp;

    [SentryDependencyContainer.sharedInstance.framesTracker addListener:self];

    [tracer setShouldIgnoreWaitForChildrenCallback:^(id<SentrySpan> span) {
        if ([span.origin isEqualToString:SentryTraceOriginAutoUITimeToDisplay]) {
            return YES;
        }

        return NO;
    }];
    [tracer setFinishCallback:^(SentryTracer *_tracer) {
        [SentryDependencyContainer.sharedInstance.framesTracker removeListener:self];

        // Strongify the weak span references so they can't become dangling
        // mid-callback if the tracer's children are released concurrently.
        id<SentrySpan> initialSpan = self.initialDisplaySpan;
        id<SentrySpan> fullSpan = self.fullDisplaySpan;

        if (initialSpan != nil && initialSpan.isFinished == NO) {
            [initialSpan finish];
        }

        if (initialSpan != nil) {
            initialSpan.startTimestamp = _tracer.startTimestamp;
            [self addTimeToDisplayMeasurement:initialSpan name:@"time_to_initial_display"];
        }

        if (fullSpan == nil) {
            return;
        }

        fullSpan.startTimestamp = _tracer.startTimestamp;
        [self addTimeToDisplayMeasurement:fullSpan name:@"time_to_full_display"];

        if (fullSpan.status != kSentrySpanStatusDeadlineExceeded) {
            return;
        }

        if (initialSpan != nil) {
            fullSpan.timestamp = initialSpan.timestamp;
        }
        fullSpan.spanDescription =
            [NSString stringWithFormat:@"%@ - Deadline Exceeded", fullSpan.spanDescription];
        [self addTimeToDisplayMeasurement:fullSpan name:@"time_to_full_display"];
    }];

    return YES;
}

- (void)reportInitialDisplay
{
    SENTRY_LOG_DEBUG(@"Reporting initial display for %@", _name);
    _initialDisplayReported = YES;
}

- (void)reportFullyDisplayed
{
    SENTRY_LOG_DEBUG(@"Reporting full display for %@", _name);
    // All other accesses to _fullyDisplayedReported run on the main thread.
    // To avoid using locks, we execute this on the main queue instead.
    [_dispatchQueueWrapper
        dispatchAsyncOnMainQueueIfNotMainThread:^{ self->_fullyDisplayedReported = YES; }];
}

- (void)finishSpansIfNotFinished
{
    [SentryDependencyContainer.sharedInstance.framesTracker removeListener:self];

    if (self.initialDisplaySpan.isFinished == NO) {
        [self.initialDisplaySpan finish];
    }

    if (self.fullDisplaySpan.isFinished == NO) {
        if (_fullyDisplayedReported) {
            SENTRY_LOG_DEBUG(
                @"SentrySDK.reportFullyDisplayed() was called but didn't receive a new frame to "
                @"finish the TTFD span. Finishing the full display span so the SDK can start a new "
                @"time to display tracker.");
            [self.fullDisplaySpan finish];
            return;
        }

        SENTRY_LOG_WARN(@"You didn't call SentrySDK.reportFullyDisplayed() for UIViewController: "
                        @"%@. Finishing full display span with status: %@.",
            _name, nameForSentrySpanStatus(kSentrySpanStatusDeadlineExceeded));

        [self.fullDisplaySpan finishWithStatus:kSentrySpanStatusDeadlineExceeded];
    }
}

- (void)framesTrackerHasNewFrame:(NSDate *)newFrameDate
{
    // The purpose of TTID and TTFD is to measure how long
    // takes to the content of the screen to change.
    // That's why we need to wait for the next frame to be drawn.
    if (_initialDisplayReported && self.initialDisplaySpan.isFinished == NO) {
        SENTRY_LOG_DEBUG(@"Finishing initial display span");
        self.initialDisplaySpan.timestamp = newFrameDate;
        [self.initialDisplaySpan finish];
        if (!_waitForFullDisplay) {
            [SentryDependencyContainer.sharedInstance.framesTracker removeListener:self];
#    if SENTRY_TARGET_PROFILING_SUPPORTED
            if (sentry_isLaunchProfileCorrelatedToTraces()) {
                sentry_stopAndDiscardLaunchProfileTracer(SentrySDKInternal.currentHub);
            }
#    endif // SENTRY_TARGET_PROFILING_SUPPORTED
        }
    }
    if (_waitForFullDisplay && _fullyDisplayedReported && self.fullDisplaySpan.isFinished == NO
        && self.initialDisplaySpan.isFinished == YES) {
        SENTRY_LOG_DEBUG(@"Finishing full display span");
        self.fullDisplaySpan.timestamp = newFrameDate;
        [self.fullDisplaySpan finish];
#    if SENTRY_TARGET_PROFILING_SUPPORTED
        if (sentry_isLaunchProfileCorrelatedToTraces()) {
            sentry_stopAndDiscardLaunchProfileTracer(SentrySDKInternal.currentHub);
        }
#    endif // SENTRY_TARGET_PROFILING_SUPPORTED
    }

    if (self.initialDisplaySpan.isFinished == YES && self.fullDisplaySpan.isFinished == YES) {
        [SentryDependencyContainer.sharedInstance.framesTracker removeListener:self];
    }
}

- (void)addTimeToDisplayMeasurement:(id<SentrySpan>)span name:(NSString *)name
{
    if (!span.startTimestamp) {
        return;
    }
    NSTimeInterval duration =
        [span.timestamp timeIntervalSinceDate:SENTRY_UNWRAP_NULLABLE(NSDate, span.startTimestamp)]
        * 1000;
    [span setMeasurement:name value:@(duration) unit:SentryMeasurementUnitDuration.millisecond];
}

@end

#endif // SENTRY_HAS_UIKIT