@dynatrace/react-native-plugin 2.307.1 → 2.311.1

package/lib/{instrumentor/base → core}/DynatraceAction.js

@@ -3,105 +3,106 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynatraceAction = void 0;
 const StringUtils_1 = require("./util/StringUtils");
 const DynatraceBridge_1 = require("./DynatraceBridge");
-const Logger_1 = require("./Logger");
+const ConsoleLogger_1 = require("./logging/ConsoleLogger");
 class DynatraceAction {
     constructor(key, name, manual) {
         this.key = key;
         this.name = name;
         this.manual = manual;
         this.closed = false;
+        this.logger = new ConsoleLogger_1.ConsoleLogger('DynatraceAction');
     }
     reportError(errorName, errorCode, platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceAction reportError(${errorName}, ${errorCode}): Action was closed already!`);
+            this.logger.debug(`reportError(${errorName}, ${errorCode}): Action was closed already!`);
             return;
         }
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(errorName)) {
             DynatraceBridge_1.DynatraceNative.reportErrorInAction(this.key, errorName, errorCode, platform === null || platform === void 0 ? void 0 : platform.toString());
-            Logger_1.Logger.logDebug(`DynatraceAction reportError(${errorName}, ${errorCode}): in Action - ${this.name}`);
+            this.logger.debug(`reportError(${errorName}, ${errorCode}): in Action - ${this.name}`);
         }
         else {
-            Logger_1.Logger.logDebug(`DynatraceAction reportError(errorName, errorCode): Error will not be reported because errorName is invalid! errorName: ${errorName}, errorCode: ${errorCode}`);
+            this.logger.debug(`reportError(errorName, errorCode): Error will not be reported because errorName is invalid! errorName: ${errorName}, errorCode: ${errorCode}`);
         }
     }
     reportEvent(eventName, platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceAction reportEvent(${eventName}): Action was closed already!`);
+            this.logger.debug(`reportEvent(${eventName}): Action was closed already!`);
             return;
         }
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(eventName)) {
             DynatraceBridge_1.DynatraceNative.reportEventInAction(this.key, eventName, platform === null || platform === void 0 ? void 0 : platform.toString());
-            Logger_1.Logger.logDebug(`DynatraceAction reportEvent(${eventName}): in Action - ${this.name}`);
+            this.logger.debug(`reportEvent(${eventName}): in Action - ${this.name}`);
         }
         else {
-            Logger_1.Logger.logDebug(`DynatraceAction reportEvent(eventName): Event will not be reported because eventName is invalid! eventName: ${eventName} in Action - ${this.name}`);
+            this.logger.debug(`reportEvent(eventName): Event will not be reported because eventName is invalid! eventName: ${eventName} in Action - ${this.name}`);
         }
     }
     reportStringValue(valueName, value, platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceAction reportStringValue(${valueName}, ${value}): Action was closed already!`);
+            this.logger.debug(`reportStringValue(${valueName}, ${value}): Action was closed already!`);
             return;
         }
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(valueName)) {
             DynatraceBridge_1.DynatraceNative.reportStringValueInAction(this.key, valueName, value, platform === null || platform === void 0 ? void 0 : platform.toString());
-            Logger_1.Logger.logDebug(`DynatraceAction reportStringValue(${valueName}, ${value}): in Action - ${this.name}`);
+            this.logger.debug(`reportStringValue(${valueName}, ${value}): in Action - ${this.name}`);
         }
         else {
-            Logger_1.Logger.logDebug(`DynatraceAction reportStringValue(valueName, value): String value will not be reported because valueName is invalid! valueName: ${valueName}, value: ${value} in Action - ${this.name}`);
+            this.logger.debug(`reportStringValue(valueName, value): String value will not be reported because valueName is invalid! valueName: ${valueName}, value: ${value} in Action - ${this.name}`);
         }
     }
     reportIntValue(valueName, value, platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceAction reportIntValue(${valueName}, ${value}): Action was closed already!`);
