@rejourneyco/react-native 1.0.0

package/ios/Utils/RJKeychainManager.m

@@ -0,0 +1,111 @@
+//
+//  RJKeychainManager.m
+//  Rejourney
+//
+//  Secure Keychain storage implementation.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import "RJKeychainManager.h"
+#import "../Core/RJLogger.h"
+#import <Security/Security.h>
+
+static NSString *const kRJKeychainServiceName = @"com.rejourney.sdk";
+
+@implementation RJKeychainManager
+
+#pragma mark - Singleton
+
++ (instancetype)sharedManager {
+  static RJKeychainManager *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[self alloc] init];
+  });
+  return instance;
+}
+
+#pragma mark - Query Building
+
+- (NSMutableDictionary *)baseQueryForKey:(NSString *)key {
+  return [@{
+    (__bridge id)kSecClass : (__bridge id)kSecClassGenericPassword,
+    (__bridge id)kSecAttrService : kRJKeychainServiceName,
+    (__bridge id)kSecAttrAccount : key,
+    (__bridge id)kSecAttrAccessible :
+        (__bridge id)kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+  } mutableCopy];
+}
+
+#pragma mark - Storage Operations
+
+- (BOOL)setString:(NSString *)value forKey:(NSString *)key {
+  if (!value || !key)
+    return NO;
+
+  
+  [self deleteValueForKey:key];
+
+  NSData *valueData = [value dataUsingEncoding:NSUTF8StringEncoding];
+  if (!valueData)
+    return NO;
+
+  NSMutableDictionary *query = [self baseQueryForKey:key];
+  query[(__bridge id)kSecValueData] = valueData;
+
+  OSStatus status = SecItemAdd((__bridge CFDictionaryRef)query, NULL);
+
+  if (status == errSecSuccess) {
+    RJLogDebug(@"Keychain: Stored value for key '%@'", key);
+    return YES;
+  } else {
+    RJLogWarning(@"Keychain: Failed to store value for key '%@' (status: %d)",
+                 key, (int)status);
+    return NO;
+  }
+}
+
+- (nullable NSString *)stringForKey:(NSString *)key {
+  if (!key)
+    return nil;
+
+  NSMutableDictionary *query = [self baseQueryForKey:key];
+  query[(__bridge id)kSecReturnData] = @YES;
+  query[(__bridge id)kSecMatchLimit] = (__bridge id)kSecMatchLimitOne;
+
+  CFDataRef dataRef = NULL;
+  OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query,
+                                        (CFTypeRef *)&dataRef);
+
+  if (status == errSecSuccess && dataRef) {
+    NSData *data = (__bridge_transfer NSData *)dataRef;
+    return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+  }
+
+  return nil;
+}
+
+- (BOOL)deleteValueForKey:(NSString *)key {
+  if (!key)
+    return NO;
+
+  NSMutableDictionary *query = [self baseQueryForKey:key];
+  OSStatus status = SecItemDelete((__bridge CFDictionaryRef)query);
+
+  return status == errSecSuccess || status == errSecItemNotFound;
+}
+
+- (void)clearAll {
+  NSDictionary *query = @{
+    (__bridge id)kSecClass : (__bridge id)kSecClassGenericPassword,
+    (__bridge id)kSecAttrService : kRJKeychainServiceName
+  };
+
+  OSStatus status = SecItemDelete((__bridge CFDictionaryRef)query);
+  if (status == errSecSuccess) {
+    RJLogDebug(@"Keychain: Cleared all Rejourney items");
+  }
+}
+
+@end

package/ios/Utils/RJPerfTiming.h

