@dynatrace/react-native-plugin 2.341.1 → 2.343.1

package/instrumentation/libs/UserInteraction.js

@@ -83,7 +83,7 @@ const flushTouch = (responderComponentInfo) => {
     clearTimeout(timeoutId);
     pendingTouch = null;
     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.name': 'touch', positions, 'ui_element.name_origin': touchedComponentInfo.nameOrigin }, (responderComponentInfo && {
+    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,

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

package/ios/DynatraceRNBridge.h

@@ -22,6 +22,12 @@
 + (void)startView:(NSDictionary<NSString*,id>* _Nullable)fields NS_SWIFT_NAME(startView(fields:));
 + (void)stopView;
 + (void)addConfigurationSubscriber:(id<ConfigurationSubscriber>)subscriber;
++ (void)trackCrossPlatformScreenshot;
++ (void)setAutomaticUserActionDetection:(BOOL)enabled NS_SWIFT_NAME(setAutomaticUserActionDetection(enabled:));
++ (void)createUserAction:(NSString *)actionId name:(NSString *)name completeAutomatically:(BOOL)completeAutomatically properties:(NSDictionary<NSString*,id>* _Nullable)properties NS_SWIFT_NAME(createUserAction(actionId:name:completeAutomatically:properties:));
++ (void)addEventPropertyToUserAction:(NSString *)actionId key:(NSString *)key value:(id _Nullable)value NS_SWIFT_NAME(addEventPropertyToUserAction(actionId:key:value:));
++ (void)completeUserAction:(NSString *)actionId NS_SWIFT_NAME(completeUserAction(actionId:));
++ (void)setCompleteUserActionAutomatically:(NSString *)actionId enabled:(BOOL)enabled NS_SWIFT_NAME(setCompleteUserActionAutomatically(actionId:enabled:));
 @end
 
 typedef enum : NSUInteger {

package/ios/DynatraceRNBridge.mm

@@ -3,6 +3,7 @@
 //
 
 #import "DynatraceRNBridge.h"
+#import "DTXScreenshotSelfMonitor.h"
 
 // For Turbo Module
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -111,6 +112,11 @@ static bool remoteConfigSubscribed;
 static NSDictionary<NSString*, id>* lastRuntimeConfiguration;
 static RNConfigurationSubscriber* configurationSubscriber;
 
+// Screenshot self-monitoring. Registered once per process; the configuration publisher retains it
+// as a subscriber and the remote `replay_metrics_enabled` flag toggles monitoring on/off.
+static bool screenshotMonitorSubscribed;
+static DTXScreenshotSelfMonitor* screenshotMonitor;
+
 RCT_EXPORT_MODULE(DynatraceBridge);
 
 - (instancetype) init
@@ -307,6 +313,18 @@ template<typename T = void> std::enable_if_t<(facebook::react::ReactNativeVersio
     }
     remoteConfigSubscribed = YES;
     [HybridBridge addConfigurationSubscriber:(id)configurationSubscriber];
+
+    // Start the screenshot self-monitor here — same proven-safe timing as the config subscriber
+    // above (post-startup). Started once; -start touches UIApplication and the layer swizzle, so it
+    // must run on the main thread.
+#if DTX_REPLAY_METRICS_ENABLED
+    if (!screenshotMonitorSubscribed) {
+        screenshotMonitorSubscribed = YES;
+        NSLog(@"[dtxScreenshotSelfMonitor] bridge: registering screenshot self-monitor as config subscriber");
+        screenshotMonitor = [[DTXScreenshotSelfMonitor alloc] init];
+        [HybridBridge addConfigurationSubscriber:(id)screenshotMonitor];
+    }
+#endif
 }
 
 - (void)emitToJS:(NSString*)event body:(id)body
@@ -627,6 +645,41 @@ RCT_EXPORT_METHOD(forwardAppStartEvent:(NSDictionary<NSString*, id>*) attributes
     [HybridBridge forwardAppStartEvent:attributes keys:appStartKeys];
 }
 
+RCT_EXPORT_METHOD(setAutomaticUserActionDetection:(BOOL)enabled)
+{
+    [HybridBridge setAutomaticUserActionDetection:enabled];
+}
+
+RCT_EXPORT_METHOD(createUserAction:(NSString *)actionId name:(NSString *)name completeAutomatically:(BOOL)completeAutomatically properties:(NSDictionary<NSString*, id>* _Nullable)properties)
+{
+    [HybridBridge createUserAction:actionId name:name completeAutomatically:completeAutomatically properties:properties];
+}
+
+RCT_EXPORT_METHOD(addEventStringPropertyToUserAction:(NSString *)actionId key:(NSString *)key value:(NSString *)value)
+{
+    [HybridBridge addEventPropertyToUserAction:actionId key:key value:value];
+}
+
+RCT_EXPORT_METHOD(addEventDoublePropertyToUserAction:(NSString *)actionId key:(NSString *)key value:(double)value)
+{
+    [HybridBridge addEventPropertyToUserAction:actionId key:key value:@(value)];
+}
+
+RCT_EXPORT_METHOD(addEventBooleanPropertyToUserAction:(NSString *)actionId key:(NSString *)key value:(BOOL)value)
+{
+    [HybridBridge addEventPropertyToUserAction:actionId key:key value:@(value)];
+}
+
+RCT_EXPORT_METHOD(completeUserAction:(NSString *)actionId)
+{
+    [HybridBridge completeUserAction:actionId];
+}
+
+RCT_EXPORT_METHOD(setCompleteUserActionAutomatically:(NSString *)actionId enabled:(BOOL)enabled)
+{
+    [HybridBridge setCompleteUserActionAutomatically:actionId enabled:enabled];
+}
+
 RCT_EXPORT_METHOD(setGPSLocation:(double)latitude andLongitude: (double)longitude platform: (NSString *) platform)
 {
     if ([self shouldWorkOnIosWithPlatform: platform])

package/lib/core/Dynatrace.js

@@ -426,4 +426,6 @@ exports.Dynatrace = {
     generateTraceContext(traceparent, tracestate) {
         return Dynatrace_1.Dynatrace.generateTraceContext(traceparent, tracestate);
     },
+    createUserAction: (configuration) => Dynatrace_1.Dynatrace.createUserAction(configuration),
+    setAutomaticUserActionDetection: (enabled) => Dynatrace_1.Dynatrace.setAutomaticUserActionDetection(enabled),
 };

package/lib/core/logging/LogMessages.js

@@ -36,6 +36,8 @@ var LogMessage;
     LogMessage["COMPONENT_NOT_STARTED"] = "COMPONENT_NOT_STARTED";
     LogMessage["CONFIGURATION_DUPLICATE_STARTUP"] = "CONFIGURATION_DUPLICATE_STARTUP";
     LogMessage["CONFIGURATION_SET"] = "CONFIGURATION_SET";
+    LogMessage["CREATE_USER_ACTION"] = "CREATE_USER_ACTION";
+    LogMessage["CREATE_USER_ACTION_NOT_STARTED"] = "CREATE_USER_ACTION_NOT_STARTED";
     LogMessage["END_SESSION"] = "END_SESSION";
     LogMessage["END_SESSION_NOT_STARTED"] = "END_SESSION_NOT_STARTED";
     LogMessage["ENTER_AUTO_ACTION"] = "ENTER_AUTO_ACTION";
@@ -115,6 +117,8 @@ var LogMessage;
     LogMessage["SEND_SESSION_PROPERTY_EVENT"] = "SEND_SESSION_PROPERTY_EVENT";
     LogMessage["SEND_SESSION_PROPERTY_EVENT_INVALID_TYPE"] = "SEND_SESSION_PROPERTY_EVENT_INVALID_TYPE";
     LogMessage["SESSION_PROPERTIES_FILTERED"] = "SESSION_PROPERTIES_FILTERED";
+    LogMessage["SET_AUTOMATIC_USER_ACTION_DETECTION"] = "SET_AUTOMATIC_USER_ACTION_DETECTION";
+    LogMessage["SET_AUTOMATIC_USER_ACTION_DETECTION_NOT_STARTED"] = "SET_AUTOMATIC_USER_ACTION_DETECTION_NOT_STARTED";
     LogMessage["SET_BEACON_HEADERS"] = "SET_BEACON_HEADERS";
     LogMessage["SET_BEACON_HEADERS_NOT_STARTED"] = "SET_BEACON_HEADERS_NOT_STARTED";
     LogMessage["SET_CRASH_REPORTING_OPTED_IN"] = "SET_CRASH_REPORTING_OPTED_IN";
@@ -137,6 +141,10 @@ var LogMessage;
     LogMessage["TRACE_CONTEXT_NOT_STARTED"] = "TRACE_CONTEXT_NOT_STARTED";
     LogMessage["TRIM_STRING_VALUE_LIMITED"] = "TRIM_STRING_VALUE_LIMITED";
     LogMessage["UI_INTERACTION_DEBUG"] = "UI_INTERACTION_DEBUG";
+    LogMessage["USER_ACTION_ADD_EVENT_PROPERTY"] = "USER_ACTION_ADD_EVENT_PROPERTY";
+    LogMessage["USER_ACTION_COMPLETE"] = "USER_ACTION_COMPLETE";
+    LogMessage["USER_ACTION_CREATED"] = "USER_ACTION_CREATED";
+    LogMessage["USER_ACTION_SET_COMPLETE_AUTOMATICALLY"] = "USER_ACTION_SET_COMPLETE_AUTOMATICALLY";
     LogMessage["VALUE_SIZE_LIMITED"] = "VALUE_SIZE_LIMITED";
     LogMessage["WEB_REQUEST_TIMING_START"] = "WEB_REQUEST_TIMING_START";
     LogMessage["WEB_REQUEST_TIMING_START_FAILED"] = "WEB_REQUEST_TIMING_START_FAILED";
@@ -281,6 +289,15 @@ exports.LOG_MESSAGES = {
         template: ({ config }) => `Configuration set: ${config}`,
         logType: LogType_1.LogType.Info,
     },
+    [LogMessage.CREATE_USER_ACTION]: {
+        template: ({ customName, completeAutomatically, }) => `createUserAction(${customName}, ${completeAutomatically})`,
+        logType: LogType_1.LogType.Info,
+    },
+    [LogMessage.CREATE_USER_ACTION_NOT_STARTED]: {
+        template: 'createUserAction(): React Native plugin has not been started yet! User action will not be created!',
+        logType: LogType_1.LogType.Warning,
+        documentationUri: 'https://dt-url.net/r2g3975',
+    },
     [LogMessage.END_SESSION]: {
         template: 'Dynatrace endSession()',
         logType: LogType_1.LogType.Info,
@@ -640,6 +657,15 @@ exports.LOG_MESSAGES = {
         logType: LogType_1.LogType.Warning,
         documentationUri: 'https://dt-url.net/lsk39cn',
     },
+    [LogMessage.SET_AUTOMATIC_USER_ACTION_DETECTION]: {
+        template: ({ enabled }) => `setAutomaticUserActionDetection(${enabled})`,
+        logType: LogType_1.LogType.Info,
+    },
+    [LogMessage.SET_AUTOMATIC_USER_ACTION_DETECTION_NOT_STARTED]: {
+        template: 'setAutomaticUserActionDetection(): React Native plugin has not been started yet! Setting will not be applied!',
+        logType: LogType_1.LogType.Warning,
+        documentationUri: 'https://dt-url.net/r2g3975',
+    },
     [LogMessage.SET_BEACON_HEADERS]: {
         template: 'setBeaconHeaders(headers)',
         logType: LogType_1.LogType.Info,
@@ -738,6 +764,22 @@ exports.LOG_MESSAGES = {
         template: ({ event }) => `[DT UI]${event}`,
         logType: LogType_1.LogType.Info,
     },
+    [LogMessage.USER_ACTION_ADD_EVENT_PROPERTY]: {
+        template: ({ key, value, customName, }) => `addEventProperty(${key}, ${value}): in UserAction - ${customName}`,
+        logType: LogType_1.LogType.Info,
+    },
+    [LogMessage.USER_ACTION_COMPLETE]: {
+        template: ({ customName }) => `complete(): ${customName}`,
+        logType: LogType_1.LogType.Info,
+    },
+    [LogMessage.USER_ACTION_CREATED]: {
+        template: ({ customName, completeAutomatically, actionId, }) => `UserAction created: ${customName} (actionId: ${actionId}, completeAutomatically: ${completeAutomatically})`,
+        logType: LogType_1.LogType.Info,
+    },
+    [LogMessage.USER_ACTION_SET_COMPLETE_AUTOMATICALLY]: {
+        template: ({ enabled, customName, }) => `setCompleteAutomatically(${enabled}): ${customName}`,
+        logType: LogType_1.LogType.Info,
+    },
     [LogMessage.VALUE_SIZE_LIMITED]: {
         template: ({ key, maxLength }) => `restrictingValueSize(): Limiting value of ${key} as maximum value length (${maxLength}) is reached!`,
         logType: LogType_1.LogType.Warning,

package/lib/features/ui-interaction/IUserInteractionEvent.js

@@ -8,7 +8,7 @@ var UserInteractionEventKey;
     UserInteractionEventKey["UiElementComponents"] = "ui_element.components";
     UserInteractionEventKey["UiElementId"] = "ui_element.id";
     UserInteractionEventKey["UiElementNameOrigin"] = "ui_element.name_origin";
-    UserInteractionEventKey["InteractionName"] = "interaction.name";
+    UserInteractionEventKey["InteractionType"] = "interaction.type";
     UserInteractionEventKey["UiElementResponderDetectedName"] = "ui_element.responder.detected_name";
     UserInteractionEventKey["UiElementResponderComponents"] = "ui_element.responder.components";
     UserInteractionEventKey["UiElementResponderOriginName"] = "ui_element.responder.name_origin";

package/lib/features/ui-interaction/Runtime.js

@@ -330,7 +330,7 @@ function _an_flat(e) {
         [IUserInteractionEvent_1.UserInteractionEventKey.UiElementDetectedName]: (_c = (_b = e === null || e === void 0 ? void 0 : e.ui_element) === null || _b === void 0 ? void 0 : _b.detected_name) !== null && _c !== void 0 ? _c : null,
         [IUserInteractionEvent_1.UserInteractionEventKey.UiElementComponents]: normalizedUiComponents,
         [IUserInteractionEvent_1.UserInteractionEventKey.UiElementId]: (_e = (_d = e === null || e === void 0 ? void 0 : e.ui_element) === null || _d === void 0 ? void 0 : _d.id) !== null && _e !== void 0 ? _e : null,
-        [IUserInteractionEvent_1.UserInteractionEventKey.InteractionName]: _an_interaction_type(e),
+        [IUserInteractionEvent_1.UserInteractionEventKey.InteractionType]: _an_interaction_type(e),
         positions: Array.isArray(e === null || e === void 0 ? void 0 : e.positions)
             ? e.positions.map((pos) => ({
                 x: Math.trunc(pos.x),

package/lib/next/Dynatrace.js

@@ -14,6 +14,8 @@ const EventData_1 = require("./events/EventData");
 const SessionPropertyEventData_1 = require("./events/SessionPropertyEventData");
 const ExceptionEventData_1 = require("./events/ExceptionEventData");
 const HttpRequestEventData_1 = require("./events/HttpRequestEventData");
+const NullUserAction_1 = require("./userAction/NullUserAction");
+const UserActionImpl_1 = require("./userAction/UserActionImpl");
 const DynatraceArgValidators_1 = require("./DynatraceArgValidators");
 const TraceContextUtils_1 = require("./util/TraceContextUtils");
 const DECISION_REASON_TEXT = {
@@ -169,12 +171,14 @@ class DynatraceImpl {
         let parsedTraceparent = traceparent === undefined
             ? undefined
             : (0, TraceContextUtils_1.parseTraceparent)(traceparent);
+        let traceparentFromDynatrace = false;
         if (parsedTraceparent === undefined) {
             traceparent = (0, TraceContextUtils_1.generateTraceparentHeader)();
             parsedTraceparent = (0, TraceContextUtils_1.parseTraceparent)(traceparent);
             tracestate = undefined;
+            traceparentFromDynatrace = true;
         }
-        tracestate = (0, TraceContextUtils_1.generateTracestate)(parsedTraceparent.parentId, tracestate);
+        tracestate = (0, TraceContextUtils_1.generateTracestate)(parsedTraceparent.parentId, traceparentFromDynatrace, tracestate);
         if (tracestate === undefined) {
             this.logger.info(LogMessages_1.LogMessage.TRACE_CONTEXT_DISABLED_OR_INVALID, {
                 existingTraceparent: existingTraceparent !== null && existingTraceparent !== void 0 ? existingTraceparent : 'undefined',
@@ -187,5 +191,26 @@ class DynatraceImpl {
             tracestate,
         };
     }
+    createUserAction(configuration) {
+        if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
+            this.logger.info(LogMessages_1.LogMessage.CREATE_USER_ACTION_NOT_STARTED);
+            return new NullUserAction_1.NullUserAction();
+        }
+        this.logger.debug(LogMessages_1.LogMessage.CREATE_USER_ACTION, {
+            customName: configuration.customName,
+            completeAutomatically: configuration.completeAutomatically,
+        });
+        return new UserActionImpl_1.UserActionImpl(configuration);
+    }
+    setAutomaticUserActionDetection(enabled) {
+        if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
+            this.logger.info(LogMessages_1.LogMessage.SET_AUTOMATIC_USER_ACTION_DETECTION_NOT_STARTED);
+            return;
+        }
+        this.logger.debug(LogMessages_1.LogMessage.SET_AUTOMATIC_USER_ACTION_DETECTION, {
+            enabled,
+        });
+        DynatraceBridge_1.DynatraceNative.setAutomaticUserActionDetection(enabled);
+    }
 }
 exports.Dynatrace = new DynatraceImpl(TimestampProvider_1.defaultTimestampProvider);