@truewatchtech/react-native-mobile 0.4.1 → 0.4.3-alpha.2

package/ios/FTJSLongTaskMonitor.m

@@ -0,0 +1,250 @@
+#import "FTJSLongTaskMonitor.h"
+
+#import <QuartzCore/CADisplayLink.h>
+#import <TrueWatchSDK/FTExternalDataManager.h>
+#import <React/RCTBridge.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTJSThread.h>
+
+static const double FTNanosecondsPerSecond = 1000000000.0;
+
+@interface FTReactBridgeJSQueue : NSObject <FTJSLongTaskQueue>
+@property (nonatomic, weak) RCTBridge *bridge;
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+@end
+
+@implementation FTReactBridgeJSQueue
+- (instancetype)initWithBridge:(RCTBridge *)bridge {
+  self = [super init];
+  if (self) {
+    _bridge = bridge;
+  }
+  return self;
+}
+
+- (BOOL)dispatchBlock:(dispatch_block_t)block {
+  RCTBridge *bridge = self.bridge;
+  if (bridge == nil) {
+    return NO;
+  }
+  @try {
+    // RCTBridgeProxy.valid is always NO, including while bridgeless RN is active.
+    [bridge dispatchBlock:block queue:RCTJSThread];
+    return YES;
+  } @catch (NSException *exception) {
+    // Bridge teardown may race a start request. Monitoring must not take down the host.
+    return NO;
+  }
+}
+@end
+
+// The display link retains this callback target, not the scheduler that owns it.
+@interface FTJSLongTaskDisplayLinkTarget : NSObject
+@property (nonatomic, copy) FTJSLongTaskFrameCallback callback;
+@end
+
+@implementation FTJSLongTaskDisplayLinkTarget
+- (void)displayLinkDidFire:(CADisplayLink *)displayLink {
+  self.callback(displayLink.timestamp);
+}
+@end
+
+@interface FTCADisplayLinkScheduler : NSObject <FTJSLongTaskFrameScheduler>
+@property (nonatomic, copy) FTJSLongTaskFrameCallback callback;
+@property (nonatomic, strong, nullable) CADisplayLink *displayLink;
+- (instancetype)initWithCallback:(FTJSLongTaskFrameCallback)callback;
+@end
+
+@implementation FTCADisplayLinkScheduler
+- (instancetype)initWithCallback:(FTJSLongTaskFrameCallback)callback {
+  self = [super init];
+  if (self) {
+    _callback = [callback copy];
+  }
+  return self;
+}
+
+- (void)start {
+  [self stop];
+  FTJSLongTaskDisplayLinkTarget *target = [FTJSLongTaskDisplayLinkTarget new];
+  target.callback = self.callback;
+  self.displayLink = [CADisplayLink displayLinkWithTarget:target selector:@selector(displayLinkDidFire:)];
+  [self.displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+- (void)stop {
+  // CADisplayLink.invalidate is thread safe and releases its run loop and target
+  // references without requiring a live JS queue.
+  [self.displayLink invalidate];
+  self.displayLink = nil;
+}
+
+- (void)dealloc {
+  [_displayLink invalidate];
+}
+@end
+
+@interface FTCADisplayLinkSchedulerFactory : NSObject <FTJSLongTaskFrameSchedulerFactory>
+@end
+
+@implementation FTCADisplayLinkSchedulerFactory
+- (id<FTJSLongTaskFrameScheduler>)createSchedulerWithCallback:(FTJSLongTaskFrameCallback)callback {
+  return [[FTCADisplayLinkScheduler alloc] initWithCallback:callback];
+}
+@end
+
+@interface FTNativeLongTaskReporter : NSObject <FTJSLongTaskReporter>
+@end
+
+@implementation FTNativeLongTaskReporter
+- (void)reportLongTaskWithDurationNanoseconds:(int64_t)durationNanoseconds property:(NSDictionary *)property {
+  [[FTExternalDataManager sharedManager]
+    addLongTaskWithStack:@""
+    duration:@(durationNanoseconds)
+    property:property];
+}
+@end
+
+@interface FTJSLongTaskMonitor ()
+@property (nonatomic, strong) id<FTJSLongTaskQueue> queue;
+@property (nonatomic, strong) id<FTJSLongTaskFrameSchedulerFactory> schedulerFactory;
+@property (nonatomic, strong) id<FTJSLongTaskReporter> reporter;
+@property (nonatomic, strong) NSObject *stateLock;
+@property (nonatomic, assign) NSTimeInterval thresholdSeconds;
+@property (nonatomic, assign) NSUInteger generation;
+@property (nonatomic, assign) BOOL requestedRunning;
+@property (nonatomic, strong, nullable) id<FTJSLongTaskFrameScheduler> scheduler;
+@property (nonatomic, assign) NSUInteger activeGeneration;
+@property (nonatomic, assign) CFTimeInterval lastFrameTimestamp;
+@property (atomic, copy) NSDictionary *bridgeContext;
+@end
+
+@implementation FTJSLongTaskMonitor
+
++ (instancetype)monitorWithBridge:(RCTBridge *)bridge {
+  return [[self alloc]
+    initWithQueue:[[FTReactBridgeJSQueue alloc] initWithBridge:bridge]
+    schedulerFactory:[FTCADisplayLinkSchedulerFactory new]
+    reporter:[FTNativeLongTaskReporter new]];
+}
+
+- (instancetype)initWithQueue:(id<FTJSLongTaskQueue>)queue
+              schedulerFactory:(id<FTJSLongTaskFrameSchedulerFactory>)schedulerFactory
+                       reporter:(id<FTJSLongTaskReporter>)reporter {
+  self = [super init];
+  if (self) {
+    _queue = queue;
+    _schedulerFactory = schedulerFactory;
+    _reporter = reporter;
+    _stateLock = [NSObject new];
+    _bridgeContext = @{};
+  }
+  return self;
+}
+
+- (void)setThresholdMilliseconds:(double)thresholdMilliseconds {
+  @synchronized (self.stateLock) {
+    self.thresholdSeconds = thresholdMilliseconds <= 0 ? 0 : thresholdMilliseconds / 1000.0;
+    if (thresholdMilliseconds <= 0) {
+      [self stopLocked];
+    }
+  }
+}
+
+- (void)start {
+  NSUInteger startGeneration;
+  @synchronized (self.stateLock) {
+    if (self.thresholdSeconds == 0) {
+      return;
+    }
+    self.requestedRunning = YES;
+    startGeneration = ++self.generation;
+  }
+
+  __weak typeof(self) weakSelf = self;
+  BOOL dispatched = [self.queue dispatchBlock:^{
+    // A pending block must not keep a destroyed monitor (and its queue) alive.
+    typeof(self) strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    @synchronized (strongSelf.stateLock) {
+      if (strongSelf.generation != startGeneration || !strongSelf.requestedRunning) {
+        return;
+      }
+      [strongSelf.scheduler stop];
+      strongSelf.scheduler = [strongSelf.schedulerFactory createSchedulerWithCallback:^(CFTimeInterval timestamp) {
+        [weakSelf handleFrameTimestamp:timestamp generation:startGeneration];
+      }];
+      strongSelf.activeGeneration = startGeneration;
+      strongSelf.lastFrameTimestamp = 0;
+      [strongSelf.scheduler start];
+    }
+  }];
+  if (!dispatched) {
+    @synchronized (self.stateLock) {
+      if (self.generation == startGeneration) {
+        [self stopLocked];
+      }
+    }
+  }
+}
+
+- (void)stop {
+  [self stopWithCompletion:nil];
+}
+
+- (void)disableWithCompletion:(dispatch_block_t)completion {
+  @synchronized (self.stateLock) {
+    self.thresholdSeconds = 0;
+    [self stopLocked];
+  }
+  if (completion != nil) {
+    completion();
+  }
+}
+
+- (void)stopWithCompletion:(dispatch_block_t)completion {
+  @synchronized (self.stateLock) {
+    [self stopLocked];
+  }
+  if (completion != nil) {
+    completion();
+  }
+}
+
+// Caller holds stateLock, also used by scheduler installation and frame callbacks.
+// Cleanup deliberately never dispatches to RN: an invalid proxy may silently drop it.
+- (void)stopLocked {
+  self.requestedRunning = NO;
+  self.generation++;
+  [self.scheduler stop];
+  self.scheduler = nil;
+  self.activeGeneration = 0;
+  self.lastFrameTimestamp = 0;
+}
+
+- (void)handleFrameTimestamp:(CFTimeInterval)timestamp generation:(NSUInteger)generation {
+  @synchronized (self.stateLock) {
+    if (!self.requestedRunning || self.generation != generation ||
+        self.activeGeneration != generation || self.scheduler == nil) {
+      return;
+    }
+    if (self.lastFrameTimestamp != 0) {
+      NSTimeInterval duration = timestamp - self.lastFrameTimestamp;
+      if (duration > self.thresholdSeconds) {
+        int64_t durationNanoseconds = (int64_t)(duration * FTNanosecondsPerSecond);
+        // Capture at detection; later updates must not change an already reported event.
+        NSDictionary *property = self.bridgeContext;
+        [self.reporter reportLongTaskWithDurationNanoseconds:durationNanoseconds property:property];
+      }
+    }
+    self.lastFrameTimestamp = timestamp;
+  }
+}
+
+- (void)dealloc {
+  [_scheduler stop];
+}
+
+@end

package/ios/FTMobileReactNative.mm

@@ -8,12 +8,13 @@
 
 #import "FTMobileReactNative.h"
 #import <React/RCTConvert.h>
-#import <FTMobileSDK/FTMobileAgent.h>
-#import <FTMobileSDK/FTMobileConfig+Private.h>
-#import <FTMobileSDK/FTThreadDispatchManager.h>
-#import <FTMobileSDK/FTConstants.h>
-#import <FTMobileSDK/FTJSONUtil.h>
-#import <FTMobileSDK/FTRemoteConfigModel+Private.h>
+#import <TrueWatchSDK/FTMobileAgent.h>
+#import <TrueWatchSDK/FTSDKConfig+Private.h>
+#import <TrueWatchSDK/FTThreadDispatchManager.h>
+#import <TrueWatchSDK/FTConstants.h>
+#import <TrueWatchSDK/FTJSONUtil.h>
+#import <TrueWatchSDK/FTRemoteConfigModel+Private.h>
+#import "FTWebSocketMetadataStore.h"
 
 static NSString *const FTRemoteConfigCallbackEvent = @"ft_remote_config_callback";
 
@@ -373,14 +374,14 @@ RCT_REMAP_METHOD(clearAllData,
 #endif
 - (void)sdkConfig:(NSDictionary *)context resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   [FTThreadDispatchManager performBlockDispatchMainSyncSafe:^{
-    FTMobileConfig *config;
+    FTSDKConfig *config;
     NSString *datakitUrl = [RCTConvert NSString:context[@"datakitUrl"]];
     NSString *dataWayUrl = [RCTConvert NSString:context[@"datawayUrl"]];
     NSString *clientToken = [RCTConvert NSString:context[@"clientToken"]];
     if(dataWayUrl && dataWayUrl.length>0 && clientToken && clientToken.length>0){
-      config = [[FTMobileConfig alloc]initWithDatawayUrl:dataWayUrl clientToken:clientToken];
+      config = [[FTSDKConfig alloc]initWithDatawayUrl:dataWayUrl clientToken:clientToken];
     }else if(datakitUrl && datakitUrl.length>0){
-      config = [[FTMobileConfig alloc]initWithDatakitUrl:datakitUrl];
+      config = [[FTSDKConfig alloc]initWithDatakitUrl:datakitUrl];
     }else{
       resolve(nil);
       return;
@@ -421,6 +422,12 @@ RCT_REMAP_METHOD(clearAllData,
     if ([context.allKeys containsObject:@"compressIntakeRequests"]) {
       config.compressIntakeRequests = [RCTConvert BOOL:context[@"compressIntakeRequests"]];
     }
+    if ([context.allKeys containsObject:@"enableDataFilter"]) {
+      config.enableDataFilter = [RCTConvert BOOL:context[@"enableDataFilter"]];
+    }
+    if ([context.allKeys containsObject:@"dataFilters"]) {
+      config.dataFilters = [RCTConvert NSDictionary:context[@"dataFilters"]];
+    }
     if ([context.allKeys containsObject:@"globalContext"]) {
       config.globalContext = [RCTConvert NSDictionary:context[@"globalContext"]];
     }
@@ -484,6 +491,7 @@ RCT_REMAP_METHOD(clearAllData,
       };
     }
     [FTMobileAgent startWithConfigOptions:config];
+    [FTWebSocketMetadataStore sdkDidStart];
     resolve(nil);
   }];
 }
@@ -531,6 +539,7 @@ RCT_REMAP_METHOD(clearAllData,
 }
 
 - (void)shutDown:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
+  [FTWebSocketMetadataStore shutDown];
   [FTMobileAgent shutDown];
   resolve(nil);
 }
@@ -547,9 +556,8 @@ RCT_REMAP_METHOD(clearAllData,
 
   }];
 }
