@dynatrace/react-native-plugin 2.339.1 → 2.343.1

package/instrumentation/jsx/components/ClassComponent.js

@@ -18,14 +18,10 @@ class DynatraceClassComponent extends react_1.Component {
         if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
             this.logger.info(LogMessages_1.LogMessage.COMPONENT_NOT_STARTED);
         }
-        else {
-            if (ConfigurationHandler_1.ConfigurationHandler.isLifecycleUpdateEnabled() ||
-                !this.componentMounted) {
-                const actionPrefix = !this.componentMounted
-                    ? 'Render '
-                    : 'Update ';
-                this.internalAction = Dynatrace_1.Dynatrace.enterAutoAction(actionPrefix + this.wrappingName);
-            }
+        else if (ConfigurationHandler_1.ConfigurationHandler.isLifecycleUpdateEnabled() ||
+            !this.componentMounted) {
+            const actionPrefix = this.componentMounted ? 'Update ' : 'Render ';
+            this.internalAction = Dynatrace_1.Dynatrace.enterAutoAction(actionPrefix + this.wrappingName);
         }
         return this.props.children;
     }

package/instrumentation/jsx/components/ComponentUtil.js

@@ -1,34 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDynatraceIgnored = exports.isDynatraceNaming = exports.getNameFromComponent = void 0;
-const getNameFromComponent = (props) => {
-    if (props !== undefined && props.children !== undefined) {
-        let child;
-        if (Array.isArray(props.children) && props.children.length === 1) {
-            child = props.children[0];
-        }
-        else {
-            child = props.children;
-        }
-        if (child.props !== undefined &&
-            child.props.dtActionName !== undefined) {
-            return child.props.dtActionName;
-        }
-        else if (child.type !== undefined) {
-            if (child.type.displayName !== undefined) {
-                return child.type.displayName;
-            }
-            else if (child.type._dtInfo !== undefined) {
-                return child.type._dtInfo.name;
-            }
-            else {
-                return child.type.name;
-            }
-        }
+const getChildFromProperties = (props) => {
+    if (Array.isArray(props.children) && props.children.length === 1) {
+        return props.children[0];
+    }
+    return props.children;
+};
+const getNameFromChild = (child) => {
+    if (child.props !== undefined && child.props.dtActionName !== undefined) {
+        return child.props.dtActionName;
+    }
+    if (child.type === undefined) {
+        return 'Undefined Name';
     }
-    else {
+    if (child.type.displayName !== undefined) {
+        return child.type.displayName;
+    }
+    if (child.type._dtInfo !== undefined) {
+        return child.type._dtInfo.name;
+    }
+    return child.type.name;
+};
+const getNameFromComponent = (props) => {
+    if (props === undefined || props.children === undefined) {
         return 'Undefined Name';
     }
+    const child = getChildFromProperties(props);
+    return getNameFromChild(child);
 };
 exports.getNameFromComponent = getNameFromComponent;
 const isDynatraceNaming = (properties) => typeof properties === 'object' &&

package/instrumentation/libs/UserInteraction.js

@@ -5,23 +5,25 @@ const React = require("react");
 const react_native_1 = require("react-native");
 const ConfigurationHandler_1 = require("../../lib/core/configuration/ConfigurationHandler");
 const EventPipeline_1 = require("../../lib/next/events/EventPipeline");
+const EventTimestamp_1 = require("../../lib/next/events/EventTimestamp");
+const TimestampProvider_1 = require("../../lib/next/provider/TimestampProvider");
 const TOUCH_FLUSH_DELAY = 250;
 let pendingTouch = null;
 const getFiberPath = (fiber) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f, _g;
     let anyParentMasked = false;
     let path = [];
     let lastDtName;
     while (fiber != null) {
-        const dtInfoName = (_a = fiber.type) === null || _a === void 0 ? void 0 : _a.dtName;
-        const dtName = (_b = fiber.memoizedProps) === null || _b === void 0 ? void 0 : _b.dtName;
-        const effectiveName = dtName !== null && dtName !== void 0 ? dtName : dtInfoName;
-        if (effectiveName && effectiveName !== lastDtName) {
-            path = [effectiveName, ...path];
-            lastDtName = effectiveName;
+        const dtNameFromComponent = (_b = (_a = fiber.type) === null || _a === void 0 ? void 0 : _a.dtActionName) !== null && _b !== void 0 ? _b : (_c = fiber.type) === null || _c === void 0 ? void 0 : _c.dtName;
+        const dtNameFromProps = (_e = (_d = fiber.memoizedProps) === null || _d === void 0 ? void 0 : _d.dtActionName) !== null && _e !== void 0 ? _e : (_f = fiber.memoizedProps) === null || _f === void 0 ? void 0 : _f.dtName;
+        const dtName = dtNameFromProps !== null && dtNameFromProps !== void 0 ? dtNameFromProps : dtNameFromComponent;
+        if (dtName && dtName !== lastDtName) {
+            path = [dtName, ...path];
+            lastDtName = dtName;
         }
         anyParentMasked =
-            anyParentMasked || ((_c = fiber.memoizedProps) === null || _c === void 0 ? void 0 : _c.dtMask) == true;
+            anyParentMasked || ((_g = fiber.memoizedProps) === null || _g === void 0 ? void 0 : _g.dtMask) == true;
         fiber = fiber.return;
     }
     return { path, anyParentMasked };
@@ -58,20 +60,20 @@ const getHostComponentInfo = (event) => {
     const id = path.join('/');
     const leaf = path[path.length - 1];
     const components = [leaf];
-    const { nameOrigin, detectedName } = fiber.type !== 'RCTText'
-        ? {
-            nameOrigin: 'component',
-            detectedName: (_b = fiber.memoizedProps.accessibilityLabel) !== null && _b !== void 0 ? _b : leaf,
-        }
-        : anyParentMasked
-            ? {
-                nameOrigin: 'masked',
-                detectedName: '***',
-            }
-            : {
-                nameOrigin: 'text',
-                detectedName: flatten(fiber.memoizedProps.children),
-            };
+    let nameOrigin;
+    let detectedName;
+    if (fiber.type !== 'RCTText') {
+        nameOrigin = 'component';
+        detectedName = (_b = fiber.memoizedProps.accessibilityLabel) !== null && _b !== void 0 ? _b : leaf;
+    }
+    else if (anyParentMasked) {
+        nameOrigin = 'masked';
+        detectedName = '***';
+    }
+    else {
+        nameOrigin = 'text';
+        detectedName = flatten(fiber.memoizedProps.children);
+    }
     return { id, components, detectedName, nameOrigin };
 };
 const flushTouch = (responderComponentInfo) => {
@@ -80,12 +82,13 @@ const flushTouch = (responderComponentInfo) => {
     const { touchedComponentInfo, positions, timeoutId } = pendingTouch;
     clearTimeout(timeoutId);
     pendingTouch = null;
-    const event = Object.assign({ 'characteristics.has_user_interaction': true, 'ui_element.detected_name': touchedComponentInfo.detectedName, 'ui_element.components': touchedComponentInfo.components, 'ui_element.id': touchedComponentInfo.id, 'interaction.name': 'touch', positions, 'ui_element.name_origin': touchedComponentInfo.nameOrigin }, (responderComponentInfo && {
+    const eventTimestamp = new EventTimestamp_1.EventTimestamp(TimestampProvider_1.defaultTimestampProvider);
+    const event = Object.assign(Object.assign({ 'characteristics.has_user_interaction': true, 'ui_element.detected_name': touchedComponentInfo.detectedName, 'ui_element.components': touchedComponentInfo.components, 'ui_element.id': touchedComponentInfo.id, 'interaction.type': 'touch', positions, 'ui_element.name_origin': touchedComponentInfo.nameOrigin }, (responderComponentInfo && {
         'ui_element.responder.detected_name': responderComponentInfo.detectedName,
         'ui_element.responder.components': responderComponentInfo.components,
         'ui_element.responder.id': responderComponentInfo.id,
         'ui_element.responder.name_origin': responderComponentInfo.nameOrigin,
-    }));
+    })), eventTimestamp.getEventTimeInfo());
     EventPipeline_1.EventPipeline.insertEvent(event);
 };
 const onTouch = (e) => {

package/instrumentation/libs/react-native/RefreshControl.js

@@ -4,12 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RefreshControl = void 0;
 const react_native_1 = require("react-native");
 const Types_1 = require("../../model/Types");
-if (typeof react_native_1.RefreshControl === 'object') {
-    exports.RefreshControl = Object.assign({ _dtInfo: { type: Types_1.Types.RefreshControl } }, react_native_1.RefreshControl);
-}
-else {
-    exports.RefreshControl = (_a = class RefreshControl extends react_native_1.RefreshControl {
-        },
-        _a._dtInfo = { type: Types_1.Types.RefreshControl },
-        _a);
-}
+exports.RefreshControl = typeof react_native_1.RefreshControl === 'object'
+    ? Object.assign({ _dtInfo: { type: Types_1.Types.RefreshControl } }, react_native_1.RefreshControl) : (_a = class RefreshControl extends react_native_1.RefreshControl {
+    },
+    _a._dtInfo = { type: Types_1.Types.RefreshControl },
+    _a);

package/instrumentation/libs/withOnPressMonitoring.js

@@ -32,11 +32,13 @@ function withOnPressMonitoring(Component, fallbackName) {
 }
 exports.withOnPressMonitoring = withOnPressMonitoring;
 const dtGetUiBridge = () => {
+    var _a;
     const g = globalThis;
-    return g && g.__DT_UII_BRIDGE ? g.__DT_UII_BRIDGE : null;
+    return (_a = g === null || g === void 0 ? void 0 : g.__DT_UII_BRIDGE) !== null && _a !== void 0 ? _a : null;
 };
 const dtBuildPressPath = (startPath, touchableName) => {
-    const base = (startPath && String(startPath)) || '';
+    var _a;
+    const base = (_a = startPath === null || startPath === void 0 ? void 0 : startPath.toString()) !== null && _a !== void 0 ? _a : '';
     if (!base)
         return `Touchable(${touchableName})`;
     const cut1 = base.lastIndexOf('/Text');
@@ -45,65 +47,72 @@ const dtBuildPressPath = (startPath, touchableName) => {
     const parent = cut > 0 ? base.slice(0, cut) : base;
     return parent + `/Touchable(${touchableName})`;
 };
-const wrapOnPress = (onPress, touchableName, isButtonLike, buttonLabel) => {
-    return (...args) => {
-        const bridge = dtGetUiBridge();
-        if (bridge && typeof bridge.registerPress === 'function') {
-            try {
-                const e = args && args[0];
-                const ne = e && e.nativeEvent;
-                const x = Number(ne && ne.pageX);
-                const y = Number(ne && ne.pageY);
-                const pos = Number.isFinite(x) && Number.isFinite(y)
-                    ? { x, y }
-                    : undefined;
-                const startPath = bridge.getStartPath &&
-                    typeof bridge.getStartPath === 'function'
-                    ? bridge.getStartPath()
-                    : null;
-                const nameForBridge = isButtonLike
-                    ? buttonLabel || touchableName
-                    : touchableName;
-                bridge.registerPress({
-                    path: dtBuildPressPath(startPath, nameForBridge),
-                    elementName: nameForBridge,
-                    pos,
-                });
-            }
-            catch (e) {
-                const errorMsg = e instanceof Error ? e.stack || e.message : String(e);
-                Logger.debug(LogMessages_1.LogMessage.REGISTER_PRESS_HOOK_FAILED, {
-                    errorMsg,
-                });
-            }
+const registerPressOnBridge = (args, touchableName, isButtonLike, buttonLabel) => {
+    const bridge = dtGetUiBridge();
+    if (!bridge || typeof bridge.registerPress !== 'function') {
+        return;
+    }
+    try {
+        const e = args === null || args === void 0 ? void 0 : args[0];
+        const ne = e === null || e === void 0 ? void 0 : e.nativeEvent;
+        const x = Number(ne === null || ne === void 0 ? void 0 : ne.pageX);
+        const y = Number(ne === null || ne === void 0 ? void 0 : ne.pageY);
+        const pos = Number.isFinite(x) && Number.isFinite(y) ? { x, y } : undefined;
+        const startPath = typeof bridge.getStartPath === 'function'
+            ? bridge.getStartPath()
+            : null;
+        const nameForBridge = isButtonLike
+            ? buttonLabel || touchableName
+            : touchableName;
+        bridge.registerPress({
+            path: dtBuildPressPath(startPath, nameForBridge),
+            elementName: nameForBridge,
+            pos,
+        });
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.stack || e.message : String(e);
+        Logger.debug(LogMessages_1.LogMessage.REGISTER_PRESS_HOOK_FAILED, {
+            errorMsg,
+        });
+    }
+};
+const notifyPressFromEvent = (args) => {
+    if (args[0] && typeof args[0] === 'object' && 'nativeEvent' in args[0]) {
+        (0, UserInteraction_1.notifyPress)(args[0]);
+    }
+};
+const invokeOnPressWithoutConfiguration = (onPress, args) => {
+    Logger.info(LogMessages_1.LogMessage.TOUCH_NOT_STARTED);
+    onPress(...args);
+};
+const invokeOnPressWithAction = (onPress, args, touchableName) => {
+    const action = Dynatrace_1.Dynatrace.enterAutoAction(`Touch on ${touchableName}`);
+    let isSync = true;
+    try {
+        const returnValue = onPress(...args);
+        if (returnValue instanceof Promise) {
+            isSync = false;
+            void Promise.resolve(returnValue).finally(() => {
+                action.leaveAction();
+            });
         }
-        if (args[0] &&
-            typeof args[0] === 'object' &&
-            'nativeEvent' in args[0]) {
-            (0, UserInteraction_1.notifyPress)(args[0]);
+    }
+    finally {
+        if (isSync) {
+            action.leaveAction();
         }
+    }
+};
+const wrapOnPress = (onPress, touchableName, isButtonLike, buttonLabel) => {
+    return (...args) => {
+        registerPressOnBridge(args, touchableName, isButtonLike, buttonLabel);
+        notifyPressFromEvent(args);
         if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger.info(LogMessages_1.LogMessage.TOUCH_NOT_STARTED);
-            onPress(...args);
-        }
-        else {
-            const action = Dynatrace_1.Dynatrace.enterAutoAction(`Touch on ${touchableName}`);
-            let isSync = true;
-            try {
-                const returnValue = onPress(...args);
-                if (returnValue instanceof Promise) {
-                    isSync = false;
-                    return Promise.resolve(returnValue).finally(() => {
-                        action.leaveAction();
-                    });
-                }
-            }
-            finally {
-                if (isSync) {
-                    action.leaveAction();
-                }
-            }
+            invokeOnPressWithoutConfiguration(onPress, args);
+            return;
         }
+        invokeOnPressWithAction(onPress, args, touchableName);
     };
 };
 exports.wrapOnPress = wrapOnPress;

package/ios/DTXScreenshotSelfMonitor.h

@@ -0,0 +1,29 @@
+//
+//  DTXScreenshotSelfMonitor.h
+//
+//  Self-monitoring counterpart of the Session Replay UI-change listener. Instead of capturing a
+//  screenshot it only increments the cross-platform screenshot counter via the agent, to estimate
+//  how many screenshots Session Replay would take in production.
+//
+//  Monitoring is gated by the remote `replay_metrics_enabled` flag delivered through the
+//  configuration; it stays dormant until the server enables it.
+//
+
+#import <Foundation/Foundation.h>
+#import "ConfigurationSubscriber.h"
+
+// Build-time master switch for the screenshot self-monitoring (replay metrics) feature.
+// Defaults to enabled. Disable for a build with `DYNATRACE_REPLAY_METRICS_ENABLED=0 pod install`
+// (the podspec then injects `#define DTX_REPLAY_METRICS_ENABLED 0` via the prefix header). When 0,
+// the monitor is never registered, regardless of the remote `replay_metrics_enabled` flag.
+#ifndef DTX_REPLAY_METRICS_ENABLED
+#define DTX_REPLAY_METRICS_ENABLED 1
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface DTXScreenshotSelfMonitor : NSObject <ConfigurationSubscriber>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/DTXScreenshotSelfMonitor.mm

@@ -0,0 +1,213 @@
+//
+//  DTXScreenshotSelfMonitor.mm
+//
+
+#import "DTXScreenshotSelfMonitor.h"
+#import "DTXScreenshotSelfMonitorSwizzler.h"
+#import <UIKit/UIKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+static const double kDebounceMs = 500.0;
+static const double kMaxDebounceMs = 2000.0;
+
+// Remote feature-flag key in the cross-platform configuration map. Monitoring stays off unless the
+// server delivers this flag as `true`.
+static NSString *const kReplayMetricsConfigKey = @"replay_metrics_enabled";
+
+// DEM-26735: replay metrics experiment sunsets on 2026-10-15T00:00:00Z; remove this class after that date.
+static const NSTimeInterval kExperimentExpiryEpoch = 1792022400.0;
+
+static BOOL DTXIsReplayMetricsExperimentExpired(void) {
+    return [[NSDate date] timeIntervalSince1970] >= kExperimentExpiryEpoch;
+}
+
+// Minimal declaration of the agent's HybridBridge facade. The implementation is provided by the
+// Dynatrace framework; we only need the screenshot-tracking entry point here.
+//
+// NOTE: the underlying store moved to ios-core (DynatraceCoreStatic's
+// Assembly.shared.crossPlatformScreenshotTracker). DynatraceCoreStatic is not exposed to this plugin
+// (it is statically merged into the Dynatrace framework and not re-exported), so we keep calling the
+// ObjC HybridBridge facade; the agent's HybridBridge delegates to the ios-core tracker
+// (+[HybridBridge trackCrossPlatformScreenshot] → [Assembly.shared.crossPlatformScreenshotTracker trackScreenshot]).
+@interface HybridBridge : NSObject
++ (void)trackCrossPlatformScreenshot;
+@end
+
+@implementation DTXScreenshotSelfMonitor {
+    BOOL _started;
+    BOOL _swizzleInstalled;
+    BOOL _pending;
+    double _lastChangeTime;
+    double _firstChangeTime;
+    uint32_t _generation;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _started = NO;
+        _swizzleInstalled = NO;
+        _pending = NO;
+        _lastChangeTime = 0;
+        _firstChangeTime = 0;
+        _generation = 0;
+    }
+    return self;
+}
+
+- (void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    if (_swizzleInstalled) {
+        [DTXScreenshotSelfMonitorSwizzler uninstall];
+        _swizzleInstalled = NO;
+    }
+}
+
+#pragma mark - ConfigurationSubscriber
+
+- (void)notifyWithConfiguration:(NSDictionary<NSString *, id> *)configuration {
+    id value = configuration[kReplayMetricsConfigKey];
+    BOOL flagEnabled = [value isKindOfClass:[NSNumber class]] && [value boolValue];
+    BOOL enabled = flagEnabled && !DTXIsReplayMetricsExperimentExpired();
+    if (flagEnabled && !enabled) {
+        NSLog(@"[dtxScreenshotSelfMonitor] config: %@=YES but experiment expired — treating as disabled", kReplayMetricsConfigKey);
+    } else {
+        NSLog(@"[dtxScreenshotSelfMonitor] config: %@=%@ → %@", kReplayMetricsConfigKey, value, enabled ? @"ENABLED" : @"DISABLED");
+    }
+
+    // Configuration is delivered on a background queue; start/stop touch UIApplication and the global
+    // swizzle, so they must run on the main thread. start/stop are idempotent.
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (enabled) {
+            [self start];
+        } else {
+            [self stop];
+        }
+    });
+}
+
+#pragma mark - Lifecycle (must be called on the main thread)
+
+- (void)start {
+    if (_started) {
+        NSLog(@"[dtxScreenshotSelfMonitor] start ignored — already started");
+        return;
+    }
+    _started = YES;
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(appDidBecomeActive)
+                                                 name:UIApplicationDidBecomeActiveNotification
+                                               object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(appDidEnterBackground)
+                                                 name:UIApplicationDidEnterBackgroundNotification
+                                               object:nil];
+
+    UIApplicationState appState = [UIApplication sharedApplication].applicationState;
+    NSLog(@"[dtxScreenshotSelfMonitor] start (appState=%ld, mainThread=%d)", (long)appState, (int)[NSThread isMainThread]);
+
+    // Install immediately unless we are backgrounded (avoids observing while there is nothing to do).
+    if (appState != UIApplicationStateBackground) {
+        [self installSwizzle];
+    } else {
+        NSLog(@"[dtxScreenshotSelfMonitor] start: app backgrounded — deferring swizzle install to appDidBecomeActive");
+    }
+}
+
+- (void)stop {
+    if (!_started) return;
+    _started = NO;
+    NSLog(@"[dtxScreenshotSelfMonitor] stop");
+
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    [self uninstallSwizzle];
+}
+
+#pragma mark - Swizzle install / uninstall
+
+- (void)installSwizzle {
+    if (_swizzleInstalled) return;
+    _swizzleInstalled = YES;
+    NSLog(@"[dtxScreenshotSelfMonitor] installing layer swizzle");
+
+    __weak __typeof__(self) weakSelf = self;
+    [DTXScreenshotSelfMonitorSwizzler installWithChangeHandler:^{
+        [weakSelf onLayerChanged];
+    }];
+}
+
+- (void)uninstallSwizzle {
+    if (!_swizzleInstalled) return;
+    _swizzleInstalled = NO;
+    NSLog(@"[dtxScreenshotSelfMonitor] uninstalling layer swizzle (disarming handler)");
+
+    [DTXScreenshotSelfMonitorSwizzler uninstall];
+    _generation++;
+    _pending = NO;
+}
+
+#pragma mark - App lifecycle
+
+- (void)appDidBecomeActive {
+    NSLog(@"[dtxScreenshotSelfMonitor] appDidBecomeActive");
+    [self installSwizzle];
+}
+
+- (void)appDidEnterBackground {
+    NSLog(@"[dtxScreenshotSelfMonitor] appDidEnterBackground");
+    [self uninstallSwizzle];
+}
+
+#pragma mark - CALayer change callback
+
+- (void)onLayerChanged {
+    double now = CACurrentMediaTime() * 1000.0;
+    _lastChangeTime = now;
+
+    if (!_pending) {
+        _pending = YES;
+        _firstChangeTime = now;
+        NSLog(@"[dtxScreenshotSelfMonitor] UI change detected — starting %.0fms debounce", kDebounceMs);
+        [self scheduleCapture];
+    }
+}
+
+#pragma mark - Debounce & capture
+
+- (void)scheduleCapture {
+    uint32_t gen = _generation;
+    __weak __typeof__(self) weakSelf = self;
+    dispatch_after(
+        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(kDebounceMs * NSEC_PER_MSEC)),
+        dispatch_get_main_queue(),
+        ^{
+            __typeof__(self) strongSelf = weakSelf;
+            if (!strongSelf || gen != strongSelf->_generation) return;
+            [strongSelf performCapture];
+        }
+    );
+}
+
+- (void)performCapture {
+    double now = CACurrentMediaTime() * 1000.0;
+    double elapsed = now - _lastChangeTime;
+    double sinceFirst = now - _firstChangeTime;
+
+    if (elapsed < kDebounceMs && sinceFirst < kMaxDebounceMs) {
+        NSLog(@"[dtxScreenshotSelfMonitor] UI still active (%.0fms since last change) — rescheduling", elapsed);
+        [self scheduleCapture];
+        return;
+    }
+
+    _pending = NO;
+
+    @try {
+        NSLog(@"[dtxScreenshotSelfMonitor] capture settled — calling [HybridBridge trackCrossPlatformScreenshot]");
+        [HybridBridge trackCrossPlatformScreenshot];
+    } @catch (NSException *exception) {
+        NSLog(@"[dtxScreenshotSelfMonitor] trackCrossPlatformScreenshot threw: %@", exception.name);
+    }
+}
+
+@end

package/ios/DTXScreenshotSelfMonitorSwizzler.h

@@ -0,0 +1,15 @@
+//
+//  DTXScreenshotSelfMonitorSwizzler.h
+//
+//  Detects UI changes by swizzling -[CALayer layoutSublayers] and invoking a change handler on
+//  the main thread. Used by the cross-platform screenshot self-monitoring feature.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface DTXScreenshotSelfMonitorSwizzler : NSObject
+
++ (void)installWithChangeHandler:(void (^)(void))handler;
++ (void)uninstall;
+
+@end

package/ios/DTXScreenshotSelfMonitorSwizzler.mm

@@ -0,0 +1,68 @@
+//
+//  DTXScreenshotSelfMonitorSwizzler.mm
+//
+
+#import "DTXScreenshotSelfMonitorSwizzler.h"
+#import <QuartzCore/QuartzCore.h>
+#import <objc/runtime.h>
+
+static void (^_changeHandler)(void) = nil;
+static BOOL _installed = NO;
+static BOOL _isHandlingChange = NO;
+
+static IMP original_layoutSublayers_imp = NULL;
+
+static void notifyChange(void) {
+    if (!_changeHandler) return;
+    if (![NSThread isMainThread]) return;
+    if (_isHandlingChange) return;
+
+    _isHandlingChange = YES;
+    _changeHandler();
+    _isHandlingChange = NO;
+}
+
+static void swizzled_layoutSublayers(id self, SEL _cmd) {
+    ((void (*)(id, SEL))original_layoutSublayers_imp)(self, _cmd);
+    notifyChange();
+}
+
+@implementation DTXScreenshotSelfMonitorSwizzler
+
++ (void)installWithChangeHandler:(void (^)(void))handler {
+    _changeHandler = [handler copy];
+
+    // Swizzle exactly once for the process lifetime, then drive activity through _changeHandler.
+    //
+    // We must NOT swizzle/unswizzle on every foreground/background. -[CALayer layoutSublayers] is a
+    // shared selector that DynatraceSessionReplay also swizzles; two independent swizzlers each
+    // restoring + re-installing the IMP can interleave such that an install captures an
+    // already-swizzled IMP as its "original". swizzled_layoutSublayers() then calls back into a
+    // swizzled implementation, recursing without bound → stack overflow (EXC_BAD_ACCESS on
+    // foreground). Installing once removes all IMP churn and keeps the swizzle chain stable.
+    if (_installed) {
+        NSLog(@"[dtxScreenshotSelfMonitor] swizzler: handler re-armed (already installed)");
+        return;
+    }
+    _installed = YES;
+
+    Class cls = [CALayer class];
+    Method m = class_getInstanceMethod(cls, @selector(layoutSublayers));
+    IMP current = method_getImplementation(m);
+    // Defensive: never capture our own swizzled function as the original (would self-recurse).
+    if (current != (IMP)swizzled_layoutSublayers) {
+        original_layoutSublayers_imp = current;
+    }
+    method_setImplementation(m, (IMP)swizzled_layoutSublayers);
+    NSLog(@"[dtxScreenshotSelfMonitor] swizzler: installed on -[CALayer layoutSublayers] (one-time)");
+}
+
++ (void)uninstall {
+    // Intentionally does NOT restore the original IMP (see installWithChangeHandler:). Restoring is
+    // what enables the cross-swizzler recursion above, and it would also clobber any swizzler layered
+    // on top of us. We leave the one-time swizzle in place and simply stop notifying — notifyChange()
+    // no-ops while _changeHandler is nil, so there is no work and no risk when monitoring is off.
+    _changeHandler = nil;
+}
+
+@end