@amplitude/session-replay-browser 1.47.0-sr-trc-debug-log.3 → 1.47.0

package/lib/esm/session-replay.js

@@ -14,7 +14,6 @@ import { SessionIdentifiers } from './identifiers';
 import { SafeLoggerProvider } from './logger';
 import { getOrInitReplayStartTime, pruneStaleReplayStartTimes, removeReplayStartTime, setReplayStartTime, } from './replay-start-time-store';
 import { evaluateTargetingAndStore } from './targeting/targeting-manager';
-import { SrDiagnostic } from './diagnostics';
 import { isSessionInSample } from './sampling';
 import { VERSION } from './version';
 import { createUrlTrackingPlugin, subscribeToUrlChanges } from './plugins/url-tracking-plugin';
@@ -26,10 +25,6 @@ var SessionReplay = /** @class */ (function () {
         this.recordCancelCallback = null;
         this.eventCount = 0;
         this.sessionTargetingMatch = false;
-        // Session for which the one-per-session TRC diagnostic event was already emitted. The
-        // diagnostics client caps in-memory events, so per-call signals go through counters and only
-        // a single rich snapshot event is recorded per session.
-        this.trcDiagnosticSessionId = undefined;
         // Public on purpose. `pageLeaveFns` is iterated by `pageLeaveListener`,
         // `rrwebEventManager` is dereferenced in `asyncSetSessionId` to drop the beacon buffer
         // at a session boundary, and `sessionStartTime` drives `isBelowMinSessionDuration()`.
@@ -52,9 +47,6 @@ var SessionReplay = /** @class */ (function () {
         this.recordEventsPendingShouldLogMetadata = null;
         /** Cleanup for URL change listener used to re-evaluate targeting on SPA route changes */
         this.urlChangeCleanup = null;
-        // Ensures the url_poll.first_tick diagnostic event is emitted at most once per listener setup
-        // (the per-tick counter still increments every tick; only the rich event is one-shot).
-        this.urlPollFirstTickRecorded = false;
         this.crossOriginIframeCoordinator = null;
         this.crossOriginParentSignalCleanup = null;
         /** Monotonic counter to ignore stale URL-change targeting results */
@@ -123,23 +115,12 @@ var SessionReplay = /** @class */ (function () {
             if (forceRestart === void 0) { forceRestart = false; }
             if (forceTargetingReevaluation === void 0) { forceTargetingReevaluation = false; }
             return __awaiter(_this, void 0, void 0, function () {
-                var targetingConfig, shouldReEvaluate, urlChangeEvaluationId, eventForTargeting, pageUrl, pageForTargeting, evalStart, targetingMatch, evalDurationMs, trigger;
-                var _a, _b, _c, _d, _e, _f, _g;
-                return __generator(this, function (_h) {
-                    switch (_h.label) {
+                var targetingConfig, shouldReEvaluate, urlChangeEvaluationId, eventForTargeting, pageUrl, pageForTargeting, targetingMatch;
+                var _a, _b, _c, _d, _e, _f;
+                return __generator(this, function (_g) {
+                    switch (_g.label) {
                         case 0:
-                            // What triggered this evaluation (init vs SPA URL change vs analytics event) — shows in
-                            // DataDog how often re-evaluation actually runs.
-                            this.incrementDiagnostic(SrDiagnostic.evalTrigger(isInit ? 'init' : forceTargetingReevaluation ? 'urlchange' : 'event'));
                             if (!this.identifiers || !this.identifiers.sessionId || !this.config) {
-                                // Q4: eval can't run because a prerequisite is missing — record exactly which one.
-                                this.incrementDiagnostic(SrDiagnostic.evalMissingPrereq);
-                                this.recordDiagnosticEvent(SrDiagnostic.evalMissingPrereq, {
-                                    hasIdentifiers: !!this.identifiers,
-                                    hasSessionId: !!((_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId),
-                                    hasConfig: !!this.config,
-                                    hasDeviceId: !!this.getDeviceId(),
-                                });
                                 if (this.identifiers && !this.identifiers.sessionId) {
                                     this.loggerProvider.log('Session ID has not been set yet, cannot evaluate targeting for Session Replay.');
                                 }
@@ -150,7 +131,6 @@ var SessionReplay = /** @class */ (function () {
                             }
                             // Handle cases where there's no targeting config
                             if (!this.config.targetingConfig) {
-                                this.incrementDiagnostic(SrDiagnostic.evalNoConfig);
                                 if (isInit) {
                                     this.loggerProvider.log('Targeting config has not been set yet, cannot evaluate targeting.');
                                 }
@@ -170,20 +150,8 @@ var SessionReplay = /** @class */ (function () {
                                 Object.values(SpecialEventType).includes(eventForTargeting.event_type)) {
                                 eventForTargeting = undefined;
                             }
-                            pageUrl = (_f = (_c = (_b = targetingParams.page) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : (_e = (_d = getGlobalScope()) === null || _d === void 0 ? void 0 : _d.location) === null || _e === void 0 ? void 0 : _e.href) !== null && _f !== void 0 ? _f : '';
-                            pageForTargeting = (_g = targetingParams.page) !== null && _g !== void 0 ? _g : (pageUrl !== '' ? { url: pageUrl } : undefined);
-                            // Record the targeting trigger event
-                            this.recordDiagnosticEvent(SrDiagnostic.targetingTrigger, {
-                                sessionId: this.identifiers.sessionId,
-                                deviceId: this.getDeviceId(),
-                                targetingConfig: this.config.targetingConfig,
-                                targetingParams: {
-                                    userProperties: targetingParams.userProperties,
-                                    event: eventForTargeting,
-                                    page: pageForTargeting,
-                                },
-                            });
-                            evalStart = Date.now();
+                            pageUrl = (_e = (_b = (_a = targetingParams.page) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : (_d = (_c = getGlobalScope()) === null || _c === void 0 ? void 0 : _c.location) === null || _d === void 0 ? void 0 : _d.href) !== null && _e !== void 0 ? _e : '';
+                            pageForTargeting = (_f = targetingParams.page) !== null && _f !== void 0 ? _f : (pageUrl !== '' ? { url: pageUrl } : undefined);
                             return [4 /*yield*/, evaluateTargetingAndStore({
                                     sessionId: this.identifiers.sessionId,
                                     targetingConfig: targetingConfig,
@@ -195,76 +163,38 @@ var SessionReplay = /** @class */ (function () {
                                         page: pageForTargeting,
                                     },
                                     urlChange: forceTargetingReevaluation,
-                                    diagnosticsClient: this.config.diagnosticsClient,
-                                    deviceId: this.getDeviceId(),
                                 })];
                         case 1:
-                            targetingMatch = _h.sent();
-                            evalDurationMs = Date.now() - evalStart;
-                            trigger = isInit ? 'init' : forceTargetingReevaluation ? 'urlchange' : 'event';
-                            // Evaluation latency — surfaces the slow-network residual gap (SR-4234) in DataDog as
-                            // sdk.diagnostics.sr.trc.eval.duration_ms.{avg,max,...}.
-                            this.recordDiagnosticHistogram(SrDiagnostic.evalDurationMs, evalDurationMs);
+                            targetingMatch = _g.sent();
                             if (forceTargetingReevaluation &&
                                 urlChangeEvaluationId !== undefined &&
                                 urlChangeEvaluationId !== this.latestUrlChangeTargetingEvaluationId) {
-                                this.incrementDiagnostic(SrDiagnostic.evalStaleDiscarded);
-                                this.recordDiagnosticEvent(SrDiagnostic.evalStaleDiscarded, {
-                                    sessionId: this.identifiers.sessionId,
-                                    pageUrl: pageForTargeting === null || pageForTargeting === void 0 ? void 0 : pageForTargeting.url,
-                                    evaluationId: urlChangeEvaluationId,
-                                    latestEvaluationId: this.latestUrlChangeTargetingEvaluationId,
-                                    evalDurationMs: evalDurationMs,
-                                });
                                 this.loggerProvider.debug("Ignoring stale URL-change targeting result #".concat(urlChangeEvaluationId, "; latest is #").concat(this.latestUrlChangeTargetingEvaluationId, "."));
                                 return [2 /*return*/];
                             }
-                            // Per-evaluation outcome (distinct from the per-session sr.gate.* gate counters).
-                            this.incrementDiagnostic(targetingMatch ? SrDiagnostic.evalMatch : SrDiagnostic.evalNoMatch);
                             // Keep targeting match monotonic within a session: once true, always true.
                             // This avoids races where an older in-flight evaluation resolves false after
                             // a newer evaluation already resolved true.
                             this.sessionTargetingMatch = this.sessionTargetingMatch || targetingMatch;
-                            // Q5: record ALL evaluation params (→ DataDog Logs) so a single evaluation can be fully
-                            // reconstructed by URL, identifiers, inputs, outcome, trigger and latency. userProperties
-                            // values are intentionally reduced to keys to avoid logging PII.
-                            this.recordDiagnosticEvent(SrDiagnostic.evalEvent, {
-                                // sessionId + deviceId are stamped by recordDiagnosticEvent.
-                                trigger: trigger,
-                                matched: targetingMatch,
-                                sessionTargetingMatch: this.sessionTargetingMatch,
-                                pageUrl: pageForTargeting === null || pageForTargeting === void 0 ? void 0 : pageForTargeting.url,
-                                hasDeviceId: !!this.getDeviceId(),
-                                hasEvent: !!eventForTargeting,
-                                eventType: eventForTargeting === null || eventForTargeting === void 0 ? void 0 : eventForTargeting.event_type,
-                                userPropertyKeys: targetingParams.userProperties ? Object.keys(targetingParams.userProperties) : [],
-                                evalDurationMs: evalDurationMs,
-                            });
                             this.loggerProvider.debug(JSON.stringify({
                                 name: 'targeted replay capture config',
                                 sessionTargetingMatch: this.sessionTargetingMatch,
                                 event: eventForTargeting,
                                 targetingParams: targetingParams,
                             }, null, 2));
-                            return [3 /*break*/, 3];
+                            _g.label = 2;
                         case 2:
-                            if (targetingConfig && this.sessionTargetingMatch) {
-                                // Already matched earlier this session — recording continues without re-evaluation.
-                                this.incrementDiagnostic(SrDiagnostic.evalSkippedAlreadyMatched);
-                            }
-                            _h.label = 3;
-                        case 3:
-                            if (!isInit) return [3 /*break*/, 4];
+                            if (!isInit) return [3 /*break*/, 3];
                             void this.initialize(true);
-                            return [3 /*break*/, 6];
-                        case 4:
-                            if (!(forceRestart || !this.recordCancelCallback)) return [3 /*break*/, 6];
+                            return [3 /*break*/, 5];
+                        case 3:
+                            if (!(forceRestart || !this.recordCancelCallback)) return [3 /*break*/, 5];
                             this.loggerProvider.log('Recording events for session due to forceRestart or no ongoing recording.');
                             return [4 /*yield*/, this.recordEvents()];
-                        case 5:
-                            _h.sent();
-                            _h.label = 6;
-                        case 6: return [2 /*return*/];
+                        case 4:
+                            _g.sent();
+                            _g.label = 5;
+                        case 5: return [2 /*return*/];
                     }
                 });
             });
@@ -340,31 +270,17 @@ var SessionReplay = /** @class */ (function () {
      */
     SessionReplay.prototype.setupUrlChangeListener = function () {
         var _this = this;
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b;
         // If init() runs multiple times, remove the previous URL-change subscription first
         // so we don't leak callbacks and trigger duplicate targeting evaluations.
         (_a = this.urlChangeCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
         var globalScope = getGlobalScope();
         if (!(globalScope === null || globalScope === void 0 ? void 0 : globalScope.location)) {
-            // No window/location (SSR, worker, or pre-render) — the listener can't attach, so TRC will
-            // never re-evaluate on navigation. Surface it rather than failing silently.
-            this.incrementDiagnostic(SrDiagnostic.urlListenerSkipped);
-            this.recordDiagnosticEvent(SrDiagnostic.urlListenerSkipped, { reason: 'no_global_scope' });
-            this.loggerProvider.debug('URL-change listener not attached: no global scope/location.');
             return;
         }
         var hasTargeting = !!((_b = this.config) === null || _b === void 0 ? void 0 : _b.targetingConfig);
         var onUrlChange = function (href) {
             _this.currentPageUrl = href;
-            // Team-visible signal that an SPA navigation was detected at all (covers the "is the SDK
-            // even seeing route changes in this framework?" question — counter + a log with the href
-            // and whether it triggered a targeting re-eval).
-            _this.incrementDiagnostic(SrDiagnostic.urlChange);
-            _this.recordDiagnosticEvent(SrDiagnostic.urlChangeEvent, {
-                href: href,
-                hasTargeting: hasTargeting,
-                alreadyMatched: _this.sessionTargetingMatch,
-            });
             if (hasTargeting) {
                 var evaluationId = ++_this.latestUrlChangeTargetingEvaluationId;
                 void _this.evaluateTargetingAndCapture({
@@ -375,39 +291,7 @@ var SessionReplay = /** @class */ (function () {
                 _this.loggerProvider.debug("Queued URL-change targeting re-evaluation #".concat(evaluationId, " for ").concat(href, "."));
             }
         };
-        // Pass the polling options so targeting re-evaluation also respects `enableUrlChangePolling`.
-        // Without this, the targeting listener only sees history.pushState/replaceState + popstate +
-        // hashchange — so SPA navigations that bypass the history API never re-evaluate TRC and
-        // recording never starts on the new URL (enableUrlChangePolling previously only affected the
-        // rrweb URL-tracking plugin, which runs only once recording is already active).
-        var enablePolling = (_d = (_c = this.config) === null || _c === void 0 ? void 0 : _c.enableUrlChangePolling) !== null && _d !== void 0 ? _d : false;
-        this.urlPollFirstTickRecorded = false;
-        var unsubscribe = subscribeToUrlChanges(globalScope, onUrlChange, {
-            enablePolling: enablePolling,
-            pollingInterval: (_e = this.config) === null || _e === void 0 ? void 0 : _e.urlChangePollingInterval,
-            // Mirror each poll tick to the console (Debug level) so we can confirm polling is firing.
-            log: this.loggerProvider.debug.bind(this.loggerProvider),
-            // Prove in DataDog that polling actually FIRES (not just that it was scheduled). Per-tick is a
-            // cheap aggregated counter; the rich event is emitted once (with href) to avoid flooding the
-            // diagnostics endpoint with one capture POST per second.
-            onPoll: function (href, changed) {
-                _this.incrementDiagnostic(SrDiagnostic.urlPollTick);
-                if (!_this.urlPollFirstTickRecorded) {
-                    _this.urlPollFirstTickRecorded = true;
-                    // pollingInterval is already on url_listener.attached, so it's omitted here.
-                    _this.recordDiagnosticEvent(SrDiagnostic.urlPollFirstTick, { href: href, changed: changed });
-                }
-            },
-        });
-        // Confirm the listener is actually live, and under what settings — if recording never starts on
-        // navigation, this tells us whether the listener existed and whether polling (the fallback for
-        // SPAs that bypass the History API) was on.
-        this.recordDiagnosticEvent(SrDiagnostic.urlListenerAttached, {
-            hasTargeting: hasTargeting,
-            enablePolling: enablePolling,
-            pollingInterval: (_f = this.config) === null || _f === void 0 ? void 0 : _f.urlChangePollingInterval,
-        });
-        this.loggerProvider.debug("URL-change listener attached (polling: ".concat(String(enablePolling), ")."));
+        var unsubscribe = subscribeToUrlChanges(globalScope, onUrlChange);
         this.urlChangeCleanup = function () {
             unsubscribe();
             _this.urlChangeCleanup = null;
@@ -436,34 +320,14 @@ var SessionReplay = /** @class */ (function () {
         var currentUrl = (_b = (_a = getGlobalScope()) === null || _a === void 0 ? void 0 : _a.location) === null || _b === void 0 ? void 0 : _b.href;
         return currentUrl != null ? { url: currentUrl } : undefined;
     };
-    /**
-     * Best-effort navigation type from the Navigation Timing API: 'reload' | 'navigate' |
-     * 'back_forward' | 'prerender'. Surfaced in the init diagnostic so a page refresh ('reload')
-     * is distinguishable from a fresh load ('navigate') — neither changes the session id, so this
-     * is the only way to tell them apart. Returns undefined when the API is unavailable.
-     */
-    SessionReplay.prototype.getNavigationType = function () {
-        try {
-            var globalScope = getGlobalScope();
-            var performance_1 = globalScope && globalScope.performance;
-            if (!performance_1 || typeof performance_1.getEntriesByType !== 'function') {
-                return undefined;
-            }
-            var navEntries = performance_1.getEntriesByType('navigation');
-            return navEntries.length > 0 ? navEntries[0].type : undefined;
-        }
-        catch (_a) {
-            return undefined;
-        }
-    };
     SessionReplay.prototype._init = function (apiKey, options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         return __awaiter(this, void 0, void 0, function () {
-            var now, _u, _v, joinedConfig, localConfig, remoteConfig, scrollWatcher, managers, storeType, compressionWorkerScript, trackDestinationWorkerScript, globalScope, _w, compressionScript, trackDestinationScript, rrwebEventManager, error_1, typedError, payloadBatcher, interactionEventManager, error_2, typedError, onFullSnapshotProcessed, pending_2, pending_1, pending_1_1, _x, event_1, sessionId, messenger, needsUrlTracking;
-            var e_2, _y;
+            var now, _q, _r, joinedConfig, localConfig, remoteConfig, scrollWatcher, managers, storeType, compressionWorkerScript, trackDestinationWorkerScript, globalScope, _s, compressionScript, trackDestinationScript, rrwebEventManager, error_1, typedError, payloadBatcher, interactionEventManager, error_2, typedError, onFullSnapshotProcessed, pending_2, pending_1, pending_1_1, _t, event_1, sessionId, messenger, needsUrlTracking;
+            var e_2, _u;
             var _this = this;
-            return __generator(this, function (_z) {
-                switch (_z.label) {
+            return __generator(this, function (_v) {
+                switch (_v.label) {
                     case 0:
                         // Re-init should always tear down any previous URL-change subscription, even when the
                         // next config has no targeting config and we don't subscribe again.
@@ -479,13 +343,13 @@ var SessionReplay = /** @class */ (function () {
                             options.sessionId !== undefined
                                 ? (_b = getOrInitReplayStartTime(apiKey, options.sessionId, now, this.loggerProvider)) !== null && _b !== void 0 ? _b : now
                                 : now;
-                        _u = this;
+                        _q = this;
                         return [4 /*yield*/, createSessionReplayJoinedConfigGenerator(apiKey, options)];
                     case 1:
-                        _u.joinedConfigGenerator = _z.sent();
+                        _q.joinedConfigGenerator = _v.sent();
                         return [4 /*yield*/, this.joinedConfigGenerator.generateJoinedConfig()];
                     case 2:
-                        _v = _z.sent(), joinedConfig = _v.joinedConfig, localConfig = _v.localConfig, remoteConfig = _v.remoteConfig;
+                        _r = _v.sent(), joinedConfig = _r.joinedConfig, localConfig = _r.localConfig, remoteConfig = _r.remoteConfig;
                         this.config = joinedConfig;
                         this.setMetadata(options.sessionId, joinedConfig, localConfig, remoteConfig, (_c = options.version) === null || _c === void 0 ? void 0 : _c.version, VERSION, (_d = options.version) === null || _d === void 0 ? void 0 : _d.type);
                         this.pageLeaveFns = [];
@@ -509,12 +373,12 @@ var SessionReplay = /** @class */ (function () {
                         if (!(this.config.useWebWorker && globalScope && globalScope.Worker)) return [3 /*break*/, 4];
                         return [4 /*yield*/, import('./worker')];
                     case 3:
-                        _w = _z.sent(), compressionScript = _w.compressionScript, trackDestinationScript = _w.trackDestinationScript;
+                        _s = _v.sent(), compressionScript = _s.compressionScript, trackDestinationScript = _s.trackDestinationScript;
                         compressionWorkerScript = compressionScript;
                         trackDestinationWorkerScript = trackDestinationScript;
-                        _z.label = 4;
+                        _v.label = 4;
                     case 4:
-                        _z.trys.push([4, 6, , 7]);
+                        _v.trys.push([4, 6, , 7]);
                         return [4 /*yield*/, createEventsManager({
                                 config: this.config,
                                 type: 'replay',
@@ -526,21 +390,21 @@ var SessionReplay = /** @class */ (function () {
                                 shouldSend: function () { return !_this.isBelowMinSessionDuration(); },
                             })];
                     case 5:
-                        rrwebEventManager = _z.sent();
+                        rrwebEventManager = _v.sent();
                         this.rrwebEventManager = rrwebEventManager;
                         managers.push({ name: 'replay', manager: rrwebEventManager });
                         return [3 /*break*/, 7];
                     case 6:
-                        error_1 = _z.sent();
+                        error_1 = _v.sent();
                         typedError = error_1;
                         this.loggerProvider.warn("Error occurred while creating replay events manager: ".concat(typedError.toString()));
                         return [3 /*break*/, 7];
                     case 7:
                         if (!((_j = this.config.interactionConfig) === null || _j === void 0 ? void 0 : _j.enabled)) return [3 /*break*/, 11];
                         payloadBatcher = this.config.interactionConfig.batch ? clickBatcher : clickNonBatcher;
-                        _z.label = 8;
+                        _v.label = 8;
                     case 8:
-                        _z.trys.push([8, 10, , 11]);
+                        _v.trys.push([8, 10, , 11]);
                         return [4 /*yield*/, createEventsManager({
                                 config: this.config,
                                 type: 'interaction',
@@ -552,11 +416,11 @@ var SessionReplay = /** @class */ (function () {
                                 trackDestinationWorkerScript: trackDestinationWorkerScript,
                             })];
                     case 9:
-                        interactionEventManager = _z.sent();
+                        interactionEventManager = _v.sent();
                         managers.push({ name: 'interaction', manager: interactionEventManager });
                         return [3 /*break*/, 11];
                     case 10:
-                        error_2 = _z.sent();
+                        error_2 = _v.sent();
                         typedError = error_2;
                         this.loggerProvider.warn("Error occurred while creating interaction events manager: ".concat(typedError.toString()));
                         return [3 /*break*/, 11];
@@ -574,14 +438,14 @@ var SessionReplay = /** @class */ (function () {
                             pending_2 = this.pendingEmitEvents.splice(0);
                             try {
                                 for (pending_1 = __values(pending_2), pending_1_1 = pending_1.next(); !pending_1_1.done; pending_1_1 = pending_1.next()) {
-                                    _x = pending_1_1.value, event_1 = _x.event, sessionId = _x.sessionId;
+                                    _t = pending_1_1.value, event_1 = _t.event, sessionId = _t.sessionId;
                                     this.eventCompressor.enqueueEvent(event_1, sessionId);
                                 }
                             }
                             catch (e_2_1) { e_2 = { error: e_2_1 }; }
                             finally {
                                 try {
-                                    if (pending_1_1 && !pending_1_1.done && (_y = pending_1.return)) _y.call(pending_1);
+                                    if (pending_1_1 && !pending_1_1.done && (_u = pending_1.return)) _u.call(pending_1);
                                 }
                                 finally { if (e_2) throw e_2.error; }
                             }
@@ -618,7 +482,7 @@ var SessionReplay = /** @class */ (function () {
                         ], false);
                         return [4 /*yield*/, this.initializeNetworkObservers()];
                     case 12:
-                        _z.sent();
+                        _v.sent();
                         // Enable background capture when this page is opened by the Amplitude app
                         // (window.opener exists). Uses the shared messenger singleton so that if
                         // autocapture is also loaded, both share a single messenger and script load.
@@ -629,38 +493,10 @@ var SessionReplay = /** @class */ (function () {
                         }
                         this.loggerProvider.log('Installing @amplitude/session-replay-browser.');
                         this.teardownEventListeners(false);
-                        // Q1 "did init happen?": its presence in DataDog proves init() ran to completion for this
-                        // session; the props show whether the prerequisites (session/device id, config) were present.
-                        this.incrementDiagnostic(SrDiagnostic.init);
-                        this.recordDiagnosticEvent(SrDiagnostic.init, {
-                            // sessionId is always stamped by recordDiagnosticEvent, so no separate hasSessionId here.
-                            hasDeviceId: !!this.getDeviceId(),
-                            captureEnabled: this.config.captureEnabled,
-                            hasTargetingConfig: !!this.config.targetingConfig,
-                            sampleRate: this.config.sampleRate,
-                            optOut: this.shouldOptOut(),
-                            currentUrl: (_m = this.getCurrentPageForTargeting()) === null || _m === void 0 ? void 0 : _m.url,
-                            // 'reload' tells a page refresh apart from a fresh load ('navigate') or back/forward
-                            // ('back_forward'). New tabs and refreshes keep the same session id, so this is the only
-                            // way to distinguish a refresh from a brand-new init within a session.
-                            navigationType: this.getNavigationType(),
-                        });
                         return [4 /*yield*/, this.evaluateTargetingAndCapture({ userProperties: options.userProperties, page: this.getCurrentPageForTargeting() }, true)];
                     case 13:
-                        _z.sent();
-                        needsUrlTracking = this.config.targetingConfig || ((_q = (_p = (_o = this.config.privacyConfig) === null || _o === void 0 ? void 0 : _o.urlMaskLevels) === null || _p === void 0 ? void 0 : _p.length) !== null && _q !== void 0 ? _q : 0) > 0;
-                        // Record whether we even attempt to wire up the URL-change listener, and the inputs behind that
-                        // decision. If `needsUrlTracking` is false the listener is never attached, so SPA navigations are
-                        // invisible to TRC — this is the first thing to check when "TRC is on but never re-evaluates".
-                        this.recordDiagnosticEvent(SrDiagnostic.urlListenerSetup, {
-                            needsUrlTracking: !!needsUrlTracking,
-                            hasTargetingConfig: !!this.config.targetingConfig,
-                            urlMaskLevels: (_t = (_s = (_r = this.config.privacyConfig) === null || _r === void 0 ? void 0 : _r.urlMaskLevels) === null || _s === void 0 ? void 0 : _s.length) !== null && _t !== void 0 ? _t : 0,
-                            // config always defaults this to a boolean (see local-config), so no `?? false` needed here.
-                            enableUrlChangePolling: this.config.enableUrlChangePolling,
-                            urlChangePollingInterval: this.config.urlChangePollingInterval,
-                        });
-                        this.loggerProvider.debug("URL-change listener needed: ".concat(String(!!needsUrlTracking), "."));
+                        _v.sent();
+                        needsUrlTracking = this.config.targetingConfig || ((_p = (_o = (_m = this.config.privacyConfig) === null || _m === void 0 ? void 0 : _m.urlMaskLevels) === null || _o === void 0 ? void 0 : _o.length) !== null && _p !== void 0 ? _p : 0) > 0;
                         if (needsUrlTracking) {
                             this.setupUrlChangeListener();
                         }
@@ -700,18 +536,6 @@ var SessionReplay = /** @class */ (function () {
                             this.sendEvents(previousSessionId);
                         }
                         isSessionChange = previousSessionId !== sessionId;
-                        // A real session transition (not the first set): recording stops/restarts and targeting is
-                        // re-evaluated here, so session churn (timeout, multi-tab custom ids, explicit setSessionId)
-                        // is a prime suspect for "sometimes records, sometimes not". recordDiagnosticEvent ships to
-                        // DataDog AND mirrors to loggerProvider.debug. New tabs / refreshes keep the same id and won't
-                        // hit this — use the init diagnostic's navigationType for those.
-                        if (isSessionChange && previousSessionId !== undefined) {
-                            this.recordDiagnosticEvent(SrDiagnostic.sessionChanged, {
-                                from: previousSessionId,
-                                to: sessionId,
-                                deviceIdChanged: deviceId !== undefined && deviceId !== currentDeviceId,
-                            });
-                        }
                         // Drop any beacon-buffered events from the previous session BEFORE installing the
                         // new identifiers / start time. Otherwise the page-leave beacon path could attribute
                         // old-session events to the new session id, and the gate (using the new start time)
@@ -808,9 +632,6 @@ var SessionReplay = /** @class */ (function () {
                 // Cross-session leak is prevented in asyncSetSessionId, which drops the buffer
                 // at the session transition. The page-leave path also gates independently.
                 this.suppressedSendCount++;
-                // gap #1: recording but events held back by min_session_duration — another "recording yet
-                // no replay in Amplitude" cause.
-                this.incrementDiagnostic(SrDiagnostic.sendSuppressedMinDuration);
                 return;
             }
             // On the first send-after-pass for the session, emit a custom rrweb event so the
@@ -867,120 +688,17 @@ var SessionReplay = /** @class */ (function () {
         }
         return identityStoreOptOut !== undefined ? identityStoreOptOut : (_b = this.config) === null || _b === void 0 ? void 0 : _b.optOut;
     };
-    /**
-     * Increment a diagnostics counter so the team can see the distribution of recording decisions
-     * across a customer's sessions (e.g. lots of sr.gate.trc_no_match => rule isn't matching).
-     * Ships via the analytics SDK's DiagnosticsClient. No-op when there's no client or diagnostics
-     * isn't sampled in; never throws — diagnostics must never interfere with recording.
-     */
-    SessionReplay.prototype.incrementDiagnostic = function (counter) {
-        var _a, _b;
-        try {
-            // Mirror to the console (Debug level) so the full set of diagnostics is visible in the
-            // browser, not only in DataDog — helps debugging when a customer can't share a repro env.
-            this.loggerProvider.debug("[SR diagnostics] ".concat(counter));
-            (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.diagnosticsClient) === null || _b === void 0 ? void 0 : _b.increment(counter);
-        }
-        catch (_c) {
-            // swallow — diagnostics is best-effort
-        }
-    };
-    /**
-     * Record a diagnostics histogram value (min/max/avg/count in DataDog). Same best-effort, never-
-     * throws contract as incrementDiagnostic. Use for latencies/sizes, not per-call counts.
-     */
-    SessionReplay.prototype.recordDiagnosticHistogram = function (name, value) {
-        var _a, _b;
-        try {
-            // Mirror to the console (Debug level) — see incrementDiagnostic.
-            this.loggerProvider.debug("[SR diagnostics] ".concat(name, "=").concat(value));
-            // The only caller runs inside evaluateTargetingAndCapture's `this.config` guard, so the
-            // `config == null` arm of this optional chain is unreachable here (kept as defensive parity
-            // with recordDiagnosticEvent). The diagnosticsClient-absent arm IS exercised by no-client tests.
-            /* istanbul ignore next */
-            (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.diagnosticsClient) === null || _b === void 0 ? void 0 : _b.recordHistogram(name, value);
-        }
-        catch (_c) {
-            // swallow — diagnostics is best-effort
-        }
-    };
-    /**
-     * Record a diagnostics EVENT with properties. Events are forwarded to DataDog Logs, so the
-     * properties become queryable fields (e.g. @matched, @pageUrl). Use sparingly vs counters: the
-     * client caps in-memory events (~10 per save interval), so this is for context-rich signals at
-     * meaningful decision points, not per-call tallies. Best-effort, never throws.
-     */
-    SessionReplay.prototype.recordDiagnosticEvent = function (name, properties) {
-        var _a, _b, _c, _d, _e, _f;
-        try {
-            var sessionId = (_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId;
-            var deviceId = this.getDeviceId();
-            // Always stamp sessionId, deviceId and srId so every diagnostics event (→ DataDog Logs) can
-            // be correlated to a single session/device — and to the actual replay, since the Session
-            // Replay ID is `${deviceId}/${sessionId}`. Caller props override if they pass their own.
-            var enriched = __assign({ sessionId: sessionId, deviceId: deviceId, srId: deviceId != null && sessionId != null ? "".concat(deviceId, "/").concat(sessionId) : undefined }, properties);
-            // Mirror to the console (Debug level) so the full event + props are visible in the browser,
-            // not only in DataDog — see incrementDiagnostic.
-            this.loggerProvider.debug("[SR diagnostics] ".concat(name, " ").concat(JSON.stringify(enriched)));
-            (_c = (_b = this.config) === null || _b === void 0 ? void 0 : _b.diagnosticsClient) === null || _c === void 0 ? void 0 : _c.recordEvent(name, enriched);
-            // Flush immediately so the event ships now rather than on the client's ~5-min timer (and so
-            // short sessions that never reach the timer aren't lost). NOTE: this sends one capture POST
-            // per event — higher request volume; revisit/gate before production.
-            void ((_f = (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.diagnosticsClient) === null || _e === void 0 ? void 0 : _e._flush) === null || _f === void 0 ? void 0 : _f.call(_e));
-        }
-        catch (_g) {
-            // swallow — diagnostics is best-effort
-        }
-    };
-    /**
-     * Emit a single rich TRC decision snapshot per session to diagnostics — surfaced even when
-     * nothing records (the exact case customers can't reproduce locally).
-     */
-    SessionReplay.prototype.recordTrcDecisionDiagnostic = function (shouldRecord) {
-        var _a, _b;
-        var config = this.config;
-        // Every caller is past getShouldRecord's `!this.identifiers`/`!this.config` guard, so both are
-        // defined here; the `?.` arms below are unreachable defensive narrowing and excluded from
-        // coverage. The reachable guards (no diagnosticsClient, undefined/duplicate sessionId) are tested.
-        /* istanbul ignore next */
-        if (!config) {
-            return;
-        }
-        /* istanbul ignore next */
-        var sessionId = (_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId;
-        // Once past this guard, config.diagnosticsClient is truthy, so the fields below read config
-        // directly rather than re-asserting with `?.` on every access.
-        if (!config.diagnosticsClient || sessionId === undefined || sessionId === this.trcDiagnosticSessionId) {
-            return;
-        }
-        this.trcDiagnosticSessionId = sessionId;
-        // Goes through recordDiagnosticEvent so it carries sessionId + deviceId like every other event.
-        this.recordDiagnosticEvent(SrDiagnostic.decision, {
-            shouldRecord: shouldRecord,
-            captureEnabled: config.captureEnabled,
-            hasTargetingConfig: !!config.targetingConfig,
-            sessionTargetingMatch: this.sessionTargetingMatch,
-            sampleRate: config.sampleRate,
-            pageUrl: (_b = this.getCurrentPageForTargeting()) === null || _b === void 0 ? void 0 : _b.url,
-            sdkVersion: VERSION,
-        });
-    };
     SessionReplay.prototype.getShouldRecord = function () {
         if (!this.identifiers || !this.config || !this.identifiers.sessionId) {
             this.loggerProvider.warn("Session is not being recorded due to lack of config, please call sessionReplay.init.");
-            this.incrementDiagnostic(SrDiagnostic.gateNoIdentifiers);
             return false;
         }
         if (!this.config.captureEnabled) {
             this.loggerProvider.log("Session ".concat(this.identifiers.sessionId, " not being captured due to capture being disabled for project or because the remote config could not be fetched."));
-            this.incrementDiagnostic(SrDiagnostic.gateCaptureDisabled);
-            this.recordTrcDecisionDiagnostic(false);
             return false;
         }
         if (this.shouldOptOut()) {
             this.loggerProvider.log("Opting session ".concat(this.identifiers.sessionId, " out of recording due to optOut config."));
-            this.incrementDiagnostic(SrDiagnostic.gateOptOut);
-            this.recordTrcDecisionDiagnostic(false);
             return false;
         }
         var shouldRecord = false;
@@ -994,14 +712,12 @@ var SessionReplay = /** @class */ (function () {
                 this.loggerProvider.log(message);
                 shouldRecord = false;
                 matched = false;
-                this.incrementDiagnostic(SrDiagnostic.gateTrcNoMatch);
             }
             else {
                 message = "Capturing replays for session ".concat(this.identifiers.sessionId, " due to matching targeting conditions.");
                 this.loggerProvider.log(message);
                 shouldRecord = true;
                 matched = true;
-                this.incrementDiagnostic(SrDiagnostic.gateTrcMatch);
             }
         }
         else {
@@ -1011,12 +727,10 @@ var SessionReplay = /** @class */ (function () {
                 this.loggerProvider.log(message);
                 shouldRecord = false;
                 matched = false;
-                this.incrementDiagnostic(SrDiagnostic.gateSampleOut);
             }
             else {
                 shouldRecord = true;
                 matched = true;
-                this.incrementDiagnostic(SrDiagnostic.gateSampleIn);
             }
         }
         // Only send custom rrweb event for targeting decision when the decision changes
@@ -1029,7 +743,6 @@ var SessionReplay = /** @class */ (function () {
             });
             this.lastShouldRecordDecision = shouldRecord;
         }
-        this.recordTrcDecisionDiagnostic(shouldRecord);
         return shouldRecord;
     };
     SessionReplay.prototype.getBlockSelectors = function () {
@@ -1194,9 +907,6 @@ var SessionReplay = /** @class */ (function () {
                         recordFunction = _o.sent();
                         // May be undefined if cannot import rrweb-record
                         if (!recordFunction) {
-                            // gap #1: gate said record, but rrweb couldn't load → no replay despite shouldRecord=true.
-                            this.incrementDiagnostic(SrDiagnostic.recordNoRecordFn);
-                            this.recordDiagnosticEvent(SrDiagnostic.recordNoRecordFn, {});
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, this.initializeNetworkObservers()];
@@ -1227,11 +937,6 @@ var SessionReplay = /** @class */ (function () {
                             : {};
                         ugcFilterRules = (interactionConfig === null || interactionConfig === void 0 ? void 0 : interactionConfig.enabled) && interactionConfig.ugcFilterRules ? interactionConfig.ugcFilterRules : [];
                         this.loggerProvider.log("Session Replay capture beginning for ".concat(sessionId, "."));
-                        // gap #1: rrweb is actually starting. Closes the "gate said yes but no replay" blind spot,
-                        // and its srId is the id the replay uploads under (compare with analytics events to catch the
-                        // device-id mismatch that breaks stitching).
-                        this.incrementDiagnostic(SrDiagnostic.recordStarted);
-                        this.recordDiagnosticEvent(SrDiagnostic.recordStarted, {});
                         _o.label = 3;
                     case 3:
                         _o.trys.push([3, 5, , 6]);