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

package/ios/FTReactNativeTrace.mm

@@ -8,12 +8,22 @@
 
 #import "FTReactNativeTrace.h"
 #import "FtMobileAgent.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 <TrueWatchSDK/FTExternalDataManager+Private.h>
+#import "FTWebSocketResourceData.h"
+#import <TrueWatchSDK/FTResourceMetricsModel.h>
+#import <TrueWatchSDK/FTResourceContentModel.h>
 #import <React/RCTConvert.h>
-#import <FTMobileSDK/FTTraceManager.h>
+#import <TrueWatchSDK/FTTraceManager.h>
+
+@interface FTReactNativeTrace ()
+// Keep no extra owner alive. Cancellation must not obtain a singleton after
+// shutdown or depend on a WebSocket Resource having started.
+@property (nonatomic, weak) id<FTExternalResourceProtocol> traceResourceDelegate;
+- (nullable NSDictionary *)traceHeaderFieldsForURL:(NSString *)url key:(nullable NSString *)key;
+@end
+
 @implementation FTReactNativeTrace
 RCT_EXPORT_MODULE()
 
@@ -32,6 +42,21 @@ RCT_REMAP_METHOD(getTraceHeaderFields,
   [self getTraceHeaderFields:url key:key resolve:resolve reject:reject];
 }
 
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getTraceHeaderFieldsSync:(NSString *)url
+                                       key:(NSString *)key) {
+  return [self traceHeaderFieldsForURL:url key:key];
+}
+
+RCT_REMAP_METHOD(cancelWebSocketTrace,
+                 cancelWebSocketTrace:(NSString *)key
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    FTWebSocketDiscardTraceResource(self.traceResourceDelegate, key);
+  }
+  resolve(nil);
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeFTReactNativeTraceSpecJSI>(params);
@@ -42,12 +67,7 @@ RCT_REMAP_METHOD(getTraceHeaderFields,
 }
 
 - (void)getTraceHeaderFields:(NSString *)url key:(NSString *)key resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
-  NSDictionary *traceHeader = nil;
-  if(key&&key.length>0){
-      traceHeader = [[FTExternalDataManager sharedManager] getTraceHeaderWithKey:key url:[NSURL URLWithString:url]];
-  }else{
-      traceHeader = [[FTExternalDataManager sharedManager] getTraceHeaderWithUrl:[NSURL URLWithString:url]];
-  }
+  NSDictionary *traceHeader = [self traceHeaderFieldsForURL:url key:key];
   if (traceHeader) {
       resolve(traceHeader);
   }else{
@@ -55,10 +75,34 @@ RCT_REMAP_METHOD(getTraceHeaderFields,
   }
 }
 
