@dynatrace/react-native-plugin 2.321.2 → 2.323.2

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

@@ -1,51 +1,12 @@
 "use strict";
-var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pressable = exports.Text = exports.TouchableWithoutFeedback = exports.TouchableNativeFeedback = exports.TouchableHighlight = exports.TouchableOpacity = exports.Button = void 0;
 const ReactNative = require("react-native");
-const React = require("react");
-const Types_1 = require("../../model/Types");
-exports.Button = React.forwardRef((props, ref) => (React.createElement(ReactNative.Button, Object.assign({ title: props.title }, props, { ref: ref }))));
-exports.Button._dtInfo = { type: Types_1.Types.Button };
-if (typeof ReactNative.TouchableOpacity === 'object') {
-    exports.TouchableOpacity = Object.assign({ _dtInfo: { type: Types_1.Types.TouchableOpacity } }, ReactNative.TouchableOpacity);
-}
-else {
-    exports.TouchableOpacity = (_a = class TouchableOpacity extends (ReactNative.TouchableOpacity) {
-        },
-        _a._dtInfo = { type: Types_1.Types.TouchableOpacity },
-        _a);
-}
-if (typeof ReactNative.TouchableHighlight === 'object') {
-    exports.TouchableHighlight = Object.assign({ _dtInfo: { type: Types_1.Types.TouchableHighlight } }, ReactNative.TouchableHighlight);
-}
-else {
-    exports.TouchableHighlight = (_b = class TouchableHighlight extends (ReactNative.TouchableHighlight) {
-        },
-        _b._dtInfo = { type: Types_1.Types.TouchableHighlight },
-        _b);
-}
-if (typeof ReactNative.TouchableNativeFeedback === 'object') {
-    exports.TouchableNativeFeedback = Object.assign({ _dtInfo: { type: Types_1.Types.TouchableNativeFeedback } }, ReactNative.TouchableNativeFeedback);
-}
-else {
-    exports.TouchableNativeFeedback = (_c = class TouchableNativeFeedback extends (ReactNative.TouchableNativeFeedback) {
-        },
-        _c._dtInfo = { type: Types_1.Types.TouchableNativeFeedback },
-        _c);
-}
-exports.TouchableWithoutFeedback = React.forwardRef((props, ref) => (React.createElement(ReactNative.TouchableWithoutFeedback, Object.assign({}, props, { ref: ref }))));
-exports.TouchableWithoutFeedback._dtInfo = {
-    type: Types_1.Types.TouchableWithoutFeedback,
-};
-if (typeof ReactNative.Text === 'object') {
-    exports.Text = Object.assign({ _dtInfo: { type: Types_1.Types.Text } }, ReactNative.Text);
-}
-else {
-    exports.Text = (_d = class Text extends ReactNative.Text {
-        },
-        _d._dtInfo = { type: Types_1.Types.Text },
-        _d);
-}
-exports.Pressable = React.forwardRef((props, ref) => (React.createElement(ReactNative.Pressable, Object.assign({}, props, { ref: ref }))));
-exports.Pressable._dtInfo = { type: Types_1.Types.Pressable };
+const withOnPressMonitoring_1 = require("../withOnPressMonitoring");
+exports.Button = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.Button, 'Button');
+exports.TouchableOpacity = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.TouchableOpacity, 'Touchable');
+exports.TouchableHighlight = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.TouchableHighlight, 'Touchable');
+exports.TouchableNativeFeedback = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.TouchableNativeFeedback, 'Touchable');
+exports.TouchableWithoutFeedback = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.TouchableWithoutFeedback, 'Touchable');
+exports.Text = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.Text, 'Text');
+exports.Pressable = (0, withOnPressMonitoring_1.withOnPressMonitoring)(ReactNative.Pressable, 'Pressable');

