@luciq/react-native 19.4.0 → 19.6.0-51917-SNAPSHOT

package/dist/utils/XhrNetworkInterceptor.js

@@ -1,6 +1,8 @@
 import LuciqConstants from './LuciqConstants';
 import { stringifyIfNotString, generateW3CHeader } from './LuciqUtils';
-import { FeatureFlags } from '../utils/FeatureFlags';
+import { getCachedW3cFlags } from './FeatureFlags';
+import { Logger } from './logger';
+const TAG = 'LCQ-RN-NET:';
 const XMLHttpRequest = global.XMLHttpRequest;
 let originalXHROpen = XMLHttpRequest.prototype.open;
 let originalXHRSend = XMLHttpRequest.prototype.send;
@@ -8,40 +10,34 @@ let originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
 let onProgressCallback;
 let onDoneCallback;
 let isInterceptorEnabled = false;
-let network;
-const _reset = () => {
-    network = {
-        id: '',
-        url: '',
-        method: '',
-        requestBody: '',
-        requestBodySize: 0,
-        responseBody: '',
-        responseBodySize: 0,
-        responseCode: 0,
-        requestHeaders: {},
-        responseHeaders: {},
-        contentType: '',
-        errorDomain: '',
-        errorCode: 0,
-        startTime: 0,
-        duration: 0,
-        gqlQueryName: '',
-        serverErrorMessage: '',
-        requestContentType: '',
-        isW3cHeaderFound: null,
-        partialId: null,
-        networkStartTimeInSeconds: null,
-        w3cGeneratedHeader: null,
-        w3cCaughtHeader: null,
-    };
-};
-const getTraceparentHeader = async (networkData) => {
-    const [isW3cExternalTraceIDEnabled, isW3cExternalGeneratedHeaderEnabled, isW3cCaughtHeaderEnabled,] = await Promise.all([
-        FeatureFlags.isW3ExternalTraceID(),
-        FeatureFlags.isW3ExternalGeneratedHeader(),
-        FeatureFlags.isW3CaughtHeader(),
-    ]);
+const networkMap = new WeakMap();
+const createNetworkData = () => ({
+    id: '',
+    url: '',
+    method: '',
+    requestBody: '',
+    requestBodySize: 0,
+    responseBody: '',
+    responseBodySize: 0,
+    responseCode: 0,
+    requestHeaders: {},
+    responseHeaders: {},
+    contentType: '',
+    errorDomain: '',
+    errorCode: 0,
+    startTime: 0,
+    duration: 0,
+    gqlQueryName: '',
+    serverErrorMessage: '',
+    requestContentType: '',
+    isW3cHeaderFound: null,
+    partialId: null,
+    networkStartTimeInSeconds: null,
+    w3cGeneratedHeader: null,
+    w3cCaughtHeader: null,
+});
+const getTraceparentHeader = (networkData) => {
+    const { isW3cExternalTraceIDEnabled, isW3cExternalGeneratedHeaderEnabled, isW3cCaughtHeaderEnabled, } = getCachedW3cFlags();
     return injectHeaders(networkData, {
         isW3cExternalTraceIDEnabled,
         isW3cExternalGeneratedHeaderEnabled,
@@ -85,39 +81,57 @@ export default {
         onProgressCallback = callback;
     },
     enableInterception() {
-        // Prevents infinite calls to XMLHttpRequest.open when enabling interception multiple times
         if (isInterceptorEnabled) {
+            Logger.debug(TAG, 'enableInterception called but already enabled, skipping');
             return;
         }
+        Logger.debug(TAG, 'Enabling XHR network interception');
         originalXHROpen = XMLHttpRequest.prototype.open;
         originalXHRSend = XMLHttpRequest.prototype.send;
         originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
         // An error code that signifies an issue with the RN client.
         const clientErrorCode = 9876;
         XMLHttpRequest.prototype.open = function (method, url, ...args) {
-            _reset();
-            network.url = url;
-            network.method = method;
+            const networkData = createNetworkData();
+            networkData.url = url;
+            networkData.method = method;
+            networkMap.set(this, networkData);
+            Logger.debug(TAG, `[open] ${method} ${url}`);
             originalXHROpen.apply(this, [method, url, ...args]);
         };
         XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
-            // According to the HTTP RFC, headers are case-insensitive, so we convert
-            // them to lower-case to make accessing headers predictable.
-            // This avoid issues like failing to get the Content-Type header for a request
-            // because the header is set as 'Content-Type' instead of 'content-type'.
             const key = header.toLowerCase();
-            network.requestHeaders[key] = stringifyIfNotString(value);
+            const networkData = networkMap.get(this);
+            if (networkData) {
+                networkData.requestHeaders[key] = stringifyIfNotString(value);
+            }
+            else {
+                Logger.debug(TAG, `[setRequestHeader] No networkData found in WeakMap for header "${key}" — request may have been GC'd or open() was not called`);
+            }
             originalXHRSetRequestHeader.apply(this, [header, value]);
         };
-        XMLHttpRequest.prototype.send = async function (data) {
-            const cloneNetwork = JSON.parse(JSON.stringify(network));
+        XMLHttpRequest.prototype.send = function (data) {
+            const networkData = networkMap.get(this);
+            if (!networkData) {
+                Logger.debug(TAG, '[send] No networkData found in WeakMap — falling back to original send (open() was not intercepted)');
+                originalXHRSend.apply(this, [data]);
+                return;
+            }
+            Logger.debug(TAG, `[send] ${networkData.method} ${networkData.url}`);
+            const cloneNetwork = JSON.parse(JSON.stringify(networkData));
             cloneNetwork.requestBody = data ? data : '';
             if (typeof cloneNetwork.requestBody !== 'string') {
                 cloneNetwork.requestBody = JSON.stringify(cloneNetwork.requestBody);
             }
+            let isReported = false;
             if (this.addEventListener) {
                 this.addEventListener('readystatechange', async () => {
                     if (!isInterceptorEnabled) {
+                        Logger.debug(TAG, `[readystatechange] Interceptor disabled, ignoring state=${this.readyState} for ${cloneNetwork.url}`);
+                        return;
+                    }
+                    if (isReported) {
+                        Logger.debug(TAG, `[readystatechange] Already reported, ignoring state=${this.readyState} for ${cloneNetwork.url}`);
                         return;
                     }
                     if (this.readyState === this.HEADERS_RECEIVED) {
@@ -146,6 +160,7 @@ export default {
                             cloneNetwork.requestContentType =
                                 cloneNetwork.requestHeaders['content-type'].split(';')[0];
                         }
+                        Logger.debug(TAG, `[readystatechange] HEADERS_RECEIVED for ${cloneNetwork.url}, contentType=${cloneNetwork.contentType}`);
                     }
                     if (this.readyState === this.DONE) {
                         cloneNetwork.duration = Date.now() - cloneNetwork.startTime;
@@ -166,11 +181,11 @@ export default {
                             cloneNetwork.requestBody =
                                 typeof _response === 'string' ? _response : JSON.stringify(_response);
                             cloneNetwork.responseBody = '';
-                            // Detect a more descriptive error message.
                             if (typeof _response === 'string' && _response.length > 0) {
                                 cloneNetwork.errorDomain = _response;
                             }
                             cloneNetwork.responseBody = `ERROR: ${cloneNetwork.errorDomain}`;
+                            Logger.debug(TAG, `[readystatechange] DONE with client error for ${cloneNetwork.url}, errorDomain=${cloneNetwork.errorDomain}`);
                             // @ts-ignore
                         }
                         else if (this._timedOut) {
@@ -179,6 +194,7 @@ export default {
                             cloneNetwork.responseCode = 0;
                             cloneNetwork.contentType = 'text/plain';
                             cloneNetwork.responseBody = `ERROR: ${cloneNetwork.errorDomain}`;
+                            Logger.debug(TAG, `[readystatechange] DONE with timeout for ${cloneNetwork.url}`);
                         }
                         // Only set response body if not already set by error handlers
                         if (!cloneNetwork.errorDomain) {
@@ -225,16 +241,20 @@ export default {
                         else {
                             delete cloneNetwork.gqlQueryName;
                         }
+                        isReported = true;
+                        Logger.debug(TAG, `[readystatechange] DONE for ${cloneNetwork.method} ${cloneNetwork.url} — status=${cloneNetwork.responseCode}, duration=${cloneNetwork.duration}ms, hasCallback=${!!onDoneCallback}`);
                         if (onDoneCallback) {
                             onDoneCallback(cloneNetwork);
                         }
+                        else {
+                            Logger.debug(TAG, `[readystatechange] WARNING: onDoneCallback is null, network log for ${cloneNetwork.url} will be LOST`);
+                        }
                     }
                 });
                 const downloadUploadProgressCallback = (event) => {
                     if (!isInterceptorEnabled) {
                         return;
                     }
-                    // check if will be able to compute progress
                     if (event.lengthComputable && onProgressCallback) {
                         const totalBytesSent = event.loaded;
                         const totalBytesExpectedToSend = event.total - event.loaded;
@@ -243,31 +263,43 @@ export default {
                 };
                 this.addEventListener('progress', downloadUploadProgressCallback);
                 this.upload.addEventListener('progress', downloadUploadProgressCallback);
-                // Handler for abort events (works with fetch, Axios, and any XHR-based requests)
                 this.addEventListener('abort', () => {
                     if (!isInterceptorEnabled) {
+                        Logger.debug(TAG, `[abort] Interceptor disabled, ignoring abort for ${cloneNetwork.url}`);
+                        return;
+                    }
+                    if (isReported) {
+                        Logger.debug(TAG, `[abort] Already reported via readystatechange DONE, ignoring duplicate abort for ${cloneNetwork.url}`);
                         return;
                     }
+                    isReported = true;
                     cloneNetwork.duration = Date.now() - cloneNetwork.startTime;
                     cloneNetwork.responseCode = 0;
                     cloneNetwork.errorCode = clientErrorCode;
                     cloneNetwork.errorDomain = 'cancelled';
                     cloneNetwork.responseBody = `ERROR: ${cloneNetwork.errorDomain}`;
+                    Logger.debug(TAG, `[abort] Request cancelled: ${cloneNetwork.method} ${cloneNetwork.url}, duration=${cloneNetwork.duration}ms, hasCallback=${!!onDoneCallback}`);
+                    if (onDoneCallback) {
+                        onDoneCallback(cloneNetwork);
+                    }
+                    else {
+                        Logger.debug(TAG, `[abort] WARNING: onDoneCallback is null, cancelled log for ${cloneNetwork.url} will be LOST`);
+                    }
                 });
             }
             cloneNetwork.startTime = Date.now();
-            const traceparent = await getTraceparentHeader(cloneNetwork);
+            const traceparent = getTraceparentHeader(cloneNetwork);
             if (traceparent) {
                 this.setRequestHeader('Traceparent', traceparent);
-            }
-            if (this.readyState === this.UNSENT) {
-                return; // Prevent sending the request if not opened
+                Logger.debug(TAG, `[send] Injected traceparent header for ${cloneNetwork.url}`);
             }
             originalXHRSend.apply(this, [data]);
         };
         isInterceptorEnabled = true;
+        Logger.debug(TAG, 'XHR network interception enabled');
     },
     disableInterception() {
+        Logger.debug(TAG, 'Disabling XHR network interception');
         isInterceptorEnabled = false;
         XMLHttpRequest.prototype.send = originalXHRSend;
         XMLHttpRequest.prototype.open = originalXHROpen;

package/ios/RNLuciq/LuciqAPMBridge.m

@@ -8,6 +8,7 @@
 #import <LuciqSDK/LCQTypes.h>
 #import <React/RCTUIManager.h>
 #import "Util/LCQAPM+PrivateAPIs.h"
+#import "LuciqScreenLoadingFrameTracker.h"
 
 @implementation LuciqAPMBridge
 
@@ -145,7 +146,88 @@ RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
     }
 }
 
+// Screen Loading methods
+RCT_EXPORT_METHOD(initScreenFrameTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [[LuciqScreenLoadingFrameTracker sharedInstance] initializeFrameTracking];
+        resolve(nil);
+    });
+}
+
+RCT_EXPORT_METHOD(setActiveScreenSpanId:(NSString *)spanId)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [[LuciqScreenLoadingFrameTracker sharedInstance] startTrackingForSpanId:spanId];
+    });
+}
+
+RCT_EXPORT_METHOD(getScreenTimeToDisplay:(NSString *)spanId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        NSNumber *timestamp = [[LuciqScreenLoadingFrameTracker sharedInstance] getFrameTimestampForSpanId:spanId];
+        resolve(timestamp);
+    });
+}
+
+RCT_EXPORT_METHOD(isScreenLoadingEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject){
 
+    BOOL isScreenLoadingEnabled = LCQAPM.screenLoadingEnabled;
+    resolve(@(isScreenLoadingEnabled));
+}
+
+RCT_EXPORT_METHOD(isEndScreenLoadingEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject){
+
+    BOOL isEndScreenLoadingEnabled = LCQAPM.endScreenLoadingEnabled;
+    resolve(@(isEndScreenLoadingEnabled));
+}
+
+// uiTraceId is unused on iOS but required to keep the React Native Bridge call
+// signature consistent with Android, which uses it.
+RCT_EXPORT_METHOD(endScreenLoading:(double)timeStampMicro
+                  uiTraceId:(double)uiTraceId){
+    [LCQAPM endScreenLoadingCPWithEndTimestampMUS:timeStampMicro];
+}
+
+RCT_EXPORT_METHOD(setScreenLoadingEnabled:(BOOL)isEnabled){
+    LCQAPM.screenLoadingEnabled = isEnabled;
+}
+
+- (NSMutableDictionary<NSString *, NSNumber *> *)buildStagesMapFromAttributes:(NSDictionary *)stages {
+    NSMutableDictionary<NSString *, NSNumber *> *stagesMap = [NSMutableDictionary dictionary];
+    NSArray<NSString *> *keys = @[@"cnst_mus_st" , @"cnst_mus",@"rnd_mus_st", @"rnd_mus", @"mnt_mus_st" ,@"mnt_mus", @"lyt_mus_st" , @"lyt_mus"];
+    for (NSString *key in keys) {
+        if (stages[key])
+            stagesMap[key] = @([stages[key] longLongValue]);
+    }
+    return stagesMap;
+}
+
+// Syncs screen loading data to native layer for reporting
+RCT_EXPORT_METHOD(syncScreenLoading:(double)spanId
+                  screenName:(NSString *)screenName
+                  startTimestamp:(double)startTimestamp
+                  ttid_us:(double)ttid_us
+                  attributes:(NSDictionary *)stages){
+
+    NSMutableDictionary<NSString *, NSNumber *> *stagesMap = [self buildStagesMapFromAttributes:stages];
+    [LCQAPM reportScreenLoadingCPWithStartTimestampMUS:startTimestamp durationMUS:ttid_us stages:stagesMap];
+}
+
+// Syncs manual screen loading measurements to native layer for reporting (no span ID)
+RCT_EXPORT_METHOD(syncManualScreenLoading:(NSString *)screenName
+                  startTimestamp:(double)startTimestamp
+                  ttid_mus:(double)ttid_mus
+                  attributes:(NSDictionary *)stages){
+
+    NSMutableDictionary<NSString *, NSNumber *> *stagesMap = [self buildStagesMapFromAttributes:stages];
+    [LCQAPM reportScreenLoadingCPUITraceWithName:screenName screenLoadingStartMUS:startTimestamp screenLoadingDurationMUS:ttid_mus stages:stagesMap];
+}
 
 @synthesize description;
 

package/ios/RNLuciq/LuciqReactBridge.m

@@ -453,7 +453,7 @@ RCT_EXPORT_METHOD(show) {
     [[NSRunLoop mainRunLoop] performSelector:@selector(show) target:[Luciq class] argument:nil order:0 modes:@[NSDefaultRunLoopMode]];
 }
 
-RCT_EXPORT_METHOD(reportScreenChange:(NSString *)screenName) {
+RCT_EXPORT_METHOD(reportScreenChange:(NSString *)screenName spanId:(NSString * _Nullable)spanId) {
     SEL setPrivateApiSEL = NSSelectorFromString(@"logViewDidAppearEvent:");
     if ([[Luciq class] respondsToSelector:setPrivateApiSEL]) {
         NSInvocation *inv = [NSInvocation invocationWithMethodSignature:[[Luciq class] methodSignatureForSelector:setPrivateApiSEL]];

package/ios/RNLuciq/LuciqScreenLoadingFrameTracker.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+@interface LuciqScreenLoadingFrameTracker : NSObject
+
++ (instancetype)sharedInstance;
+- (void)startTrackingForSpanId:(NSString *)spanId;
+- (NSNumber *)getFrameTimestampForSpanId:(NSString *)spanId;
+- (void)initializeFrameTracking;
+- (void)cleanup;
+
+@end

package/ios/RNLuciq/LuciqScreenLoadingFrameTracker.m

@@ -0,0 +1,121 @@
+#import "LuciqScreenLoadingFrameTracker.h"
+#import <QuartzCore/CADisplayLink.h>
+
+@interface LuciqScreenLoadingFrameTracker ()
+@property (nonatomic, strong) NSMutableDictionary<NSString *, NSNumber *> *spanIdToTimestamp;
+@property (nonatomic, strong) NSMutableSet<NSString *> *activeSpanIds;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, NSNumber *> *spanIdToTrackingStart;
+@property (nonatomic, assign) NSInteger maxStorageCapacity;
+@property (nonatomic, assign) BOOL isTracking;
+@property (nonatomic, strong) CADisplayLink *displayLink;
+@end
+
+@implementation LuciqScreenLoadingFrameTracker
+
++ (instancetype)sharedInstance {
+    static LuciqScreenLoadingFrameTracker *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] init];
+    });
+    return instance;
+}
+
+- (instancetype)init {
+    if (self = [super init]) {
+        self.spanIdToTimestamp = [NSMutableDictionary dictionary];
+        self.activeSpanIds = [NSMutableSet set];
+        self.spanIdToTrackingStart = [NSMutableDictionary dictionary];
+        self.maxStorageCapacity = 50;
+        self.isTracking = NO;
+    }
+    return self;
+}
+
+- (void)initializeFrameTracking {
+    if (self.isTracking) {
+        return;
+    }
+
+    self.displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(handleDisplayLink:)];
+    [self.displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+    self.isTracking = YES;
+}
+
+- (void)handleDisplayLink:(CADisplayLink *)displayLink {
+    [self frameRenderedWithTimestamp:displayLink.timestamp];
+}
+
+- (void)frameRenderedWithTimestamp:(NSTimeInterval)timestamp {
+    if (self.activeSpanIds.count > 0) {
+        // timestamp is monotonic (seconds since boot, from CADisplayLink / mach_absolute_time)
+        // Convert to epoch microseconds using the same approach as Android:
+        // figure out how long ago the frame was rendered, then subtract from current epoch
+        NSTimeInterval currentUptime = [[NSProcessInfo processInfo] systemUptime];
+        NSTimeInterval currentEpoch = [[NSDate date] timeIntervalSince1970];
+        NSTimeInterval timeSinceFrame = currentUptime - timestamp;
+        NSTimeInterval frameEpochSeconds = currentEpoch - timeSinceFrame;
+        NSTimeInterval epochTimestampMicroseconds = frameEpochSeconds * 1000000;
+        NSNumber *timestampNumber = @(epochTimestampMicroseconds);
+
+        NSMutableSet<NSString *> *resolvedSpanIds = [NSMutableSet set];
+        for (NSString *spanId in self.activeSpanIds) {
+            NSNumber *trackingStart = self.spanIdToTrackingStart[spanId];
+            if (trackingStart && timestamp < trackingStart.doubleValue) {
+                NSLog(@"[ScreenLoading] Skipping frame for span %@ (VSync %.6fs < tracking start %.6fs)", spanId, timestamp, trackingStart.doubleValue);
+                continue;
+            }
+            self.spanIdToTimestamp[spanId] = timestampNumber;
+            [resolvedSpanIds addObject:spanId];
+            [self.spanIdToTrackingStart removeObjectForKey:spanId];
+            NSLog(@"[ScreenLoading] Frame rendered for span %@ at %.0fμs", spanId, epochTimestampMicroseconds);
+        }
+        [self.activeSpanIds minusSet:resolvedSpanIds];
+
+        // Cleanup if exceeding capacity
+        if (self.spanIdToTimestamp.count > self.maxStorageCapacity) {
+            [self cleanupStorage];
+        }
+    }
+}
+
+- (void)startTrackingForSpanId:(NSString *)spanId {
+    [self.activeSpanIds addObject:spanId];
+    self.spanIdToTrackingStart[spanId] = @([[NSProcessInfo processInfo] systemUptime]);
+    NSLog(@"[ScreenLoading] Started tracking for span %@", spanId);
+}
+
+- (NSNumber *)getFrameTimestampForSpanId:(NSString *)spanId {
+    NSNumber *timestamp = self.spanIdToTimestamp[spanId];
+    if (timestamp) {
+        [self.spanIdToTimestamp removeObjectForKey:spanId];
+        NSLog(@"[ScreenLoading] Retrieved timestamp %@μs for span %@", timestamp, spanId);
+    }
+    return timestamp;
+}
+
+- (void)cleanup {
+    if (self.isTracking) {
+        [self.displayLink invalidate];
+        self.displayLink = nil;
+        self.isTracking = NO;
+    }
+    [self.spanIdToTimestamp removeAllObjects];
+    [self.activeSpanIds removeAllObjects];
+}
+
+- (void)cleanupStorage {
+    NSArray *sortedKeys = [self.spanIdToTimestamp keysSortedByValueUsingComparator:^NSComparisonResult(NSNumber *obj1, NSNumber *obj2) {
+        return [obj1 compare:obj2];
+    }];
+
+    NSInteger itemsToRemove = self.spanIdToTimestamp.count - 30;
+    if (itemsToRemove > 0) {
+        for (NSInteger i = 0; i < itemsToRemove; i++) {
+            [self.spanIdToTimestamp removeObjectForKey:sortedKeys[i]];
+        }
+    }
+}
+
+@end
+