+            this.logger.debug(`reportIntValue(${valueName}, ${value}): Action was closed already!`);
             return;
         }
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(valueName)) {
             DynatraceBridge_1.DynatraceNative.reportIntValueInAction(this.key, valueName, value, platform === null || platform === void 0 ? void 0 : platform.toString());
-            Logger_1.Logger.logDebug(`DynatraceAction reportIntValue(${valueName}, ${value}): in Action - ${this.name}`);
+            this.logger.debug(`reportIntValue(${valueName}, ${value}): in Action - ${this.name}`);
         }
         else {
-            Logger_1.Logger.logDebug(`DynatraceAction reportIntValue(valueName, value): Int value will not be reported because valueName is invalid! valueName: ${valueName}, value: ${value} in Action - ${this.name}`);
+            this.logger.debug(`reportIntValue(valueName, value): Int value will not be reported because valueName is invalid! valueName: ${valueName}, value: ${value} in Action - ${this.name}`);
         }
     }
     reportDoubleValue(valueName, value, platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceAction reportDoubleValue(${valueName}, ${value}): Action was closed already!`);
+            this.logger.debug(`reportDoubleValue(${valueName}, ${value}): Action was closed already!`);
             return;
         }
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(valueName)) {
             DynatraceBridge_1.DynatraceNative.reportDoubleValueInAction(this.key, valueName, value, platform === null || platform === void 0 ? void 0 : platform.toString());
-            Logger_1.Logger.logDebug(`DynatraceAction reportDoubleValue(${valueName}, ${value}): in Action - ${this.name}`);
+            this.logger.debug(`reportDoubleValue(${valueName}, ${value}): in Action - ${this.name}`);
         }
         else {
-            Logger_1.Logger.logDebug(`DynatraceAction reportDoubleValue(valueName, value): Double value will not be reported because valueName is invalid! valueName: ${valueName}, value: ${value} in Action - ${this.name}`);
+            this.logger.debug(`reportDoubleValue(valueName, value): Double value will not be reported because valueName is invalid! valueName: ${valueName}, value: ${value} in Action - ${this.name}`);
         }
     }
     leaveAction(platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug('DynatraceAction leaveAction(): Action was closed already!');
+            this.logger.debug('leaveAction(): Action was closed already!');
             return;
         }
         this.closed = true;
-        Logger_1.Logger.logDebug(`DynatraceAction leaveAction(): ${this.name}`);
+        this.logger.debug(`leaveAction(): ${this.name}`);
         DynatraceBridge_1.DynatraceNative.leaveAction(this.key, this.manual, platform === null || platform === void 0 ? void 0 : platform.toString());
     }
     cancel(platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug('DynatraceAction cancelAction(): Action was closed already!');
+            this.logger.debug('cancelAction(): Action was closed already!');
             return;
         }
         this.closed = true;
-        Logger_1.Logger.logDebug(`DynatraceAction cancelAction(): ${this.name}`);
+        this.logger.debug(`cancelAction(): ${this.name}`);
         DynatraceBridge_1.DynatraceNative.cancelAction(this.key, platform === null || platform === void 0 ? void 0 : platform.toString());
     }
     getRequestTag(url) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceAction getRequestTag(${url}): Action was closed already!`);
+            this.logger.debug(`getRequestTag(${url}): Action was closed already!`);
             return new Promise((resolve) => {
                 resolve('');
             });
         }