package/instrumentation/libs/withOnPressMonitoring.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTouchableName = exports.chooseTouchableName = exports.wrapOnPress = exports.withOnPressMonitoring = void 0;
+const ReactNative = require("react-native");
+const React = require("react");
+const ConsoleLogger_1 = require("../../lib/core/logging/ConsoleLogger");
+const ConfigurationHandler_1 = require("../../lib/core/configuration/ConfigurationHandler");
+const Dynatrace_1 = require("../../lib/core/Dynatrace");
+const ComponentUtil_1 = require("../jsx/components/ComponentUtil");
+const Logger = new ConsoleLogger_1.ConsoleLogger('TouchableHelper');
+function withOnPressMonitoring(Component, fallbackName) {
+    return React.forwardRef((props, ref) => {
+        const { onPress, onLongPress } = props;
+        const touchableName = (0, exports.chooseTouchableName)(props, fallbackName);
+        const dynatraceIgnored = (0, ComponentUtil_1.isDynatraceIgnored)(props);
+        const propsWithoutRef = Object.assign(Object.assign(Object.assign({}, props), (!dynatraceIgnored &&
+            onPress && {
+            onPress: (0, exports.wrapOnPress)(onPress, touchableName),
+        })), (!dynatraceIgnored &&
+            onLongPress && {
+            onLongPress: (0, exports.wrapOnPress)(onLongPress, touchableName),
+        }));
+        const propsWithRef = Object.assign(Object.assign({}, propsWithoutRef), { ref });
+        return React.createElement(Component, Object.assign({}, propsWithRef));
+    });
+}
+exports.withOnPressMonitoring = withOnPressMonitoring;
+const wrapOnPress = (onPress, touchableName) => {
+    return (...args) => {
+        if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
+            Logger.info('React Native plugin has not been started yet! Touch will not be reported!');
+            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();
+                }
+            }
+        }
+    };
+};
+exports.wrapOnPress = wrapOnPress;
+const chooseTouchableName = (props, fallbackName) => {
+    if (props.dtActionName) {
+        return props.dtActionName;
+    }
+    if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable() &&
+        ConfigurationHandler_1.ConfigurationHandler.isActionNamePrivacyEnabled()) {
+        return fallbackName;
+    }
+    return (0, exports.findTouchableName)(props) || fallbackName;
+};
+exports.chooseTouchableName = chooseTouchableName;
+const findTouchableName = (props) => {
+    if ('title' in props) {
+        return props.title;
+    }
+    if (props.accessibilityLabel !== undefined) {
+        return props.accessibilityLabel;
+    }
+    if (typeof props.children === 'function') {
+        return null;
+    }
+    return findTouchableNameRecursive(props.children);
+};
+exports.findTouchableName = findTouchableName;
+function findTouchableNameRecursive(node) {
+    if (typeof node === 'string') {
+        return node;
+    }
+    if (isReactNodeIterable(node)) {
+        for (const child of node) {
+            const result = findTouchableNameRecursive(child);
+            if (result !== null)
+                return result;
+        }
+    }
+    if (React.isValidElement(node)) {
+        if (isReactNativeImage(node)) {
+            const uri = getUriFromSource(node.props.source);
+            return uri ? 'Image Button: ' + uri : 'Image Button';
+        }
+        if (isCustomIcon(node)) {
+            return node.props.name;
+        }
+        if (hasReactNodeChildren(node))
+            return findTouchableNameRecursive(node.props.children);
+    }
+    return null;
+}
+function getUriFromSource(source) {
+    if (typeof source === 'object' &&
+        'uri' in source &&
+        source.uri !== undefined) {
+        return source.uri;
+    }
+    return null;
+}
+const isReactNodeIterable = (node) => typeof node === 'object' && node !== null && Symbol.iterator in node;
+const isReactNativeImage = (element) => element.type === ReactNative.Image;
+const isCustomIcon = (element) => typeof element.type === 'function' &&
+    element.type.name === 'Icon' &&
+    typeof element.props === 'object' &&
+    element.props !== null &&
+    'name' in element.props &&
+    typeof element.props.name === 'string';
+const hasReactNodeChildren = (element) => typeof element.props === 'object' &&
+    element.props !== null &&
+    'children' in element.props;

