@ansight/react-native 1.3.0-preview.1 → 1.3.0-preview.11

package/ios/AnsightReactNative.swift

@@ -139,6 +139,7 @@ final class AnsightReactNative: RCTEventEmitter {
 
     private let lock = NSLock()
     private var hasListeners = false
+    private var hostConnectionStatusSubscription: HostConnectionStatusSubscription?
     private var activeCustomToolIds: Set<String> = []
     private var pendingToolCalls: [String: PendingToolCall] = [:]
     private var reactNativeMemorySampler: ReactNativeMemorySamplerBox?
@@ -150,10 +151,14 @@ final class AnsightReactNative: RCTEventEmitter {
     override init() {
         super.init()
         AnsightLogger.registerCallback(logCallback)
+        hostConnectionStatusSubscription = AnsightRuntime.shared.addHostConnectionStatusListener { [weak self] status, _ in
+            self?.emitHostConnectionStatusEvent(status)
+        }
     }
 
     deinit {
         AnsightLogger.removeCallback(logCallback)
+        hostConnectionStatusSubscription?.remove()
     }
 
     override static func requiresMainQueueSetup() -> Bool {
@@ -161,7 +166,7 @@ final class AnsightReactNative: RCTEventEmitter {
     }
 
     override func supportedEvents() -> [String]! {
-        ["AnsightToolCall", "AnsightLog"]
+        ["AnsightToolCall", "AnsightLog", "AnsightHostConnectionStatus"]
     }
 
     override func startObserving() {
@@ -292,6 +297,52 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    @objc(recordNetworkRequest:resolver:rejecter:)
+    func recordNetworkRequest(
+        _ input: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        guard JSONSerialization.isValidJSONObject(input),
+              let data = try? JSONSerialization.data(withJSONObject: input),
+              let request = try? JSONDecoder().decode(AnsightNetworkRequest.self, from: data),
+              request.schema == AnsightNetworkRequest.schemaName
+        else {
+            resolve(operationResultDictionary(
+                .failure("Network request must use the ansight.network-request.v1 schema.")
+            ))
+            return
+        }
+        Task {
+            resolve(operationResultDictionary(await AnsightRuntime.shared.recordNetworkRequest(request)))
+        }
+    }
+
+    @objc(recordCrashCandidate:resolver:rejecter:)
+    func recordCrashCandidate(
+        _ input: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        let metadata: [String: String]
+        if let metadataJson = stringValue(input, "metadata"),
+           let data = metadataJson.data(using: .utf8),
+           let decoded = try? JSONDecoder().decode([String: String].self, from: data) {
+            metadata = decoded
+        } else {
+            metadata = [:]
+        }
+        let candidateId = AnsightRuntime.shared.recordCrashCandidate(
+            runtime: stringValue(input, "runtime") ?? "react-native-javascript",
+            kind: stringValue(input, "kind") ?? "unhandled_javascript_error",
+            message: stringValue(input, "message"),
+            stack: stringValue(input, "stack"),
+            fatal: boolValue(input, "fatal", defaultValue: false),
+            metadata: metadata
+        )
+        resolve(candidateId.map { ["candidateId": $0] } ?? [:])
+    }
+
     @objc(screenViewed:details:resolver:rejecter:)
     func screenViewed(
         _ name: NSString,
@@ -834,6 +885,17 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    private func emitHostConnectionStatusEvent(_ status: HostConnectionStatus) {
+        let shouldEmit = lock.withLock { hasListeners }
+        guard shouldEmit else { return }
+        DispatchQueue.main.async {
+            self.sendEvent(
+                withName: "AnsightHostConnectionStatus",
+                body: self.hostConnectionStatusDictionary(status)
+            )
+        }
+    }
+
     private func configureReactNativeMemoryProfiling(_ dictionary: NSDictionary?) throws {
         let options = ReactNativeMemoryProfilingOptions(dictionary: dictionary)
         currentReactNativeMemoryOptions = options
@@ -895,6 +957,13 @@ final class AnsightReactNative: RCTEventEmitter {
         if hasBool(dictionary, "enableBatteryLevel") {
             options.enableBatteryLevel = boolValue(dictionary, "enableBatteryLevel", defaultValue: options.enableBatteryLevel)
         }
+        if hasBool(dictionary, "enableOpenFileHandleTracking") {
+            options.enableOpenFileHandleTracking = boolValue(
+                dictionary,
+                "enableOpenFileHandleTracking",
+                defaultValue: options.enableOpenFileHandleTracking
+            )
+        }
         if let memory = dictionary?["defaultMemoryChannels"] as? NSDictionary {
             var channels: DefaultMemoryChannels = []
             if boolValue(memory, "managedHeap", defaultValue: boolValue(memory, "javaHeap", defaultValue: false)) {
@@ -942,9 +1011,14 @@ final class AnsightReactNative: RCTEventEmitter {
                         "captureGpuBackedSurfaces",
                         defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureGpuBackedSurfaces
                     ),
-                    mode: stringValue(jpeg, "mode") == "screenshotAndVisualTree"
-                        ? .screenshotAndVisualTree
-                        : .screenshotOnly
+                    mode: AnsightSessionJpegCaptureMode(
+                        rawValue: stringValue(jpeg, "mode") ?? ""
+                    ) ?? .screenshotOnly,
+                    captureKeyboardPresence: boolValue(
+                        jpeg,
+                        "captureKeyboardPresence",
+                        defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureKeyboardPresence
+                    )
                 )
             }
         }
@@ -960,6 +1034,21 @@ final class AnsightReactNative: RCTEventEmitter {
                 )
             }
         }
+        if let raw = dictionary?["crashCapture"] {
+            if (raw as? Bool) == false {
+                options.crashCapture.enabled = false
+            } else if let crash = raw as? NSDictionary {
+                options.crashCapture = AnsightCrashCaptureOptions(
+                    enabled: boolValue(crash, "enabled", defaultValue: true),
+                    studioHandoffEnabled: boolValue(crash, "studioHandoffEnabled", defaultValue: true),
+                    offlineCaptureAttachmentEnabled: boolValue(crash, "offlineCaptureAttachmentEnabled", defaultValue: true),
+                    maximumPendingReports: intValue(crash, "maximumPendingReports", defaultValue: 8),
+                    retentionDays: intValue(crash, "retentionDays", defaultValue: 7),
+                    maximumBreadcrumbs: intValue(crash, "maximumBreadcrumbs", defaultValue: 64),
+                    maximumTraceBytes: intValue(crash, "maximumTraceBytes", defaultValue: 1_048_576)
+                )
+            }
+        }
         if let lifecycle = dictionary?["lifecycleCapture"] as? NSDictionary {
             options.lifecycleCapture = AnsightLifecycleCaptureOptions(
                 enabled: boolValue(lifecycle, "enabled", defaultValue: options.lifecycleCapture.enabled),
@@ -1271,9 +1360,14 @@ final class AnsightReactNative: RCTEventEmitter {
                 "captureGpuBackedSurfaces",
                 defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureGpuBackedSurfaces
             ),
-            mode: stringValue(dictionary, "mode") == "screenshotAndVisualTree"
-                ? .screenshotAndVisualTree
-                : .screenshotOnly
+            mode: AnsightSessionJpegCaptureMode(
+                rawValue: stringValue(dictionary, "mode") ?? ""
+            ) ?? .screenshotOnly,
+            captureKeyboardPresence: boolValue(
+                dictionary,
+                "captureKeyboardPresence",
+                defaultValue: AnsightSessionJpegCaptureOptions.defaultCaptureKeyboardPresence
+            )
         )
     }
 
@@ -1283,6 +1377,8 @@ final class AnsightReactNative: RCTEventEmitter {
             "retentionPeriodSeconds": options.retentionPeriodSeconds,
             "enableFramesPerSecond": options.enableFramesPerSecond,
             "enableBatteryLevel": options.enableBatteryLevel,
+            "enableOpenFileHandleTracking": options.enableOpenFileHandleTracking,
+            "enableJniReferenceCountTracking": false,
             "defaultMemoryChannels": [
                 "managedHeap": options.defaultMemoryChannels.contains(.managedHeap),
                 "javaHeap": options.defaultMemoryChannels.contains(.managedHeap),
@@ -1322,6 +1418,7 @@ final class AnsightReactNative: RCTEventEmitter {
                 "quality": capture.quality,
                 "maxWidth": capture.maxWidth as Any,
                 "captureGpuBackedSurfaces": capture.captureGpuBackedSurfaces,
+                "captureKeyboardPresence": capture.captureKeyboardPresence,
                 "mode": capture.mode.rawValue,
             ]
         } else {

package/ios/AnsightReactNativeModule.m

@@ -33,6 +33,14 @@ RCT_EXTERN_METHOD(recordEvent:(NSDictionary *)input
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(recordNetworkRequest:(NSDictionary *)input
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(recordCrashCandidate:(NSDictionary *)input
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(screenViewed:(NSString *)name
                   details:(NSDictionary *)details
                   resolver:(RCTPromiseResolveBlock)resolve