+- (nullable NSDictionary *)traceHeaderFieldsForURL:(NSString *)url key:(nullable NSString *)key {
+  NSURL *requestURL = [NSURL URLWithString:url];
+  if (!requestURL) {
+    return nil;
+  }
+  if (key.length > 0) {
+    @synchronized (self) {
+      // Use the exact delegate that creates the keyed correlation. Record it
+      // before generation, including a generation that subsequently throws.
+      id<FTExternalResourceProtocol> delegate = [FTExternalDataManager sharedManager].resourceDelegate;
+      self.traceResourceDelegate = delegate;
+      if ([delegate respondsToSelector:@selector(getTraceHeaderWithKey:url:)]) {
+        return [delegate getTraceHeaderWithKey:key url:requestURL];
+      }
+      return nil;
+    }
+  }
+  return [[FTExternalDataManager sharedManager] getTraceHeaderWithUrl:requestURL];
+}
+
+- (void)invalidate {
+  @synchronized (self) { self.traceResourceDelegate = nil; }
+}
+
 - (void)setConfig:(NSDictionary *)context resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   FTTraceConfig *trace = [[FTTraceConfig alloc]init];
   if ([context.allKeys containsObject:@"sampleRate"]) {
-      trace.samplerate =[RCTConvert double:context[@"sampleRate"]] * 100;
+      trace.sampleRate = [RCTConvert double:context[@"sampleRate"]] * 100;
   }
   if ([context.allKeys containsObject:@"traceType"]) {
       int traceType = [RCTConvert int:context[@"traceType"]];
@@ -71,4 +115,3 @@ RCT_REMAP_METHOD(getTraceHeaderFields,
 }
 
 @end
-

package/ios/FTReactNativeUtils.m

@@ -9,24 +9,19 @@
 
 @implementation FTReactNativeUtils
 + (BOOL)filterBlackResource:(NSURL *)url{
-    static NSMutableArray *internalDevResourceBlacklist;
+    static NSRegularExpression *internalDevResourceRegex;
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
-        internalDevResourceBlacklist = [NSMutableArray new];
-        NSError *error = nil;
-        NSString *pattern = @"^http://((10|172|192).[0-9]+.[0-9]+.[0-9]+|localhost|127.0.0.1):808[0-9]/logs$";
-        NSRegularExpression * regularExpress = [NSRegularExpression regularExpressionWithPattern:pattern options:NSRegularExpressionCaseInsensitive error:&error];
-        [internalDevResourceBlacklist addObject:regularExpress];
-        NSString *rn = @"^http://localhost:808[0-9]/(hot|symbolicate|message|inspector|status|assets).*$";
-        NSRegularExpression * rnRegularExpress = [NSRegularExpression regularExpressionWithPattern:rn options:NSRegularExpressionCaseInsensitive error:&error];
-        [internalDevResourceBlacklist addObject:rnRegularExpress];
+        NSString *pattern = @"^(?:https?|wss?)://(?:(?:10|172|192)(?:\\.[0-9]+){3}|localhost|127\\.0\\.0\\.1|\\[::1\\]):808[0-9]/(?:hot|symbolicate|message|inspector|status|assets|logs|debugger-proxy)(?:[/?#].*)?$";
+        internalDevResourceRegex = [NSRegularExpression regularExpressionWithPattern:pattern
+                                                                             options:NSRegularExpressionCaseInsensitive
+                                                                               error:NULL];
     });
-    for (NSRegularExpression *regex in internalDevResourceBlacklist) {
-        NSTextCheckingResult *firstMatch =[regex firstMatchInString:url.absoluteString options:0 range:NSMakeRange(0, [url.absoluteString length])];
-        if (firstMatch) {
-            return YES;
-        }
+    NSString *absoluteString = url.absoluteString;
+    if (absoluteString.length == 0) {
+        return NO;
     }
-    return NO;
+    NSRange fullRange = NSMakeRange(0, absoluteString.length);
+    return [internalDevResourceRegex firstMatchInString:absoluteString options:0 range:fullRange] != nil;
 }
 @end

package/ios/FTReactNativeWebSocket.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <FTSdkReactNative/FTSdkReactNative.h>
+@interface FTReactNativeWebSocket : NSObject <NativeFTReactNativeWebSocketSpec>
+#else
+@interface FTReactNativeWebSocket : NSObject <RCTBridgeModule>
+#endif
+@end

package/ios/FTReactNativeWebSocket.mm

