@dynatrace/react-native-plugin 2.307.1 → 2.309.1

package/ios/DynatraceRNBridge.h

@@ -7,13 +7,18 @@
 
 #import <Dynatrace/Dynatrace.h>
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface DynatraceRNBridge : NSObject <RCTBridgeModule>
+@interface DynatraceRNBridge : RCTEventEmitter <RCTBridgeModule>
 - (void) newAction:(NSString *)name key:(NSString *)key parentAction:(DTXAction *)parentAction;
 - (DTXAction *) getAction:(NSString *)key;
 - (BOOL) shouldWorkOnIosWithPlatform: (NSString *) platform;
 @end
 
+@interface HybridBridge : NSObject
++ (void)forwardEvent:(NSDictionary<NSString*,id>* _Nullable)fields NS_SWIFT_NAME(forwardEvent(fields:));
+@end
+
 typedef enum : NSUInteger {
     DTXActionPlatformJavaScript = 1,
     DTXActionPlatformXamarin,
@@ -27,6 +32,10 @@ typedef enum : NSUInteger {
 - (DTX_StatusCode)reportExternalErrorForPlatformType:(DTXActionPlatformType)platformType errorName:(NSString*)errorName errorValue:(NSString*)errorValue reason:(NSString*)reason stacktrace:(NSString*)stacktrace;
 @end
 
+@interface DTXAction (CrossPlatform)
++ (DTX_StatusCode)internalReportError:(NSString* _Nonnull)errorName errorValue:(int)errorValue;
+@end
+
 @interface Dynatrace (Events)
 + (void)sendBizEventWithType:(NSString *)type attributes:(NSDictionary<NSString *, id> *_Nullable)attributes;
 @end

package/ios/DynatraceRNBridge.mm

@@ -11,18 +11,46 @@
 
 #import <Foundation/Foundation.h>
 #import <CoreLocation/CoreLocation.h>
+#import <React/RCTPerformanceLogger.h>
+#import <React/RCTRootView.h>
 
 @implementation DynatraceRNBridge
 
 NSMutableDictionary *actionDict;
 NSMutableDictionary *webTimingsDict;
 
+// Platform types
 NSString *const PlatformAndroid = @"android";
 NSString *const PlatformiOS = @"ios";
+
+// Data collection levels
 NSString *const DataCollectionOff = @"OFF";
 NSString *const DataCollectionPerformance = @"PERFORMANCE";
 NSString *const DataCollectionUserBehavior = @"USER_BEHAVIOR";
 
+/**
+* Emitting app start event with this identifier
+*/
+NSString *const EmitAppMeasurementsIdentifier = @"dynatraceAppStartMeasurements";
+
+// All types which are interesting for us
+NSString *const DownloadStart = @"downloadStart";
+NSString *const DownloadEnd = @"downloadEnd";
+NSString *const RunJSBundleStart = @"runJsBundleStart";
+NSString *const RunJSBundleEnd = @"runJsBundleEnd";
+NSString *const Reload = @"reload";
+NSString *const ContentAppeared = @"contentAppeared";
+
+/**
+* Telling us if we can actually emit events
+*/
+bool hasListeners = NO;
+
+/**
+* When events have been emitted this value will be true, so we don't emit again
+*/
+bool didEmit = NO;
+
 RCT_EXPORT_MODULE(DynatraceBridge);
 
 - (id) init
@@ -35,6 +63,114 @@ RCT_EXPORT_MODULE(DynatraceBridge);
   return self;
 }
 
+- (NSArray<NSString *> *)supportedEvents {
+    return @[EmitAppMeasurementsIdentifier];
+}
+
+/**
+* When bridge is starting we will add an observer for content did appear so we can emit our app start measurements
+*/
+- (void)setBridge:(RCTBridge *)bridge
+{
+    [super setBridge:bridge];
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(emitMeasurements)
+                                                 name:RCTContentDidAppearNotification
+                                               object:nil];
+}
+
+/**
+* Emitting all events which are available and important for our app start measurements
+*/
+- (void)emitMeasurements
+{
+    if (!didEmit && hasListeners && [self.bridge.performanceLogger valueForTag:RCTPLTTI] != 0) {
+        didEmit = YES;
+
+        NSMutableDictionary<NSString*, NSNumber*> *appStartMeasurements = [[NSMutableDictionary alloc] init];
+
+        [self addStartMeasurement:RCTPLScriptDownload withName:DownloadStart intoDict:appStartMeasurements];
+        [self addEndMeasurement:RCTPLScriptDownload withName:DownloadEnd intoDict:appStartMeasurements];
+        [self addStartMeasurement:RCTPLScriptExecution withName:RunJSBundleStart intoDict:appStartMeasurements];
+        [self addEndMeasurement:RCTPLScriptExecution withName:RunJSBundleEnd intoDict:appStartMeasurements];
+        [self addStartMeasurement:RCTPLBridgeStartup withName:Reload intoDict:appStartMeasurements];
+        [self addStartMeasurement:RCTPLTTI withName:ContentAppeared intoDict:appStartMeasurements];
+
+        if (hasListeners) {
+            [self sendEventWithName:EmitAppMeasurementsIdentifier body:appStartMeasurements];
+        }
+    }
+}
+
+/**
+* Adding a start measurement
+*
+* @param type Tag which is used for the internal react native performance logger
+* @param name Name which should be used for inserting a specific timestamp into the dict
+* @param measurements Dictionary which is used to insert the timing
+*/
+- (void)addStartMeasurement:(RCTPLTag)type withName:(NSString *)name intoDict:(NSMutableDictionary *) measurements {
+    int64_t duration = [self.bridge.performanceLogger durationForTag:type];
+    int64_t end = [self.bridge.performanceLogger valueForTag:type];
+
+    if (duration == 0 || end == 0) {
+        return;
+    }
+
+    [measurements setObject:[self correctionOfTimestamp:end-duration] forKey:name];
+}
+
+/**
+* Adding a end measurement
+*
+* @param type Tag which is used for the internal react native performance logger
+* @param name Name which should be used for inserting a specific timestamp into the dict
+* @param measurements Dictionary which is used to insert the timing
+*/
+- (void)addEndMeasurement:(RCTPLTag)type withName:(NSString *)name intoDict:(NSMutableDictionary *) measurements {
+    int64_t end = [self.bridge.performanceLogger valueForTag:type];
+    
+    if (end == 0) {
+        return;
+    }
+    
+    [measurements setObject:[self correctionOfTimestamp:end] forKey:name];
+}
+
+- (NSNumber* )correctionOfTimestamp:(int64_t) timestamp
+{
+    return [NSNumber numberWithLongLong:timestamp + [[NSDate date] timeIntervalSince1970] - (CACurrentMediaTime() * 1000)];
+}
+
+/**
+* Invalidation should remove the observer for certain events
+*/
+- (void)invalidate
+{
+    [super invalidate];
+    [NSNotificationCenter.defaultCenter removeObserver:self];
+}
+
+/**
+* Triggered when starting to emit events
+*/
+- (void)startObserving
+{
+    hasListeners = YES;
+    [self emitMeasurements];
+}
+
+/**
+* Triggered when stopping to emit events
+*/
+-(void)stopObserving
+{
+    hasListeners = NO;
+}
+
+/**
+* Constants which are exported to the JS part
+*/
 - (NSDictionary *)constantsToExport
 {
     return @{ @"PLATFORM_ANDROID" : PlatformAndroid,
@@ -154,6 +290,16 @@ RCT_EXPORT_METHOD(endVisit: (NSString *) platform)
     }
 }
 