package/instrumentation/model/Types.js

@@ -5,19 +5,7 @@ var Types;
 (function (Types) {
     Types[Types["FunctionalComponent"] = 0] = "FunctionalComponent";
     Types[Types["ClassComponent"] = 1] = "ClassComponent";
-    Types[Types["Button"] = 2] = "Button";
-    Types[Types["TouchableOpacity"] = 3] = "TouchableOpacity";
-    Types[Types["TouchableHighlight"] = 4] = "TouchableHighlight";
-    Types[Types["TouchableNativeFeedback"] = 5] = "TouchableNativeFeedback";
-    Types[Types["TouchableWithoutFeedback"] = 6] = "TouchableWithoutFeedback";
-    Types[Types["Text"] = 7] = "Text";
-    Types[Types["Picker"] = 8] = "Picker";
-    Types[Types["Pressable"] = 9] = "Pressable";
-    Types[Types["TouchableOpacityGestureHandler"] = 10] = "TouchableOpacityGestureHandler";
-    Types[Types["TouchableHighlightGestureHandler"] = 11] = "TouchableHighlightGestureHandler";
-    Types[Types["TouchableNativeFeedbackGestureHandler"] = 12] = "TouchableNativeFeedbackGestureHandler";
-    Types[Types["TouchableWithoutFeedbackGestureHandler"] = 13] = "TouchableWithoutFeedbackGestureHandler";
-    Types[Types["RectButtonGestureHandler"] = 14] = "RectButtonGestureHandler";
-    Types[Types["RefreshControl"] = 15] = "RefreshControl";
-    Types[Types["Switch"] = 16] = "Switch";
+    Types[Types["Picker"] = 2] = "Picker";
+    Types[Types["RefreshControl"] = 3] = "RefreshControl";
+    Types[Types["Switch"] = 4] = "Switch";
 })(Types = exports.Types || (exports.Types = {}));

package/instrumentation/model/TypesUtil.js

@@ -1,48 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNameForType = exports.isTypeTouchable = exports.isTypeGestureHandlerTouchable = exports.isTypeReactNativeTouchable = void 0;
+exports.getNameForType = void 0;
 const Types_1 = require("./Types");
