@dynatrace/react-native-plugin 2.327.2 → 2.331.1

package/ios/DynatraceRNBridge.h

@@ -8,6 +8,7 @@
 #import <Dynatrace/Dynatrace.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import "ConfigurationSubscriber.h"
 
 @interface DynatraceRNBridge : RCTEventEmitter <RCTBridgeModule>
 - (void) newAction:(NSString *)name key:(NSString *)key parentAction:(DTXAction *)parentAction;
@@ -18,6 +19,9 @@
 @interface HybridBridge : NSObject
 + (void)forwardEvent:(NSDictionary<NSString*,id>* _Nullable)fields NS_SWIFT_NAME(forwardEvent(fields:));
 + (void)forwardAppStartEvent:(NSDictionary<NSString*,id>* _Nullable)fields keys:(NSArray<NSString*>* _Nullable)keys NS_SWIFT_NAME(forwardEvent(fields:keys:));
++ (void)startView:(NSDictionary<NSString*,id>* _Nullable)fields NS_SWIFT_NAME(startView(fields:));
++ (void)stopView;
++ (void)addConfigurationSubscriber:(id<ConfigurationSubscriber>)subscriber;
 @end
 
 typedef enum : NSUInteger {

package/ios/DynatraceRNBridge.mm

@@ -13,12 +13,46 @@
 #import <CoreLocation/CoreLocation.h>
 #import <React/RCTPerformanceLogger.h>
 #import <React/RCTRootView.h>
+#import <React/RCTBridge+Private.h>
 #import <cxxreact/ReactMarker.h>
 #import <cxxreact/ReactNativeVersion.h>
 
 #include <chrono>
 #include <type_traits>
 
+@interface DynatraceRNBridge ()
+- (void)handleRuntimeConfiguration:(NSDictionary<NSString*, id>*)configuration;
+- (void)setupRuntimeConfigurationListenerIfNeeded;
+- (void)emitToJS:(NSString*)event body:(id)body;
+@end
+
+@interface RNConfigurationSubscriber : NSObject <ConfigurationSubscriber>
+@property (nonatomic, weak) DynatraceRNBridge* bridge;
+- (instancetype)initWithBridge:(DynatraceRNBridge*)bridge;
+@end
+
+@implementation RNConfigurationSubscriber
+
+- (instancetype)initWithBridge:(DynatraceRNBridge*)bridge
+{
+    self = [super init];
+    if (self) {
+        _bridge = bridge;
+    }
+    return self;
+}
+
+- (void)notifyWithConfiguration:(NSDictionary<NSString*, id>*)configuration
+{
+    DynatraceRNBridge* bridge = self.bridge;
+    if (bridge == nil) {
+        return;
+    }
+    [bridge handleRuntimeConfiguration:configuration];
+}
+
+@end
+
 @implementation DynatraceRNBridge
 
 NSMutableDictionary *actionDict;
@@ -37,6 +71,7 @@ NSString *const DataCollectionUserBehavior = @"USER_BEHAVIOR";
 * Emitting app start event with this identifier
 */
 NSString *const EmitAppMeasurementsIdentifier = @"dynatraceAppStartMeasurements";
+NSString *const EmitDynatraceConfiguration = @"dynatraceConfiguration";
 
 // All types which are interesting for us
 NSString *const DownloadStart = @"downloadStart";
@@ -71,6 +106,11 @@ int64_t runJSBundleStartTime;
 */
 int64_t runJSBundleEndTime;
 
+// Runtime configuration (remote config)
+static bool remoteConfigSubscribed;
+static NSDictionary<NSString*, id>* lastRuntimeConfiguration;
+static RNConfigurationSubscriber* configurationSubscriber;
+
 RCT_EXPORT_MODULE(DynatraceBridge);
 
 - (instancetype) init
@@ -83,6 +123,11 @@ RCT_EXPORT_MODULE(DynatraceBridge);
     contentAppeared = -1;
     runJSBundleStartTime = -1;
     runJSBundleEndTime = -1;
+
+    remoteConfigSubscribed = NO;
+    lastRuntimeConfiguration = nil;
+    configurationSubscriber = [[RNConfigurationSubscriber alloc] initWithBridge:self];
+
     registerLogTaggedMarkerCallbacks();
   }
   return self;