package/ios/RNLuciq/Util/LCQAPM+PrivateAPIs.h

@@ -10,7 +10,21 @@
 @interface LCQAPM (PrivateAPIs)
 
 @property (class, atomic, assign) BOOL networkEnabled;
+@property (class, atomic, readonly) BOOL endScreenLoadingEnabled;
+
+typedef void (^LCQDisplayLinkObservationCallback)(NSTimeInterval currentTimestamp, NSTimeInterval targetTimestamp);
 
 + (BOOL)customSpansEnabled;
 
++ (void)endScreenLoadingCPWithEndTimestampMUS:(double)endTimestampMUS;
++ (void)reportScreenLoadingCPWithStartTimestampMUS:(double)startTimestampMUS
+                                       durationMUS:(double)durationMUS
+                                    stages:(nullable NSDictionary<NSString *, NSNumber *> *)stages;;
+
++ (void)startObservingDisplayLinkWithCallback:(LCQDisplayLinkObservationCallback _Nonnull)callback;
++ (void)stopObservingDisplayLink;
++ (void)reportScreenLoadingCPUITraceWithName:(NSString *_Nonnull)name
+                       screenLoadingStartMUS:(double)screenLoadingStartMUS
+                    screenLoadingDurationMUS:(double)screenLoadingDurationMUS
+                                      stages:(nullable NSDictionary<NSString *, NSNumber *> *)stages;
 @end