-        Logger_1.Logger.logDebug(`DynatraceAction getRequestTag(${url}): in Action - ${this.name}`);
+        this.logger.debug(`getRequestTag(${url}): in Action - ${this.name}`);
         return DynatraceBridge_1.DynatraceNative.getRequestTag(this.key, url);
     }
     getRequestTagHeader() {

package/lib/core/DynatraceInternal.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynatraceInternal = void 0;
+const react_native_1 = require("react-native");
+const Dynatrace_1 = require("../next/Dynatrace");
+const DynatraceBridge_1 = require("./DynatraceBridge");
+const StringUtils_1 = require("./util/StringUtils");
+const ConsoleLogger_1 = require("./logging/ConsoleLogger");
+let counter = 0;
+const logger = new ConsoleLogger_1.ConsoleLogger('DyntraceInt');
+exports.DynatraceInternal = {
+    reportErrorFromHandler: (isFatal, errorName, reason, stacktrace, isReportFatalErrorAsCrash, platform) => {
+        if (isFatal && isReportFatalErrorAsCrash) {
+            if (react_native_1.Platform.OS === 'ios') {
+                logger.debug(`storeCrash(${errorName}, ${reason}, ${stacktrace})`);
+                DynatraceBridge_1.DynatraceNative.storeCrash(errorName, reason, stacktrace);
+            }
+            else {
+                logger.debug(`reportCrash(${errorName}, ${reason}, ${stacktrace})`);
+                DynatraceBridge_1.DynatraceNative.reportCrash(errorName, reason, stacktrace, true, platform === null || platform === void 0 ? void 0 : platform.toString());
+            }
+            Dynatrace_1.Dynatrace.reportCrash({
+                name: errorName,
+                message: reason,
+                stack: stacktrace,
+            }, false, isFatal);
+        }
+        else {
+            if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(stacktrace)) {
+                logger.debug(`reportError(${errorName}, ${reason}, ${stacktrace})`);
+                DynatraceBridge_1.DynatraceNative.reportError(errorName, '-', reason, stacktrace, platform === null || platform === void 0 ? void 0 : platform.toString());
+                Dynatrace_1.Dynatrace.reportError({
+                    name: errorName,
+                    message: reason,
+                    stack: stacktrace,
+                }, false);
+            }
+            else {
+                logger.debug(`reportError(${errorName})`);
+                DynatraceBridge_1.DynatraceNative.reportErrorWithoutStacktrace(errorName, -1);
+                Dynatrace_1.Dynatrace.reportErrorCode(errorName, -1, false);
+            }
+        }
+    },
+    getCounter: () => counter++,
+};

package/lib/{instrumentor/base → core}/DynatraceRootAction.js

@@ -3,18 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynatraceRootAction = void 0;
 const StringUtils_1 = require("./util/StringUtils");
 const DynatraceBridge_1 = require("./DynatraceBridge");
-const Logger_1 = require("./Logger");
 const DynatraceAction_1 = require("./DynatraceAction");
 const NullAction_1 = require("./NullAction");
 const DynatraceInternal_1 = require("./DynatraceInternal");
 const ConfigurationHandler_1 = require("./configuration/ConfigurationHandler");
+const ConsoleLogger_1 = require("./logging/ConsoleLogger");
 class DynatraceRootAction extends DynatraceAction_1.DynatraceAction {
     constructor(key, name) {
         super(key, name, true);
+        this.logger = new ConsoleLogger_1.ConsoleLogger('DynatraceRootAction');
     }
     enterAction(name, platform) {
         if (this.closed) {
-            Logger_1.Logger.logDebug(`DynatraceRootAction enterAction(${name}): Action was closed already!`);
+            this.logger.debug(`enterAction(${name}): Action was closed already!`);
             return new NullAction_1.NullAction();
         }
         let childKey;
@@ -28,12 +29,12 @@ class DynatraceRootAction extends DynatraceAction_1.DynatraceAction {
             childKey = 'DEFAULT_' + DynatraceInternal_1.DynatraceInternal.getCounter();
         }
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(name)) {
-            Logger_1.Logger.logDebug(`DynatraceRootAction enterAction(${name})`);
+            this.logger.debug(`enterAction(${name})`);
             DynatraceBridge_1.DynatraceNative.enterManualActionWithParent(name, childKey, this.key, platform === null || platform === void 0 ? void 0 : platform.toString());
             return new DynatraceAction_1.DynatraceAction(childKey, name, true);
         }
         else {
-            Logger_1.Logger.logDebug('Action Name was empty or null! Action will have no effect.');
+            this.logger.debug(`enterAction(${name}): Action Name was empty or null! Action will have no effect.`);
             return new NullAction_1.NullAction();
         }
     }

package/lib/{instrumentor/base → core}/DynatraceWebRequestTiming.js

@@ -2,20 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynatraceWebRequestTiming = void 0;
 const DynatraceBridge_1 = require("./DynatraceBridge");