-const isTypeReactNativeTouchable = (type) => type === Types_1.Types.TouchableHighlight ||
-    type === Types_1.Types.TouchableNativeFeedback ||
-    type === Types_1.Types.TouchableOpacity ||
-    type === Types_1.Types.TouchableWithoutFeedback;
-exports.isTypeReactNativeTouchable = isTypeReactNativeTouchable;
-const isTypeGestureHandlerTouchable = (type) => type === Types_1.Types.TouchableHighlightGestureHandler ||
-    type === Types_1.Types.TouchableNativeFeedbackGestureHandler ||
-    type === Types_1.Types.TouchableOpacityGestureHandler ||
-    type === Types_1.Types.TouchableWithoutFeedbackGestureHandler ||
-    type === Types_1.Types.RectButtonGestureHandler;
-exports.isTypeGestureHandlerTouchable = isTypeGestureHandlerTouchable;
-const isTypeTouchable = (type) => (0, exports.isTypeGestureHandlerTouchable)(type) || (0, exports.isTypeReactNativeTouchable)(type);
-exports.isTypeTouchable = isTypeTouchable;
 const getNameForType = (type) => {
     switch (type) {
-        case Types_1.Types.Button:
-        case Types_1.Types.RectButtonGestureHandler:
-            return 'Button';
-        case Types_1.Types.Text:
-            return 'Text';
-        case Types_1.Types.TouchableHighlight:
-        case Types_1.Types.TouchableNativeFeedback:
-        case Types_1.Types.TouchableOpacity:
-        case Types_1.Types.TouchableWithoutFeedback:
-        case Types_1.Types.TouchableHighlightGestureHandler:
-        case Types_1.Types.TouchableNativeFeedbackGestureHandler:
-        case Types_1.Types.TouchableOpacityGestureHandler:
-        case Types_1.Types.TouchableWithoutFeedbackGestureHandler:
-            return 'Touchable';
-        case Types_1.Types.Pressable:
-            return 'Pressable';
+        case Types_1.Types.FunctionalComponent:
+            return 'Functional Component';
+        case Types_1.Types.ClassComponent:
+            return 'Class Component';
         case Types_1.Types.Picker:
             return 'Picker';
         case Types_1.Types.RefreshControl:
             return 'Refresh Control';
         case Types_1.Types.Switch:
             return 'Switch';
-        case Types_1.Types.ClassComponent:
-            return 'Class Component';
-        case Types_1.Types.FunctionalComponent:
-            return 'Functional Component';
         default:
             return 'Undefined';
     }

package/lib/core/Dynatrace.js

@@ -33,7 +33,7 @@ exports.Dynatrace = {
             if (configuration !== undefined) {
                 yield DynatraceBridge_1.DynatraceNative.start(configuration);
                 if (configuration.errorHandler) {
-                    (0, ErrorHandler_1.registerErrorHandler)(configuration.reportFatalErrorAsCrash);
+                    (0, ErrorHandler_1.startErrorHandler)(configuration.reportFatalErrorAsCrash);
                 }
                 else {
                     logger.debug('Dynatrace error handler will not be enabled as errorHandler was set to false!');
@@ -353,4 +353,7 @@ exports.Dynatrace = {
     sendExceptionEvent: (error, fields) => {
         Dynatrace_1.Dynatrace.sendExceptionEvent(error, fields);
     },
+    sendHttpRequestEvent(httpRequestEventBuilder) {
+        Dynatrace_1.Dynatrace.sendHttpRequestEvent(httpRequestEventBuilder);
+    },
 };

package/lib/core/ErrorHandler.js

@@ -1,56 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._reportErrorToDynatrace = exports.registerErrorHandler = void 0;
-const react_native_1 = require("react-native");
+exports.reportErrorToDynatrace = exports.startErrorHandler = void 0;
 const DynatraceInternal_1 = require("./DynatraceInternal");
 const Dynatrace_1 = require("./Dynatrace");
 const StringUtils_1 = require("./util/StringUtils");
 const ConsoleLogger_1 = require("./logging/ConsoleLogger");
-let _isReportFatalErrorAsCrash = true;
-const _isReactNativeGlobal = (globalScope) => globalScope.ErrorUtils !== undefined;
 const logger = new ConsoleLogger_1.ConsoleLogger('ErrorHandler');
-const registerErrorHandler = (reportFatalErrorAsCrash) => {
-    if (global !== undefined && _isReactNativeGlobal(global)) {
-        _isReportFatalErrorAsCrash = reportFatalErrorAsCrash;
-        const oldHandler = global.ErrorUtils.getGlobalHandler();
-        global.ErrorUtils.setGlobalHandler((error, isFatal) => {
-            (0, exports._reportErrorToDynatrace)(error, isFatal, oldHandler);
-        });
-        const setter = global.ErrorUtils.setGlobalHandler;
-        global.ErrorUtils.setGlobalHandler = (errorHandler) => {
-            setter((error, isFatal) => {
-                (0, exports._reportErrorToDynatrace)(error, isFatal, errorHandler);
-            });
-        };
-    }
+let manualStart = { enabled: false };
+const startErrorHandler = (reportFatalErrorAsCrash) => {
+    manualStart = {
+        enabled: true,
+        reportFatalErrorAsCrash: reportFatalErrorAsCrash,
+    };
 };
-exports.registerErrorHandler = registerErrorHandler;
-const _reportErrorToDynatrace = (exception, isFatal, oldHandler) => {
+exports.startErrorHandler = startErrorHandler;
+const reportErrorToDynatrace = (exception, isFatal, reportFatalErrorAsCrashFromConfig, autoStart) => {
+    if (!autoStart && !manualStart)
+        return;
+    const reportFatalErrorAsCrash = manualStart.enabled
+        ? manualStart.reportFatalErrorAsCrash
+        : reportFatalErrorAsCrashFromConfig;
     if (exception != null && isExceptionAnError(exception)) {
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(exception.name)) {
             if (isFatal === undefined) {
                 isFatal = false;
             }
-            DynatraceInternal_1.DynatraceInternal.reportErrorFromHandler(isFatal, String(exception.name), adjustedReason(exception.message), exception.stack != null ? exception.stack : '', _isReportFatalErrorAsCrash);
-            logger.debug(`_reportErrorToDynatrace(${exception}, ${isFatal})`);
+            DynatraceInternal_1.DynatraceInternal.reportErrorFromHandler(isFatal, String(exception.name), adjustedReason(exception.message), exception.stack != null ? exception.stack : '', reportFatalErrorAsCrash);
+            logger.debug(`reportErrorToDynatrace(${exception}, ${isFatal})`);
         }
     }
     else {
         Dynatrace_1.Dynatrace.reportError(String(exception), -1);
-        logger.debug(`_reportErrorToDynatrace(${exception}, -1)`);
-    }
-    if (oldHandler !== undefined) {
-        if (react_native_1.Platform.OS === 'ios') {
-            setTimeout(() => {
-                oldHandler(exception, isFatal);
-            }, 200);
-        }
-        else {
-            oldHandler(exception, isFatal);
-        }
+        logger.debug(`reportErrorToDynatrace(${exception}, -1)`);
     }
 };
-exports._reportErrorToDynatrace = _reportErrorToDynatrace;
+exports.reportErrorToDynatrace = reportErrorToDynatrace;
 const adjustedReason = (reason) => {
     if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(reason)) {
         const reasonNewLineIndex = reason.indexOf('\n');

package/lib/next/Dynatrace.js

@@ -42,8 +42,8 @@ class DynatraceImpl {
         const eventTimestamp = new EventTimestamp_1.EventTimestamp(this.timestampProvider);
         const event = Object.assign(Object.assign({}, (0, EventCreator_1.createCrashEvent)(crash.name, crash.message, crash.stack, isFatal)), eventTimestamp.getEventTimeInfo());
         if (isApiReported) {
-            event["characteristics.is_api_reported"] =
-                true;
+            (0, EventModifierUtil_1.addIsApiReported)(event);
+            event["dt.support.is_legacy_api_reported"] = true;
         }
         EventPipeline_1.EventPipeline.insertEvent(event);
     }
@@ -52,8 +52,8 @@ class DynatraceImpl {
         const eventTimestamp = new EventTimestamp_1.EventTimestamp(this.timestampProvider);
         const event = Object.assign(Object.assign({}, (0, EventCreator_1.createErrorCodeEvent)(errorName, errorCode)), eventTimestamp.getEventTimeInfo());
         if (isApiReported) {
-            event["characteristics.is_api_reported"] =
-                true;
+            (0, EventModifierUtil_1.addIsApiReported)(event);
+            event["dt.support.is_legacy_api_reported"] = true;
         }
         EventPipeline_1.EventPipeline.insertEvent(event);
     }
@@ -62,8 +62,8 @@ class DynatraceImpl {
         const eventTimestamp = new EventTimestamp_1.EventTimestamp(this.timestampProvider);
         const event = Object.assign(Object.assign({}, (0, EventCreator_1.createErrorEvent)(error.name, error.message, error.stack)), eventTimestamp.getEventTimeInfo());
         if (isApiReported) {
-            event["characteristics.is_api_reported"] =
-                true;
+            (0, EventModifierUtil_1.addIsApiReported)(event);
+            event["dt.support.is_legacy_api_reported"] = true;
         }
         EventPipeline_1.EventPipeline.insertEvent(event);
     }
@@ -73,15 +73,14 @@ class DynatraceImpl {
         const event = Object.assign({}, (0, EventCreator_1.createErrorEvent)(error.name, error.message, error.stack));
         let eventValidated = SendEventValidation_1.SendEventValidation.modifyEvent(fieldsCheck);
         eventValidated = Object.assign(Object.assign({}, event), eventValidated);
-        eventValidated["characteristics.is_api_reported"] = true;
+        (0, EventModifierUtil_1.addIsApiReported)(eventValidated);
         EventPipeline_1.EventPipeline.insertEvent(eventValidated);
     }
     sendEvent(properties, context) {
         this.logger.debug(`sendEvent(${JSON.stringify(properties, context)})`);
         const eventValidated = SendEventValidation_1.SendEventValidation.modifyEvent(properties);
-        if (eventValidated != null && (0, EventModifierUtil_1.containEventProperties)(eventValidated)) {
-            eventValidated["characteristics.has_event_properties"] = true;
-        }
+        (0, EventModifierUtil_1.flagEventProperties)(eventValidated);
+        (0, EventModifierUtil_1.addIsApiReported)(eventValidated);
         EventPipeline_1.EventPipeline.insertEvent(eventValidated, context);
     }
     sendSessionPropertyEvent(properties) {
@@ -91,7 +90,14 @@ class DynatraceImpl {
             (0, EventModifierUtil_1.containSessionProperties)(eventValidated)) {
             eventValidated["characteristics.has_session_properties"] = true;
         }
+        (0, EventModifierUtil_1.addIsApiReported)(eventValidated);
         EventPipeline_1.EventPipeline.insertEvent(eventValidated);
     }
+    sendHttpRequestEvent(httpRequestEventBuilder) {
+        const sanitizedEvent = httpRequestEventBuilder.build();
+        this.logger.debug(`sendHttpRequestEvent(${JSON.stringify(sanitizedEvent)})`);
+        (0, EventModifierUtil_1.flagEventProperties)(sanitizedEvent);
+        EventPipeline_1.EventPipeline.insertEvent(sanitizedEvent);
+    }
 }
 exports.Dynatrace = new DynatraceImpl(TimestampProvider_1.defaultTimestampProvider);

package/lib/next/events/EventCreator.js

@@ -26,7 +26,8 @@ const createErrorCodeEvent = (errorName, errorCode) => {
         'error.is_fatal': false,
     };
     if (errorName != null) {
-        event["name"] = errorName;
+        event["error.name"] = errorName;
+        event["error.has_custom_name"] = true;
     }
     if (errorCode != null) {
         event["error.code"] = errorCode;

package/lib/next/events/HttpRequestEventBuilder.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConsoleLogger_1 = require("../../core/logging/ConsoleLogger");
+const SendEventValidation_1 = require("./modifier/SendEventValidation");
+const TimestampProvider_1 = require("../provider/TimestampProvider");
+const logger = new ConsoleLogger_1.ConsoleLogger('Dynatrace');
+class HttpRequestEventBuilder {
+    constructor(url, requestMethod) {
+        this.url = url;
+        this.requestMethod = requestMethod;
+        this.duration = 0;
+        this.rawEventProperties = {};
+        this.hasDroppedTraceparent = false;
+        this.hasDroppedCustomProperties = false;
+        this.hasNfnValues = false;
+        this.triedToOverwriteDuration = false;
+        this.requestMethod =
+            requestMethod.toUpperCase();
+    }
+    withDuration(duration) {
+        this.duration = duration;
+        this.triedToOverwriteDuration = true;
+        return this;
+    }
+    withStatusCode(statusCode) {
+        this.statusCode = statusCode;
+        return this;
+    }
+    withReasonPhrase(reasonPhrase) {
+        this.reasonPhrase = reasonPhrase;
+        return this;
+    }
+    withError(error) {
+        this.error = error;
+        return this;
+    }
+    withBytesSent(bytesSent) {
+        this.bytesSent = bytesSent;
+        return this;
+    }
+    withBytesReceived(bytesReceived) {
+        this.bytesReceived = bytesReceived;
+        return this;
+    }
+    withTraceparentHeader(traceparentHeader) {
+        this.traceparentHeader = traceparentHeader;
+        return this;
+    }
+    addEventProperty(key, value) {
+        this.rawEventProperties[key] = value;
+        return this;
+    }
+    build() {
+        if (!this.hasValidMandatoryAttriutes()) {
+            logger.debug('HttpRequestEventBuilder dropped invalid event');
+            return null;
+        }
+        this.sanitizeDuration();
+        this.sanitizeStatusCode();
+        this.sanitizeReasonPhrase();
+        this.sanitizeBytesReceived();
+        this.sanitizeBytesSent();
+        const parsedTraceparentHeader = this.traceparentHeader &&
+            this.parseTraceparent(this.traceparentHeader);
+        this.hasDroppedTraceparent =
+            !!this.traceparentHeader && !parsedTraceparentHeader;
+        const hasFailedRequest = this.isStatusCodeError() || !!this.error;
+        const filteredEventProperties = Object.fromEntries(Object.entries(this.rawEventProperties).filter(this.isEventPropertyKey, this));
+        const sanitizedEventProperties = SendEventValidation_1.SendEventValidation.modifyEvent(filteredEventProperties);
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, sanitizedEventProperties), { ["url.full"]: this.url, ["network.protocol.name"]: 'http', ["http.request.method"]: this.requestMethod, ["duration"]: this.duration, ["start_time"]: TimestampProvider_1.defaultTimestampProvider.getCurrentTimestamp() - this.duration }), (this.triedToOverwriteDuration && {
+            ["dt.support.api.overridden_fields"]: [
+                'duration',
+            ],
+        })), this.includeIfDefined("http.response.status_code", this.statusCode)), this.includeIfDefined("http.response.reason_phrase", this.reasonPhrase)), this.includeIfDefined("request.bytes_sent", this.bytesSent)), this.includeIfDefined("request.bytes_received", this.bytesReceived)), { ["characteristics.has_request"]: true, ["characteristics.is_api_reported"]: true }), this.includeIfTrue("characteristics.has_failed_request", hasFailedRequest)), this.includeIfTrue("characteristics.has_error", hasFailedRequest)), (this.error !== undefined && Object.assign({ ["characteristics.has_exception"]: true, ["exception.type"]: this.error.name, ["exception.message"]: this.error.message }, this.includeIfDefined("exception.stack_trace", this.error.stack)))), (parsedTraceparentHeader && {
+            ["trace.id"]: parsedTraceparentHeader.traceId,
+            ["span.id"]: parsedTraceparentHeader.spanId,
+        })), (this.hasDroppedTraceparent && {
+            ["request.trace_context_hint"]: 'invalid_header',
+        })), this.includeIfTrue("dt.support.api.has_dropped_custom_properties", this.hasDroppedCustomProperties)), this.includeIfTrue("dt.support.has_nfn_values", this.hasNfnValues));
+    }
+    hasValidMandatoryAttriutes() {
+        let isValid = true;
+        if (this.isInvalidUrl(this.url)) {
+            logger.debug(`HttpRequestEventBuilder: dropped event since given URL is malformed: ${this.url}`);
+            isValid = false;
+        }
+        if (!HttpRequestEventBuilder.allowedRequestMethods.includes(this.requestMethod)) {
+            logger.debug(`HttpRequestEventBuilder: dropped event since given Request Method is invalid: ${this.requestMethod}`);
+            isValid = false;
+        }
+        return isValid;
+    }
+    isInvalidUrl(url) {
+        try {
+            if (!url.match(/^(https?):\/\/[^\s/$.?#-][^\s]*$/i)) {
+                return true;
+            }
+            new URL(url);
+            return false;
+        }
+        catch (_a) {
+            return true;
+        }
+    }
+    sanitizeStatusCode() {
+        if (this.statusCode == undefined && this.error === undefined) {
+            this.statusCode = 0;
+        }
+        if (this.statusCode && this.statusCode < 0) {
+            logger.debug('HttpRequestEventBuilder: overriding invalid Status Code with 0');
+            this.statusCode = 0;
+            this.hasDroppedCustomProperties = true;
+        }
+    }
+    sanitizeReasonPhrase() {
+        if (this.reasonPhrase &&
+            this.reasonPhrase.length >
+                HttpRequestEventBuilder.maxReasonPhraseLength) {
+            logger.debug(`HttpRequestEventBuilder: trimming too long Reason Phrase to a length of ${HttpRequestEventBuilder.maxReasonPhraseLength}`);
+            this.reasonPhrase = this.reasonPhrase.slice(0, HttpRequestEventBuilder.maxReasonPhraseLength);
+        }
+    }
+    sanitizeDuration() {
+        this.hasNfnValues || (this.hasNfnValues = !Number.isFinite(this.duration));
+        if (!Number.isFinite(this.duration) || this.duration < 0) {
+            logger.debug('HttpRequestEventBuilder: overriding invalid Duration with 0');
+            this.duration = 0;
+            this.hasDroppedCustomProperties = true;
+        }
+    }
+    sanitizeBytesSent() {
+        if (this.bytesSent && this.bytesSent < 0) {
+            logger.debug(`HttpRequestEventBuilder: dropping invalid value for Bytes Sent: ${this.bytesSent}`);
+            this.bytesSent = undefined;
+            this.hasDroppedCustomProperties = true;
+        }
+    }
+    sanitizeBytesReceived() {
+        if (this.bytesReceived && this.bytesReceived < 0) {
+            logger.debug(`HttpRequestEventBuilder: dropping invalid value for Bytes Received: ${this.bytesReceived}`);
+            this.bytesReceived = undefined;
+            this.hasDroppedCustomProperties = true;
+        }
+    }
+    isStatusCodeError() {
+        return (this.statusCode && 400 <= this.statusCode && this.statusCode <= 599);
+    }
+    isEventPropertyKey([key, _]) {
+        if (key.startsWith("event_properties")) {
+            return true;
+        }
+        logger.debug(`HttpRequestEventBuilder: dropped event property '$key' as it did not start with prefix ${"event_properties"}`);
+        this.hasDroppedCustomProperties = true;
+        return false;
+    }
+    includeIfDefined(key, value) {
+        return value !== undefined ? { [key]: value } : {};
+    }
+    includeIfTrue(key, value) {
+        return value === true ? { [key]: value } : {};
+    }
+    parseTraceparent(header) {
+        const traceparentRegex = /^00-([0-9a-f]{32})-([0-9a-f]{16})-0[01]$/;
+        const match = header.match(traceparentRegex);
+        if (!match) {
+            logger.debug("The provided traceparent header does not match the format: '00-<trace-id-32-HEXDIG>-<parent-id-16-HEXDIG>-<trace-flags-2-HEXDIG>'");
+            return null;
+        }
+        const [, traceId, spanId] = match;
+        if (this.allZeros(traceId)) {
+            logger.debug('Trace ID in traceparent header must not be all zeros');
+            return null;
+        }
+        if (this.allZeros(spanId)) {
+            logger.debug('Parent ID in traceparent header must not be all zeros');
+            return null;
+        }
+        return { traceId, spanId };
+    }
+    allZeros(str) {
+        return /^0*$/.test(str);
+    }
+}
+exports.default = HttpRequestEventBuilder;
+HttpRequestEventBuilder.allowedRequestMethods = [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'CONNECT',
+    'OPTIONS',
+    'TRACE',
+    'PATCH',
+];
+HttpRequestEventBuilder.maxReasonPhraseLength = 5000;

package/lib/next/events/ViewInfoCreator.js

@@ -8,7 +8,7 @@ const ASCII_CODE_A = 65;
 const NUMERICAL_CHARACTER_COUNT = 10;
 const OFFSET_A = ASCII_CODE_A - NUMERICAL_CHARACTER_COUNT;
 const createViewInfo = (name) => ({
-    ["view.id"]: createRandomHexString(VIEW_ID_LENGTH),
+    ["view.instance_id"]: createRandomHexString(VIEW_ID_LENGTH),
     ["view.name"]: name,
 });
 exports.createViewInfo = createViewInfo;