@rejourneyco/react-native 1.0.0

package/ios/Utils/RJTelemetry.m

@@ -0,0 +1,320 @@
+//
+// RJTelemetry.m
+// Rejourney SDK Telemetry
+//
+// Provides observability metrics for SDK health monitoring.
+//
+
+#import "RJTelemetry.h"
+#import "../Core/RJLogger.h"
+
+static void *kRJTelemetryQueueKey = &kRJTelemetryQueueKey;
+
+#pragma mark - RJTelemetryMetrics Implementation
+
+@interface RJTelemetryMetrics ()
+
+@property(nonatomic, assign, readwrite) NSInteger uploadSuccessCount;
+@property(nonatomic, assign, readwrite) NSInteger uploadFailureCount;
+@property(nonatomic, assign, readwrite) NSInteger retryAttemptCount;
+@property(nonatomic, assign, readwrite) NSInteger circuitBreakerOpenCount;
+@property(nonatomic, assign, readwrite) NSInteger memoryEvictionCount;
+@property(nonatomic, assign, readwrite) NSInteger offlinePersistCount;
+@property(nonatomic, assign, readwrite) NSInteger sessionStartCount;
+@property(nonatomic, assign, readwrite) NSInteger crashCount;
+@property(nonatomic, assign, readwrite) NSInteger anrCount;
+@property(nonatomic, assign, readwrite) double uploadSuccessRate;
+@property(nonatomic, assign, readwrite) NSTimeInterval avgUploadDurationMs;
+@property(nonatomic, assign, readwrite) NSInteger currentQueueDepth;
+@property(nonatomic, strong, readwrite) NSDate *lastUploadTime;
+@property(nonatomic, strong, readwrite) NSDate *lastRetryTime;
+
+@end
+
+@implementation RJTelemetryMetrics
+@end
+
+#pragma mark - RJTelemetry Implementation
+
+@interface RJTelemetry ()
+
+@property(nonatomic, strong) dispatch_queue_t metricsQueue;
+@property(nonatomic, strong) RJTelemetryMetrics *metrics;
+@property(nonatomic, assign) NSInteger totalUploadCount;
+@property(nonatomic, assign) NSTimeInterval totalUploadDurationMs;
+@property(nonatomic, assign) NSUInteger totalBytesUploaded;
+@property(nonatomic, assign) NSUInteger totalBytesEvicted;
+
+@end
+
+@implementation RJTelemetry
+
++ (instancetype)sharedInstance {
+  static RJTelemetry *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[RJTelemetry alloc] init];
+  });
+  return instance;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _metricsQueue =
+        dispatch_queue_create("com.rejourney.telemetry", DISPATCH_QUEUE_SERIAL);
+    dispatch_queue_set_specific(_metricsQueue, kRJTelemetryQueueKey,
+                                kRJTelemetryQueueKey, NULL);
+    _metrics = [[RJTelemetryMetrics alloc] init];
+    [self resetMetrics];
+  }
+  return self;
+}
+
+- (void)recordEvent:(RJTelemetryEventType)eventType {
+  [self recordEvent:eventType metadata:nil];
+}
+
+- (void)recordEvent:(RJTelemetryEventType)eventType
+           metadata:(nullable NSDictionary<NSString *, id> *)metadata {
+  dispatch_async(self.metricsQueue, ^{
+    switch (eventType) {
+    case RJTelemetryEventUploadSuccess:
+      self.metrics.uploadSuccessCount++;
+      self.metrics.lastUploadTime = [NSDate date];
+      break;
+
+    case RJTelemetryEventUploadFailure:
+      self.metrics.uploadFailureCount++;
+      break;
+
+    case RJTelemetryEventRetryAttempt:
+      self.metrics.retryAttemptCount++;
+      self.metrics.lastRetryTime = [NSDate date];
+      break;
+
+    case RJTelemetryEventCircuitBreakerOpen:
+      self.metrics.circuitBreakerOpenCount++;
+      RJLogWarning(@"[Telemetry] Circuit breaker opened (total: %ld)",
+                   (long)self.metrics.circuitBreakerOpenCount);
+      break;
+
+    case RJTelemetryEventCircuitBreakerClose:
+      RJLogDebug(@"[Telemetry] Circuit breaker closed");
+      break;
+
+    case RJTelemetryEventMemoryPressureEviction:
+      self.metrics.memoryEvictionCount++;
+      break;
+
+    case RJTelemetryEventOfflineQueuePersist:
+      self.metrics.offlinePersistCount++;
+      RJLogDebug(@"[Telemetry] Offline queue persisted (total: %ld)",
+                 (long)self.metrics.offlinePersistCount);
+      break;
+
+    case RJTelemetryEventOfflineQueueRestore:
+      RJLogDebug(@"[Telemetry] Offline queue restored");
+      break;
+
+    case RJTelemetryEventSessionStart:
+      self.metrics.sessionStartCount++;
+      break;
+
+    case RJTelemetryEventSessionEnd:
+      
+      [self logCurrentMetricsInternal];
+      break;
+
+    case RJTelemetryEventCrashDetected:
+      self.metrics.crashCount++;
+      RJLogWarning(@"[Telemetry] Crash detected (total: %ld)",
+                   (long)self.metrics.crashCount);
+      break;
+
+    case RJTelemetryEventTokenRefresh:
+      RJLogDebug(@"[Telemetry] Token refresh triggered");
+      break;
+    }
+
+    
+    [self updateSuccessRate];
+  });
+}
+
+- (void)recordUploadDuration:(NSTimeInterval)durationMs
+                     success:(BOOL)success
+                   byteCount:(NSUInteger)bytes {
+  dispatch_async(self.metricsQueue, ^{
+    self.totalUploadCount++;
+    self.totalUploadDurationMs += durationMs;
+    self.metrics.avgUploadDurationMs =
+        self.totalUploadDurationMs / (double)self.totalUploadCount;
+
+    if (success) {
+      self.totalBytesUploaded += bytes;
+      self.metrics.uploadSuccessCount++;
+      self.metrics.lastUploadTime = [NSDate date];
+    } else {
+      self.metrics.uploadFailureCount++;
+    }
+
+    [self updateSuccessRate];
+  });
+}
+
+- (void)recordFrameEviction:(NSUInteger)bytesEvicted
+                 frameCount:(NSInteger)count {
+  dispatch_async(self.metricsQueue, ^{
+    self.metrics.memoryEvictionCount += count;
+    self.totalBytesEvicted += bytesEvicted;
+
+    RJLogWarning(
+        @"[Telemetry] Memory eviction: %ld frames, %.1f KB total evicted",
+        (long)count, self.totalBytesEvicted / 1024.0);
+  });
+}
+
+- (void)recordQueueDepth:(NSInteger)depth {
+  dispatch_async(self.metricsQueue, ^{
+    self.metrics.currentQueueDepth = depth;
+  });
+}
+
+- (void)recordANR {
+  dispatch_async(self.metricsQueue, ^{
+    self.metrics.anrCount++;
+    RJLogWarning(@"[Telemetry] ANR detected (total: %ld)",
+                 (long)self.metrics.anrCount);
+  });
+}
+
+- (void)updateSuccessRate {
+  NSInteger total =
+      self.metrics.uploadSuccessCount + self.metrics.uploadFailureCount;
+  if (total > 0) {
+    self.metrics.uploadSuccessRate =
+        (double)self.metrics.uploadSuccessCount / (double)total;
+  } else {
+    self.metrics.uploadSuccessRate = 1.0; 
+  }
+}
+
+- (RJTelemetryMetrics *)currentMetrics {
+  RJTelemetryMetrics *snapshot = [[RJTelemetryMetrics alloc] init];
+  void (^capture)(void) = ^{
+    snapshot.uploadSuccessCount = self.metrics.uploadSuccessCount;
+    snapshot.uploadFailureCount = self.metrics.uploadFailureCount;
+    snapshot.retryAttemptCount = self.metrics.retryAttemptCount;
+    snapshot.circuitBreakerOpenCount = self.metrics.circuitBreakerOpenCount;
+    snapshot.memoryEvictionCount = self.metrics.memoryEvictionCount;
+    snapshot.offlinePersistCount = self.metrics.offlinePersistCount;
+    snapshot.sessionStartCount = self.metrics.sessionStartCount;
+    snapshot.crashCount = self.metrics.crashCount;
+    snapshot.anrCount = self.metrics.anrCount;
+    snapshot.uploadSuccessRate = self.metrics.uploadSuccessRate;
+    snapshot.avgUploadDurationMs = self.metrics.avgUploadDurationMs;
+    snapshot.currentQueueDepth = self.metrics.currentQueueDepth;
+    snapshot.lastUploadTime = self.metrics.lastUploadTime;
+    snapshot.lastRetryTime = self.metrics.lastRetryTime;
+  };
+
+  if (dispatch_get_specific(kRJTelemetryQueueKey)) {
+    capture();
+  } else {
+    dispatch_sync(self.metricsQueue, capture);
+  }
+
+  return snapshot;
+}
+
+- (NSDictionary<NSString *, id> *)metricsAsDictionary {
+  RJTelemetryMetrics *m = [self currentMetrics];
+  __block NSUInteger totalBytesUploaded = 0;
+  __block NSUInteger totalBytesEvicted = 0;
+  void (^captureTotals)(void) = ^{
+    totalBytesUploaded = self.totalBytesUploaded;
+    totalBytesEvicted = self.totalBytesEvicted;
+  };
+  if (dispatch_get_specific(kRJTelemetryQueueKey)) {
+    captureTotals();
+  } else {
+    dispatch_sync(self.metricsQueue, captureTotals);
+  }
+  return @{
+    @"uploadSuccessCount" : @(m.uploadSuccessCount),
+    @"uploadFailureCount" : @(m.uploadFailureCount),
+    @"retryAttemptCount" : @(m.retryAttemptCount),
+    @"circuitBreakerOpenCount" : @(m.circuitBreakerOpenCount),
+    @"memoryEvictionCount" : @(m.memoryEvictionCount),
+    @"offlinePersistCount" : @(m.offlinePersistCount),
+    @"sessionStartCount" : @(m.sessionStartCount),
+    @"crashCount" : @(m.crashCount),
+    @"anrCount" : @(m.anrCount),
+    @"uploadSuccessRate" : @(m.uploadSuccessRate),
+    @"avgUploadDurationMs" : @(m.avgUploadDurationMs),
+    @"currentQueueDepth" : @(m.currentQueueDepth),
+    @"lastUploadTime" : m.lastUploadTime
+        ? @([m.lastUploadTime timeIntervalSince1970] * 1000)
+        : [NSNull null],
+    @"lastRetryTime" : m.lastRetryTime
+        ? @([m.lastRetryTime timeIntervalSince1970] * 1000)
+        : [NSNull null],
+    @"totalBytesUploaded" : @(totalBytesUploaded),
+    @"totalBytesEvicted" : @(totalBytesEvicted),
+  };
+}
+
+- (void)resetMetrics {
+  dispatch_async(self.metricsQueue, ^{
+    self.metrics.uploadSuccessCount = 0;
+    self.metrics.uploadFailureCount = 0;
+    self.metrics.retryAttemptCount = 0;
+    self.metrics.circuitBreakerOpenCount = 0;
+    self.metrics.memoryEvictionCount = 0;
+    self.metrics.offlinePersistCount = 0;
+    self.metrics.sessionStartCount = 0;
+    self.metrics.crashCount = 0;
+    self.metrics.anrCount = 0;
+    self.metrics.uploadSuccessRate = 1.0;
+    self.metrics.avgUploadDurationMs = 0;
+    self.metrics.currentQueueDepth = 0;
+    self.metrics.lastUploadTime = nil;
+    self.metrics.lastRetryTime = nil;
+    self.totalUploadCount = 0;
+    self.totalUploadDurationMs = 0;
+    self.totalBytesUploaded = 0;
+    self.totalBytesEvicted = 0;
+  });
+}
+
+- (void)logCurrentMetrics {
+#ifdef DEBUG
+  dispatch_async(self.metricsQueue, ^{
+    [self logCurrentMetricsInternal];
+  });
+#endif
+}
+
+- (void)logCurrentMetricsInternal {
+  RJLogDebug(@"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  RJLogDebug(@" SDK Telemetry Summary");
+  RJLogDebug(@"   Uploads: %ld success, %ld failed (%.1f%% success rate)",
+             (long)self.metrics.uploadSuccessCount,
+             (long)self.metrics.uploadFailureCount,
+             self.metrics.uploadSuccessRate * 100);
+  RJLogDebug(@"   Avg upload latency: %.1f ms",
+             self.metrics.avgUploadDurationMs);
+  RJLogDebug(@"   Retries: %ld attempts", (long)self.metrics.retryAttemptCount);
+  RJLogDebug(@"   Circuit breaker opens: %ld",
+             (long)self.metrics.circuitBreakerOpenCount);
+  RJLogDebug(@"   Memory evictions: %ld frames (%.1f KB)",
+             (long)self.metrics.memoryEvictionCount,
+             self.totalBytesEvicted / 1024.0);
+  RJLogDebug(@"   Offline persists: %ld",
+             (long)self.metrics.offlinePersistCount);
+  RJLogDebug(@"   Data uploaded: %.1f KB", self.totalBytesUploaded / 1024.0);
+  RJLogDebug(@"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+}
+
+@end

package/ios/Utils/RJWindowUtils.h

@@ -0,0 +1,66 @@
+//
+//  RJWindowUtils.h
+//  Rejourney
+//
+//  Window and view utility functions.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Utility class for window and view operations.
+ */
+@interface RJWindowUtils : NSObject
+
+/**
+ * Returns the current key window.
+ * Handles iOS 13+ window scene architecture.
+ *
+ * @return The key window, or nil if none is available.
+ */
++ (nullable UIWindow *)keyWindow;
+
+/**
+ * Finds the accessibility label for a view or its ancestors.
+ *
+ * @param view The view to start searching from.
+ * @return The first accessibility label found, or nil.
+ */
++ (nullable NSString *)accessibilityLabelForView:(nullable UIView *)view;
+
+/**
+ * Generates a unique session ID.
+ *
+ * Format: session_{timestamp}_{random_hex}
+ *
+ * @return A unique session identifier.
+ */
++ (NSString *)generateSessionId;
+
+/**
+ * Returns the current timestamp in milliseconds.
+ *
+ * @return Current time as milliseconds since Unix epoch.
+ */
++ (NSTimeInterval)currentTimestampMillis;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Utils/RJWindowUtils.m

@@ -0,0 +1,133 @@
+//
+//  RJWindowUtils.m
+//  Rejourney
+//
+//  Window and view utility functions implementation.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import "RJWindowUtils.h"
+
+@implementation RJWindowUtils
+
++ (UIWindow *)keyWindow {
+    if (@available(iOS 13.0, *)) {
+        // IMPORTANT:
+        // "Key window" can temporarily become a system window such as:
+        // - UITextEffectsWindow
+        // - UIRemoteKeyboardWindow / UIInputWindowController-hosted windows
+        // Capturing those can trigger keyboard autolayout warnings/spikes even if the
+        // user never focused a text field. Prefer a normal-level app window.
+        //
+        // ALSO IMPORTANT:
+        // Some frameworks (including React Native/Expo modals/overlays) may present
+        // content in a separate UIWindow with a windowLevel > UIWindowLevelNormal.
+        // If we only consider "normal" level, we may capture the wrong window and
+        // miss TextInputs entirely (privacy masking failure).
+        //
+        // We therefore prefer the TOP-MOST visible non-system window, while still
+        // excluding keyboard/text-effects windows.
+
+        UIWindow *bestKeyApp = nil;
+        CGFloat bestKeyAppLevel = -CGFLOAT_MAX;
+        UIWindow *bestApp = nil;
+        CGFloat bestAppLevel = -CGFLOAT_MAX;
+        UIWindow *anyKey = nil;
+
+        for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
+            if (![scene isKindOfClass:[UIWindowScene class]]) {
+                continue;
+            }
+            UIWindowScene *windowScene = (UIWindowScene *)scene;
+            if (windowScene.activationState != UISceneActivationStateForegroundActive) {
+                continue;
+            }
+
+            for (UIWindow *window in windowScene.windows) {
+                if (!window || window.isHidden || window.alpha <= 0.01) {
+                    continue;
+                }
+
+                NSString *cls = NSStringFromClass([window class]);
+                BOOL isSystemInputWindow =
+                    ([cls containsString:@"Keyboard"] ||
+                     [cls containsString:@"TextEffects"] ||
+                     [cls containsString:@"InputWindow"] ||
+                     [cls containsString:@"RemoteKeyboard"]);
+
+                BOOL hasRoot = (window.rootViewController != nil);
+                BOOL isAppCandidate = (!isSystemInputWindow && hasRoot);
+                CGFloat level = window.windowLevel;
+
+                if (window.isKeyWindow) {
+                    // Keep as a last-ditch fallback (even if it's a system window).
+                    if (!anyKey) {
+                        anyKey = window;
+                    }
+                    if (isAppCandidate && level > bestKeyAppLevel) {
+                        bestKeyAppLevel = level;
+                        bestKeyApp = window;
+                    }
+                }
+
+                if (isAppCandidate && level > bestAppLevel) {
+                    bestAppLevel = level;
+                    bestApp = window;
+                }
+            }
+        }
+
+        if (bestKeyApp) {
+            return bestKeyApp;
+        }
+        if (bestApp) {
+            return bestApp;
+        }
+        if (anyKey) {
+            return anyKey;
+        }
+    } else {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        return [UIApplication sharedApplication].keyWindow;
+#pragma clang diagnostic pop
+    }
+    return nil;
+}
+
++ (NSString *)accessibilityLabelForView:(UIView *)view {
+    UIView *current = view;
+    while (current) {
+        if (current.accessibilityLabel.length > 0) {
+            return current.accessibilityLabel;
+        }
+        current = current.superview;
+    }
+    return nil;
+}
+
++ (NSString *)generateSessionId {
+    NSTimeInterval timestamp = [[NSDate date] timeIntervalSince1970];
+    NSString *timestampStr = [NSString stringWithFormat:@"%.0f", timestamp * 1000];
+    NSString *randomHex = [NSString stringWithFormat:@"%08X", arc4random()];
+    return [NSString stringWithFormat:@"session_%@_%@", timestampStr, randomHex];
+}
+
++ (NSTimeInterval)currentTimestampMillis {
+    return [[NSDate date] timeIntervalSince1970] * 1000;
+}
+
+@end

package/lib/commonjs/NativeRejourney.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+/**
+ * TurboModule spec for Rejourney SDK
+ *
+ * This file defines the native module interface for React Native's New Architecture.
+ * It follows the official React Native TurboModules pattern for Codegen compatibility.
+ *
+ * IMPORTANT: This spec file is used by Codegen to generate native bindings.
+ * The default export MUST be a direct TurboModuleRegistry.get() call.
+ *
+ * @see https://reactnative.dev/docs/turbo-native-modules-introduction
+ */
+/**
+ * SDK telemetry metrics for observability
+ */
+/**
+ * Native Rejourney module specification for TurboModules (New Architecture)
+ *
+ * This interface defines all methods exposed by the native module.
+ * Codegen uses this to generate:
+ * - iOS: RejourneySpec.h (protocol) and RejourneySpec-generated.mm (JSI bindings)
+ * - Android: NativeRejourneySpec.java (interface)
+ */
+/**
+ * Default export for Codegen.
+ *
+ * CRITICAL: This MUST be a direct TurboModuleRegistry.get() call.
+ * Codegen parses this file statically and requires this exact pattern.
+ *
+ * Using getEnforcing() would throw if module not found.
+ * Using get() returns null, which is safer during development/testing.
+ */
+var _default = exports.default = _reactNative.TurboModuleRegistry.get('Rejourney');
+//# sourceMappingURL=NativeRejourney.js.map

package/lib/commonjs/components/Mask.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Mask = void 0;
+var _react = _interopRequireDefault(require("react"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } /**
+ * Mask Component
+ * 
+ * Wrapper component to mask sensitive content in session replays.
+ * All children wrapped in this component will be obscured in recordings.
+ * 
+ * IMPORTANT: This file uses lazy loading to avoid "PlatformConstants could not be found"
+ * errors on React Native 0.81+ with New Architecture (Bridgeless).
+ * 
+ * @example
+ * ```tsx
+ * import { Mask } from 'rejourney';
+ * 
+ * // Mask sensitive user ID
+ * <Mask>
+ *   <Text>User ID: {user.id}</Text>
+ * </Mask>
+ * 
+ * // Mask credit card info
+ * <Mask>
+ *   <CreditCardDisplay card={card} />
+ * </Mask>
+ * ```
+ */
+// Lazy-loaded React Native modules
+let _RN = null;
+function getRN() {
+  if (_RN) return _RN;
+  try {
+    _RN = require('react-native');
+    return _RN;
+  } catch {
+    return null;
+  }
+}
+/**
+ * Wrapper component to mask sensitive content in session replays.
+ * All children will be obscured in recordings.
+ * 
+ * Uses accessibilityHint to signal to the native capture engine
+ * that this view and its contents should be masked.
+ */
+const Mask = ({
+  children,
+  style,
+  ...props
+}) => {
+  const RN = getRN();
+
+  // If RN isn't loaded yet (shouldn't happen in practice), render children directly
+  if (!RN) {
+    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, children);
+  }
+  const {
+    View,
+    StyleSheet
+  } = RN;
+  const styles = StyleSheet.create({
+    container: {
+      // Minimal container style - doesn't affect layout
+    }
+  });
+  return /*#__PURE__*/_react.default.createElement(View, _extends({}, props, {
+    style: [styles.container, style],
+    accessibilityHint: "rejourney_occlude",
+    collapsable: false
+  }), children);
+};
+exports.Mask = Mask;
+var _default = exports.default = Mask;
+//# sourceMappingURL=Mask.js.map