@@ -0,0 +1,201 @@
+#import "FTReactNativeWebSocket.h"
+#import "FTWebSocketMetadataStore.h"
+#import "FTWebSocketResourceData.h"
+#import "FTReactNativeResource.h"
+#import <TrueWatchSDK/FTExternalDataManager.h>
+#import <TrueWatchSDK/FTURLSessionInterceptor.h>
+#import <TrueWatchSDK/FTURLSessionInterceptorProtocol.h>
+#import <React/RCTBridge.h>
+
+@interface FTReactNativeWebSocket ()
+// Retired capture sessions can finish after configuration disables/re-enables
+// collection. Each store keeps its own association namespace; all socket refs
+// still share the process-wide 256 cap and native expiry timer.
+@property (nonatomic, strong) NSMutableDictionary<NSString *, FTWebSocketMetadataStore *> *sessions;
+@property (nonatomic, strong) NSMutableArray<NSString *> *sessionOrder;
+@property (nonatomic, copy) NSString *currentSession;
+// Capture the current native instance weakly. Cancellation must not call
+// +shared after shutdown and accidentally recreate an interceptor singleton.
+@property (nonatomic, weak) id<FTURLSessionInterceptorProtocol> resourceInterceptor;
+@end
+
+@implementation FTReactNativeWebSocket
+@synthesize bridge = _bridge;
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _sessions = [NSMutableDictionary new];
+    _sessionOrder = [NSMutableArray new];
+  }
+  return self;
+}
+
+- (dispatch_queue_t)methodQueue { return dispatch_get_main_queue(); }
+
+RCT_REMAP_METHOD(startCapture,
+                 startCapture:(NSString *)session
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    @try {
+      if (self.sessions[session]) {
+        // A duplicate setup cannot reactivate a retired session.
+        resolve(nil);
+        return;
+      }
+      id owner = nil;
+      @try {
+        Class moduleClass = NSClassFromString(@"RCTWebSocketModule");
+        owner = moduleClass ? [self.bridge moduleForClass:moduleClass] : nil;
+      } @catch (__unused NSException *exception) {
+        // RN module lookup only affects optional socket enrichment.
+      }
+      [self.sessions[self.currentSession ?: @""] stopForSession:self.currentSession];
+      FTWebSocketMetadataStore *store = [FTWebSocketMetadataStore new];
+      if ([store startForOwner:owner session:session]) {
+        // Bound bookkeeping for repeated configuration as well as socket refs.
+        if (self.sessionOrder.count >= 256) {
+          NSString *oldest = self.sessionOrder.firstObject;
+          [self.sessions[oldest] clear];
+          [self.sessions removeObjectForKey:oldest];
+          [self.sessionOrder removeObjectAtIndex:0];
+        }
+        self.sessions[session] = store;
+        [self.sessionOrder addObject:session];
+        self.currentSession = session;
+      }
+      resolve(nil);
+    } @catch (__unused NSException *exception) { reject(@"E_WS_CAPTURE", @"Unable to create WebSocket capture session", nil); }
+  }
+}
+
+RCT_REMAP_METHOD(stopCapture,
+                 stopCapture:(NSString *)session
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    [self.sessions[session] stopForSession:session];
+    resolve(nil);
+  }
+}
+
+RCT_REMAP_METHOD(clear,
+                 clear:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    [self clearSessions];
+    resolve(nil);
+  }
+}
+
+RCT_REMAP_METHOD(startResource,
+                 startResource:(NSString *)key
+                 socketID:(double)socketID
+                 url:(NSString *)url
+                 session:(NSString *)session
+                 sequence:(double)sequence
+                 property:(NSDictionary *)property
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    @try {
+      FTWebSocketMetadataStore *store = self.sessions[session];
+      [store startResource:key socketID:@(socketID) URL:url session:session sequence:sequence report:^{
+        // The store invokes this block under its SDK lifecycle lock. Resolve
+        // the singleton here, before shutdown can clear the native instance.
+        id<FTURLSessionInterceptorProtocol> interceptor = (id)[FTURLSessionInterceptor shared];
+        self.resourceInterceptor = interceptor;
+        FTResourceUrlHandler blocked = nil;
+        FTIntakeUrl allowed = nil;
+        if ([interceptor respondsToSelector:@selector(resourceUrlHandler)]) blocked = interceptor.resourceUrlHandler;
+        if ([interceptor respondsToSelector:@selector(intakeUrlHandler)]) allowed = interceptor.intakeUrlHandler;
+        if (!FTWebSocketShouldCollectResource([NSURL URLWithString:url], blocked, allowed)) {
+          // Cancel also leaves a terminal tombstone, so queued stop/add cannot
+          // report a filtered Resource or retain its socket until expiry.
+          [store cancelResource:key session:session];
+          FTWebSocketDiscardTraceResource(interceptor, key);
+          return;
+        }
+        [[FTExternalDataManager sharedManager] startResourceWithKey:key property:property];
+      }];
+      resolve(nil);
+    } @catch (__unused NSException *exception) {
+      if ([self.sessions[session] cancelResource:key session:session]) {
+        FTWebSocketDiscardTraceResource(self.resourceInterceptor, key);
+      }
+      reject(@"E_WS_RESOURCE", @"Unable to start WebSocket resource", nil);
+    }
+  }
+}
+
+RCT_REMAP_METHOD(stopResource,
+                 stopResource:(NSString *)key
+                 event:(NSString *)event
+                 session:(NSString *)session
+                 property:(NSDictionary *)property
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    @try {
+      [self.sessions[session] stopResource:key event:event session:session report:^{
+        [[FTExternalDataManager sharedManager] stopResourceWithKey:key property:property];
+      }];
+      resolve(nil);
+    } @catch (__unused NSException *exception) { reject(@"E_WS_RESOURCE", @"Unable to stop WebSocket resource", nil); }
+  }
+}
+
+RCT_REMAP_METHOD(addResource,
+                 addResource:(NSString *)key
+                 content:(NSDictionary *)content
+                 metrics:(NSDictionary *)metrics
+                 session:(NSString *)session
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    @try {
+      [self.sessions[session] addResource:key event:content[@"webSocketEvent"] session:session report:^(NSDictionary *metadata, NSString *event) {
+        NSDictionary *data = FTWebSocketResourceData(content, metrics, metadata, event);
+        FTAddReactNativeResource(key, data[@"content"], data[@"metrics"]);
+      }];
+      resolve(nil);
+    } @catch (__unused NSException *exception) { reject(@"E_WS_RESOURCE", @"Unable to add WebSocket resource", nil); }
+  }
+}
+
+RCT_REMAP_METHOD(releaseResource,
+                 releaseResource:(NSString *)key
+                 session:(NSString *)session
+                 resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject) {
+  @synchronized (self) {
+    if ([self.sessions[session] cancelResource:key session:session]) {
+      FTWebSocketDiscardTraceResource(self.resourceInterceptor, key);
+    }
+    resolve(nil);
+  }
+}
+
+- (void)invalidate { [self clearSessions]; }
+- (void)clearSessions {
+  @synchronized (self) {
+    for (FTWebSocketMetadataStore *store in self.sessions.allValues) [store clear];
+    [self.sessions removeAllObjects];
+    [self.sessionOrder removeAllObjects];
+    self.currentSession = nil;
+    self.resourceInterceptor = nil;
+  }
+}
+- (void)dealloc {
+  for (FTWebSocketMetadataStore *store in _sessions.allValues) [store clear];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeFTReactNativeWebSocketSpecJSI>(params);
+}
+#endif
+@end

