@peers-app/peers-sdk 0.7.21 → 0.7.23

package/dist/logging/console-logger.d.ts

@@ -1,9 +1,10 @@
+type ConsoleLevel = 'debug' | 'info' | 'log' | 'warn' | 'error';
 /**
  * Setup console proxy to capture all console output and write to ConsoleLogs table.
  * Also subscribes to dataChanged events to output logs from other process instances.
  * @param processName - The name of the process (e.g., 'main', 'renderer')
  */
-export declare function setupConsoleProxy(processName: string): Promise<void>;
+export declare function setupConsoleLogsProxy(processName: string): void;
 /**
  * Restore original console methods
  */
@@ -14,15 +15,6 @@ export declare function restoreConsole(): void;
  * @internal Exported for testing
  */
 export declare function extractCoreMessage(message: string): string;
-/**
- * Mark the logging system as initialized and flush any pending logs
- */
-export declare function markLoggingInitialized(): void;
-/**
- * Reset logging initialization state (primarily for testing)
- * @internal
- */
-export declare function resetLoggingState(): void;
 /**
  * Logger class for creating source-specific loggers
  *
@@ -35,6 +27,8 @@ export declare function resetLoggingState(): void;
  */
 export declare class Logger {
     private source;
+    private pendingLogs;
+    private waitingForConsoleLogsTable;
     constructor(source?: string);
     /**
      * Log a debug message
@@ -59,5 +53,7 @@ export declare class Logger {
     /**
      * Internal method to write log to database
      */
-    private writeLog;
+    writeLog(level: ConsoleLevel, args: any[]): void;
+    flushPendingLogs(): Promise<void>;
 }
+export {};

package/dist/logging/console-logger.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-exports.setupConsoleProxy = setupConsoleProxy;
+exports.setupConsoleLogsProxy = setupConsoleLogsProxy;
 exports.restoreConsole = restoreConsole;
 exports.extractCoreMessage = extractCoreMessage;
-exports.markLoggingInitialized = markLoggingInitialized;
-exports.resetLoggingState = resetLoggingState;
+const lodash_1 = require("lodash");
+const serial_json_1 = require("../serial-json");
 const utils_1 = require("../utils");
 const console_logs_table_1 = require("./console-logs.table");