+RCT_EXPORT_METHOD(startView: (NSString *) name)
+{
+    [Dynatrace startViewWithName:name];
+}
+
+RCT_EXPORT_METHOD(stopView)
+{
+    [Dynatrace stopView];
+}
+
 RCT_EXPORT_METHOD(reportErrorWithoutStacktrace:(NSString *)errorName errorCode:(nonnull NSNumber *)errorCode platform: (NSString *) platform)
 {
     if ([self shouldWorkOnIosWithPlatform: platform])
@@ -211,6 +357,7 @@ RCT_EXPORT_METHOD(reportErrorInAction:(nonnull NSString *)key errorName:(NSStrin
         if (action == nil)
             return;
         [action reportErrorWithName:errorName errorValue:[errorCode intValue]];
+        // [action internalReportError:errorName errorValue:[errorCode intValue]];
     }
 }
 
@@ -309,6 +456,11 @@ RCT_EXPORT_METHOD(sendBizEvent:(NSString *)type withAttributes:(NSDictionary<NSS
     }
 }
 
+RCT_EXPORT_METHOD(forwardEvent:(NSDictionary<NSString*, id>*) attributes)
+{
+    [HybridBridge forwardEvent:attributes];
+}
+
 RCT_EXPORT_METHOD(setGPSLocation:(double)latitude andLongitude: (double)longitude platform: (NSString *) platform)
 {
     if ([self shouldWorkOnIosWithPlatform: platform])

package/jsx-dev-runtime.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const jsxDevRuntime = require("./lib/jsx-dev-runtime");
+const jsxDevRuntime = require("./instrumentation/jsx/JsxDevRuntime");
 module.exports = Object.assign({}, jsxDevRuntime);

package/jsx-runtime.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const jsxRuntime = require("./lib/jsx-runtime");
+const jsxRuntime = require("./instrumentation/jsx/JsxRuntime");
 module.exports = Object.assign({}, jsxRuntime);

package/lib/core/Application.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationHandler = void 0;
+const ConfigurationBuilder_1 = require("./configuration/ConfigurationBuilder");
+const ConfigurationHandler_1 = require("./configuration/ConfigurationHandler");
+const ConsoleLogger_1 = require("./logging/ConsoleLogger");
+const logger = new ConsoleLogger_1.ConsoleLogger('ApplicationHandler');
+exports.ApplicationHandler = {
+    startup: (configuration) => {
+        if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
+            let config = configuration;
+            if (config === undefined) {
+                config = new ConfigurationBuilder_1.ConfigurationBuilder('', '').buildConfiguration();
+            }
+            ConfigurationHandler_1.ConfigurationHandler.setConfiguration(config);
+            logger.debug('Configuration set: ' + config.toString());
+            logger.info('Dynatrace React Native Plugin started!');
+        }
+    },
+};

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

@@ -10,12 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dynatrace = void 0;
-const Types_1 = require("../model/Types");
+const Types_1 = require("../../instrumentation/model/Types");
+const DynatraceSecondGenForwarder_1 = require("../next/DynatraceSecondGenForwarder");
 const StringUtils_1 = require("./util/StringUtils");
 const DynatraceBridge_1 = require("./DynatraceBridge");
 const DataCollectionLevel_1 = require("./model/DataCollectionLevel");
 const UserPrivacyOptions_1 = require("./UserPrivacyOptions");
-const Logger_1 = require("./Logger");
+const ConsoleLogger_1 = require("./logging/ConsoleLogger");
 const ConfigurationHandler_1 = require("./configuration/ConfigurationHandler");
 const DynatraceRootAction_1 = require("./DynatraceRootAction");
 const NullRootAction_1 = require("./NullRootAction");
@@ -23,6 +24,8 @@ const DynatraceInternal_1 = require("./DynatraceInternal");
 const DynatraceAction_1 = require("./DynatraceAction");
 const NullAction_1 = require("./NullAction");
 const ErrorHandler_1 = require("./ErrorHandler");
+const Application_1 = require("./Application");
+const logger = new ConsoleLogger_1.ConsoleLogger('Dynatrace');
 exports.Dynatrace = {
     start: (configuration) => __awaiter(void 0, void 0, void 0, function* () {
         if (!ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
@@ -32,15 +35,16 @@ exports.Dynatrace = {
                     (0, ErrorHandler_1.registerErrorHandler)(configuration.reportFatalErrorAsCrash);
                 }
                 else {
-                    Logger_1.Logger.logDebug('Dynatrace error handler will not be enabled as errorHandler was set to false!');
+                    logger.debug('Dynatrace error handler will not be enabled as errorHandler was set to false!');
                 }
-                ConfigurationHandler_1.ConfigurationHandler.setConfiguration(configuration);
-                Logger_1.Logger.logDebug('Configuration set: ' + configuration.toString());
+                Application_1.ApplicationHandler.startup(configuration);
             }
             else {
                 throw new Error('Configuration is empty! Not allowed for Manual Startup!');
             }
-            Logger_1.Logger.logInfo('Dynatrace React Native Plugin started!');
+        }
+        else {
+            logger.debug('Configuration is already available! Duplicated startup blocked.');
         }
     }),
     withMonitoring: (Component, name) => {
@@ -75,17 +79,17 @@ exports.Dynatrace = {
                 key = 'DEFAULT_' + DynatraceInternal_1.DynatraceInternal.getCounter();
             }
             if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(name)) {
-                Logger_1.Logger.logDebug(`Dynatrace enterManualAction(${name})`);
+                logger.debug(`enterManualAction(${name})`);
                 DynatraceBridge_1.DynatraceNative.enterManualAction(name, key, platform === null || platform === void 0 ? void 0 : platform.toString());
                 return new DynatraceRootAction_1.DynatraceRootAction(key, name);
             }
             else {
-                Logger_1.Logger.logDebug('Action Name was empty or null! Action will have no effect.');
+                logger.debug('Action Name was empty or null! Action will have no effect.');
                 return new NullRootAction_1.NullRootAction();
             }
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace enterManualAction(${name}): React Native plugin has not been started yet! Action can't be created!`);
+            logger.info(`enterManualAction(${name}): React Native plugin has not been started yet! Action can't be created!`);
             return new NullRootAction_1.NullRootAction();
         }
     },