package/ios/FTWebSocketMetadataStore.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Bounded handshake-only ownership. Hooks initialization and HTTP response
+/// completion; JS alone controls Resource lifecycle. No delegate events hooked.
+@interface FTWebSocketMetadataStore : NSObject
+// An unavailable RN owner disables enrichment only; Resource reporting remains valid.
+- (BOOL)startForOwner:(nullable id)owner session:(NSString *)session;
+- (void)stopForSession:(NSString *)session;
+- (void)clear;
+- (void)bindResource:(NSString *)key socketID:(NSNumber *)socketID URL:(NSString *)URL session:(NSString *)session sequence:(double)sequence;
+- (void)releaseResource:(NSString *)key session:(NSString *)session;
+- (nullable NSDictionary *)takeResource:(NSString *)key session:(NSString *)session;
+// All callbacks run synchronously under the lifecycle lock on the module's
+// main queue. No callback, bridge promise, or business socket is stored here.
+- (void)startResource:(NSString *)key socketID:(NSNumber *)socketID URL:(NSString *)URL session:(NSString *)session sequence:(double)sequence report:(void (^)(void))report;
+- (void)stopResource:(NSString *)key event:(NSString *)event session:(NSString *)session report:(void (^)(void))report;
+- (void)addResource:(NSString *)key event:(NSString *)event session:(NSString *)session report:(void (^)(NSDictionary * _Nullable metadata, NSString *event))report;
+- (BOOL)cancelResource:(NSString *)key session:(NSString *)session;
++ (void)sdkDidStart;
++ (void)shutDown;
+@end
+
+NS_ASSUME_NONNULL_END