@sanctum-key/react-native-sdk 1.0.49 → 1.0.51

package/src/utils/logger.ts

@@ -1,48 +1,201 @@
-/**
- * Logger utility that only logs in development mode
- * In production, all logs are suppressed
- */
+import { Platform, AppState, AppStateStatus } from 'react-native';
+import axios from 'axios';
+import KYCConfig from '../config/KYCConfig';
 
 const isProduction = (): boolean => {
-  // Check for React Native __DEV__ flag
   if (typeof __DEV__ !== 'undefined') {
     return !__DEV__;
   }
-  // Check for Node.js environment
   if (typeof process !== 'undefined' && process.env) {
     return process.env.NODE_ENV === 'production';
   }
-  // Default to development mode if we can't determine
   return false;
 };
 
-const shouldLog = !isProduction();
+const IS_PROD = isProduction();
 
 export const logger = {
-  log: (...args: any[]) => {
-    if (shouldLog) {
-      console.log(...args);
+  log: (...args: any[]) => { if (!IS_PROD) console.log(...args); },
+  error: (...args: any[]) => { if (!IS_PROD) console.error(...args); },
+  warn: (...args: any[]) => { if (!IS_PROD) console.warn(...args); },
+  info: (...args: any[]) => { if (!IS_PROD) console.info(...args); },
+  debug: (...args: any[]) => { if (!IS_PROD) console.debug(...args); },
+};
+
+// ==========================================
+// 2. SDK TELEMETRY LOGGER (REMOTE)
+// ==========================================
+// 🚨 FIX 1: Changed 'warn' to 'warning' to match backend enums
+type LogLevel = 'info' | 'warning' | 'error' | 'debug'; 
+
+interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: string;
+  session_id?: string;
+  metadata?: any;
+}
+
+class SDKTelemetryLogger {
+  private queue: LogEntry[] = [];
+  private isFlushing = false;
+  private maxQueueSize = 3;
+  private flushIntervalMs = 3000;
+  private sessionId: string | undefined;
+  private apiKey: string | undefined;
+  private timerId?: ReturnType<typeof setInterval>;
+  private appStateSubscription: any;
+
+  constructor() {
+    this.timerId = setInterval(() => this.flush(), this.flushIntervalMs);
+
+    if (Platform.OS !== 'web') {
+      this.appStateSubscription = AppState.addEventListener('change', this.handleAppStateChange);
     }
-  },
-  error: (...args: any[]) => {
-    if (shouldLog) {
-      console.error(...args);
+  }
+
+  private handleAppStateChange = (nextAppState: AppStateStatus) => {
+    if (nextAppState === 'background' || nextAppState === 'inactive') {
+      this.flush();
     }
-  },
-  warn: (...args: any[]) => {
-    if (shouldLog) {
-      console.warn(...args);
+  };
+
+  public setSessionId(id: string) {
+    this.sessionId = id;
+    
+    this.queue = this.queue.map(log => {
+      if (!log.session_id) {
+        return { ...log, session_id: id };
+      }
+      return log;
+    });
+
+    this.flush();
+  }
+
+  public clearSessionId() {
+    this.sessionId = undefined;
+  }
+
+  public setApiKey(key: string) {
+    this.apiKey = key;
+  }
+
+  private parseArgs(args: any[]): { message: string, metadata: any } {
+    let message = '';
+    let metadata: any = {};
+
+    args.forEach(arg => {
+      if (typeof arg === 'string') {
+        message += (message ? ' ' : '') + arg;
+      } else if (arg instanceof Error) {
+        message += (message ? ' ' : '') + arg.message;
+        metadata.error_stack = arg.stack;
+      } else if (typeof arg === 'object' && arg !== null) {
+        Object.assign(metadata, arg);
+      } else {
+        message += (message ? ' ' : '') + String(arg);
+      }
+    });
+
+    return { message: message || 'No message provided', metadata };
+  }
+
+  public processLog(level: LogLevel, ...args: any[]) {
+    const { message, metadata } = this.parseArgs(args);
+
+    if (!IS_PROD) {
+      const devPrefix = `[SDK_TELEMETRY_${level.toUpperCase()}]`;
+      if (level === 'error') console.error(devPrefix, message, metadata);
+      else if (level === 'warning') console.warn(devPrefix, message, metadata); // Match updated level
+      else console.log(devPrefix, message, metadata);
     }
-  },
-  info: (...args: any[]) => {
-    if (shouldLog) {
-      console.info(...args);
+
+    const entry: LogEntry = {
+      level,
+      message: message.substring(0, 500),
+      timestamp: new Date().toISOString(),
+      session_id: this.sessionId,
+      metadata: {
+        ...metadata,
+        os: Platform.OS,
+        osVersion: Platform.Version,
+      }
+    };
+
+    this.queue.push(entry);
+
+    const isError = level === 'error';
+    const hitLimit = this.queue.length >= this.maxQueueSize;
+
+    if (isError || (this.sessionId && hitLimit)) {
+      this.flush();
     }
-  },
-  debug: (...args: any[]) => {
-    if (shouldLog) {
-      console.debug(...args);
+  }
+
+  public async flush() {
+    if (this.queue.length === 0 || this.isFlushing) return;
+
+    const batch = this.queue.map(log => ({
+      ...log,
+      session_id: log.session_id || 'pre-session-startup' 
+    }));
+
+    this.isFlushing = true;
+    this.queue = [];
+
+    try {
+      const url = `${KYCConfig.getBackendUrl()}/core/sdk/logs/`; 
+      
+      const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+      if (this.apiKey) {
+        headers['Authorization'] = `ApiKey ${this.apiKey}`;
+      }
+
+      await axios.post(url, { logs: batch }, {
+        headers,
+        timeout: 5000 
+      });
+    } catch (error: any) {
+      // 🚨 FIX 2: Stop Infinite Loops
+      // If the backend actively rejects our payload (400-499 error code), do NOT requeue it.
+      const isClientError = error.response && error.response.status >= 400 && error.response.status < 500;
+
+      if (!isClientError) {
+        // Only retry if it's a network failure or a 5xx Server Error
+        if (this.queue.length < 50) {
+          this.queue = [...batch, ...this.queue].slice(0, 50);
+        }
+      } else {
+        if (!IS_PROD) {
+          console.error("[SDK_TELEMETRY] Backend rejected log payload. Dropping batch to prevent infinite loop.", error.response.data);
+        }
+      }
+    } finally {
+      this.isFlushing = false;
     }
-  },
-};
+  }
+
+  public destroy() {
+    if (this.timerId) clearInterval(this.timerId);
+    if (this.appStateSubscription) this.appStateSubscription.remove();
+    this.flush();
+  }
+}
+
+const telemetryInstance = new SDKTelemetryLogger();
 
+export const sdkLogger = {
+  setSessionId: (id: string) => telemetryInstance.setSessionId(id),
+  clearSessionId: () => telemetryInstance.clearSessionId(),
+  flush: () => telemetryInstance.flush(),
+  destroy: () => telemetryInstance.destroy(),
+  setApiKey: (key: string) => telemetryInstance.setApiKey(key),
+  
+  log: (...args: any[]) => telemetryInstance.processLog('info', ...args),
+  info: (...args: any[]) => telemetryInstance.processLog('info', ...args),
+  // 🚨 FIX 1 (Continued): Map warn() function to send 'warning' to backend
+  warn: (...args: any[]) => telemetryInstance.processLog('warning', ...args), 
+  error: (...args: any[]) => telemetryInstance.processLog('error', ...args),
+  debug: (...args: any[]) => telemetryInstance.processLog('debug', ...args),
+};