@@ -127,7 +172,7 @@ int64_t getRunJSBundleEndTime() {
 }
 
 - (NSArray<NSString *> *)supportedEvents {
-    return @[EmitAppMeasurementsIdentifier];
+    return @[EmitAppMeasurementsIdentifier, EmitDynatraceConfiguration];
 }
 
 int64_t GetTimestampUnix()
@@ -148,13 +193,13 @@ template<typename T = void> std::enable_if_t<(facebook::react::ReactNativeVersio
     using namespace facebook::react::ReactMarker;
     auto logTaggedMarkerCommon = [](const ReactMarkerId markerId, const char* tag, auto previousLogTaggedMarker) {
         if (previousLogTaggedMarker) {
-            previousLogTaggedMarker(markerId, tag); 
+            previousLogTaggedMarker(markerId, tag);
         }
 
         if (markerId == RUN_JS_BUNDLE_START) {
-            runJSBundleStartTime = GetTimestampUnix(); 
+            runJSBundleStartTime = GetTimestampUnix();
         } else if (markerId == RUN_JS_BUNDLE_STOP) {
-            runJSBundleEndTime = GetTimestampUnix(); 
+            runJSBundleEndTime = GetTimestampUnix();
         }
     };
 
@@ -182,7 +227,7 @@ template<typename T = void> std::enable_if_t<(facebook::react::ReactNativeVersio
 
 - (BOOL)isReady
 {
-    return contentAppeared != -1 && getRunJSBundleEndTime() != -1;  
+    return contentAppeared != -1 && getRunJSBundleEndTime() != -1;
 }
 
 - (void) contentAppeared
@@ -198,13 +243,13 @@ template<typename T = void> std::enable_if_t<(facebook::react::ReactNativeVersio
 {
     if (!didEmit && hasListeners && [self isReady]) {
         didEmit = YES;
-        
+
         NSMutableDictionary<NSString*, NSNumber*> *appStartMeasurements = [[NSMutableDictionary alloc] init];
-        
+
         [appStartMeasurements setObject:[self correctionOfTimestamp:getRunJSBundleStartTime()] forKey:RunJSBundleStart];
         [appStartMeasurements setObject:[self correctionOfTimestamp:getRunJSBundleEndTime()] forKey:RunJSBundleEnd];
         [appStartMeasurements setObject:[NSNumber numberWithLongLong:contentAppeared] forKey:ContentAppeared];
-        
+
         if (hasListeners) {
             [self sendEventWithName:EmitAppMeasurementsIdentifier body:appStartMeasurements];
         }
@@ -238,6 +283,12 @@ template<typename T = void> std::enable_if_t<(facebook::react::ReactNativeVersio
 {
     hasListeners = YES;
     [self emitMeasurements];
+
+    [self setupRuntimeConfigurationListenerIfNeeded];
+
+    if (lastRuntimeConfiguration != nil) {
+        [self emitToJS:EmitDynatraceConfiguration body:lastRuntimeConfiguration];
+    }
 }
 
 /**
@@ -248,6 +299,39 @@ template<typename T = void> std::enable_if_t<(facebook::react::ReactNativeVersio
     hasListeners = NO;
 }
 
+- (void)setupRuntimeConfigurationListenerIfNeeded
+{
+    if (remoteConfigSubscribed) {
+        return;
+    }
+    remoteConfigSubscribed = YES;
+    [HybridBridge addConfigurationSubscriber:(id)configurationSubscriber];
+}
+
+- (void)emitToJS:(NSString*)event body:(id)body
+{
+    if (self.bridge == nil) {
+        return;
+    }
+
+    id payload = body == nil ? [NSNull null] : body;
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self.bridge.eventDispatcher sendDeviceEventWithName:event body:payload];
+    });
+}
+
+- (void)handleRuntimeConfiguration:(NSDictionary<NSString*, id>*)configuration
+{
+    lastRuntimeConfiguration = configuration;
+
+    if (!hasListeners) {
+        return;
+    }
+
+    [self emitToJS:EmitDynatraceConfiguration body:configuration];
+}
+
 /**
 * Constants which are exported to the JS part
 */
@@ -265,9 +349,9 @@ RCT_EXPORT_METHOD(start:(NSDictionary *) options)
     if (options == nil) {
         return;
     }
-    
+
     NSMutableDictionary<NSString*, id> *properties = [[NSMutableDictionary alloc] init];
-    
+
     if (options[@"applicationId"] != NULL) {
         properties[@"DTXApplicationID"] = options[@"applicationId"];
     }
@@ -279,11 +363,11 @@ RCT_EXPORT_METHOD(start:(NSDictionary *) options)
     if (options[@"userOptIn"] != NULL && [[options valueForKey:@"userOptIn"] isEqual: @(YES)]) {
         properties[@"DTXUserOptIn"] = @YES;
     }
-    
+
     if (options[@"reportCrash"] != NULL && [[options valueForKey:@"reportCrash"] isEqual: @(NO)]) {
         properties[@"DTXCrashReportingEnabled"] = @NO;
     }
-    
+
     if (options[@"logLevel"] != NULL && [((NSNumber *) options[@"logLevel"]) intValue] == 0){
         properties[@"DTXLogLevel"] = @"ALL";
     }
@@ -309,7 +393,7 @@ RCT_EXPORT_METHOD(enterManualAction:(NSString *)name key:(nonnull NSString *)key
   if ([self shouldWorkOnIosWithPlatform: platform])
   {
     DTXAction *action = [DTXAction enterActionWithName:name];
-    
+
     if (action)
     {
         [actionDict setObject:action forKey:key];
@@ -326,7 +410,7 @@ RCT_EXPORT_METHOD(enterManualActionWithParent:(NSString *)name key:(nonnull NSSt
         if (parentAction != nil)
         {
             DTXAction *childAction = [DTXAction enterActionWithName:name parentAction:parentAction];
-            
+
             if (childAction)
             {
                 [actionDict setObject:childAction forKey:key];
@@ -378,11 +462,6 @@ 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])
@@ -406,11 +485,11 @@ RCT_EXPORT_METHOD(reportCrash:(NSString *)errorName errorReason:(NSString *)erro
     if ([self shouldWorkOnIosWithPlatform: platform])
     {
         if(isRealError){
-            [DTXAction reportExternalCrashForPlatformType:DTXActionPlatformJavaScript crashName:errorName reason:errorReason stacktrace:stacktrace]; 
+            [DTXAction reportExternalCrashForPlatformType:DTXActionPlatformJavaScript crashName:errorName reason:errorReason stacktrace:stacktrace];
         }else{
             [DTXAction reportExternalCrashForPlatformType:DTXActionPlatformCustom crashName:errorName reason:errorReason stacktrace:stacktrace];
         }
-        
+
         // Always end the session as the iOS agent has no troubles with this behavior
         [Dynatrace endVisit];
     }
@@ -488,7 +567,6 @@ RCT_EXPORT_METHOD(startWebRequestTiming:(NSString*) requestTag url:(NSString*) u
             [timing startWebRequestTiming];
         }
     }
-    
 }
 
 - (void)stopWebRequestTimingHelper:(NSString*) requestTag url:(NSString*)url responseCode:(nonnull NSNumber*) responseCode responseMessage:(NSString*)responseMessage bytesSent:(nonnull NSNumber*)bytesSent bytesReceived:(nonnull NSNumber*)bytesReceived
@@ -590,7 +668,7 @@ RCT_EXPORT_METHOD(getDataCollectionLevel:(NSString *) platform findEventsWithRes
     if ([self shouldWorkOnIosWithPlatform: platform])
     {
         int i = [Dynatrace dataCollectionLevel];
-        
+
         if(i == DTX_DataCollectionUserBehavior){
             resolve(DataCollectionUserBehavior);
         }else if(i == DTX_DataCollectionPerformance){
@@ -633,7 +711,7 @@ RCT_EXPORT_METHOD(getUserPrivacyOptions:(NSString *) platform findEventsWithReso
     {
         id<DTXUserPrivacyOptions> privacyConfig = [Dynatrace userPrivacyOptions];
         NSString * level;
-        
+
         if(privacyConfig.dataCollectionLevel == DTX_DataCollectionUserBehavior){
             level = DataCollectionUserBehavior;
         }else if(privacyConfig.dataCollectionLevel == DTX_DataCollectionPerformance){
@@ -653,7 +731,7 @@ RCT_EXPORT_METHOD(applyUserPrivacyOptions:(NSDictionary *) userPrivacyOptions pl
     if ([self shouldWorkOnIosWithPlatform: platform])
     {
         id<DTXUserPrivacyOptions> privacyConfig = [Dynatrace userPrivacyOptions];
-        
+
         if([[userPrivacyOptions valueForKey:@"_dataCollectionLevel"] isEqualToString: DataCollectionPerformance]){
             privacyConfig.dataCollectionLevel = DTX_DataCollectionPerformance;
         }else if([[userPrivacyOptions valueForKey:@"_dataCollectionLevel"] isEqualToString: DataCollectionUserBehavior]){
@@ -663,7 +741,7 @@ RCT_EXPORT_METHOD(applyUserPrivacyOptions:(NSDictionary *) userPrivacyOptions pl
         } else {
             // do nothing and keep current value
         }
-        
+
         if ([[userPrivacyOptions valueForKey:@"_crashReportingOptedIn"] isEqual: @(YES)]) {
             privacyConfig.crashReportingOptedIn = YES;
         } else if ([[userPrivacyOptions valueForKey:@"_crashReportingOptedIn"]  isEqual: @(NO)]) {
@@ -678,10 +756,29 @@ RCT_EXPORT_METHOD(applyUserPrivacyOptions:(NSDictionary *) userPrivacyOptions pl
     }
 }
 
+RCT_EXPORT_METHOD(getCurrentConfiguration:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    if (lastRuntimeConfiguration != nil) {
+        resolve(lastRuntimeConfiguration);
+    } else {
+        resolve([NSNull null]);
+    }
+}
+
+RCT_EXPORT_METHOD(startViewInternal:(NSDictionary<NSString*, id>*) fields)
+{
+    [HybridBridge startView:fields];
+}
+
+RCT_EXPORT_METHOD(stopViewInternal)
+{
+    [HybridBridge stopView];
+}
+
 - (void)newAction:(NSString *)name key:(nonnull NSString *)key parentAction:(DTXAction *)parentAction
 {
     DTXAction *action = [DTXAction integrateActionWithName:name];
-    
+
     if (action)
     {
         [actionDict setObject:action forKey:key];
@@ -693,7 +790,6 @@ RCT_EXPORT_METHOD(applyUserPrivacyOptions:(NSDictionary *) userPrivacyOptions pl
   return [actionDict objectForKey:key];
 }
 
-
 + (BOOL)requiresMainQueueSetup
 {
   return YES;
@@ -713,4 +809,4 @@ RCT_EXPORT_METHOD(applyUserPrivacyOptions:(NSDictionary *) userPrivacyOptions pl
  }
 #endif
 
-@end
+@end

package/lib/core/Dynatrace.js

@@ -338,22 +338,19 @@ exports.Dynatrace = {
     },
     addEventModifier: (eventModifier) => Dynatrace_1.Dynatrace.addEventModifier(eventModifier),
     removeEventModifier: (eventModifier) => Dynatrace_1.Dynatrace.removeEventModifier(eventModifier),
-    sendEvent: (properties) => {
-        Dynatrace_1.Dynatrace.sendEvent(properties);
-    },
     startView: (name) => {
         Dynatrace_1.Dynatrace.startView(name);
     },
-    stopView: () => {
-        Dynatrace_1.Dynatrace.stopView();
+    sendEvent: (customEvent) => {
+        Dynatrace_1.Dynatrace.sendEvent(customEvent);
     },
-    sendSessionPropertyEvent: (properties) => {
-        Dynatrace_1.Dynatrace.sendSessionPropertyEvent(properties);
+    sendSessionPropertyEvent: (sessionPropertyEventData) => {
+        Dynatrace_1.Dynatrace.sendSessionPropertyEvent(sessionPropertyEventData);
     },
-    sendExceptionEvent: (error, fields) => {
-        Dynatrace_1.Dynatrace.sendExceptionEvent(error, fields);
+    sendExceptionEvent: (exceptionEvent) => {
+        Dynatrace_1.Dynatrace.sendExceptionEvent(exceptionEvent);
     },
-    sendHttpRequestEvent(httpRequestEventBuilder) {
-        Dynatrace_1.Dynatrace.sendHttpRequestEvent(httpRequestEventBuilder);
+    sendHttpRequestEvent: (httpRequestEvent) => {
+        Dynatrace_1.Dynatrace.sendHttpRequestEvent(httpRequestEvent);
     },
 };

package/lib/core/configuration/ConfigurationHandler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigurationHandler = void 0;
+const RuntimeConfigurationObserver_1 = require("../../next/configuration/RuntimeConfigurationObserver");
 const LogLevel_1 = require("../logging/LogLevel");
 let _configuration;
 exports.ConfigurationHandler = {
@@ -14,6 +15,8 @@ exports.ConfigurationHandler = {
         _configuration.logLevel === LogLevel_1.LogLevel.Debug,
     isLifecycleUpdateEnabled: () => _configuration.lifecycleUpdate,
     isActionNamePrivacyEnabled: () => _configuration.actionNamePrivacy,
+    isGrailEnabled: () => RuntimeConfigurationObserver_1.RuntimeConfigurationObserver.getCurrentRuntimeConfiguration()['3rd_gen_enabled'],
+    isRuntimeConfigurationInitiated: () => RuntimeConfigurationObserver_1.RuntimeConfigurationObserver.isInitiated(),
     getBundleName: () => _configuration.bundleName,
     getBundleVersion: () => _configuration.bundleVersion,
 };

package/lib/next/Dynatrace.js

@@ -7,24 +7,41 @@ 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");
+const EventData_1 = require("./events/EventData");
+const SessionPropertyEventData_1 = require("./events/SessionPropertyEventData");
+const ExceptionEventData_1 = require("./events/ExceptionEventData");
+const HttpRequestEventData_1 = require("./events/HttpRequestEventData");
+const DynatraceArgValidators_1 = require("./DynatraceArgValidators");
 class DynatraceImpl {
     constructor(timestampProvider) {
         this.timestampProvider = timestampProvider;
         this.logger = new ConsoleLogger_1.ConsoleLogger('Dynatrace');
     }
     addEventModifier(eventModifier) {
+        if (!(0, DynatraceArgValidators_1.isEventModifier)(eventModifier)) {
+            this.logger.info('addEventModifier(eventModifier): eventModifier is not of type IEventModifier');
+            return {
+                modifyEvent: (event) => event,
+            };
+        }
         this.logger.debug('addEventModifier()');
         return EventPipeline_1.EventPipeline.addEventModifier(eventModifier);
     }
     removeEventModifier(eventModifier) {
+        if (!(0, DynatraceArgValidators_1.isEventModifier)(eventModifier)) {
+            this.logger.info('removeEventModifier(eventModifier): eventModifier is not of type IEventModifier');
+            return false;
+        }
         this.logger.debug('removeEventModifier()');
         return EventPipeline_1.EventPipeline.removeEventModifier(eventModifier);
     }
     startView(name) {
+        if (typeof name !== 'string') {
+            this.logger.info(`startView(name): Name must be a string!`);
+            return;
+        }
         this.logger.debug(`startView(${name})`);
-        EventPipeline_1.EventPipeline.generateViewData(name);
         if (name != null && name.length > 0) {
             DynatraceBridge_1.DynatraceNative.startView(name);
         }
@@ -32,11 +49,6 @@ class DynatraceImpl {
             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);
@@ -67,42 +79,47 @@ class DynatraceImpl {
         }
         EventPipeline_1.EventPipeline.insertEvent(event);
     }
-    sendExceptionEvent(error, fields) {
-        this.logger.debug(`sendExceptionEvent(${JSON.stringify(error)}, ${JSON.stringify(fields)})`);
-        const event = Object.assign({}, (0, EventCreator_1.createErrorEvent)(error.name, error.message, error.stack));
-        let eventValidated = null;
-        if (fields) {
-            eventValidated = Object.assign({}, SendEventValidation_1.SendEventValidation.modifyEvent(fields));
-        }
-        eventValidated = Object.assign(Object.assign({}, event), eventValidated);
-        (0, EventModifierUtil_1.addIsApiReported)(eventValidated);
-        EventPipeline_1.EventPipeline.insertEvent(eventValidated);
+    sendExceptionEvent(exceptionEventData) {
+        if (!(exceptionEventData instanceof ExceptionEventData_1.default)) {
+            this.logger.info('sendExceptionEvent(exceptionEventData): exceptionEventData is not of type ExceptionEventData');
+            return;
+        }
+        this.logger.debug('sendExceptionEvent(exceptionEventData)');
+        const eventValidated = exceptionEventData.toJSON();
+        if (eventValidated !== null) {
+            EventPipeline_1.EventPipeline.insertEvent(eventValidated);
+        }
     }
-    sendEvent(properties) {
-        this.logger.debug(`sendEvent(${JSON.stringify(properties)})`);
-        const eventValidated = SendEventValidation_1.SendEventValidation.modifyEvent(properties);
+    sendEvent(eventData) {
+        if (!(eventData instanceof EventData_1.default)) {
+            this.logger.info('sendEvent(eventData): eventData is not of type EventData');
+            return;
+        }
+        this.logger.debug('sendEvent(eventData)');
+        const eventValidated = eventData.toJSON();
         if (eventValidated !== null) {
-            (0, EventModifierUtil_1.flagEventProperties)(eventValidated);
-            (0, EventModifierUtil_1.addIsApiReported)(eventValidated);
             EventPipeline_1.EventPipeline.insertEvent(eventValidated);
         }
     }
-    sendSessionPropertyEvent(properties) {
-        this.logger.debug(`sendSessionPropertyEvent(${JSON.stringify(properties)})`);
-        const eventValidated = SendEventValidation_1.SendSessionPropertyEventValidation.modifyEvent(properties);
+    sendSessionPropertyEvent(sessionPropertyEventData) {
+        if (!(sessionPropertyEventData instanceof SessionPropertyEventData_1.default)) {
+            this.logger.info('sendSessionPropertyEvent(SessionPropertyEventData): sessionPropertyEventData is not of type SessionPropertyEventData');
+            return;
+        }
+        this.logger.debug('sendSessionPropertyEvent(SessionPropertyEventData)');
+        const eventValidated = sessionPropertyEventData.toJSON();
         if (eventValidated !== null) {
-            if ((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)})`);
+    sendHttpRequestEvent(httpRequestEvent) {
+        if (!(httpRequestEvent instanceof HttpRequestEventData_1.default)) {
+            this.logger.info('sendHttpRequestEvent(HttpRequestEventData): httpRequestEvent is not of type HttpRequestEventData');
+            return;
+        }
+        this.logger.debug('sendHttpRequestEvent(HttpRequestEventData)');
+        const sanitizedEvent = httpRequestEvent.toJSON();
         if (sanitizedEvent !== null) {
-            (0, EventModifierUtil_1.flagEventProperties)(sanitizedEvent);
             EventPipeline_1.EventPipeline.insertEvent(sanitizedEvent);
         }
     }

package/lib/next/DynatraceArgValidators.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEventModifier = void 0;
+function isEventModifier(eventModifier) {
+    return (typeof eventModifier === 'object' &&
+        eventModifier !== null &&
+        'modifyEvent' in eventModifier &&
+        typeof eventModifier.modifyEvent === 'function');
+}
+exports.isEventModifier = isEventModifier;

package/lib/next/DynatraceEventBus.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addListenerOnce = exports.createEmitterNativeOnly = exports.createEmitterRuntimeConfig = void 0;
+const react_native_1 = require("react-native");
+const DynatraceBridge_1 = require("../core/DynatraceBridge");
+const isEmptyObject = (value) => {
+    if (value == null) {
+        return true;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+    return Object.keys(value).length === 0;
+};
+const createEmitterRuntimeConfig = () => {
+    if (react_native_1.Platform.OS === 'ios' && isEmptyObject(DynatraceBridge_1.DynatraceNative || {})) {
+        return null;
+    }
+    const iosModule = react_native_1.NativeModules.DynatraceBridge;
+    const nativeEmitterModule = react_native_1.Platform.OS === 'android' ? DynatraceBridge_1.DynatraceNative : iosModule;
+    return new react_native_1.NativeEventEmitter(nativeEmitterModule);
+};
+exports.createEmitterRuntimeConfig = createEmitterRuntimeConfig;
+const createEmitterNativeOnly = () => new react_native_1.NativeEventEmitter(DynatraceBridge_1.DynatraceNative);
+exports.createEmitterNativeOnly = createEmitterNativeOnly;
+const addListenerOnce = (emitter, current, eventName, handler) => {
+    if (current != null) {
+        return current;
+    }
+    if (emitter == null) {
+        return null;
+    }
+    return emitter.addListener(eventName, handler);
+};
+exports.addListenerOnce = addListenerOnce;

package/lib/next/appstart/AppStartObserver.js

@@ -1,11 +1,10 @@
 "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");
+const DynatraceEventBus_1 = require("../DynatraceEventBus");
 class AppStartObserverImpl {
     constructor() {
         this.EMIT_APP_START = 'dynatraceAppStartMeasurements';
@@ -15,7 +14,7 @@ class AppStartObserverImpl {
     call() {
     }
     setupNativeEventEmitter() {
-        const emitter = new react_native_1.NativeEventEmitter(DynatraceBridge_1.DynatraceNative);
+        const emitter = (0, DynatraceEventBus_1.createEmitterNativeOnly)();
         emitter.addListener(this.EMIT_APP_START, (data) => {
             this.logger.debug(`emitter(${JSON.stringify(data)}})`);
             const appStartEvent = (0, EventCreator_1.createAppStartEvent)(data);

package/lib/next/configuration/INativeRuntimeConfiguration.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultConfiguration = void 0;
+const generateDefaultConfiguration = () => ({
+    '3rd_gen_enabled': true,
+});
+exports.generateDefaultConfiguration = generateDefaultConfiguration;

package/lib/next/configuration/RuntimeConfigurationObserver.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeConfigurationObserver = void 0;
+const DynatraceBridge_1 = require("../../core/DynatraceBridge");
+const DynatraceEventBus_1 = require("../DynatraceEventBus");
+const INativeRuntimeConfiguration_1 = require("./INativeRuntimeConfiguration");
+class RuntimeConfigurationObserverImpl {
+    constructor() {
+        this.EMIT_CONFIGURATION = 'dynatraceConfiguration';
+        this.runtimeConfiguration = (0, INativeRuntimeConfiguration_1.generateDefaultConfiguration)();
+        this.observerIsInitiated = false;
+        this.subscription = null;
+        this.setupNativeEventEmitter();
+    }
+    getCurrentRuntimeConfiguration() {
+        return this.runtimeConfiguration;
+    }
+    isInitiated() {
+        return this.observerIsInitiated;
+    }
+    setupNativeEventEmitter() {
+        const emitter = (0, DynatraceEventBus_1.createEmitterRuntimeConfig)();
+        this.subscription = (0, DynatraceEventBus_1.addListenerOnce)(emitter, this.subscription, this.EMIT_CONFIGURATION, (data) => {
+            this.runtimeConfiguration = data;
+            this.observerIsInitiated = true;
+        });
+        if (typeof DynatraceBridge_1.DynatraceNative.getCurrentConfiguration === 'function') {
+            Promise.resolve(DynatraceBridge_1.DynatraceNative.getCurrentConfiguration())
+                .then((data) => {
+                if (data) {
+                    this.runtimeConfiguration = data;
+                    this.observerIsInitiated = true;
+                }
+            })
+                .catch(() => {
+            });
+        }
+    }
+}
+exports.RuntimeConfigurationObserver = new RuntimeConfigurationObserverImpl();

package/lib/next/events/EventBuilderUtil.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includeIfTrue = exports.includeIfDefined = void 0;
+const includeIfDefined = (key, value) => (value !== undefined ? { [key]: value } : {});
+exports.includeIfDefined = includeIfDefined;
+const includeIfTrue = (key, value) => value === true ? { [key]: value } : {};
+exports.includeIfTrue = includeIfTrue;