@@ -102,27 +106,28 @@ exports.Dynatrace = {
                 key = 'DEFAULT_' + DynatraceInternal_1.DynatraceInternal.getCounter();
             }
             if (!StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(name)) {
-                Logger_1.Logger.logDebug(`Dynatrace enterAutoAction(${name})`);
+                logger.debug(`enterAutoAction(${name})`);
                 DynatraceBridge_1.DynatraceNative.enterAction(name, key, platform === null || platform === void 0 ? void 0 : platform.toString());
                 return new DynatraceAction_1.DynatraceAction(key, name, false);
             }
             else {
-                Logger_1.Logger.logDebug('Action Name was empty or null! Action will have no effect.');
+                logger.debug('Action Name was empty or null! Action will have no effect.');
                 return new NullAction_1.NullAction();
             }
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace enterAutoAction(${name}): React Native plugin has not been started yet! Action can't be created!`);
+            logger.info(`enterAutoAction(${name}): React Native plugin has not been started yet! Action can't be created!`);
             return new NullAction_1.NullAction();
         }
     },
     reportError: (errorName, errorCode, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug(`Dynatrace reportError(${errorName}, ${errorCode})`);
+            logger.debug(`reportError(${errorName}, ${errorCode})`);
             DynatraceBridge_1.DynatraceNative.reportErrorWithoutStacktrace(errorName, errorCode, platform === null || platform === void 0 ? void 0 : platform.toString());
+            DynatraceSecondGenForwarder_1.DynatraceSecondGenForwarder.reportError(errorName, errorCode);
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace reportError(${errorName}, ${errorCode}): React Native plugin has not been started yet! Error will not be reported!`);
+            logger.info(`reportError(${errorName}, ${errorCode}): React Native plugin has not been started yet! Error will not be reported!`);
         }
     },
     reportErrorWithStacktrace: (errorName, reason, stacktrace, platform) => {
@@ -133,11 +138,12 @@ exports.Dynatrace = {
                     reason = reason.substring(0, reasonNewLineIndex);
                 }
             }
-            Logger_1.Logger.logDebug(`Dynatrace reportErrorStacktrace(${errorName}, ${reason}, ${stacktrace})`);
+            logger.debug(`reportErrorStacktrace(${errorName}, ${reason}, ${stacktrace})`);
             DynatraceBridge_1.DynatraceNative.reportError(errorName, '-', reason, stacktrace, platform === null || platform === void 0 ? void 0 : platform.toString());
+            DynatraceSecondGenForwarder_1.DynatraceSecondGenForwarder.reportErrorWithStacktrace(errorName, reason, stacktrace);
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace reportErrorStacktrace(${errorName}, ${reason}, ${stacktrace}): React Native plugin has not been started yet! Error will not be reported!`);
+            logger.info(`reportErrorStacktrace(${errorName}, ${reason}, ${stacktrace}): React Native plugin has not been started yet! Error will not be reported!`);
         }
     },
     reportErrorStacktrace: (errorName, errorValue, reason, stacktrace, platform) => {
@@ -148,11 +154,12 @@ exports.Dynatrace = {
                     reason = reason.substring(0, reasonNewLineIndex);
                 }
             }