-const startupDelayForWritingLogsToDB = Date.now() + 2_000;
 // Store original console methods
 const originalConsole = {
     debug: console.debug,
@@ -17,35 +16,32 @@ const originalConsole = {
     warn: console.warn,
     error: console.error,
 };
-let isProxySetup = false;
+let isConsoleLogsProxySetup = false;
 let currentProcessName = 'unknown';
 let currentProcessInstanceId = '';
-// Guard against infinite recursion during log processing (single process)
-let isWritingLog = false;
-let recursionAttempts = 0;
-const MAX_RECURSION_ATTEMPTS = 3;
 // Guard against cross-process infinite loops
 // Track recent log signatures (hash of message + level + source)
 const recentLogSignatures = new Map();
 const LOG_SIGNATURE_WINDOW_MS = 5000; // 5 second window
 const MAX_IDENTICAL_LOGS_IN_WINDOW = 10; // Max same log in window
 // Track initialization state
-let isInitialized = false;
-const pendingLogs = [];
 const MAX_PENDING_LOGS = 1000; // Prevent memory buildup if initialization never happens
+let defaultLogger = undefined;
+let consoleLogsProxySubscription = undefined;
 /**
  * Setup console proxy to capture all console output and write to ConsoleLogs table.
  * Also subscribes to dataChanged events to output logs from other process instances.
  * @param processName - The name of the process (e.g., 'main', 'renderer')
  */
-async function setupConsoleProxy(processName) {
-    if (isProxySetup) {
-        console.warn('Console proxy already setup, skipping...');
+function setupConsoleLogsProxy(processName) {
+    if (isConsoleLogsProxySetup) {
+        originalConsole.warn('Console logs proxy already setup, skipping...');
         return;
     }
-    isProxySetup = true;
+    isConsoleLogsProxySetup = true;
     currentProcessName = processName;
     currentProcessInstanceId = (0, utils_1.newid)(); // Unique ID for this process instance
+    defaultLogger = new Logger(currentProcessName);
     const levels = ['debug', 'info', 'log', 'warn', 'error'];
     // Monkey-patch console methods to capture local logs
     levels.forEach((level) => {
@@ -53,130 +49,62 @@ async function setupConsoleProxy(processName) {
         console[level] = function (...args) {
             // Always call original console method first (preserve terminal output)
             original.apply(console, args);
-            // Asynchronously write to database (don't block console output)
-            writeLogToDatabase(level, args).catch((err) => {
-                // Use original console to avoid infinite recursion
-                originalConsole.error('Failed to write log to database:', err);
-            });
+            defaultLogger.writeLog(level, args);
         };
     });
     // Subscribe to dataChanged events to output logs from OTHER process instances
-    try {
-        const consoleLogsTable = await (0, console_logs_table_1.ConsoleLogs)();
-        consoleLogsTable.dataChanged.subscribe((evt) => {
-            const log = evt.dataObject;
-            // Skip if this is our own log
-            if (log.processInstanceId === currentProcessInstanceId) {
-                return;
-            }
-            // Output log from another process with prefix
-            const colorCode = log.process === 'renderer' ? '\x1b[36m' : '\x1b[35m'; // cyan for renderer, magenta for main
-            const resetCode = '\x1b[0m';
-            const prefix = `${colorCode}[${log.process}]${resetCode}`;
-            const logLevel = log.level;
-            const logArgs = [prefix, log.message];
-            if (log.context) {
-                logArgs.push(log.context);
-            }
-            if (originalConsole[logLevel]) {
-                originalConsole[logLevel](...logArgs);
-            }
-            else {
-                originalConsole.log(...logArgs);
-            }
-            // Also output stack trace for errors
-            if (log.stackTrace) {
-                originalConsole.error(log.stackTrace);
-            }
-        });
-    }
-    catch (err) {
-        originalConsole.error('Failed to subscribe to console logs dataChanged:', err);
-    }
-    console.log(`Console proxy initialized for process: ${processName} (instance: ${currentProcessInstanceId})`);
+    (0, console_logs_table_1.ConsoleLogs)().then(async (consoleLogsTable) => {
+        try {
+            consoleLogsProxySubscription = consoleLogsTable.dataChanged.subscribe((evt) => {
+                const log = evt.dataObject;
+                // Skip if this is our own log
+                if (log.processInstanceId === currentProcessInstanceId) {
+                    return;
+                }
+                // Output log from another process with prefix
+                const colorCode = log.process === 'renderer' ? '\x1b[36m' : '\x1b[35m'; // cyan for renderer, magenta for main
+                const resetCode = '\x1b[0m';
+                const prefix = `${colorCode}[${log.process}]${resetCode}`;
+                const logLevel = log.level;
+                const logArgs = [prefix, log.message];
+                if (log.context) {
+                    logArgs.push(log.context);
+                }
+                if (originalConsole[logLevel]) {
+                    originalConsole[logLevel](...logArgs);
+                }
+                else {
+                    originalConsole.log({ logLevel }, ...logArgs);
+                }
+                // Also output stack trace for errors
+                if (log.stackTrace) {
+                    originalConsole.error(log.stackTrace);
+                }
+            });
+        }
+        catch (err) {
+            originalConsole.error('Failed to subscribe to console logs dataChanged:', err);
+        }
+    });
+    originalConsole.log(`Console proxy initialized for process: ${processName} (instance: ${currentProcessInstanceId})`);
 }
 /**
  * Restore original console methods
  */
 function restoreConsole() {
-    if (!isProxySetup) {
+    if (!isConsoleLogsProxySetup) {
         return;
     }
+    consoleLogsProxySubscription?.unsubscribe();
+    consoleLogsProxySubscription = undefined;
     console.debug = originalConsole.debug;
     console.info = originalConsole.info;
     console.log = originalConsole.log;
     console.warn = originalConsole.warn;
     console.error = originalConsole.error;
-    isProxySetup = false;
+    isConsoleLogsProxySetup = false;
     originalConsole.log('Console proxy removed, original console restored');
 }
-/**
- * Write a log entry to the ConsoleLogs table
- */
-async function writeLogToDatabase(level, args) {
-    const timestamp = (0, utils_1.getTimestamp)();
-    if (timestamp < startupDelayForWritingLogsToDB) {
-        await (0, utils_1.sleep)(startupDelayForWritingLogsToDB - timestamp);
-    }
-    // Guard against infinite recursion (same process)
-    if (isWritingLog) {
-        recursionAttempts++;
-        if (recursionAttempts >= MAX_RECURSION_ATTEMPTS) {
-            // Break the loop by using original console
-            originalConsole.error(`[console-logger] Infinite loop detected after ${recursionAttempts} attempts, dropping log write`, { level, args });
-            // Reset counter after a delay to allow recovery
-            setTimeout(() => {
-                recursionAttempts = 0;
-            }, 1000);
-            return;
-        }
-        // Allow a few attempts in case of legitimate nested logging
-        return;
-    }
-    isWritingLog = true;
-    try {
-        // Format message from arguments
-        const message = formatLogMessage(args);
-        // Extract context objects from arguments
-        const context = extractContext(args);
-        // Get stack trace for errors
-        const stackTrace = level === 'error' ? getStackTrace() : undefined;
-        // Extract source from stack trace
-        const source = extractSource(stackTrace);
-        // Guard against cross-process infinite loops
-        // Extract core message to detect loops even when processes add prefixes
-        const coreMessage = extractCoreMessage(message);
-        // Create signature from level + source + core message (not the full message)
-        const signature = `${level}:${source || 'unknown'}:${coreMessage.substring(0, 100)}`;
-        if (!checkLogSignature(signature)) {
-            // Too many identical logs in window, likely an infinite loop
-            originalConsole.warn(`[console-logger] Cross-process infinite loop detected for log: ${signature.substring(0, 80)}...`);
-            return;
-        }
-        const logRecord = {
-            logId: (0, utils_1.newid)(),
-            timestamp,
-            level,
-            process: currentProcessName,
-            processInstanceId: currentProcessInstanceId,
-            source,
-            message,
-            context,
-            stackTrace,
-        };
-        const consoleLogsTable = await (0, console_logs_table_1.ConsoleLogs)();
-        await consoleLogsTable.insert(logRecord);
-    }
-    catch (err) {
-        originalConsole.error(`error while trying to write console log`, err);
-        // Silently fail if table not available (e.g., during initialization)
-        // Don't use console here to avoid infinite recursion
-    }
-    finally {
-        isWritingLog = false;
-        recursionAttempts = 0;
-    }
-}
 /**
  * Extract core message by removing common prefixes that might be added by different processes
  * This helps detect cross-process loops where each process adds its own prefix
@@ -226,42 +154,6 @@ function checkLogSignature(signature) {
     }
     return true;
 }
-/**
- * Format log arguments into a single message string
- */
-function formatLogMessage(args) {
-    return args.map((arg) => {
-        if (typeof arg === 'string') {
-            return arg;
-        }
-        if (arg instanceof Error) {
-            return `${arg.name}: ${arg.message}`;
-        }
-        if (typeof arg === 'object') {
-            try {
-                return JSON.stringify(arg);
-            }
-            catch {
-                return String(arg);
-            }
-        }
-        return String(arg);
-    }).join(' ');
-}
-/**
- * Extract structured context objects from log arguments
- */
-function extractContext(args) {
-    const objects = args.filter((arg) => arg && typeof arg === 'object' && !(arg instanceof Error) && !(arg instanceof Date));
-    if (objects.length === 0) {
-        return undefined;
-    }
-    if (objects.length === 1) {
-        return objects[0];
-    }
-    // Merge multiple objects
-    return Object.assign({}, ...objects);
-}
 /**
  * Get current stack trace
  */
@@ -306,71 +198,37 @@ function extractSource(stackTrace) {
     }
     return undefined;
 }
-/**
- * Mark the logging system as initialized and flush any pending logs
- */
-function markLoggingInitialized() {
-    isInitialized = true;
-    // Flush pending logs sequentially with small delays to avoid recursion guard
-    if (pendingLogs.length > 0) {
-        originalConsole.log(`[console-logger] Flushing ${pendingLogs.length} pending logs...`);
-        const logsToFlush = [...pendingLogs]; // Copy array
-        pendingLogs.length = 0; // Clear the original array
-        // Flush logs with small delays between them
-        let delay = 0;
-        for (const { level, source, args } of logsToFlush) {
-            setTimeout(() => {
-                writeLogToDatabaseWithSource(level, source, args).catch((err) => {
-                    originalConsole.error('[console-logger] Failed to flush pending log:', err);
-                });
-            }, delay);
-            delay += 10; // 10ms between each log
-        }
-    }
-}
-/**
- * Reset logging initialization state (primarily for testing)
- * @internal
- */
-function resetLoggingState() {
-    isInitialized = false;
-    pendingLogs.length = 0;
-}
 /**
  * Write a log entry to the ConsoleLogs table with a specific source
  */
 async function writeLogToDatabaseWithSource(level, source, args) {
-    const timestamp = (0, utils_1.getTimestamp)();
-    if (timestamp < startupDelayForWritingLogsToDB) {
-        await (0, utils_1.sleep)(startupDelayForWritingLogsToDB - timestamp);
-    }
-    // Guard against infinite recursion (same process)
-    if (isWritingLog) {
-        recursionAttempts++;
-        if (recursionAttempts >= MAX_RECURSION_ATTEMPTS) {
-            originalConsole.error(`[console-logger] Infinite loop detected after ${recursionAttempts} attempts, dropping log write`, { level, source, args });
-            setTimeout(() => {
-                recursionAttempts = 0;
-            }, 1000);
-            return;
-        }
-        return;
-    }
-    isWritingLog = true;
     try {
+        const timestamp = (0, utils_1.getTimestamp)();
         // Format message from arguments
-        const message = formatLogMessage(args);
-        // Extract context objects from arguments
-        const context = extractContext(args);
-        // Get stack trace for errors
-        const stackTrace = level === 'error' ? getStackTrace() : undefined;
-        // Guard against cross-process infinite loops
+        let message = typeof args[0] === 'string' ?
+            args.shift() :
+            (0, serial_json_1.toJSONString)(args[0]);
+        // Check for infinite loop before writing
+        // Extract core message to detect cross-process loops where prefixes are added
         const coreMessage = extractCoreMessage(message);
-        const signature = `${level}:${source}:${coreMessage.substring(0, 100)}`;
+        const signature = `${level}:${coreMessage}:${source}`;
         if (!checkLogSignature(signature)) {
-            originalConsole.warn(`[console-logger] Cross-process infinite loop detected for log: ${signature.substring(0, 80)}...`);
+            // This log is suspected to be part of an infinite loop, drop it
             return;
         }
+        // Extract context objects from arguments
+        for (const a of [...args]) {
+            if (typeof a === 'object' && !((0, lodash_1.isDate)(a) || a === null)) {
+                break;
+            }
+            message += ' ' + args.shift();
+        }
+        let context = args.length === 0 ?
+            undefined : args.length === 1 ?
+            args[0] :
+            args;
+        // Get stack trace for errors
+        const stackTrace = level === 'error' ? getStackTrace() : undefined;
         const logRecord = {
             logId: (0, utils_1.newid)(),
             timestamp,
@@ -386,11 +244,7 @@ async function writeLogToDatabaseWithSource(level, source, args) {
         await consoleLogsTable.insert(logRecord);
     }
     catch (err) {
-        // Silently fail if table not available
-    }
-    finally {
-        isWritingLog = false;
-        recursionAttempts = 0;
+        originalConsole.error('[console-logger] Failed to write log to database:', err);
     }
 }
 /**
@@ -405,6 +259,8 @@ async function writeLogToDatabaseWithSource(level, source, args) {
  */
 class Logger {
     source;
+    pendingLogs = [];
+    waitingForConsoleLogsTable = true;
     constructor(source) {
         // If no source provided, try to extract from caller's location
         if (!source) {
@@ -412,9 +268,10 @@ class Logger {
             source = extractSource(stack) || 'unknown';
         }
         this.source = source;
-        // ConsoleLogs().then(() => {
-        //   markLoggingInitialized();
-        // })
+        (0, console_logs_table_1.ConsoleLogs)().then(() => {
+            this.waitingForConsoleLogsTable = false;
+            this.flushPendingLogs();
+        });
     }
     /**
      * Log a debug message
@@ -455,14 +312,14 @@ class Logger {
      * Internal method to write log to database
      */
     writeLog(level, args) {
-        if (!isInitialized) {
+        if (this.waitingForConsoleLogsTable) {
             // Queue the log until system is initialized
-            if (pendingLogs.length < MAX_PENDING_LOGS) {
-                pendingLogs.push({ level, source: this.source, args });
+            if (this.pendingLogs.length < MAX_PENDING_LOGS) {
+                this.pendingLogs.push({ level, args });
             }
             else {
                 // Drop logs if queue is full to prevent memory issues
-                if (pendingLogs.length === MAX_PENDING_LOGS) {
+                if (this.pendingLogs.length === MAX_PENDING_LOGS) {
                     originalConsole.warn('[console-logger] Pending log queue is full, dropping new logs until initialization');
                 }
             }
@@ -473,5 +330,15 @@ class Logger {
             originalConsole.error('[console-logger] Failed to write log:', err);
         });
     }
+    async flushPendingLogs() {
+        const _pendingLogs = [...this.pendingLogs];
+        this.pendingLogs.length = 0;
+        for (const { level, args } of _pendingLogs) {
+            await (0, utils_1.sleep)(10); // small delay to avoid stampede
+            await writeLogToDatabaseWithSource(level, this.source, args).catch((err) => {
+                originalConsole.error('[console-logger] Failed to flush pending log:', err);
+            });
+        }
+    }
 }
 exports.Logger = Logger;

package/dist/logging/console-logger.test.js

@@ -11,12 +11,16 @@ jest.mock('./console-logs.table', () => {
     };
     return {
         ConsoleLogs: jest.fn().mockResolvedValue(mockTable),
+        __mockTable: mockTable, // Export for test access
     };
 });
+// Get reference to mock table
+const { __mockTable: mockTable } = require('./console-logs.table');
 // Mock utils
 jest.mock('../utils', () => ({
     newid: () => 'test-id-123',
     getTimestamp: () => '2024-01-01T00:00:00.000Z',
+    sleep: jest.fn().mockResolvedValue(undefined),
 }));
 describe('console-logger', () => {
     let originalConsole;
@@ -62,6 +66,8 @@ describe('console-logger', () => {
         jest.clearAllMocks();
         // Restore console before each test
         (0, console_logger_1.restoreConsole)();
+        // Reset mock table
+        mockTable.insert.mockClear();
     });
     afterAll(() => {
         // Restore original console methods
@@ -73,8 +79,6 @@ describe('console-logger', () => {
     });
     describe('Single-process infinite loop detection', () => {
         it('should detect infinite loop when logging from within log handler', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
             // Setup mock to throw error that triggers another log
             let callCount = 0;
             mockTable.insert.mockImplementation(() => {
@@ -85,23 +89,25 @@ describe('console-logger', () => {
                 }
                 return Promise.resolve();
             });
-            await (0, console_logger_1.setupConsoleProxy)('test-process');
+            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            // Wait for setup to complete
+            await new Promise(resolve => setTimeout(resolve, 100));
             // This should trigger the loop
             console.error('Initial error');
             // Wait for async operations
             await new Promise(resolve => setTimeout(resolve, 100));
             // Should have called insert but stopped early due to recursion guard
             expect(mockTable.insert).toHaveBeenCalled();
-            // The recursion guard should stop it after just 1 attempt
-            // (because isWritingLog prevents re-entry)
-            expect(callCount).toBeLessThanOrEqual(2); // Setup log + 1 error attempt
+            // The calls should be limited
+            expect(callCount).toBeLessThanOrEqual(5);
         });
     });
     describe('Cross-process infinite loop detection', () => {
         it('should detect when same log is written too many times in window', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            await (0, console_logger_1.setupConsoleProxy)('test-process');
+            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            // Wait for setup
+            await new Promise(resolve => setTimeout(resolve, 100));
+            mockTable.insert.mockClear();
             // Log the same message many times quickly (simulating cross-process loop)
             for (let i = 0; i < 15; i++) {
                 console.error('Same error message');
@@ -111,14 +117,13 @@ describe('console-logger', () => {
             // Wait for async operations
             await new Promise(resolve => setTimeout(resolve, 100));
             // Should have stopped writing after threshold (10)
-            // Plus 1 for the setup log
             expect(mockTable.insert.mock.calls.length).toBeLessThan(15);
             expect(mockTable.insert.mock.calls.length).toBeGreaterThan(0);
         });
         it('should NOT detect loop for different messages', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            await (0, console_logger_1.setupConsoleProxy)('test-process');
+            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            // Wait for setup
+            await new Promise(resolve => setTimeout(resolve, 100));
             // Clear setup log
             mockTable.insert.mockClear();
             // Log different messages
@@ -133,9 +138,10 @@ describe('console-logger', () => {
             expect(mockTable.insert.mock.calls.length).toBeLessThanOrEqual(15);
         });
         it('should detect loop even with modified messages (prefix added)', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            await (0, console_logger_1.setupConsoleProxy)('test-process');
+            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            // Wait for setup
+            await new Promise(resolve => setTimeout(resolve, 100));
+            mockTable.insert.mockClear();
             // Simulate cross-process loop where each process adds a prefix
             // This represents Process A logging "Error X"
             // Process B seeing it and logging "[main] Error X"
@@ -170,9 +176,10 @@ describe('console-logger', () => {
     });
     describe('Loop detection recovery', () => {
         it('should allow logging again after window expires', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            await (0, console_logger_1.setupConsoleProxy)('test-process');
+            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            // Wait for setup
+            await new Promise(resolve => setTimeout(resolve, 100));
+            mockTable.insert.mockClear();
             // Trigger loop detection
             for (let i = 0; i < 12; i++) {
                 console.error('Same error');
@@ -190,10 +197,9 @@ describe('console-logger', () => {
     });
     describe('Normal logging behavior', () => {
         it('should write logs to database for normal usage', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            await (0, console_logger_1.setupConsoleProxy)('test-process');
-            // Get fresh mock reference after setup
-            const mockTable = await ConsoleLogs();
+            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            // Wait for setup to complete
+            await new Promise(resolve => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
             console.log('Test message');
             await new Promise(resolve => setTimeout(resolve, 50));
@@ -208,15 +214,10 @@ describe('console-logger', () => {
         });
     });
     describe('Logger class', () => {
-        beforeEach(() => {
-            // Reset state before each Logger test
-            (0, console_logger_1.resetLoggingState)();
-        });
         it('should create logger with specified source', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            (0, console_logger_1.markLoggingInitialized)();
             const logger = new console_logger_1.Logger('MyModule');
+            // Wait for Logger to initialize
+            await new Promise(resolve => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
             logger.log('Test message');
             await new Promise(resolve => setTimeout(resolve, 100));
@@ -226,10 +227,9 @@ describe('console-logger', () => {
             expect(call[0].message).toBe('Test message');
         });
         it('should support all log levels', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            (0, console_logger_1.markLoggingInitialized)();
             const logger = new console_logger_1.Logger('TestModule');
+            // Wait for Logger to initialize
+            await new Promise(resolve => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
             logger.debug('Debug message');
             await new Promise(resolve => setTimeout(resolve, 20));
@@ -248,11 +248,14 @@ describe('console-logger', () => {
             const uniqueLevels = new Set(levels);
             expect(uniqueLevels.size).toBeGreaterThanOrEqual(4);
         });
-        it('should queue logs before initialization', async () => {
+        it('should queue logs before initialization and flush after', async () => {
+            // Create a delayed promise for ConsoleLogs
+            let resolveConsoleLogs;
+            const delayedPromise = new Promise((resolve) => {
+                resolveConsoleLogs = resolve;
+            });
             const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            // Ensure we're not initialized
-            // (resetLoggingState was called in beforeEach)
+            ConsoleLogs.mockReturnValueOnce(delayedPromise);
             const logger = new console_logger_1.Logger('EarlyModule');
             // Log before initialization
             logger.log('Early message 1');
@@ -260,21 +263,19 @@ describe('console-logger', () => {
             logger.error('Early message 3');
             // Small delay to ensure logs are queued
             await new Promise(resolve => setTimeout(resolve, 50));
-            mockTable.insert.mockClear();
             // Should not have written yet
             expect(mockTable.insert).not.toHaveBeenCalled();
-            // Now initialize
-            (0, console_logger_1.markLoggingInitialized)();
+            // Now resolve the ConsoleLogs promise
+            resolveConsoleLogs(mockTable);
             // Wait for flush
             await new Promise(resolve => setTimeout(resolve, 300));
             // Should have flushed pending logs
             expect(mockTable.insert.mock.calls.length).toBeGreaterThanOrEqual(2);
         });
         it('should write logs directly after initialization', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            (0, console_logger_1.markLoggingInitialized)();
             const logger = new console_logger_1.Logger('LateModule');
+            // Wait for initialization
+            await new Promise(resolve => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
             logger.log('Direct message');
             await new Promise(resolve => setTimeout(resolve, 100));
@@ -282,11 +283,10 @@ describe('console-logger', () => {
             expect(mockTable.insert.mock.calls[0][0].message).toBe('Direct message');
         });
         it('should use reliable source from constructor', async () => {
-            const { ConsoleLogs } = require('./console-logs.table');
-            const mockTable = await ConsoleLogs();
-            (0, console_logger_1.markLoggingInitialized)();
             const logger1 = new console_logger_1.Logger('SourceA');
             const logger2 = new console_logger_1.Logger('SourceB');
+            // Wait for initialization
+            await new Promise(resolve => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
             logger1.log('From A');
             await new Promise(resolve => setTimeout(resolve, 50));

package/dist/logging/console-logs.table.d.ts

@@ -9,7 +9,7 @@ export declare const consoleLogSchema: z.ZodObject<{
     processInstanceId: z.ZodString;
     source: z.ZodOptional<z.ZodString>;
     message: z.ZodString;
-    context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+    context: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>, z.ZodArray<z.ZodAny, "many">]>>;
     stackTrace: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     message: string;
@@ -19,7 +19,7 @@ export declare const consoleLogSchema: z.ZodObject<{
     process: string;
     processInstanceId: string;
     source?: string | undefined;
-    context?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    context?: any[] | z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
     stackTrace?: string | undefined;
 }, {
     message: string;
@@ -29,7 +29,7 @@ export declare const consoleLogSchema: z.ZodObject<{
     processInstanceId: string;
     source?: string | undefined;
     timestamp?: number | undefined;
-    context?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    context?: any[] | z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
     stackTrace?: string | undefined;
 }>;
 export type IConsoleLog = z.infer<typeof consoleLogSchema>;

package/dist/logging/console-logs.table.js

@@ -51,7 +51,7 @@ exports.consoleLogSchema = zod_1.z.object({
     processInstanceId: zod_1.z.string().describe('Unique ID for this process instance to filter own logs'),
     source: zod_1.z.string().optional().describe('The source file or module that generated the log'),
     message: zod_1.z.string().describe('The log message'),
-    context: zod_types_1.zodAnyObject.optional().describe('Additional structured context data'),
+    context: zod_types_1.zodAnyObjectOrArray.optional().describe('Additional structured context data'),
     stackTrace: zod_1.z.string().optional().describe('Stack trace for errors'),
 });
 const metaData = {

package/dist/rpc-types.js

@@ -28,7 +28,8 @@ exports.rpcServerCalls = {
 };
 exports.rpcClientCalls = {
     ping: async (msg) => `pong: ${msg}`,
-    emitEvent: rpcStub('emitEvent'),
+    // emitEvent: rpcStub('emitEvent') as ((event: IEventData) => Promise<boolean>),
+    emitEvent: ((...args) => Promise.resolve(false)),
     setClientPath: rpcStub('setClientPath'),
     openThread: rpcStub('openThread'),
 };

package/dist/utils.js

@@ -235,6 +235,10 @@ async function retryOnErrorOrTimeout({ fn, connection, opts = {}, }) {
         throw finalError;
     }
     else {
+        const weightedTimeout = timeoutCount * 0.1;
+        const weightedInverse = 1 - weightedTimeout;
+        connection.errorRate = (connection.errorRate * weightedInverse) + weightedTimeout;
+        connection.latencyMs = (weightedTimeout * timeout) + (connection.latencyMs * weightedInverse);
         throw new Error(`Timeout after ${timeoutCount} retries waiting for ${timeout}ms`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.7.21",
+  "version": "0.7.23",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"

package/dist/logging/logger-example.d.ts

@@ -1,41 +0,0 @@
-/**
- * Example usage of the Logger class
- *
- * This file demonstrates how to use the Logger class for reliable, source-specific logging
- */
-/**
- * Example function that uses the logger
- */
-export declare function processData(data: any): void;
-/**
- * Example initialization flow
- */
-export declare function initializeApp(): Promise<void>;
-/**
- * Benefits of using Logger class:
- *
- * 1. **Reliable Source Tracking**: Source is set once at construction time,
- *    not extracted from stack traces which can be unreliable
- *
- * 2. **Initialization Safety**: Logs before system is ready are queued and
- *    flushed once markLoggingInitialized() is called
- *
- * 3. **Infinite Loop Protection**: Inherits all the cross-process and
- *    single-process infinite loop detection
- *
- * 4. **Type Safety**: Full TypeScript support with proper typing
- *
- * 5. **Console Passthrough**: All logs still appear in the console immediately,
- *    database writes happen asynchronously
- *
- * Usage pattern:
- * ```typescript
- * // At the top of each file:
- * const logger = new Logger('FeatureName');
- *
- * // Throughout your code:
- * logger.log('Something happened');
- * logger.error('Something went wrong', error);
- * logger.debug('Detailed debugging info', { context });
- * ```
- */

package/dist/logging/logger-example.js

@@ -1,74 +0,0 @@
-"use strict";
-/**
- * Example usage of the Logger class
- *
- * This file demonstrates how to use the Logger class for reliable, source-specific logging
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processData = processData;
-exports.initializeApp = initializeApp;
-const console_logger_1 = require("./console-logger");
-// Create a logger at the top of your file with a descriptive source name
-const logger = new console_logger_1.Logger('MyModule');
-// You can also let it auto-detect the source from the filename
-// const logger = new Logger();
-/**
- * Example function that uses the logger
- */
-function processData(data) {
-    logger.log('Processing data', { dataSize: data.length });
-    try {
-        // Do some work
-        if (!data) {
-            logger.warn('No data provided');
-            return;
-        }
-        // More processing...
-        logger.debug('Data processing in progress', { step: 'validation' });
-        // Success
-        logger.info('Data processed successfully');
-    }
-    catch (error) {
-        logger.error('Failed to process data', error);
-        throw error;
-    }
-}
-/**
- * Example initialization flow
- */
-async function initializeApp() {
-    // Early logging (before system is ready) - these get queued
-    logger.log('Application starting...');
-    // ... Initialize databases, connections, etc ...
-    // Mark logging as initialized - this flushes all queued logs
-    (0, console_logger_1.markLoggingInitialized)();
-    logger.log('Application fully initialized');
-}
-/**
- * Benefits of using Logger class:
- *
- * 1. **Reliable Source Tracking**: Source is set once at construction time,
- *    not extracted from stack traces which can be unreliable
- *
- * 2. **Initialization Safety**: Logs before system is ready are queued and
- *    flushed once markLoggingInitialized() is called
- *
- * 3. **Infinite Loop Protection**: Inherits all the cross-process and
- *    single-process infinite loop detection
- *
- * 4. **Type Safety**: Full TypeScript support with proper typing
- *
- * 5. **Console Passthrough**: All logs still appear in the console immediately,
- *    database writes happen asynchronously
- *
- * Usage pattern:
- * ```typescript
- * // At the top of each file:
- * const logger = new Logger('FeatureName');
- *
- * // Throughout your code:
- * logger.log('Something happened');
- * logger.error('Something went wrong', error);
- * logger.debug('Detailed debugging info', { context });
- * ```
- */