@@ -0,0 +1,209 @@
+//
+//  RJPerfTiming.h
+//  Rejourney
+//
+//  Wall-clock CPU timing using mach_absolute_time() with in-memory aggregation.
+//  Provides µs-level timing for internal SDK performance validation.
+//
+//  Usage:
+//  - Enable by defining RJ_PERF=1 at compile time
+//  - Accumulates metrics in-memory, dumps periodically (every 5s or 100 frames)
+//  - Extremely low overhead (~20-30ns per timing call)
+//  - Works in release builds
+//
+//  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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// ============================================================================
+// COMPILE-TIME SWITCH
+// Define RJ_PERF=1 in your build settings to enable performance timing
+// Ship production with RJ_PERF=0 or undefined
+// ============================================================================
+#ifndef RJ_PERF
+// Force enable for testing - change to 0 for production
+#define RJ_PERF 1
+#endif
+
+// ============================================================================
+// TIMING MACROS (zero-cost when disabled)
+// ============================================================================
+#if RJ_PERF
+
+/// Start timing a section. Call at the beginning of the code block to time.
+#define RJ_TIME_START uint64_t __rj_t0 = rj_perf_now()
+
+/// End timing and accumulate to the specified metric.
+/// @param metric One of: RJPerfMetricFrame, RJPerfMetricScreenshot, etc.
+#define RJ_TIME_END(metric) rj_perf_record(metric, __rj_t0, rj_perf_now())
+
+/// Start timing with a custom variable name (for nested timing).
+#define RJ_TIME_START_NAMED(name) uint64_t __rj_t0_##name = rj_perf_now()
+
+/// End timing with a custom variable name.
+#define RJ_TIME_END_NAMED(name, metric)                                        \
+  rj_perf_record(metric, __rj_t0_##name, rj_perf_now())
+
+/// Dump metrics if enough time has passed (call periodically from main loop).
+#define RJ_PERF_DUMP_IF_NEEDED() rj_perf_dump_if_needed()
+
+/// Force dump metrics immediately.
+#define RJ_PERF_DUMP() rj_perf_dump()
+
+/// Reset all metrics.
+#define RJ_PERF_RESET() rj_perf_reset()
+
+#else
+
+// No-op when disabled
+#define RJ_TIME_START
+#define RJ_TIME_END(metric)
+#define RJ_TIME_START_NAMED(name)
+#define RJ_TIME_END_NAMED(name, metric)
+#define RJ_PERF_DUMP_IF_NEEDED()
+#define RJ_PERF_DUMP()
+#define RJ_PERF_RESET()
+
+#endif
+
+// ============================================================================
+// METRIC TYPES
+// ============================================================================
+
+/// Performance metrics that can be tracked.
+typedef NS_ENUM(NSInteger, RJPerfMetric) {
+  /// Total frame processing time (screenshot + encode + upload)
+  RJPerfMetricFrame = 0,
+
+  /// Screenshot capture time (UIGraphics rendering)
+  RJPerfMetricScreenshot,
+
+  /// Raw Core Animation/Graphics rendering time (layer.render or
+  /// drawViewHierarchy)
+  RJPerfMetricRender,
+
+  /// Privacy mask drawing time
+  RJPerfMetricPrivacyMask,
+
+  /// View hierarchy scanning time
+  RJPerfMetricViewScan,
+
+  /// View hierarchy serialization time
+  RJPerfMetricViewSerialize,
+
+  /// Video encoding time (H.264 compression)
+  RJPerfMetricEncode,
+
+  /// Pixel buffer creation time (UIImage -> CVPixelBuffer)
+  RJPerfMetricPixelBuffer,
+
+  /// Downscaling time (vImage)
+  RJPerfMetricDownscale,
+
+  /// Buffer allocation time (CVPixelBufferPool)
+  RJPerfMetricBufferAlloc,
+
+  /// Encoder append time (pixel buffer -> H.264)
+  RJPerfMetricEncodeAppend,
+
+  /// Segment upload time (network)
+  RJPerfMetricUpload,
+
+  /// Number of metric types (keep last)
+  RJPerfMetricCount
+};
+
+// ============================================================================
+// C INTERFACE (for maximum performance)
+// ============================================================================
+
+#if RJ_PERF
+
+/// Get current timestamp (mach_absolute_time).
+FOUNDATION_EXPORT uint64_t rj_perf_now(void);
+
+/// Record a timing measurement.
+/// @param metric The metric to record to
+/// @param start Start timestamp from rj_perf_now()
+/// @param end End timestamp from rj_perf_now()
+FOUNDATION_EXPORT void rj_perf_record(RJPerfMetric metric, uint64_t start,
+                                      uint64_t end);
+
+/// Dump metrics if more than 5 seconds have passed since last dump.
+FOUNDATION_EXPORT void rj_perf_dump_if_needed(void);
+
+/// Force dump metrics immediately.
+FOUNDATION_EXPORT void rj_perf_dump(void);
+
+/// Reset all accumulated metrics.
+FOUNDATION_EXPORT void rj_perf_reset(void);
+
+/// Get a snapshot of current metrics (for programmatic access).
+/// Returns dictionary with avg/max/count for each metric.
+FOUNDATION_EXPORT
+NSDictionary<NSString *, NSDictionary<NSString *, NSNumber *> *> *
+rj_perf_snapshot(void);
+
+#endif
+
+// ============================================================================
+// OBJECTIVE-C INTERFACE (for convenience)
+// ============================================================================
+
+/**
+ * RJPerfTiming provides wall-clock CPU timing with in-memory aggregation.
+ *
+ * This class is a thin wrapper around the C functions for ObjC convenience.
+ * For hot paths, use the C macros directly for best performance.
+ *
+ * ## Example Usage
+ *
+ * ```objc
+ * // In a hot loop:
+ * RJ_TIME_START;
+ * [self doExpensiveWork];
+ * RJ_TIME_END(RJPerfMetricFrame);
+ *
+ * // Periodically (e.g., in capture timer):
+ * RJ_PERF_DUMP_IF_NEEDED();
+ *
+ * // Or get metrics programmatically:
+ * NSDictionary *metrics = [RJPerfTiming snapshot];
+ * ```
+ */
+@interface RJPerfTiming : NSObject
+
+/// Whether performance timing is enabled (compile-time).
++ (BOOL)isEnabled;
+
+/// Get current metrics snapshot.
++ (nullable NSDictionary<NSString *, NSDictionary<NSString *, NSNumber *> *> *)
+    snapshot;
+
+/// Force dump metrics to console.
++ (void)dump;
+
+/// Reset all metrics.
++ (void)reset;
+
+/// Get human-readable name for a metric.
++ (NSString *)nameForMetric:(RJPerfMetric)metric;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Utils/RJPerfTiming.m

@@ -0,0 +1,264 @@
+//
+//  RJPerfTiming.m
+//  Rejourney
+//
+//  Wall-clock CPU timing implementation using mach_absolute_time().
+//
+//  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 "RJPerfTiming.h"
+#import "../Core/RJLogger.h"
+#import <mach/mach_time.h>
+#import <os/lock.h>
+
+#if RJ_PERF
+
+static mach_timebase_info_data_t rj_timebase;
+
+static BOOL rj_perf_initialized = NO;
+
+__attribute__((constructor)) static void RJPerfTimingInit(void) {
+  mach_timebase_info(&rj_timebase);
+  rj_perf_initialized = YES;
+  RJLogInfo(@"[Rejourney PERF] ✅ Performance timing initialized (RJ_PERF=1)");
+}
+
+static inline double rj_ms(uint64_t start, uint64_t end) {
+  return (double)(end - start) * rj_timebase.numer / rj_timebase.denom /
+         1000000.0;
+}
+
+static const char *const rj_metric_names[] = {
+    "frame_total", "screenshot_ui",  "render_draw",   "privacy_mask",
+    "view_scan",   "view_serialize", "encode_h264",   "pixel_buffer",
+    "downscale",   "buffer_alloc",   "encode_append", "upload_net"};
+
+static double rj_totals[RJPerfMetricCount] = {0};
+
+static double rj_maxes[RJPerfMetricCount] = {0};
+
+static uint64_t rj_counts[RJPerfMetricCount] = {0};
+
+static uint64_t rj_last_dump = 0;
+
+static const double RJ_DUMP_INTERVAL_MS = 5000.0; // 5s
+
+static const uint64_t RJ_MIN_SAMPLES = 5;
+
+static os_unfair_lock rj_perf_lock = OS_UNFAIR_LOCK_INIT;
+
+uint64_t rj_perf_now(void) { return mach_absolute_time(); }
+
+void rj_perf_record(RJPerfMetric metric, uint64_t start, uint64_t end) {
+  if (metric < 0 || metric >= RJPerfMetricCount)
+    return;
+
+  double ms = rj_ms(start, end);
+
+  // IMMEDIATE LOGGING (Request by user)
+  // Pinpoints main thread blockers
+  BOOL isMain = [NSThread isMainThread];
+  const char *threadName = isMain ? "MAIN" : "BG";
+
+  // Log critical main thread hitches (> 4ms) visibly
+  // Or just log everything as requested ("intense logging")
+  // Using specific emoji to highlight potential issues
+  if (isMain && ms > 4.0) {
+    RJLogInfo(@"[RJ-PERF] ⚠️ [%s] %s: %.2fms", threadName, rj_metric_names[metric],
+          ms);
+  } else {
+    RJLogInfo(@"[RJ-PERF] [%s] %s: %.2fms", threadName, rj_metric_names[metric],
+          ms);
+  }
+
+  os_unfair_lock_lock(&rj_perf_lock);
+  rj_counts[metric]++;
+  rj_totals[metric] += ms;
+  if (ms > rj_maxes[metric]) {
+    rj_maxes[metric] = ms;
+  }
+  os_unfair_lock_unlock(&rj_perf_lock);
+}
+
+void rj_perf_dump_if_needed(void) {
+  uint64_t now = rj_perf_now();
+
+  if (rj_last_dump != 0 && rj_ms(rj_last_dump, now) < RJ_DUMP_INTERVAL_MS) {
+    return;
+  }
+
+  os_unfair_lock_lock(&rj_perf_lock);
+
+  if (rj_last_dump != 0 && rj_ms(rj_last_dump, now) < RJ_DUMP_INTERVAL_MS) {
+    os_unfair_lock_unlock(&rj_perf_lock);
+    return;
+  }
+
+  uint64_t total_samples = 0;
+  for (int i = 0; i < RJPerfMetricCount; i++) {
+    total_samples += rj_counts[i];
+  }
+
+  if (total_samples < RJ_MIN_SAMPLES) {
+    os_unfair_lock_unlock(&rj_perf_lock);
+    return;
+  }
+
+  rj_last_dump = now;
+
+  NSMutableString *log =
+      [NSMutableString stringWithString:@"[Rejourney PERF SUMMARY]"];
+
+  for (int i = 0; i < RJPerfMetricCount; i++) {
+    if (rj_counts[i] > 0) {
+      double avg = rj_totals[i] / rj_counts[i];
+      [log appendFormat:@" %s=%llu/%.1f/%.1fms", rj_metric_names[i],
+                        (unsigned long long)rj_counts[i], avg, rj_maxes[i]];
+    }
+  }
+
+  os_unfair_lock_unlock(&rj_perf_lock);
+
+  RJLogInfo(@"%@", log);
+}
+
+void rj_perf_dump(void) {
+  os_unfair_lock_lock(&rj_perf_lock);
+
+  uint64_t total_samples = 0;
+  for (int i = 0; i < RJPerfMetricCount; i++) {
+    total_samples += rj_counts[i];
+  }
+
+  if (total_samples == 0) {
+    os_unfair_lock_unlock(&rj_perf_lock);
+    RJLogInfo(@"[Rejourney PERF] No samples collected");
+    return;
+  }
+
+  NSMutableString *log = [NSMutableString stringWithString:@"\n"];
+  [log appendString:@"╔════════════════════════════════════════════════════════"
+                    @"══════╗\n"];
+  [log appendString:@"║              REJOURNEY SDK PERFORMANCE METRICS (ms)    "
+                    @"      ║\n"];
+  [log appendString:@"╠════════════════════════════════════════════════════════"
+                    @"══════╣\n"];
+  [log appendFormat:@"║  %-16s │ %8s │ %10s │ %10s  ║\n", "METRIC", "COUNT",
+                    "AVG (ms)", "MAX (ms)"];
+  [log appendString:@"╠════════════════════════════════════════════════════════"
+                    @"══════╣\n"];
+
+  for (int i = 0; i < RJPerfMetricCount; i++) {
+    if (rj_counts[i] > 0) {
+      double avg = rj_totals[i] / rj_counts[i];
+      [log appendFormat:@"║  %-16s │ %8llu │ %10.2f │ %10.2f  ║\n",
+                        rj_metric_names[i], (unsigned long long)rj_counts[i],
+                        avg, rj_maxes[i]];
+    }
+  }
+
+  [log appendString:
+           @"╚══════════════════════════════════════════════════════════════╝"];
+
+  rj_last_dump = rj_perf_now();
+
+  os_unfair_lock_unlock(&rj_perf_lock);
+
+  RJLogInfo(@"%@", log);
+}
+
+void rj_perf_reset(void) {
+  os_unfair_lock_lock(&rj_perf_lock);
+
+  for (int i = 0; i < RJPerfMetricCount; i++) {
+    rj_totals[i] = 0;
+    rj_maxes[i] = 0;
+    rj_counts[i] = 0;
+  }
+  rj_last_dump = 0;
+
+  os_unfair_lock_unlock(&rj_perf_lock);
+
+  RJLogInfo(@"[Rejourney PERF] Metrics reset");
+}
+
+NSDictionary<NSString *, NSDictionary<NSString *, NSNumber *> *> *
+rj_perf_snapshot(void) {
+  NSMutableDictionary *result = [NSMutableDictionary dictionary];
+
+  os_unfair_lock_lock(&rj_perf_lock);
+
+  for (int i = 0; i < RJPerfMetricCount; i++) {
+    if (rj_counts[i] > 0) {
+      NSString *name = [NSString stringWithUTF8String:rj_metric_names[i]];
+      double avg = rj_totals[i] / rj_counts[i];
+
+      result[name] = @{
+        @"count" : @(rj_counts[i]),
+        @"avg_us" : @(avg),
+        @"max_us" : @(rj_maxes[i]),
+        @"total_us" : @(rj_totals[i])
+      };
+    }
+  }
+
+  os_unfair_lock_unlock(&rj_perf_lock);
+
+  return [result copy];
+}
+
+#endif
+
+@implementation RJPerfTiming
+
++ (BOOL)isEnabled {
+#if RJ_PERF
+  return YES;
+#else
+  return NO;
+#endif
+}
+
++ (NSDictionary<NSString *, NSDictionary<NSString *, NSNumber *> *> *)snapshot {
+#if RJ_PERF
+  return rj_perf_snapshot();
+#else
+  return nil;
+#endif
+}
+
++ (void)dump {
+#if RJ_PERF
+  rj_perf_dump();
+#endif
+}
+
++ (void)reset {
+#if RJ_PERF
+  rj_perf_reset();
+#endif
+}
+
++ (NSString *)nameForMetric:(RJPerfMetric)metric {
+#if RJ_PERF
+  if (metric >= 0 && metric < RJPerfMetricCount) {
+    return [NSString stringWithUTF8String:rj_metric_names[metric]];
+  }
+#endif
+  return @"unknown";
+}
+
+@end

package/ios/Utils/RJTelemetry.h

@@ -0,0 +1,92 @@
+//
+// RJTelemetry.h
+// Rejourney SDK Telemetry
+//
+// Provides observability metrics for SDK health monitoring.
+// Tracks upload success rates, retry counts, circuit breaker events, and memory
+// pressure.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Telemetry event types
+typedef NS_ENUM(NSInteger, RJTelemetryEventType) {
+  RJTelemetryEventUploadSuccess,
+  RJTelemetryEventUploadFailure,
+  RJTelemetryEventRetryAttempt,
+  RJTelemetryEventCircuitBreakerOpen,
+  RJTelemetryEventCircuitBreakerClose,
+  RJTelemetryEventMemoryPressureEviction,
+  RJTelemetryEventOfflineQueuePersist,
+  RJTelemetryEventOfflineQueueRestore,
+  RJTelemetryEventSessionStart,
+  RJTelemetryEventSessionEnd,
+  RJTelemetryEventCrashDetected,
+  RJTelemetryEventTokenRefresh,
+};
+
+/// SDK health metrics snapshot
+@interface RJTelemetryMetrics : NSObject
+
+@property(nonatomic, assign, readonly) NSInteger uploadSuccessCount;
+@property(nonatomic, assign, readonly) NSInteger uploadFailureCount;
+@property(nonatomic, assign, readonly) NSInteger retryAttemptCount;
+@property(nonatomic, assign, readonly) NSInteger circuitBreakerOpenCount;
+@property(nonatomic, assign, readonly) NSInteger memoryEvictionCount;
+@property(nonatomic, assign, readonly) NSInteger offlinePersistCount;
+@property(nonatomic, assign, readonly) NSInteger sessionStartCount;
+@property(nonatomic, assign, readonly) NSInteger crashCount;
+@property(nonatomic, assign, readonly) NSInteger anrCount;
+@property(nonatomic, assign, readonly) double uploadSuccessRate;
+@property(nonatomic, assign, readonly) NSTimeInterval avgUploadDurationMs;
+@property(nonatomic, assign, readonly) NSInteger currentQueueDepth;
+@property(nonatomic, strong, readonly) NSDate *lastUploadTime;
+@property(nonatomic, strong, readonly) NSDate *lastRetryTime;
+
+@end
+
+/// Telemetry collector for SDK observability
+@interface RJTelemetry : NSObject
+
+/// Shared instance
++ (instancetype)sharedInstance;
+
+/// Record a telemetry event
+- (void)recordEvent:(RJTelemetryEventType)eventType;
+
+/// Record an event with additional context
+- (void)recordEvent:(RJTelemetryEventType)eventType
+           metadata:(nullable NSDictionary<NSString *, id> *)metadata;
+
+/// Record upload duration for latency tracking
+- (void)recordUploadDuration:(NSTimeInterval)durationMs
+                     success:(BOOL)success
+                   byteCount:(NSUInteger)bytes;
+
+/// Record memory pressure eviction
+- (void)recordFrameEviction:(NSUInteger)bytesEvicted
+                 frameCount:(NSInteger)count;
+
+/// Record retry queue depth
+- (void)recordQueueDepth:(NSInteger)depth;
+
+/// Record an ANR event
+- (void)recordANR;
+
+/// Get current metrics snapshot
+- (RJTelemetryMetrics *)currentMetrics;
+
+/// Get metrics as dictionary for reporting
+- (NSDictionary<NSString *, id> *)metricsAsDictionary;
+
+/// Reset all metrics (typically on session end)
+- (void)resetMetrics;
+
+/// Export metrics to console for debugging (only in DEBUG builds)
+- (void)logCurrentMetrics;
+
+@end
+
+NS_ASSUME_NONNULL_END