-            Logger_1.Logger.logDebug(`Dynatrace reportErrorStacktrace(${errorName}, ${errorValue}, ${reason}, ${stacktrace})`);
+            logger.debug(`reportErrorStacktrace(${errorName}, ${errorValue}, ${reason}, ${stacktrace})`);
             DynatraceBridge_1.DynatraceNative.reportError(errorName, errorValue, reason, stacktrace, platform === null || platform === void 0 ? void 0 : platform.toString());
+            DynatraceSecondGenForwarder_1.DynatraceSecondGenForwarder.reportErrorStacktrace(errorName, errorValue, reason, stacktrace);
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace reportErrorStacktrace(${errorName}, ${errorValue}, ${reason}, ${stacktrace}): React Native plugin has not been started yet! Error will not be reported!`);
+            logger.info(`reportErrorStacktrace(${errorName}, ${errorValue}, ${reason}, ${stacktrace}): React Native plugin has not been started yet! Error will not be reported!`);
         }
     },
     reportCrash: (crashName, reason, stacktrace, platform) => {
@@ -164,12 +171,13 @@ exports.Dynatrace = {
                         reason = reason.substring(0, reasonNewLineIndex);
                     }
                 }
-                Logger_1.Logger.logDebug(`Dynatrace reportCrash(${crashName}, ${reason}, ${stacktrace})`);
+                logger.debug(`reportCrash(${crashName}, ${reason}, ${stacktrace})`);
                 DynatraceBridge_1.DynatraceNative.reportCrash(crashName, reason, stacktrace, false, platform === null || platform === void 0 ? void 0 : platform.toString());
+                DynatraceSecondGenForwarder_1.DynatraceSecondGenForwarder.reportCrash(crashName, reason, stacktrace);
             }
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace reportCrash(${crashName}, ${reason}, ${stacktrace}): React Native plugin has not been started yet! Crash will not be reported!`);
+            logger.info(`reportCrash(${crashName}, ${reason}, ${stacktrace}): React Native plugin has not been started yet! Crash will not be reported!`);
         }
     },
     reportCrashWithException: (crashName, crash, platform) => {
@@ -183,108 +191,109 @@ exports.Dynatrace = {
                         crashReason = crashReason.substring(0, reasonNewLineIndex);
                     }
                 }