-RCT_REMAP_METHOD(updateRemoteConfig,
-                 updateRemoteConfig_findEventsWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject){
+RCT_EXPORT_METHOD(updateRemoteConfig:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject){
     if (!_remoteConfigurationEnabled) {
       reject(@"E_REMOTE_CONFIG_DISABLED", @"Remote configuration is not enabled.", nil);
       return;
@@ -574,11 +582,10 @@ RCT_REMAP_METHOD(updateRemoteConfig,
       return nil;
     }];
 }
-RCT_REMAP_METHOD(updateRemoteConfigWithMiniUpdateInterval,
-                  interval:(int)interval
+RCT_EXPORT_METHOD(updateRemoteConfigWithMiniUpdateInterval:(double)interval
                   rules:(NSArray *)rules
-                  findEventsWithResolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject){
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject){
   if (!_remoteConfigurationEnabled) {
     reject(@"E_REMOTE_CONFIG_DISABLED", @"Remote configuration is not enabled.", nil);
     return;

package/ios/FTReactNativeLog.mm

@@ -7,9 +7,9 @@
 //
 
 #import "FTReactNativeLog.h"
-#import <FTMobileSDK/FTMobileAgent.h>
+#import <TrueWatchSDK/FTMobileAgent.h>
 #import <React/RCTConvert.h>
-#import <FTMobileSDK/FTLogger+Private.h>
+#import <TrueWatchSDK/FTLogger+Private.h>
 @implementation FTReactNativeLog
 RCT_EXPORT_MODULE()
 
@@ -43,7 +43,7 @@ RCT_REMAP_METHOD(logWithStatusString,
 - (void)logConfig:(NSDictionary *)context resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   FTLoggerConfig *logger = [[FTLoggerConfig alloc]init];
   if ([context.allKeys containsObject:@"sampleRate"]) {
-      logger.samplerate  = [RCTConvert double:context[@"sampleRate"]]*100;
+      logger.sampleRate = [RCTConvert double:context[@"sampleRate"]] * 100;
   }
   NSArray<NSNumber *>*filters = [RCTConvert NSNumberArray:context[@"logLevelFilters"]];
   if (filters) {
@@ -76,4 +76,3 @@ RCT_REMAP_METHOD(logWithStatusString,
 }
 
 @end
-

package/ios/FTReactNativeRUM.mm

@@ -7,21 +7,48 @@
 //
 
 #import "FTReactNativeRUM.h"
-#import <FTMobileSDK/FTMobileAgent.h>
-#import <FTMobileSDK/FTExternalDataManager.h>
-#import <FTMobileSDK/FTResourceMetricsModel.h>
-#import <FTMobileSDK/FTResourceContentModel.h>
+#import <TrueWatchSDK/FTMobileAgent.h>
+#import <TrueWatchSDK/FTExternalDataManager.h>
+#import "FTReactNativeResource.h"
 #import <React/RCTConvert.h>
+#import <React/RCTBridge.h>
+#import <UIKit/UIKit.h>
 #import "FTReactNativeUtils.h"
+#import "FTJSLongTaskMonitor.h"
+
+@interface FTReactNativeRUM ()
+@property (atomic, strong, nullable) FTJSLongTaskMonitor *jsLongTaskMonitor;
+- (FTJSLongTaskMonitor *)getOrCreateLongTaskMonitor;
+@end
+
 
 @implementation FTReactNativeRUM
+@synthesize bridge = _bridge;
 RCT_EXPORT_MODULE()
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(setLongTaskContext:(NSDictionary *)context) {
+  [[self getOrCreateLongTaskMonitor] setBridgeContext:context ?: @{}];
+  return @YES;
+}
+
+- (FTJSLongTaskMonitor *)getOrCreateLongTaskMonitor {
+  @synchronized (self) {
+    if (self.jsLongTaskMonitor == nil) {
+      self.jsLongTaskMonitor = [FTJSLongTaskMonitor monitorWithBridge:self.bridge];
+    }
+    return self.jsLongTaskMonitor;
+  }
+}
 RCT_REMAP_METHOD(setConfig,
                  context:(NSDictionary *)context
                  findEventsWithResolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject){
   [self setConfig:context resolve:resolve reject:reject];
 }
+RCT_REMAP_METHOD(stopLongTaskTracking,
+                 stopLongTaskTrackingWithResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject){
+  [self stopLongTaskTracking:resolve reject:reject];
+}
 RCT_REMAP_METHOD(startAction,
                  actionName:(NSString *)actionName actionType:(NSString *)actionType property:(NSDictionary *)property
                  findEventsWithResolver:(RCTPromiseResolveBlock)resolve
@@ -88,6 +115,33 @@ RCT_REMAP_METHOD(addResource,
 }
 #endif
 
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    [[NSNotificationCenter defaultCenter]
+      addObserver:self
+      selector:@selector(applicationDidBecomeActive:)
+      name:UIApplicationDidBecomeActiveNotification
+      object:nil];
+    [[NSNotificationCenter defaultCenter]
+      addObserver:self
+      selector:@selector(applicationWillResignActive:)
+      name:UIApplicationWillResignActiveNotification
+      object:nil];
+  }
+  return self;
+}
+
+- (void)invalidate {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [self.jsLongTaskMonitor disableWithCompletion:nil];
+}
+
+- (void)dealloc {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [_jsLongTaskMonitor disableWithCompletion:nil];
+}
+
 - (void)addAction:(NSString *)actionName actionType:(NSString *)actionType property:(NSDictionary *)property resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
   [[FTExternalDataManager sharedManager] addAction:actionName actionType:actionType property:property];
   resolve(nil);
@@ -104,29 +158,7 @@ RCT_REMAP_METHOD(addResource,
 }
 
 - (void)addResource:(NSString *)key resource:(NSDictionary *)content metrics:(NSDictionary *)metrics resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
-  if (key.length==0 || content.allKeys.count == 0) {
-      return;
-  }
-  FTResourceMetricsModel *metricsModel = nil;
-  if (metrics.allKeys.count>0) {
-      metricsModel = [[FTResourceMetricsModel alloc]init];
-      metricsModel.duration = [RCTConvert NSNumber:metrics[@"duration"]];
-      metricsModel.resource_dns = [RCTConvert NSNumber:metrics[@"resource_dns"]];
-      metricsModel.resource_tcp = [RCTConvert NSNumber:metrics[@"resource_tcp"]];
-      metricsModel.resource_ssl = [RCTConvert NSNumber:metrics[@"resource_ssl"]];
-      metricsModel.resource_ttfb = [RCTConvert NSNumber:metrics[@"resource_ttfb"]];
-      metricsModel.resource_trans = [RCTConvert NSNumber:metrics[@"resource_trans"]];
-      metricsModel.resource_first_byte = [RCTConvert NSNumber:metrics[@"resource_first_byte"]];
-  }
-  FTResourceContentModel *contentModel = [[FTResourceContentModel alloc]init];
-  contentModel.url = [RCTConvert NSURL:content[@"url"]];
-  contentModel.httpMethod = [RCTConvert NSString:content[@"httpMethod"]];
-  contentModel.requestHeader = [RCTConvert NSDictionary:content[@"requestHeader"]];
-  contentModel.responseHeader = [RCTConvert NSDictionary:content[@"responseHeader"]];
-  contentModel.responseBody = [RCTConvert NSString:content[@"responseBody"]];
-  contentModel.httpStatusCode = [RCTConvert int:content[@"resourceStatus"]];
-
-  [[FTExternalDataManager sharedManager] addResourceWithKey:key metrics:metricsModel content:contentModel];
+  FTAddReactNativeResource(key, content, metrics);
   resolve(nil);
 }
 
@@ -139,7 +171,7 @@ RCT_REMAP_METHOD(addResource,
   NSString *rumAppId = [RCTConvert NSString:context[@"iOSAppId"]];
   FTRumConfig *rumConfig = [[FTRumConfig alloc]initWithAppid:rumAppId];
   if ([context.allKeys containsObject:@"sampleRate"]) {
-    rumConfig.samplerate  = [RCTConvert double:context[@"sampleRate"]]*100;
+    rumConfig.sampleRate = [RCTConvert double:context[@"sampleRate"]] * 100;
   }
   if ([context.allKeys containsObject:@"sessionOnErrorSampleRate"]) {
     rumConfig.sessionOnErrorSampleRate  = [RCTConvert double:context[@"sessionOnErrorSampleRate"]]*100;
@@ -177,6 +209,11 @@ RCT_REMAP_METHOD(addResource,
   if ([context.allKeys containsObject:@"nativeFreezeDurationMs"]){
     rumConfig.freezeDurationMs = [RCTConvert double:context[@"nativeFreezeDurationMs"]];
   }
+  BOOL enableLongTask = [RCTConvert BOOL:context[@"enableLongTask"]];
+  double configuredLongTaskThresholdMs = [context.allKeys containsObject:@"longTaskThresholdMs"]
+    ? [RCTConvert double:context[@"longTaskThresholdMs"]]
+    : 100;
+  double longTaskThresholdMs = enableLongTask ? configuredLongTaskThresholdMs : 0;
   if ([context.allKeys containsObject:@"globalContext"]) {
     rumConfig.globalContext = [RCTConvert NSDictionary:context[@"globalContext"]];
   }
@@ -201,9 +238,47 @@ RCT_REMAP_METHOD(addResource,
   };
 #endif
   [[FTMobileAgent sharedInstance] startRumWithConfigOptions:rumConfig];
+  [self getOrCreateLongTaskMonitor];
+  [self.jsLongTaskMonitor setThresholdMilliseconds:longTaskThresholdMs];
+  if (longTaskThresholdMs > 0 && [self applicationIsActive]) {
+    [self.jsLongTaskMonitor start];
+  } else {
+    [self.jsLongTaskMonitor stop];
+  }
   resolve(nil);
 }
 
+- (void)stopLongTaskTracking:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  if (self.jsLongTaskMonitor == nil) {
+    resolve(nil);
+    return;
+  }
+  [self.jsLongTaskMonitor disableWithCompletion:^{
+    resolve(nil);
+  }];
+}
+
+- (void)applicationDidBecomeActive:(NSNotification *)notification {
+  [self.jsLongTaskMonitor start];
+}
+
+- (void)applicationWillResignActive:(NSNotification *)notification {
+  [self.jsLongTaskMonitor stop];
+}
+
+- (BOOL)applicationIsActive {
+  __block BOOL active = NO;
+  dispatch_block_t readState = ^{
+    active = UIApplication.sharedApplication.applicationState == UIApplicationStateActive;
+  };
+  if (NSThread.isMainThread) {
+    readState();
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), readState);
+  }
+  return active;
+}
+
 - (void)startAction:(NSString *)actionName actionType:(NSString *)actionType property:(NSDictionary *)property resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
   [[FTExternalDataManager sharedManager] startAction:actionName actionType:actionType property:property];
   resolve(nil);

package/ios/FTReactNativeResource.h

@@ -0,0 +1,4 @@
+#import <Foundation/Foundation.h>
+
+// Shared model conversion for the public RUM bridge and internal WebSocket path.
+FOUNDATION_EXPORT void FTAddReactNativeResource(NSString *key, NSDictionary *content, NSDictionary *metrics);

package/ios/FTReactNativeResource.m

@@ -0,0 +1,58 @@
+#import "FTReactNativeResource.h"
+#import <TrueWatchSDK/FTExternalDataManager.h>
+#import <TrueWatchSDK/FTResourceMetricsModel.h>
+#import <TrueWatchSDK/FTResourceContentModel.h>
+#import <React/RCTConvert.h>
+
+static NSString * const FTReactNativeWebSocketErrorDomain = @"com.truewatch.react-native.websocket";
+
+void FTAddReactNativeResource(NSString *key, NSDictionary *content, NSDictionary *metrics) {
+  if (key.length==0 || content.allKeys.count == 0) {
+      return;
+  }
+  FTResourceMetricsModel *metricsModel = nil;
+  if (metrics.allKeys.count>0) {
+      metricsModel = [[FTResourceMetricsModel alloc]init];
+      metricsModel.duration = [RCTConvert NSNumber:metrics[@"duration"]];
+      metricsModel.resource_dns = [RCTConvert NSNumber:metrics[@"resource_dns"]];
+      metricsModel.resource_tcp = [RCTConvert NSNumber:metrics[@"resource_tcp"]];
+      metricsModel.resource_ssl = [RCTConvert NSNumber:metrics[@"resource_ssl"]];
+      metricsModel.resource_ttfb = [RCTConvert NSNumber:metrics[@"resource_ttfb"]];
+      metricsModel.resource_trans = [RCTConvert NSNumber:metrics[@"resource_trans"]];
+      metricsModel.resource_first_byte = [RCTConvert NSNumber:metrics[@"resource_first_byte"]];
+      if ([content[@"webSocketHandshake"] boolValue] && [metrics[@"resource_http_protocol"] isKindOfClass:NSString.class]) {
+        metricsModel.resourceHttpProtocol = metrics[@"resource_http_protocol"];
+      }
+  }
+  FTResourceContentModel *contentModel = [[FTResourceContentModel alloc]init];
+  contentModel.url = [RCTConvert NSURL:content[@"url"]];
+  contentModel.httpMethod = [RCTConvert NSString:content[@"httpMethod"]];
+  contentModel.requestHeader = [RCTConvert NSDictionary:content[@"requestHeader"]];
+  contentModel.responseHeader = [RCTConvert NSDictionary:content[@"responseHeader"]];
+  contentModel.responseBody = [RCTConvert NSString:content[@"responseBody"]];
+  contentModel.httpStatusCode = [RCTConvert int:content[@"resourceStatus"]];
+  if ([content.allKeys containsObject:@"errorMessage"]) {
+    NSString *errorMessage = [RCTConvert NSString:content[@"errorMessage"]];
+    if (errorMessage.length > 0) {
+      NSInteger errorCode = -1;
+      if ([content.allKeys containsObject:@"errorCode"]) {
+        errorCode = [RCTConvert NSInteger:content[@"errorCode"]];
+      }
+      contentModel.errorMessage = errorMessage;
+      contentModel.error = [NSError errorWithDomain:FTReactNativeWebSocketErrorDomain
+                                               code:errorCode
+                                           userInfo:@{NSLocalizedDescriptionKey: errorMessage}];
+    }
+  }
+  if ([content.allKeys containsObject:@"resourceType"]) {
+    contentModel.resourceType = [RCTConvert NSString:content[@"resourceType"]];
+  }
+  if ([content.allKeys containsObject:@"webSocketHandshake"]) {
+    contentModel.webSocketHandshake = [RCTConvert BOOL:content[@"webSocketHandshake"]];
+  }
+  if ([content.allKeys containsObject:@"webSocketHandshakeState"]) {
+    contentModel.webSocketHandshakeState = [RCTConvert NSString:content[@"webSocketHandshakeState"]];
+  }
+
+  [[FTExternalDataManager sharedManager] addResourceWithKey:key metrics:metricsModel content:contentModel];
+}