-const Logger_1 = require("./Logger");
+const ConsoleLogger_1 = require("./logging/ConsoleLogger");
 const StringUtils_1 = require("./util/StringUtils");
 class DynatraceWebRequestTiming {
     constructor(requestTag, url) {
         this.requestTag = requestTag;
         this.url = url;
+        this.logger = new ConsoleLogger_1.ConsoleLogger('DynatraceWebRequestTiming');
     }
     startWebRequestTiming() {
         if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(this.requestTag) &&
             !StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(this.url)) {
+            this.logger.debug(`startWebRequestTiming() - (${this.url}/${this.requestTag})`);
             DynatraceBridge_1.DynatraceNative.startWebRequestTiming(this.requestTag, this.url);
         }
         else {
-            Logger_1.Logger.logDebug('Web Request Timing could not be created!');
+            this.logger.debug(`startWebRequestTiming(): Web Request Timing could not be created! - (${this.url}/${this.requestTag})`);
         }
     }
     stopWebRequestTiming(responseCode, responseMessage) {
@@ -26,12 +28,11 @@ class DynatraceWebRequestTiming {
             !StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(this.url) &&
             responseCode != null &&
             !StringUtils_1.StringUtils.isStringNullOrUndefined(responseMessage)) {
+            this.logger.debug(`stopWebRequestTiming(${responseCode}, ${responseMessage}, ${requestSize}, ${responseSize}) - (${this.url}/${this.requestTag})`);
             DynatraceBridge_1.DynatraceNative.stopWebRequestTimingWithSize(this.requestTag, this.url, responseCode, responseMessage, requestSize, responseSize);
         }
         else {
-            Logger_1.Logger.logDebug(`Web Request Timing could not be stopped! - requestTag: ${this.requestTag} ` +
-                `url: ${this.url} responseCode: ${responseCode} responseMessage: ${responseMessage} ` +
-                `requestSize: ${requestSize} responseSize: ${responseSize}`);
+            this.logger.debug(`stopWebRequestTiming(${responseCode}, ${responseMessage}, ${requestSize}, ${responseSize}): Web Request Timing could not be stopped! - (${this.url}/${this.requestTag})`);
         }
     }
     getRequestTag() {

package/lib/{instrumentor/base → core}/ErrorHandler.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._reportErrorToDynatrace = exports.registerErrorHandler = void 0;
-const ReactNative = require("react-native");
+const react_native_1 = require("react-native");
 const DynatraceInternal_1 = require("./DynatraceInternal");
 const Dynatrace_1 = require("./Dynatrace");
 const StringUtils_1 = require("./util/StringUtils");
-const Logger_1 = require("./Logger");
+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;
@@ -31,15 +32,15 @@ const _reportErrorToDynatrace = (exception, isFatal, oldHandler) => {
                 isFatal = false;
             }
             DynatraceInternal_1.DynatraceInternal.reportErrorFromHandler(isFatal, String(exception.name), adjustedReason(exception.message), exception.stack != null ? exception.stack : '', _isReportFatalErrorAsCrash);
-            Logger_1.Logger.logDebug(`ErrorHandler _reportErrorToDynatrace(${exception}, ${isFatal})`);
+            logger.debug(`_reportErrorToDynatrace(${exception}, ${isFatal})`);
         }
     }
     else {
         Dynatrace_1.Dynatrace.reportError(String(exception), -1);
-        Logger_1.Logger.logDebug(`ErrorHandler _reportErrorToDynatrace(${exception}, -1)`);
+        logger.debug(`_reportErrorToDynatrace(${exception}, -1)`);
     }
     if (oldHandler !== undefined) {
-        if (ReactNative.Platform.OS === 'ios') {
+        if (react_native_1.Platform.OS === 'ios') {
             setTimeout(() => {
                 oldHandler(exception, isFatal);
             }, 200);

package/lib/{instrumentor/base → core}/configuration/Configuration.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Configuration = void 0;
-const LogLevel_1 = require("../model/LogLevel");
+const LogLevel_1 = require("../logging/LogLevel");
 class Configuration {
     constructor(beaconUrl, applicationId, reportCrash, errorHandler, reportFatalErrorAsCrash, logLevel, lifecycleUpdate, userOptIn, actionNamePrivacy, bundleName, bundleVersion) {
         this.beaconUrl = beaconUrl;

package/lib/{instrumentor/base → core}/configuration/ConfigurationDefaults.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_ACTION_NAME_PRIVACY = exports.DEFAULT_USER_OPT_IN = exports.DEFAULT_LOGLEVEL = exports.DEFAULT_FATAL_AS_CRASH = exports.DEFAULT_ERROR_HANDLER = exports.DEFAULT_REPORT_CRASH = exports.DEFAULT_LIFECYCLE_UPDATE = void 0;
-const LogLevel_1 = require("../model/LogLevel");
 exports.DEFAULT_LIFECYCLE_UPDATE = false;
 exports.DEFAULT_REPORT_CRASH = true;
 exports.DEFAULT_ERROR_HANDLER = true;
 exports.DEFAULT_FATAL_AS_CRASH = true;
-exports.DEFAULT_LOGLEVEL = LogLevel_1.LogLevel.Info;
+exports.DEFAULT_LOGLEVEL = 1;
 exports.DEFAULT_USER_OPT_IN = false;
 exports.DEFAULT_ACTION_NAME_PRIVACY = false;

package/lib/{instrumentor/base → core}/configuration/ConfigurationHandler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigurationHandler = void 0;
-const LogLevel_1 = require("../model/LogLevel");
 let _configuration;
 exports.ConfigurationHandler = {
     setConfiguration(configuration) {
@@ -10,7 +9,8 @@ exports.ConfigurationHandler = {
     isConfigurationAvailable: () => _configuration !== undefined,
     isErrorHandlerEnabled: () => _configuration.errorHandler,
     isReportFatalErrorAsCrash: () => _configuration.reportFatalErrorAsCrash,
-    isDebugEnabled: () => _configuration.logLevel === LogLevel_1.LogLevel.Debug,
+    isDebugEnabled: () => exports.ConfigurationHandler.isConfigurationAvailable() &&
+        _configuration.logLevel === 0,
     isLifecycleUpdateEnabled: () => _configuration.lifecycleUpdate,
     isActionNamePrivacyEnabled: () => _configuration.actionNamePrivacy,
     getBundleName: () => _configuration.bundleName,

package/lib/{instrumentor/base → core}/configuration/ManualStartupConfiguration.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManualStartupConfiguration = void 0;
-const LogLevel_1 = require("../model/LogLevel");
+const LogLevel_1 = require("../logging/LogLevel");
 const ConfigurationDefaults_1 = require("./ConfigurationDefaults");
 const ConfigurationPreset_1 = require("./ConfigurationPreset");
 class ManualStartupConfiguration {

package/lib/core/logging/ConsoleLogger.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const ConfigurationHandler_1 = require("../configuration/ConfigurationHandler");
+class ConsoleLogger {
+    constructor(name, logLevel) {
+        this.name = name;
+        this.level = logLevel;
+    }
+    debug(msg) {
+        if (this.isDebugEnabled()) {
+            this.logMessage(msg);
+        }
+    }
+    info(msg) {
+        this.logMessage(msg);
+    }
+    logMessage(msg) {
+        console.log(`[${this.name}]: ${msg}`);
+    }
+    isDebugEnabled() {
+        return (this.level === 0 ||
+            (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable() &&
+                ConfigurationHandler_1.ConfigurationHandler.isDebugEnabled()));
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;

package/lib/core/logging/LogLevel.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelToString = void 0;
+const LogLevelToString = (level) => {
+    if (level === 0) {
+        return 'Debug';
+    }
+    else {
+        return 'Info';
+    }
+};
+exports.LogLevelToString = LogLevelToString;

package/lib/dynatrace-transformer.js

@@ -6,7 +6,7 @@ const PathsConstants_1 = require("../scripts/PathsConstants");
 const config = require("../scripts/Config");
 const Logger_1 = require("../scripts/Logger");
 const CustomArgumentUtil_1 = require("../scripts/util/CustomArgumentUtil");
-const instrumentor = require("./instrumentor/DynatraceInstrumentation");
+const instrumentor = require("../instrumentation/DynatraceInstrumentation");
 const customArguments = (0, CustomArgumentUtil_1.readCustomArguments)();
 const transform = (src, filename, options) => {
     if (typeof src === 'object') {

package/lib/next/Dynatrace.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dynatrace = void 0;
+const DynatraceBridge_1 = require("../core/DynatraceBridge");
+const ConsoleLogger_1 = require("../core/logging/ConsoleLogger");
+const EventCreator_1 = require("./events/EventCreator");
+const EventPipeline_1 = require("./events/EventPipeline");
+const EventTimestamp_1 = require("./events/EventTimestamp");
+const EventModifierUtil_1 = require("./events/modifier/EventModifierUtil");
+const SendEventValidation_1 = require("./events/modifier/SendEventValidation");
+const TimestampProvider_1 = require("./provider/TimestampProvider");
+class DynatraceImpl {
+    constructor(timestampProvider) {
+        this.timestampProvider = timestampProvider;
+        this.logger = new ConsoleLogger_1.ConsoleLogger('Dynatrace');
+    }
+    addEventModifier(eventModifier) {
+        this.logger.debug('addEventModifier()');
+        return EventPipeline_1.EventPipeline.addEventModifier(eventModifier);
+    }
+    removeEventModifier(eventModifier) {
+        this.logger.debug('removeEventModifier()');
+        return EventPipeline_1.EventPipeline.removeEventModifier(eventModifier);
+    }
+    startView(name) {
+        this.logger.debug(`startView(${name})`);
+        EventPipeline_1.EventPipeline.generateViewData(name);
+        if (name != null && name.length > 0) {
+            DynatraceBridge_1.DynatraceNative.startView(name);
+        }
+        else {
+            this.logger.debug(`startView(${name}): Name can't be used. Either empty or null!`);
+        }
+    }
+    stopView() {
+        this.logger.debug('stopView()');
+        EventPipeline_1.EventPipeline.releaseViewData();
+        DynatraceBridge_1.DynatraceNative.stopView();
+    }
+    reportCrash(crash, isApiReported, isFatal = true) {
+        this.logger.debug(`reportCrash(${JSON.stringify(crash)}, ${isFatal})`);
+        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;
+        }
+        EventPipeline_1.EventPipeline.insertEvent(event);
+    }
+    reportErrorCode(errorName, errorCode, isApiReported) {
+        this.logger.debug(`reportErrorCode(${errorName}, ${errorCode})`);
+        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;
+        }
+        EventPipeline_1.EventPipeline.insertEvent(event);
+    }
+    reportError(error, isApiReported) {
+        this.logger.debug(`reportError(${JSON.stringify(error)})`);
+        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;
+        }
+        EventPipeline_1.EventPipeline.insertEvent(event);
+    }
+    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;
+        }
+        EventPipeline_1.EventPipeline.insertEvent(eventValidated, context);
+    }
+    sendSessionPropertyEvent(properties) {
+        this.logger.debug(`sendSessionPropertyEvent(${JSON.stringify(properties)})`);
+        const eventValidated = SendEventValidation_1.SendSessionPropertyEventValidation.modifyEvent(properties);
+        if (eventValidated != null &&
+            (0, EventModifierUtil_1.containSessionProperties)(eventValidated)) {
+            eventValidated["characteristics.has_session_properties"] = true;
+        }
+        EventPipeline_1.EventPipeline.insertEvent(eventValidated);
+    }
+}
+exports.Dynatrace = new DynatraceImpl(TimestampProvider_1.defaultTimestampProvider);

package/lib/next/DynatraceSecondGenForwarder.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynatraceSecondGenForwarder = void 0;
+const Dynatrace_1 = require("./Dynatrace");
+class DynatraceSecondGenForwarderImpl {
+    reportError(errorName, errorCode) {
+        Dynatrace_1.Dynatrace.reportErrorCode(errorName, errorCode, true);
+    }
+    reportErrorWithStacktrace(errorName, reason, stacktrace) {
+        Dynatrace_1.Dynatrace.reportError({
+            name: errorName,
+            message: reason,
+            stack: stacktrace,
+        }, true);
+    }
+    reportErrorStacktrace(errorName, errorValue, reason, stacktrace) {
+        Dynatrace_1.Dynatrace.reportError({
+            name: errorName,
+            message: reason,
+            stack: stacktrace,
+        }, true);
+    }
+    reportCrash(crashName, reason, stacktrace) {
+        Dynatrace_1.Dynatrace.reportCrash({
+            name: crashName,
+            message: reason,
+            stack: stacktrace,
+        }, true, false);
+    }
+    reportCrashWithException(crashName, crash) {
+        const copyCrash = Object.assign(Object.assign({}, crash), { name: crashName });
+        Dynatrace_1.Dynatrace.reportCrash(copyCrash, true, false);
+    }
+}
+exports.DynatraceSecondGenForwarder = new DynatraceSecondGenForwarderImpl();

package/lib/next/IDynatrace.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/IDynatraceForwarder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/appstart/AppStartObserver.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppStartObserver = void 0;
+const react_native_1 = require("react-native");
+const EventCreator_1 = require("../events/EventCreator");
+const ConsoleLogger_1 = require("../../core/logging/ConsoleLogger");
+const DynatraceBridge_1 = require("../../core/DynatraceBridge");
+const EventPipeline_1 = require("../events/EventPipeline");
+class AppStartObserverImpl {
+    constructor() {
+        this.EMIT_APP_START = 'dynatraceAppStartMeasurements';
+        this.logger = new ConsoleLogger_1.ConsoleLogger('AppStartObserver');
+        this.setupNativeEventEmitter();
+    }
+    call() {
+    }
+    setupNativeEventEmitter() {
+        if (react_native_1.Platform.OS === 'android' ||
+            Object.keys(DynatraceBridge_1.DynatraceNative).length !== 0) {
+            const emitter = new react_native_1.NativeEventEmitter(DynatraceBridge_1.DynatraceNative);
+            emitter.addListener(this.EMIT_APP_START, (data) => {
+                this.logger.debug(`emitter(${JSON.stringify(data)}})`);
+                const appStartEvent = (0, EventCreator_1.createAppStartEvent)(data);
+                if (appStartEvent != null) {
+                    EventPipeline_1.EventPipeline.insertEvent(Object.assign({}, appStartEvent), {});
+                }
+                else {
+                    this.logger.debug(`emitter(${JSON.stringify(data)}}): App Start event ignored!`);
+                }
+            });
+        }
+    }
+}
+exports.AppStartObserver = new AppStartObserverImpl();

package/lib/next/appstart/AppStartType.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppStartTypeKeyMapping = exports.AppStartType = void 0;
+var AppStartType;
+(function (AppStartType) {
+    AppStartType["DOWNLOAD_START"] = "downloadStart";
+    AppStartType["DOWNLOAD_END"] = "downloadEnd";
+    AppStartType["RUN_JS_BUNDLE_START"] = "runJsBundleStart";
+    AppStartType["RUN_JS_BUNDLE_END"] = "runJsBundleEnd";
+    AppStartType["CONTENT_APPEARED"] = "contentAppeared";
+    AppStartType["RELOAD"] = "reload";
+})(AppStartType = exports.AppStartType || (exports.AppStartType = {}));
+exports.AppStartTypeKeyMapping = [
+    {
+        type: AppStartType.RELOAD,
+        key: "app_start.react_native.application.reload",
+    },
+    {
+        type: AppStartType.DOWNLOAD_START,
+        key: "app_start.react_native.application.download_start",
+    },
+    {
+        type: AppStartType.RUN_JS_BUNDLE_START,
+        key: "app_start.react_native.application.run_js_bundle_start",
+    },
+    {
+        type: AppStartType.DOWNLOAD_END,
+        key: "app_start.react_native.application.download_end",
+    },
+    {
+        type: AppStartType.RUN_JS_BUNDLE_END,
+        key: "app_start.react_native.application.run_js_bundle_end",
+    },
+    {
+        type: AppStartType.CONTENT_APPEARED,
+        key: "app_start.react_native.application.content_appeared",
+    },
+];