-                Logger_1.Logger.logDebug(`Dynatrace reportCrashWithException(${crashName}, ${crash.stack})`);
+                logger.debug(`reportCrashWithException(${crashName}, ${crash.stack})`);
                 DynatraceBridge_1.DynatraceNative.reportCrash(crashName, crashReason, crash.stack, true, platform === null || platform === void 0 ? void 0 : platform.toString());
+                DynatraceSecondGenForwarder_1.DynatraceSecondGenForwarder.reportCrashWithException(crashName, crash);
             }
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace reportCrashWithException(${crashName}, ${crash}): React Native plugin has not been started yet! Crash will not be reported!`);
+            logger.info(`reportCrashWithException(${crashName}, ${crash}): React Native plugin has not been started yet! Crash will not be reported!`);
         }
     },
     sendBizEvent: (type, attributes = {}, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
             if (StringUtils_1.StringUtils.isStringNullEmptyOrUndefined(type)) {
-                Logger_1.Logger.logDebug(`Dynatrace sendBizEvent(${type}, ${attributes})): Type must be a non empty string`);
+                logger.debug(`sendBizEvent(${type}, ${attributes})): Type must be a non empty string`);
                 return;
             }
             if (typeof attributes !== 'object' ||
                 attributes === null ||
                 Array.isArray(attributes)) {
-                Logger_1.Logger.logDebug(`Dynatrace sendBizEvent(${type}, ${attributes})): Payload toplevel must be an object`);
+                logger.debug(`sendBizEvent(${type}, ${attributes})): Payload toplevel must be an object`);
                 return;
             }
             const internalAttributes = Object.assign({}, attributes);
-            Logger_1.Logger.logDebug(`Dynatrace sendBizEvent(${type}, ${internalAttributes})`);
+            logger.debug(`sendBizEvent(${type}, ${internalAttributes})`);
             DynatraceBridge_1.DynatraceNative.sendBizEvent(type, internalAttributes, platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace sendBizEvent(${type}, ${attributes}): React Native plugin has not been started yet! Biz Event will not be reported!`);