package/ios/native.rb

@@ -1,4 +1,4 @@
-$luciq= { :version => '19.5.1' }
+$luciq= { :version => '19.6.1' }
 
 def use_luciq! (spec = nil)
   version = $luciq[:version]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@luciq/react-native",
   "description": "Luciq is the Agentic Observability Platform built for Mobile.",
-  "version": "19.4.0",
+  "version": "19.6.0-51917-SNAPSHOT",
   "author": "Luciq (https://luciq.ai)",
   "repository": "github:luciqai/luciq-reactnative-sdk",
   "homepage": "https://www.luciq.ai/platforms/react-native",
@@ -43,18 +43,19 @@
   },
   "devDependencies": {
     "@apollo/client": "^3.7.0",
-    "@instabug/danger-plugin-coverage": "Instabug/danger-plugin-coverage",
     "@react-native-community/eslint-config": "^3.1.0",
     "@react-navigation/native": "^6.1.7",
     "@rollup/plugin-commonjs": "^25.0.3",
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-typescript": "^11.0.0",
+    "@testing-library/react-native": "^13.3.3",
     "@trivago/prettier-plugin-sort-imports": "^4.2.0",
     "@types/jest": "^29.5.3",
     "@types/minimatch": "3.0.4",
     "@types/node": "^20.4.8",
     "@types/react-native": "^0.72.2",
+    "@types/react-test-renderer": "^19.1.0",
     "axios": "1.11.0",
     "babel-core": "7.0.0-bridge.0",
     "babel-jest": "^29.6.2",
@@ -75,6 +76,7 @@
     "react-native": "^0.72.3",
     "react-native-navigation": "7.36.0",
     "react-navigation": "^4.4.4",
+    "react-test-renderer": "18.3.1",
     "rollup": "^3.27.2",
     "rollup-plugin-cleanup": "^3.2.1",
     "rollup-plugin-copy": "^3.5.0",

package/scripts/get-github-app-token.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# Generates a GitHub App installation token using openssl + curl.
+# No external dependencies required.
+#
+# Usage: bash get-github-app-token.sh <APP_ID_ENV> <PRIVATE_KEY_ENV> <INSTALLATION_ID_ENV>
+# Example: bash get-github-app-token.sh AND_LUCIQ_APP_ID AND_LUCIQ_PRIVATE_KEY AND_LUCIQ_INSTALLATION_ID
+# Example: bash get-github-app-token.sh AND_INSTABUG_APP_ID AND_INSTABUG_PRIVATE_KEY AND_INSTABUG_INSTALLATION_ID
+
+set -euo pipefail
+
+APP_ID_ENV="${1:?Usage: $0 <APP_ID_ENV> <PRIVATE_KEY_ENV> <INSTALLATION_ID_ENV>}"
+PRIVATE_KEY_ENV="${2:?Usage: $0 <APP_ID_ENV> <PRIVATE_KEY_ENV> <INSTALLATION_ID_ENV>}"
+INSTALL_ID_ENV="${3:?Usage: $0 <APP_ID_ENV> <PRIVATE_KEY_ENV> <INSTALLATION_ID_ENV>}"
+
+APP_ID="${!APP_ID_ENV:?Error: $APP_ID_ENV is not set}"
+PRIVATE_KEY="${!PRIVATE_KEY_ENV:?Error: $PRIVATE_KEY_ENV is not set}"
+INSTALL_ID="${!INSTALL_ID_ENV:?Error: $INSTALL_ID_ENV is not set}"
+
+# Reconstruct PEM file from flattened env var
+# CircleCI flattens multiline env vars into a single line,
+# so we extract header/footer and re-wrap the base64 body at 64 chars
+PEM_FILE=$(mktemp)
+chmod 600 "$PEM_FILE"
+trap 'rm -f "$PEM_FILE"' EXIT
+
+BODY=$(printf '%s' "$PRIVATE_KEY" | sed 's/-----BEGIN RSA PRIVATE KEY-----//;s/-----END RSA PRIVATE KEY-----//;s/ //g')
+{
+    echo "-----BEGIN RSA PRIVATE KEY-----"
+    echo "$BODY" | fold -w 64
+    echo "-----END RSA PRIVATE KEY-----"
+} > "$PEM_FILE"
+
+# Base64url encode (RFC 4648): replace +/ with -_, strip =
+b64url() {
+    openssl base64 -A | tr '+/' '-_' | tr -d '='
+}
+
+NOW=$(date +%s)
+IAT=$((NOW - 60))    # 60s clock skew allowance per GitHub docs
+EXP=$((NOW + 600))   # 10min max JWT lifetime per GitHub docs
+
+# Create JWT header and payload
+HEADER=$(printf '{"alg":"RS256","typ":"JWT"}' | b64url)
+PAYLOAD=$(printf '{"iat":%d,"exp":%d,"iss":"%s"}' "$IAT" "$EXP" "$APP_ID" | b64url)
+
+# Sign with RSA-SHA256
+SIGNATURE=$(printf '%s.%s' "$HEADER" "$PAYLOAD" | openssl dgst -sha256 -sign "$PEM_FILE" -binary | b64url)
+
+JWT_TOKEN="${HEADER}.${PAYLOAD}.${SIGNATURE}"
+
+# Exchange JWT for installation token
+RESPONSE=$(curl -sf -X POST \
+    -H "Authorization: Bearer $JWT_TOKEN" \
+    -H "Accept: application/vnd.github+json" \
+    -H "X-GitHub-Api-Version: 2022-11-28" \
+    "https://api.github.com/app/installations/${INSTALL_ID}/access_tokens") || {
+    echo "Error: GitHub API request failed (HTTP error)" >&2
+    exit 1
+}
+
+TOKEN=$(echo "$RESPONSE" | jq -r '.token // empty')
+
+if [ -z "$TOKEN" ]; then
+    ERROR_MSG=$(echo "$RESPONSE" | jq -r '.message // "unknown error"')
+    echo "Error: Failed to get installation token: $ERROR_MSG" >&2
+    exit 1
+fi
+
+echo "$TOKEN"

package/scripts/notify-github.sh

@@ -1,15 +1,24 @@
 #!/bin/bash
 
+set -euo pipefail
+
 pr_url="https://api.github.com/repos/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME/pulls?head=$CIRCLE_PROJECT_USERNAME:$CIRCLE_BRANCH&state=open"
 pr_response=$(curl --location --request GET "$pr_url" --header "Authorization: Bearer $RELEASE_GITHUB_TOKEN")
 
-if [ $(echo "$pr_response" | jq length) -eq 0 ]; then
-  echo "No PR found to update"
-else
-  pr_comment_url=$(echo "$pr_response" | jq -r ".[]._links.comments.href")
+if ! echo "$pr_response" | jq -e 'type == "array"' >/dev/null; then
+  echo "Unexpected GitHub API response (not an array):"
+  echo "$pr_response"
+  exit 1
+fi
 
-  curl --location --request POST "$pr_comment_url" \
-    --header 'Content-Type: application/json' \
-    --header "Authorization: Bearer $RELEASE_GITHUB_TOKEN" \
-    --data-raw "$1"
+if [ "$(echo "$pr_response" | jq length)" -eq 0 ]; then
+  echo "No PR found to update"
+  exit 0
 fi
+
+pr_comment_url=$(echo "$pr_response" | jq -r ".[]._links.comments.href")
+
+curl --location --request POST "$pr_comment_url" \
+  --header 'Content-Type: application/json' \
+  --header "Authorization: Bearer $RELEASE_GITHUB_TOKEN" \
+  --data-raw "$1"