@rejourneyco/react-native 1.0.0

package/ios/Network/RJRetryManager.m

@@ -0,0 +1,325 @@
+//
+//  RJRetryManager.m
+//  Rejourney
+//
+//  Retry queue and circuit breaker for upload resilience implementation.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import "RJRetryManager.h"
+#import "../Core/RJLogger.h"
+#import "../Utils/RJTelemetry.h"
+
+static const NSInteger kCircuitBreakerThreshold = 5; 
+static const NSTimeInterval kCircuitBreakerTimeout = 60.0; 
+static const NSTimeInterval kMaxRetryDelay = 60.0;         
+
+#pragma mark - Private Interface
+
+@interface RJRetryManager ()
+
+@property(nonatomic, strong) dispatch_queue_t retryQueue;
+
+@property(nonatomic, strong) NSMutableArray<NSDictionary *> *pendingRetries;
+
+@property(nonatomic, assign) BOOL isRetryScheduled;
+
+@property(nonatomic, assign) NSTimeInterval circuitOpenedTime;
+
+@property(nonatomic, assign) BOOL circuitOpen;
+
+@property(nonatomic, assign) NSInteger failureCount;
+
+@end
+
+#pragma mark - Implementation
+
+@implementation RJRetryManager
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _retryQueue =
+        dispatch_queue_create("com.rejourney.retry", DISPATCH_QUEUE_SERIAL);
+    _pendingRetries = [NSMutableArray new];
+    _isRetryScheduled = NO;
+    _circuitOpen = NO;
+    _circuitOpenedTime = 0;
+    _failureCount = 0;
+    _isShuttingDown = NO;
+  }
+  return self;
+}
+
+#pragma mark - Public Properties
+
+- (BOOL)isCircuitOpen {
+  return _circuitOpen;
+}
+
+- (NSInteger)consecutiveFailureCount {
+  return _failureCount;
+}
+
+#pragma mark - Circuit Breaker
+
+- (BOOL)shouldAllowRequest {
+  if (!self.circuitOpen) {
+    return YES;
+  }
+
+  NSTimeInterval now = [[NSDate date] timeIntervalSince1970];
+  if (now - self.circuitOpenedTime >= kCircuitBreakerTimeout) {
+    
+    RJLogDebug(@"Circuit breaker entering half-open state");
+    self.circuitOpen = NO;
+    return YES;
+  }
+
+  RJLogDebug(@"Circuit breaker open, waiting %.0fs before retry",
+             kCircuitBreakerTimeout - (now - self.circuitOpenedTime));
+  return NO;
+}
+
+- (void)recordUploadSuccess {
+  self.failureCount = 0;
+  [[RJTelemetry sharedInstance] recordEvent:RJTelemetryEventUploadSuccess];
+  if (self.circuitOpen) {
+    RJLogDebug(@"Upload succeeded, closing circuit breaker");
+    self.circuitOpen = NO;
+    [[RJTelemetry sharedInstance]
+        recordEvent:RJTelemetryEventCircuitBreakerClose];
+  }
+}
+
+- (void)recordUploadFailure {
+  self.failureCount++;
+  [[RJTelemetry sharedInstance] recordEvent:RJTelemetryEventUploadFailure];
+  if (self.failureCount >= kCircuitBreakerThreshold && !self.circuitOpen) {
+    self.circuitOpen = YES;
+    self.circuitOpenedTime = [[NSDate date] timeIntervalSince1970];
+    [[RJTelemetry sharedInstance]
+        recordEvent:RJTelemetryEventCircuitBreakerOpen];
+    RJLogWarning(@"Circuit breaker opened after %ld consecutive failures",
+                 (long)self.failureCount);
+  }
+}
+
+#pragma mark - Retry Queue
+
+- (void)addToRetryQueueWithEvents:(NSArray<NSDictionary *> *)events {
+  if (self.isShuttingDown)
+    return;
+
+  dispatch_async(self.retryQueue, ^{
+    @try {
+      NSDictionary *retryItem = @{
+        @"events" : events ?: @[],
+        @"timestamp" : @([[NSDate date] timeIntervalSince1970]),
+        @"attemptCount" : @0
+      };
+
+      [self.pendingRetries addObject:retryItem];
+      RJLogDebug(@"Added batch to retry queue (queue size: %lu)",
+                 (unsigned long)self.pendingRetries.count);
+
+      [self scheduleRetryIfNeeded];
+    } @catch (NSException *exception) {
+      RJLogWarning(@"Add to retry queue exception: %@", exception);
+    }
+  });
+}
+
+- (void)scheduleRetryIfNeeded {
+  
+  if (self.isRetryScheduled || self.pendingRetries.count == 0 ||
+      self.isShuttingDown) {
+    return;
+  }
+
+  if (![self shouldAllowRequest]) {
+    return;
+  }
+
+  self.isRetryScheduled = YES;
+
+  
+  NSTimeInterval delay = MIN(pow(2.0, self.failureCount), kMaxRetryDelay);
+
+  RJLogDebug(@"Scheduling retry in %.1fs (consecutive failures: %ld)", delay,
+             (long)self.failureCount);
+
+  __weak typeof(self) weakSelf = self;
+  dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)),
+      self.retryQueue, ^{
+        __strong typeof(weakSelf) strongSelf = weakSelf;
+        if (!strongSelf || strongSelf.isShuttingDown)
+          return;
+
+        strongSelf.isRetryScheduled = NO;
+        [strongSelf processRetryQueue];
+      });
+}
+
+- (void)processRetryQueue {
+  
+  if (self.pendingRetries.count == 0 || self.isShuttingDown) {
+    return;
+  }
+
+  if (!self.uploadBlock) {
+    RJLogWarning(@"No upload block set, cannot process retry queue");
+    return;
+  }
+
+  
+  NSDictionary *item = self.pendingRetries.firstObject;
+  NSArray *events = item[@"events"];
+  NSInteger attemptCount = [item[@"attemptCount"] integerValue];
+
+  
+  [self.pendingRetries removeObjectAtIndex:0];
+
+  RJLogDebug(@"Retrying batch (attempt %ld, remaining: %lu)",
+             (long)(attemptCount + 1),
+             (unsigned long)self.pendingRetries.count);
+
+  __weak typeof(self) weakSelf = self;
+  dispatch_async(self.retryQueue, ^{
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (!strongSelf)
+      return;
+
+    BOOL success = NO;
+    @try {
+      success = strongSelf.uploadBlock(events);
+    } @catch (NSException *exception) {
+      RJLogWarning(@"Retry upload exception: %@", exception);
+      success = NO;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (success) {
+        
+        [strongSelf recordUploadSuccess];
+        RJLogDebug(@"Retry upload succeeded");
+
+        
+        if (strongSelf.pendingRetries.count > 0) {
+          dispatch_async(strongSelf.retryQueue, ^{
+            [strongSelf scheduleRetryIfNeeded];
+          });
+        }
+      } else {
+        
+        [strongSelf recordUploadFailure];
+
+        
+        if (attemptCount < 5) {
+          NSMutableDictionary *updatedItem = [item mutableCopy];
+          updatedItem[@"attemptCount"] = @(attemptCount + 1);
+          dispatch_async(strongSelf.retryQueue, ^{
+            [strongSelf.pendingRetries addObject:updatedItem];
+            RJLogDebug(@"Re-queued failed batch (attempt %ld)",
+                       (long)(attemptCount + 1));
+            [strongSelf scheduleRetryIfNeeded];
+          });
+        } else {
+          RJLogWarning(@"Batch exceeded max retries, discarding");
+          dispatch_async(strongSelf.retryQueue, ^{
+            [strongSelf scheduleRetryIfNeeded];
+          });
+        }
+      }
+    });
+  });
+}
+
+#pragma mark - Persistence
+
+- (NSString *)failedUploadsPath {
+  NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
+                                                       NSUserDomainMask, YES);
+  NSString *cacheDir = paths.firstObject;
+  return [cacheDir stringByAppendingPathComponent:@"rj_failed_uploads.plist"];
+}
+
+- (void)persistPendingUploads {
+  dispatch_async(self.retryQueue, ^{
+    @try {
+      if (self.pendingRetries.count == 0) {
+        return;
+      }
+
+      NSString *path = [self failedUploadsPath];
+
+      
+      NSMutableArray *allPending = [NSMutableArray array];
+      if ([[NSFileManager defaultManager] fileExistsAtPath:path]) {
+        NSArray *existing = [NSArray arrayWithContentsOfFile:path];
+        if (existing) {
+          [allPending addObjectsFromArray:existing];
+        }
+      }
+
+      
+      [allPending addObjectsFromArray:self.pendingRetries];
+
+      
+      if (allPending.count > 100) {
+        allPending = [[allPending
+            subarrayWithRange:NSMakeRange(allPending.count - 100, 100)]
+            mutableCopy];
+      }
+
+      
+      BOOL success = [allPending writeToFile:path atomically:YES];
+      if (success) {
+        RJLogDebug(@"Persisted %lu failed uploads to disk",
+                   (unsigned long)allPending.count);
+        [self.pendingRetries removeAllObjects];
+      } else {
+        RJLogWarning(@"Failed to persist uploads to disk");
+      }
+    } @catch (NSException *exception) {
+      RJLogWarning(@"Persist uploads exception: %@", exception);
+    }
+  });
+}
+
+- (void)loadAndRetryPersistedUploads {
+  dispatch_async(self.retryQueue, ^{
+    @try {
+      NSString *path = [self failedUploadsPath];
+
+      if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+        return;
+      }
+
+      NSArray *persisted = [NSArray arrayWithContentsOfFile:path];
+      if (!persisted || persisted.count == 0) {
+        return;
+      }
+
+      RJLogDebug(@"Found %lu persisted failed uploads, queuing for retry",
+                 (unsigned long)persisted.count);
+
+      
+      [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
+
+      
+      [self.pendingRetries addObjectsFromArray:persisted];
+
+      
+      [self scheduleRetryIfNeeded];
+    } @catch (NSException *exception) {
+      RJLogWarning(@"Load persisted uploads exception: %@", exception);
+    }
+  });
+}
+
+@end