+            logger.info(`sendBizEvent(${type}, ${attributes}): React Native plugin has not been started yet! Biz Event will not be reported!`);
         }
     },
     endSession: (platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug('Dynatrace endSession()');
+            logger.debug('Dynatrace endSession()');
             DynatraceBridge_1.DynatraceNative.endVisit(platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo('Dynatrace endSession(): React Native plugin has not been started yet! Session will not be ended!');
+            logger.info('endSession(): React Native plugin has not been started yet! Session will not be ended!');
         }
     },
     identifyUser: (user, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug(`Dynatrace identifyUser(${user})`);
+            logger.debug(`Dynatrace identifyUser(${user})`);
             DynatraceBridge_1.DynatraceNative.identifyUser(user, platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace identifyUser(${user}): React Native plugin has not been started yet! Session will not be tagged!`);
+            logger.info(`identifyUser(${user}): React Native plugin has not been started yet! Session will not be tagged!`);
         }
     },
     setGPSLocation: (latitude, longitude, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug(`Dynatrace setGPSLocation(${latitude}, ${longitude})`);
+            logger.debug(`setGPSLocation(${latitude}, ${longitude})`);
             DynatraceBridge_1.DynatraceNative.setGPSLocation(latitude, longitude, platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace setGPSLocation(${latitude}, ${longitude}): React Native plugin has not been started yet! GPS Position will not be set!`);
+            logger.info(`setGPSLocation(${latitude}, ${longitude}): React Native plugin has not been started yet! GPS Position will not be set!`);
         }
     },
     isCrashReportingOptedIn: (platform) => __awaiter(void 0, void 0, void 0, function* () {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug('Dynatrace isCrashReportingOptedIn()');
+            logger.debug('Dynatrace isCrashReportingOptedIn()');
             return DynatraceBridge_1.DynatraceNative.isCrashReportingOptedIn(platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo('Dynatrace isCrashReportingOptedIn(): React Native plugin has not been started yet! Crash reporting value not available!');
+            logger.info('isCrashReportingOptedIn(): React Native plugin has not been started yet! Crash reporting value not available!');
             return false;
         }
     }),
     setCrashReportingOptedIn: (crashReporting, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug(`Dynatrace setCrashReportingOptedIn(${crashReporting})`);
+            logger.debug(`setCrashReportingOptedIn(${crashReporting})`);
             DynatraceBridge_1.DynatraceNative.setCrashReportingOptedIn(crashReporting, platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace setCrashReportingOptedIn(${crashReporting}): React Native plugin has not been started yet! Crash reporting value will not be set!`);
+            logger.info(`setCrashReportingOptedIn(${crashReporting}): React Native plugin has not been started yet! Crash reporting value will not be set!`);
         }
     },
     getDataCollectionLevel: (platform) => __awaiter(void 0, void 0, void 0, function* () {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug('Dynatrace getDataCollectionLevel()');
+            logger.debug('getDataCollectionLevel()');
             return (0, DataCollectionLevel_1.StringToDataCollectionLevel)(yield DynatraceBridge_1.DynatraceNative.getDataCollectionLevel(platform === null || platform === void 0 ? void 0 : platform.toString()));
         }
         else {
-            Logger_1.Logger.logInfo('Dynatrace getDataCollectionLevel(): React Native plugin has not been started yet! Data Collection level not available!');
+            logger.info('getDataCollectionLevel(): React Native plugin has not been started yet! Data Collection level not available!');
             return DataCollectionLevel_1.DataCollectionLevel.Off;
         }
     }),
     setDataCollectionLevel: (dataCollectionLevel, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug(`Dynatrace setDataCollectionLevel(${dataCollectionLevel})`);
+            logger.debug(`setDataCollectionLevel(${dataCollectionLevel})`);
             DynatraceBridge_1.DynatraceNative.setDataCollectionLevel(dataCollectionLevel.toString(), platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace setDataCollectionLevel(${dataCollectionLevel}): React Native plugin has not been started yet! Data Collection level will not be set!`);
+            logger.info(`setDataCollectionLevel(${dataCollectionLevel}): React Native plugin has not been started yet! Data Collection level will not be set!`);
         }
     },
     getUserPrivacyOptions: (platform) => __awaiter(void 0, void 0, void 0, function* () {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug('Dynatrace getUserPrivacyOptions()');
+            logger.debug('getUserPrivacyOptions()');
             const options = yield DynatraceBridge_1.DynatraceNative.getUserPrivacyOptions(platform === null || platform === void 0 ? void 0 : platform.toString());
             const currentOptions = new UserPrivacyOptions_1.UserPrivacyOptions((0, DataCollectionLevel_1.StringToDataCollectionLevel)(options.dataCollectionLevel), options.crashReportingOptedIn);
             return currentOptions;
         }
         else {
-            Logger_1.Logger.logInfo('Dynatrace getUserPrivacyOptions(): React Native plugin has not been started yet! User Privacy Options are not available!');
+            logger.info('getUserPrivacyOptions(): React Native plugin has not been started yet! User Privacy Options are not available!');
             return new UserPrivacyOptions_1.UserPrivacyOptions(DataCollectionLevel_1.DataCollectionLevel.Off, false);
         }
     }),
