@dynatrace/react-native-plugin 2.331.1 → 2.335.1

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

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTouchElementMeta = void 0;
+class TouchMetaResolver {
+    constructor(config) {
+        this.rootWrapperLikePatterns = [
+            /Animated/,
+            /Controller/,
+            /Detector/,
+            /NativeComponent/,
+            /Wrapper/,
+            /Clipping/,
+        ];
+        this.genericContainerCodeTagNames = new Set([
+            'View',
+            'Background',
+            'Drawer',
+            'DrawerView',
+            'DrawerViewBase',
+            'Freeze',
+            'DelayedFreeze',
+            'Suspender',
+            'MaybeScreen',
+            'MaybeScreenContainer',
+            'Screen',
+            'ScreenContainer',
+            'RNSScreen',
+            'RNSScreenContainer',
+            'GestureHandlerRootView',
+            'RNGestureHandlerRootView',
+            'PanGestureHandler',
+        ]);
+        this.internalCodeTagExactNames = new Set([
+            'main(RootComponent)',
+            'PerformanceLoggerContext',
+            'RootTagContext',
+            'Wrapped',
+            'AnalyticsRoot',
+        ]);
+        this.uselessWrapperCodeTagExactNames = new Set([
+            'DynatraceFunctionalComponent',
+            'DynatraceClassComponent',
+            'NavigationContainer',
+            'BaseNavigationContainer',
+            'Navigator',
+            'DrawerNavigator',
+            'SafeAreaProviderCompat',
+            'Handler',
+            'AnimatedComponent',
+            'Component',
+            'ScreenNavigationContainer',
+            'ScreenWrapper',
+            'Suspense',
+            'AnimatedScreen',
+            'ScreenComponent',
+            'KeyboardControllerViewAnimated',
+        ]);
+        this.internalCodeTagPatterns = [
+            /Context$/,
+            /Provider$/,
+            /^Route(?:\(|$)/,
+            /^Animated(?:Component)?\(.+\)$/,
+            /^Anonymous$/,
+            /NavigationContent/,
+            /NavigationStateListenerProvider/,
+            /PreventRemoveProvider/,
+            /EnsureSingleNavigator/,
+            /SceneView/,
+            /StaticContainer/,
+            /GestureHandler/,
+            /expo-router\/build\//,
+        ];
+        this.pressHandlers = [
+            'onPress',
+            'onLongPress',
+            'onPressIn',
+            'onPressOut',
+        ];
+        this.config = Object.assign({ filterInternalCodeTags: true }, config);
+    }
+    resolve(event) {
+        var _a, _b, _c, _d;
+        try {
+            const raw = event;
+            const targetInst = (_a = raw._targetInst) !== null && _a !== void 0 ? _a : (_b = raw.nativeEvent) === null || _b === void 0 ? void 0 : _b._targetInst;
+            const touchElementName = (_c = this.getNodeName(targetInst)) !== null && _c !== void 0 ? _c : 'unknown';
+            const touchPath = this.buildAppCodeTagPathFromNode(targetInst !== null && targetInst !== void 0 ? targetInst : null);
+            const pressNode = this.findPressNode(targetInst !== null && targetInst !== void 0 ? targetInst : null);
+            const press = pressNode === null
+                ? null
+                : {
+                    elementName: (_d = this.getNodeName(pressNode)) !== null && _d !== void 0 ? _d : 'unknown',
+                    appCodeTagPath: this.buildAppCodeTagPathFromNode(pressNode),
+                    isParent: Boolean(pressNode !== targetInst),
+                };
+            return {
+                touch: {
+                    elementName: touchElementName,
+                    appCodeTagPath: touchPath,
+                },
+                press,
+            };
+        }
+        catch (_e) {
+            return {
+                touch: { elementName: 'unknown', appCodeTagPath: 'unknown' },
+                press: null,
+            };
+        }
+    }
+    buildAppCodeTagPathFromNode(node) {
+        var _a;
+        if (node === null) {
+            return 'unknown';
+        }
+        const targetToRootCodeTags = [];
+        let pathCursor = node;
+        while (pathCursor !== null) {
+            const codeTagSegment = this.getNodeCodeTagSegment(pathCursor);
+            if (codeTagSegment !== null) {
+                targetToRootCodeTags.push(codeTagSegment);
+            }
+            pathCursor = (_a = pathCursor.return) !== null && _a !== void 0 ? _a : null;
+        }
+        const normalizedCodeTags = this.collapseConsecutiveDuplicates(targetToRootCodeTags);
+        const rootToTargetCodeTags = [...normalizedCodeTags].reverse();
+        const appRootTrimmedCodeTags = this.trimToAppRoot(rootToTargetCodeTags);
+        const uiRootTrimmedCodeTags = this.trimToUiRootAnchor(appRootTrimmedCodeTags);
+        const dtPathPreferredCodeTags = this.preferDtPathCodeTags(uiRootTrimmedCodeTags);
+        const dtPathPreferredCodeTagNames = dtPathPreferredCodeTags.map((segment) => segment.name);
+        const trimmedRootToTargetCodeTags = this.trimFrameworkPrefix(dtPathPreferredCodeTagNames);
+        const filteredRootToTargetCodeTags = this.config.filterInternalCodeTags
+            ? this.filterAppCodeTags(trimmedRootToTargetCodeTags)
+            : trimmedRootToTargetCodeTags;
+        const dedupedFilteredRootToTargetCodeTags = this.collapseConsecutiveDuplicateNames(filteredRootToTargetCodeTags);
+        let appRootToTargetCodeTags = ['unknown'];
+        if (dedupedFilteredRootToTargetCodeTags.length > 0) {
+            appRootToTargetCodeTags = dedupedFilteredRootToTargetCodeTags;
+        }
+        else if (trimmedRootToTargetCodeTags.length > 0) {
+            appRootToTargetCodeTags = trimmedRootToTargetCodeTags;
+        }
+        return appRootToTargetCodeTags.join('/') || 'unknown';
+    }
+    getNodeName(node) {
+        var _a, _b;
+        if (node === null || node === undefined) {
+            return null;
+        }
+        const props = (_a = node.memoizedProps) !== null && _a !== void 0 ? _a : {};
+        const dtName = props.dtName;
+        if (typeof dtName === 'string' && dtName.trim().length > 0) {
+            return dtName.trim();
+        }
+        const testId = props.testID;
+        if (typeof testId === 'string' && testId.trim().length > 0) {
+            return testId;
+        }
+        const accessibilityLabel = props.accessibilityLabel;
+        if (typeof accessibilityLabel === 'string' &&
+            accessibilityLabel.trim().length > 0) {
+            return accessibilityLabel;
+        }
+        const dtPathIdName = this.getCodeTagNameFromDtPathId(props);
+        if (dtPathIdName !== null) {
+            return dtPathIdName;
+        }
+        const codeTagName = this.getNodeCodeTagName(node);
+        const isTextLike = codeTagName === 'Text' || codeTagName === 'RCTText';
+        const shouldReadChildrenText = isTextLike || this.hasPressHandler(props);
+        if (shouldReadChildrenText) {
+            const childText = this.extractTextFromChildren(props.children);
+            if (childText !== null) {
+                return childText;
+            }
+        }
+        return ((_b = this.getComponentTypeName(node.elementType)) !== null && _b !== void 0 ? _b : this.getComponentTypeName(node.type));
+    }
+    findPressNode(startNode) {
+        var _a;
+        let cursor = startNode;
+        while (cursor !== null) {
+            if (this.hasPressHandler(cursor.memoizedProps)) {
+                return cursor;
+            }
+            cursor = (_a = cursor.return) !== null && _a !== void 0 ? _a : null;
+        }
+        return null;
+    }
+    collapseConsecutiveDuplicates(items) {
+        const result = [];
+        for (const item of items) {
+            const previous = result.at(-1);
+            if (previous === undefined || previous.name !== item.name) {
+                result.push(item);
+                continue;
+            }
+            if (item.fromDtPathId && !previous.fromDtPathId) {
+                previous.fromDtPathId = true;
+            }
+            if (item.isUiRoot && !previous.isUiRoot) {
+                previous.isUiRoot = true;
+            }
+        }
+        return result;
+    }
+    trimToUiRootAnchor(rootToTargetCodeTags) {
+        if (rootToTargetCodeTags.length === 0) {
+            return rootToTargetCodeTags;
+        }
+        let uiRootIndex = -1;
+        for (let i = rootToTargetCodeTags.length - 1; i >= 0; i--) {
+            if (rootToTargetCodeTags[i].isUiRoot) {
+                uiRootIndex = i;
+                break;
+            }
+        }
+        if (uiRootIndex < 0) {
+            return rootToTargetCodeTags;
+        }
+        return rootToTargetCodeTags.slice(uiRootIndex);
+    }
+    trimToAppRoot(rootToTargetCodeTags) {
+        if (rootToTargetCodeTags.length === 0) {
+            return rootToTargetCodeTags;
+        }
+        let start = 0;
+        const analyticsRootIndex = rootToTargetCodeTags.findIndex((segment) => segment.name === 'AnalyticsRoot');
+        if (analyticsRootIndex < 0) {
+            return [];
+        }
+        start = analyticsRootIndex + 1;
+        const enforceStableRootSignal = rootToTargetCodeTags
+            .slice(start)
+            .some((segment) => segment.fromDtPathId || segment.isUiRoot);
+        while (start < rootToTargetCodeTags.length - 1) {
+            const segment = rootToTargetCodeTags[start];
+            const name = segment.name;
+            const isProviderLike = /Provider(?:Compat)?$/.test(name);
+            const isBlacklistedStart = this.shouldDropCodeTagName(name, false);
+            const hasStableRootSignal = segment.fromDtPathId || segment.isUiRoot;
+            const shouldSkipByRootRule = enforceStableRootSignal && !hasStableRootSignal;
+            const isLikelyWrapperRoot = !hasStableRootSignal &&
+                this.rootWrapperLikePatterns.some((pattern) => pattern.test(name));
+            if (!isProviderLike &&
+                !isBlacklistedStart &&
+                !shouldSkipByRootRule &&
+                !isLikelyWrapperRoot) {
+                break;
+            }
+            start += 1;
+        }
+        return rootToTargetCodeTags.slice(start);
+    }
+    collapseConsecutiveDuplicateNames(items) {
+        const result = [];
+        for (const item of items) {
+            if (result.at(-1) !== item) {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    preferDtPathCodeTags(rootToTargetCodeTags) {
+        if (rootToTargetCodeTags.length === 0) {
+            return rootToTargetCodeTags;
+        }
+        const firstDtPathIndex = rootToTargetCodeTags.findIndex((segment) => segment.fromDtPathId);
+        if (firstDtPathIndex < 0) {
+            return rootToTargetCodeTags;
+        }
+        const fromFirstDtPath = rootToTargetCodeTags.slice(firstDtPathIndex);
+        return fromFirstDtPath.filter((segment, index) => {
+            if (segment.fromDtPathId) {
+                return true;
+            }
+            const isLeaf = index === fromFirstDtPath.length - 1;
+            return !this.shouldDropCodeTagName(segment.name, isLeaf);
+        });
+    }
+    isInternalCodeTagName(name) {
+        if (this.internalCodeTagExactNames.has(name)) {
+            return true;
+        }
+        return this.internalCodeTagPatterns.some((pattern) => pattern.test(name));
+    }
+    shouldDropCodeTagName(name, isLeaf) {
+        if (name.trim().length === 0) {
+            return true;
+        }
+        if (!isLeaf && this.uselessWrapperCodeTagExactNames.has(name)) {
+            return true;
+        }
+        if (this.isInternalCodeTagName(name)) {
+            return true;
+        }
+        if (!isLeaf && this.genericContainerCodeTagNames.has(name)) {
+            return true;
+        }
+        return false;
+    }
+    filterAppCodeTags(rootToTargetTags) {
+        return rootToTargetTags.filter((name, index) => {
+            const isLeaf = index === rootToTargetTags.length - 1;
+            return !this.shouldDropCodeTagName(name, isLeaf);
+        });
+    }
+    hasPressHandler(props) {
+        if (props === null || props === undefined) {
+            return false;
+        }
+        for (const key of this.pressHandlers) {
+            if (typeof props[key] === 'function') {
+                return true;
+            }
+        }
+        return false;
+    }
+    trimFrameworkPrefix(rootToTargetTags) {
+        if (rootToTargetTags.length === 0) {
+            return rootToTargetTags;
+        }
+        let indexRouteMarker = -1;
+        for (let i = rootToTargetTags.length - 1; i >= 0; i--) {
+            if (rootToTargetTags[i] === 'Index' ||
+                rootToTargetTags[i].startsWith('Index(')) {
+                indexRouteMarker = i;
+                break;
+            }
+        }
+        if (indexRouteMarker >= 0 &&
+            indexRouteMarker < rootToTargetTags.length - 1) {
+            return rootToTargetTags.slice(indexRouteMarker + 1);
+        }
+        const touchCaptureIndex = rootToTargetTags.lastIndexOf('TouchCapture');
+        if (touchCaptureIndex >= 0 &&
+            touchCaptureIndex < rootToTargetTags.length - 1) {
+            return rootToTargetTags.slice(touchCaptureIndex + 1);
+        }
+        return rootToTargetTags;
+    }
+    extractTextFromChildren(children, maxDepth = 5) {
+        var _a;
+        if (maxDepth <= 0) {
+            return null;
+        }
+        if (typeof children === 'string' || typeof children === 'number') {
+            const str = String(children).trim();
+            return str.length > 0 ? str : null;
+        }
+        if (Array.isArray(children)) {
+            for (const child of children) {
+                const text = this.extractTextFromChildren(child, maxDepth - 1);
+                if (text !== null) {
+                    return text;
+                }
+            }
+        }
+        if (typeof children === 'object' &&
+            children !== null &&
+            'props' in children &&
+            typeof children.props === 'object') {
+            const nestedChildren = (_a = children.props) === null || _a === void 0 ? void 0 : _a.children;
+            return this.extractTextFromChildren(nestedChildren, maxDepth - 1);
+        }
+        return null;
+    }
+    getCodeTagNameFromDtPathId(props) {
+        if (props === null || props === undefined) {
+            return null;
+        }
+        const rawDtPathId = props.dtPathID;
+        if (typeof rawDtPathId !== 'string') {
+            return null;
+        }
+        const trimmedDtPathId = rawDtPathId.trim();
+        if (trimmedDtPathId.length === 0) {
+            return null;
+        }
+        const strippedSuffix = trimmedDtPathId.replace(/_\d+_\d+$/, '');
+        const normalizedName = this.normalizeCodeTagName(strippedSuffix);
+        return normalizedName;
+    }
+    hasUiRootMarker(props) {
+        if (props === null || props === undefined) {
+            return false;
+        }
+        const rawUiRoot = props.dtUIRoot;
+        if (rawUiRoot === null || rawUiRoot === undefined) {
+            return false;
+        }
+        if (typeof rawUiRoot === 'boolean') {
+            return rawUiRoot;
+        }
+        if (typeof rawUiRoot === 'string') {
+            const normalized = rawUiRoot.trim().toLowerCase();
+            return normalized.length > 0 && normalized !== 'false';
+        }
+        return true;
+    }
+    getComponentTypeName(value) {
+        var _a, _b, _c, _d;
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'function') {
+            return ((_b = (_a = value
+                .displayName) !== null && _a !== void 0 ? _a : value.name) !== null && _b !== void 0 ? _b : null);
+        }
+        if (typeof value === 'object') {
+            const objectValue = value;
+            return (_d = (_c = objectValue.displayName) !== null && _c !== void 0 ? _c : objectValue.name) !== null && _d !== void 0 ? _d : null;
+        }
+        return null;
+    }
+    normalizeCodeTagName(name) {
+        if (name === null) {
+            return null;
+        }
+        const trimmedName = name.trim();
+        if (trimmedName.length === 0) {
+            return null;
+        }
+        if (trimmedName === 'RCTView' ||
+            trimmedName === 'RNView' ||
+            trimmedName === 'View') {
+            return 'View';
+        }
+        if (trimmedName === 'RCTText' ||
+            trimmedName === 'RNText' ||
+            trimmedName === 'Text') {
+            return 'Text';
+        }
+        if (trimmedName === 'RCTScrollView' || trimmedName === 'ScrollView') {
+            return 'ScrollView';
+        }
+        if (trimmedName === 'VirtualizedList') {
+            return 'FlatList';
+        }
+        return trimmedName;
+    }
+    getNodeCodeTagName(node) {
+        var _a, _b;
+        return (_b = (_a = this.getNodeCodeTagSegment(node)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null;
+    }
+    getNodeCodeTagSegment(node) {
+        var _a, _b;
+        if (node === null || node === undefined) {
+            return null;
+        }
+        const isUiRoot = this.hasUiRootMarker(node.memoizedProps);
+        const fromDtPathId = this.getCodeTagNameFromDtPathId(node.memoizedProps);
+        if (fromDtPathId !== null) {
+            return {
+                name: fromDtPathId,
+                fromDtPathId: true,
+                isUiRoot,
+            };
+        }
+        const dtInfoName = (_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a._dtInfo) === null || _b === void 0 ? void 0 : _b.name;
+        if (typeof dtInfoName === 'string' && dtInfoName.trim().length > 0) {
+            return {
+                name: dtInfoName.trim(),
+                fromDtPathId: false,
+                isUiRoot,
+            };
+        }
+        const fromElementType = this.normalizeCodeTagName(this.getComponentTypeName(node.elementType));
+        if (fromElementType !== null) {
+            return {
+                name: fromElementType,
+                fromDtPathId: false,
+                isUiRoot,
+            };
+        }
+        const fromType = this.normalizeCodeTagName(this.getComponentTypeName(node.type));
+        if (fromType !== null) {
+            return {
+                name: fromType,
+                fromDtPathId: false,
+                isUiRoot,
+            };
+        }
+        return null;
+    }
+}
+const resolver = new TouchMetaResolver();
+const getTouchElementMeta = (event) => resolver.resolve(event);
+exports.getTouchElementMeta = getTouchElementMeta;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Literals = void 0;
+exports.Literals = {
+    ReactFragmentFQN: 'React.Fragment',
+    NavigatorProp: 'Navigator',
+    PluginName: 'dt-user-interaction',
+    LogTag: '[dt] instrumented:',
+    RawHandlerTag: '[DT raw] handler',
+    KeySuffixPrefix: '~dt@',
+    DefaultRuntimeImport: '@dynatrace/react-native-plugin/lib/features/ui-interaction/Runtime',
+    DefaultArtifactsDir: 'node_modules/@dynatrace/react-native-plugin/build/ui_instrumented',
+    DefaultRootName: 'AnalyticsRoot',
+};

package/lib/next/Dynatrace.js

@@ -38,7 +38,7 @@ class DynatraceImpl {
     }
     startView(name) {
         if (typeof name !== 'string') {
-            this.logger.info(`startView(name): Name must be a string!`);
+            this.logger.info('startView(name): Name must be a string!');
             return;
         }
         this.logger.debug(`startView(${name})`);

package/lib/next/configuration/INativeRuntimeConfiguration.js

@@ -3,5 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDefaultConfiguration = void 0;
 const generateDefaultConfiguration = () => ({
     '3rd_gen_enabled': true,
+    touch_interaction_enabled: false,
 });
 exports.generateDefaultConfiguration = generateDefaultConfiguration;

package/lib/next/configuration/RuntimeConfigurationObserver.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeConfigurationObserver = void 0;
+const react_native_1 = require("react-native");
 const DynatraceBridge_1 = require("../../core/DynatraceBridge");
-const DynatraceEventBus_1 = require("../DynatraceEventBus");
 const INativeRuntimeConfiguration_1 = require("./INativeRuntimeConfiguration");
 class RuntimeConfigurationObserverImpl {
     constructor() {
@@ -12,25 +12,60 @@ class RuntimeConfigurationObserverImpl {
         this.subscription = null;
         this.setupNativeEventEmitter();
     }
+    call() {
+    }
     getCurrentRuntimeConfiguration() {
         return this.runtimeConfiguration;
     }
     isInitiated() {
         return this.observerIsInitiated;
     }
+    updateRuntimeConfiguration(data) {
+        if (!data || typeof data !== 'object') {
+            return;
+        }
+        const payload = data;
+        const thirdGenEnabled = typeof payload['3rd_gen_enabled'] === 'boolean'
+            ? payload['3rd_gen_enabled']
+            : undefined;
+        const touchInteractionEnabled = typeof payload.touch_interaction_enabled === 'boolean'
+            ? payload.touch_interaction_enabled
+            : undefined;
+        const normalized = Object.assign(Object.assign({}, (typeof thirdGenEnabled === 'boolean'
+            ? { '3rd_gen_enabled': thirdGenEnabled }
+            : {})), (typeof touchInteractionEnabled === 'boolean'
+            ? { touch_interaction_enabled: touchInteractionEnabled }
+            : {}));
+        this.runtimeConfiguration = Object.assign(Object.assign({}, (0, INativeRuntimeConfiguration_1.generateDefaultConfiguration)()), normalized);
+        this.observerIsInitiated = true;
+    }
+    resolveBridgeModule() {
+        const dynatraceModule = DynatraceBridge_1.DynatraceNative;
+        const hasDynatraceBridgeAPI = !!dynatraceModule &&
+            (typeof dynatraceModule.addListener === 'function' ||
+                typeof dynatraceModule.getCurrentConfiguration === 'function');
+        if (hasDynatraceBridgeAPI) {
+            return dynatraceModule;
+        }
+        return react_native_1.NativeModules.DynatraceBridge;
+    }
     setupNativeEventEmitter() {
-        const emitter = (0, DynatraceEventBus_1.createEmitterRuntimeConfig)();
-        this.subscription = (0, DynatraceEventBus_1.addListenerOnce)(emitter, this.subscription, this.EMIT_CONFIGURATION, (data) => {
-            this.runtimeConfiguration = data;
-            this.observerIsInitiated = true;
-        });
-        if (typeof DynatraceBridge_1.DynatraceNative.getCurrentConfiguration === 'function') {
-            Promise.resolve(DynatraceBridge_1.DynatraceNative.getCurrentConfiguration())
+        const bridgeModule = this.resolveBridgeModule();
+        if (!bridgeModule) {
+            return;
+        }
+        const iosModule = react_native_1.NativeModules.DynatraceBridge;
+        const nativeEmitterModule = react_native_1.Platform.OS === 'ios' ? iosModule || bridgeModule : bridgeModule;
+        const emitter = new react_native_1.NativeEventEmitter(nativeEmitterModule);
+        if (this.subscription == null) {
+            this.subscription = emitter.addListener(this.EMIT_CONFIGURATION, (data) => {
+                this.updateRuntimeConfiguration(data);
+            });
+        }
+        if (typeof bridgeModule.getCurrentConfiguration === 'function') {
+            Promise.resolve(bridgeModule.getCurrentConfiguration())
                 .then((data) => {
-                if (data) {
-                    this.runtimeConfiguration = data;
-                    this.observerIsInitiated = true;
-                }
+                this.updateRuntimeConfiguration(data);
             })
                 .catch(() => {
             });

package/lib/next/events/EventPipeline.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventPipeline = void 0;
 const DynatraceBridge_1 = require("../../core/DynatraceBridge");
 const ConsoleLogger_1 = require("../../core/logging/ConsoleLogger");
+const ConfigurationHandler_1 = require("../../core/configuration/ConfigurationHandler");
 const BaseDataEventModifier_1 = require("./modifier/BaseDataEventModifier");
 const ValueRestrictionModifier_1 = require("./modifier/ValueRestrictionModifier");
 const ModifyEventValidation_1 = require("./modifier/ModifyEventValidation");
@@ -24,6 +25,14 @@ class EventPipelineImpl {
         ];
     }
     insertEvent(event) {
+        if (!ConfigurationHandler_1.ConfigurationHandler.isRuntimeConfigurationInitiated()) {
+            this.logger.debug('isRuntimeConfigurationInitiated is not enabled! App start event will be discarded!');
+            return;
+        }
+        if (!ConfigurationHandler_1.ConfigurationHandler.isGrailEnabled()) {
+            this.logger.debug('RUM on Grail is not enabled! App start event will be discarded!');
+            return;
+        }
         this.logger.debug(`insertEvent(${JSON.stringify(event)})`);
         let isDiscarded = false;
         for (const modifier of this.getEventModifierChain()) {