package/ios/Network/RJUploadManager.h

@@ -0,0 +1,267 @@
+//
+//  RJUploadManager.h
+//  Rejourney
+//
+//  Session data upload management.
+//
+//  The upload manager handles batched uploads of session data to the
+//  dashboard server, including automatic retry and background task
+//  management.
+//
+//  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 "../Core/RJTypes.h"
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Manages session data uploads to the dashboard server.
+ *
+ * The upload manager provides:
+ * - Batched upload scheduling
+ * - Background task management for reliable uploads
+ * - Automatic retry on failure
+ * - Payload construction with device info
+ *
+ * ## Usage
+ * ```objc
+ * RJUploadManager *manager = [[RJUploadManager alloc]
+ * initWithApiUrl:@"https://api.rejourney.co"]; manager.sessionId =
+ * @"session_123"; manager.userId = @"user_456";
+ *
+ * [manager startBatchUploadTimer];
+ * // ... later ...
+ * [manager uploadBatchWithEvents:events isFinal:NO completion:^(BOOL success) {
+ *     // Handle result
+ * }];
+ * ```
+ *
+ * @note This class is thread-safe for public methods.
+ */
+@interface RJUploadManager : NSObject
+
+#pragma mark - Configuration
+
+/// API URL for session uploads
+@property(nonatomic, copy) NSString *apiUrl;
+
+/// Public route key (pk_live_xxx) for SDK authentication
+@property(nonatomic, copy, nullable) NSString *publicKey;
+
+/// Backend project ID (UUID) for attestation/ingest
+@property(nonatomic, copy, nullable) NSString *projectId;
+
+/// Current session ID
+@property(nonatomic, copy, nullable) NSString *sessionId;
+
+/// Current user ID
+@property(nonatomic, copy, nullable) NSString *userId;
+
+/// Device hash for session correlation
+@property(nonatomic, copy, nullable) NSString *deviceHash;
+
+/// Session start timestamp
+@property(nonatomic, assign) NSTimeInterval sessionStartTime;
+
+/// Total background time in milliseconds (for billing exclusion)
+@property(nonatomic, assign) NSTimeInterval totalBackgroundTimeMs;
+
+/// Current batch number
+@property(nonatomic, readonly) NSInteger batchNumber;
+
+/// Whether an upload is currently in progress
+@property(nonatomic, readonly) BOOL isUploading;
+
+/// Max recording minutes allowed for this project
+@property(nonatomic, assign) NSInteger maxRecordingMinutes;
+
+/// Sample rate (0-100) for this project
+@property(nonatomic, assign) NSInteger sampleRate;
+
+#pragma mark - Retry & Resilience
+
+/// Number of consecutive upload failures (for circuit breaker)
+@property(nonatomic, readonly) NSInteger consecutiveFailureCount;
+
+/// Whether the circuit breaker is currently open (blocking requests)
+@property(nonatomic, readonly) BOOL isCircuitOpen;
+
+/**
+ * Loads and retries any persisted failed uploads from previous sessions.
+ * Call this during session start to recover from server downtime scenarios.
+ */
+- (void)loadAndRetryPersistedUploads;
+
+/**
+ * Persists pending uploads to disk for recovery after app restart.
+ * Call this during app termination or background expiration.
+ */
+- (void)persistPendingUploads;
+
+/**
+ * Recovers any crash-persisted pending uploads and closes prior sessions.
+ * Safe to call after an upload token is available.
+ */
+- (void)recoverPendingSessionsWithCompletion:
+    (nullable RJCompletionHandler)completion;
+
+#pragma mark - Initialization
+
+/**
+ * Creates an upload manager for the specified API URL.
+ *
+ * @param apiUrl Base URL of the API server.
+ * @return A new upload manager instance.
+ */
+- (instancetype)initWithApiUrl:(NSString *)apiUrl;
+
+/// Unavailable. Use initWithApiUrl: instead.
+- (instancetype)init NS_UNAVAILABLE;
+
+#pragma mark - Project Configuration
+
+/**
+ * Fetches the project configuration (ID, limits, etc) from the server.
+ * This resolves the publicKey to a projectId and gets the recording rules.
+ *
+ * @param completion Called with success status and configuration dictionary.
+ */
+- (void)fetchProjectConfigWithCompletion:
+    (void (^)(BOOL success, NSDictionary *_Nullable config,
+              NSError *_Nullable error))completion;
+
+#pragma mark - Timer Management
+
+/**
+ * Starts the batch upload timer.
+ * The timer fires every 30 seconds to upload accumulated data.
+ */
+- (void)startBatchUploadTimer;
+
+/**
+ * Stops the batch upload timer.
+ */
+- (void)stopBatchUploadTimer;
+
+#pragma mark - Upload Methods
+
+/**
+ * Uploads a batch of events to the dashboard.
+ *
+ * @param events Array of event dictionaries.
+ * @param isFinal Whether this is the final batch for the session.
+ * @param completion Called with upload success status.
+ */
+- (void)uploadBatchWithEvents:(NSArray<NSDictionary *> *)events
+                      isFinal:(BOOL)isFinal
+                   completion:(nullable RJCompletionHandler)completion;
+
+/**
+ * Performs a synchronous upload for app termination.
+ * This is a blocking call that should only be used in willTerminate.
+ *
+ * @param events Array of event dictionaries.
+ * @return Whether the upload succeeded.
+ */
+- (BOOL)synchronousUploadWithEvents:(NSArray<NSDictionary *> *)events;
+
+/**
+ * Uploads a crash report to the dashboard.
+ *
+ * @param report The crash report dictionary.
+ * @param completion Called with success status.
+ */
+- (void)uploadCrashReport:(NSDictionary *)report
+               completion:(nullable RJCompletionHandler)completion;
+
+/**
+ * Uploads an ANR report to the dashboard.
+ *
+ * @param report The ANR report dictionary.
+ * @param completion Called with success status.
+ */
+- (void)uploadANRReport:(NSDictionary *)report
+             completion:(nullable RJCompletionHandler)completion;
+
+#pragma mark - Background Task Management
+
+/**
+ * Begins a background task for upload during app backgrounding.
+ *
+ * @param name Task name for debugging.
+ * @return Background task identifier.
+ */
+- (UIBackgroundTaskIdentifier)beginBackgroundTaskWithName:(NSString *)name;
+
+/**
+ * Ends a background task.
+ *
+ * @param taskId Task identifier from beginBackgroundTaskWithName:.
+ */
+- (void)endBackgroundTask:(UIBackgroundTaskIdentifier)taskId;
+
+#pragma mark - Session End
+
+/**
+ * Sends a session end signal to the backend synchronously.
+ * This updates the session duration and status on the server.
+ *
+ * @return Whether the request succeeded.
+ */
+- (BOOL)endSessionSync;
+
+#pragma mark - State Reset
+
+/**
+ * Updates the session recovery metadata with current timestamp.
+ * Call after successful uploads to ensure proper endedAt on recovery.
+ */
+- (void)updateSessionRecoveryMeta;
+
+/**
+ * Resets the upload manager for a new session.
+ */
+- (void)resetForNewSession;
+
+/**
+ * Shuts down the upload manager, cancelling any active uploads.
+ * Call this during module deallocation.
+ */
+- (void)shutdown;
+
+#pragma mark - Replay Promotion
+
+/// Whether this session has been promoted for replay upload.
+/// Set by evaluateReplayPromotionWithMetrics:completion:.
+@property(nonatomic, readonly) BOOL isReplayPromoted;
+
+/**
+ * Evaluates whether the session should be promoted for replay upload.
+ * Call this at session end.
+ *
+ * @param metrics Session metrics (crashCount, anrCount, errorCount, etc.)
+ * @param completion Called with promotion status and reason.
+ */
+- (void)evaluateReplayPromotionWithMetrics:(NSDictionary *)metrics
+                                completion:
+                                    (void (^)(BOOL promoted,
+                                              NSString *reason))completion;
+
+@end
+
+NS_ASSUME_NONNULL_END