@@ -293,26 +302,26 @@ exports.Dynatrace = {
             if ((userPrivacyOptions.crashReportingOptedIn === true ||
                 userPrivacyOptions.crashReportingOptedIn === false) &&
                 userPrivacyOptions.dataCollectionLevel in DataCollectionLevel_1.DataCollectionLevel) {
-                Logger_1.Logger.logDebug(`Dynatrace applyUserPrivacyOptions(${JSON.stringify(userPrivacyOptions)})`);
+                logger.debug(`applyUserPrivacyOptions(${JSON.stringify(userPrivacyOptions)})`);
                 DynatraceBridge_1.DynatraceNative.applyUserPrivacyOptions(userPrivacyOptions, platform === null || platform === void 0 ? void 0 : platform.toString());
             }
         }
         else {
-            Logger_1.Logger.logInfo(`Dynatrace applyUserPrivacyOptions(${JSON.stringify(userPrivacyOptions)}): React Native plugin has not been started yet! User Privacy Options can't be applied!`);
+            logger.info(`applyUserPrivacyOptions(${JSON.stringify(userPrivacyOptions)}): React Native plugin has not been started yet! User Privacy Options can't be applied!`);
         }
     },
     flushEvents: (platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug('Dynatrace flushEvents()');
+            logger.debug('flushEvents()');
             DynatraceBridge_1.DynatraceNative.flushEvents(platform === null || platform === void 0 ? void 0 : platform.toString());
         }
         else {
-            Logger_1.Logger.logInfo('Dynatrace flushEvents(): React Native plugin has not been started yet! Flushing Event not possible!');
+            logger.info('flushEvents(): React Native plugin has not been started yet! Flushing Event not possible!');
         }
     },
     setBeaconHeaders: (headers, platform) => {
         if (ConfigurationHandler_1.ConfigurationHandler.isConfigurationAvailable()) {
-            Logger_1.Logger.logDebug('Dynatrace setBeaconHeaders(headers)');
+            logger.debug('setBeaconHeaders(headers)');
             if (headers && headers.size > 0) {
                 const obj = {};
                 headers.forEach((value, key) => (obj[key] = value));
@@ -323,7 +332,7 @@ exports.Dynatrace = {
             }
         }
         else {
-            Logger_1.Logger.logInfo('Dynatrace setBeaconHeaders(headers): React Native plugin has not been started yet! Setting Beacon Headers is not possible!');
+            logger.info('setBeaconHeaders(headers): React Native plugin has not been started yet! Setting Beacon Headers is not possible!');
         }
     },
 };