@optimizely/ocp-local-env 1.0.0-beta.6 → 1.0.0-beta.8

package/dist/src/logging/LogManager.d.ts

@@ -2,15 +2,164 @@
  * Centralized logging system for the OCP Local Environment
  * Captures logs from builds, function executions, lifecycle hooks, and general operations
  */
-export interface LogEntry {
+/**
+ * Log source types - reduced to 2 sources
+ */
+export declare enum LogSource {
+    App = "app",
+    System = "system"
+}
+/**
+ * Log category types - specific categories for different log types
+ */
+export declare enum LogCategory {
+    Build = "build",
+    Function = "function",
+    Lifecycle = "lifecycle",
+    Destination = "destination",
+    Source = "source",
+    Jobs = "jobs",
+    Notifications = "notifications",
+    KVStore = "kvstore",
+    Settings = "settings",
+    Secrets = "secrets",
+    Config = "config",
+    AppRunner = "app-runner"
+}
+/**
+ * Log levels
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Base context interface - common fields for all log contexts
+ */
+export interface BaseLogContext {
+    id: string;
+    error?: any;
+    errorMessage?: string;
+    stack?: string;
+    [key: string]: any;
+}
+/**
+ * Empty context for categories that don't need specific context
+ */
+export interface EmptyLogContext extends BaseLogContext {
+}
+/**
+ * Function execution context
+ * id = function identifier (e.g., 'my-function')
+ */
+export interface FunctionLogContext extends BaseLogContext {
+    method?: string;
+    path?: string;
+    executionTime?: number;
+    status?: number;
+}
+/**
+ * Lifecycle execution context
+ * id = hook name (e.g., 'onInstall')
+ */
+export interface LifecycleLogContext extends BaseLogContext {
+    executionTime?: number;
+    status?: number;
+}
+/**
+ * Destination execution context
+ * id = destination identifier (e.g., 'analytics-destination')
+ */
+export interface DestinationLogContext extends BaseLogContext {
+    operation?: 'ready' | 'deliver' | 'schema';
+    batchSize?: number;
+    ready?: boolean;
+    retryable?: boolean;
+    failureReason?: string;
+}
+/**
+ * Source execution context
+ * id = source identifier (e.g., 'my-source')
+ */
+export interface SourceLogContext extends BaseLogContext {
+    operation?: string;
+    error?: any;
+}
+/**
+ * Job operation context
+ * id = job identifier or 'unknown'
+ */
+export interface JobLogContext extends BaseLogContext {
+    operation?: 'schedule' | 'execute' | 'cancel' | 'list';
+    status?: string;
+}
+/**
+ * Notification operation context
+ * id = notification identifier or 'unknown'
+ */
+export interface NotificationLogContext extends BaseLogContext {
+    operation?: 'send' | 'list' | 'clear';
+    recipient?: string;
+}
+/**
+ * Storage operation context (kvstore, settings, secrets, config)
+ * id = key identifier (e.g., 'user:123') or 'unknown'
+ */
+export interface StorageLogContext extends BaseLogContext {
+    store: string;
+    operation: 'get' | 'set' | 'delete' | 'exists' | 'list' | 'clear';
+    key?: string;
+    value?: any;
+    ttl?: number;
+}
+/**
+ * IPC communication context
+ * id = request identifier or 'unknown'
+ */
+export interface IPCLogContext extends BaseLogContext {
+    messageType?: string;
+    connectionId?: string;
+    timeout?: number;
+}
+/**
+ * Process management context
+ * id = process identifier or 'unknown'
+ */
+export interface ProcessLogContext extends BaseLogContext {
+    connectionId?: string;
+    operation?: string;
+    exitCode?: number;
+    signal?: string;
+    processId?: string;
+    appId?: string;
+    port?: number;
+}
+/**
+ * Map each category to its context type
+ */
+export type CategoryContextMap = {
+    [LogCategory.Build]: EmptyLogContext;
+    [LogCategory.Function]: FunctionLogContext;
+    [LogCategory.Lifecycle]: LifecycleLogContext;
+    [LogCategory.Destination]: DestinationLogContext;
+    [LogCategory.Source]: SourceLogContext;
+    [LogCategory.Jobs]: JobLogContext;
+    [LogCategory.Notifications]: NotificationLogContext;
+    [LogCategory.KVStore]: StorageLogContext;
+    [LogCategory.Settings]: StorageLogContext;
+    [LogCategory.Secrets]: StorageLogContext;
+    [LogCategory.Config]: StorageLogContext;
+    [LogCategory.AppRunner]: ProcessLogContext | IPCLogContext;
+};
+/**
+ * Type-safe log entry
+ */
+export type LogEntry<C extends LogCategory = LogCategory> = {
     id: string;
     timestamp: string;
-    source: 'build' | 'function' | 'lifecycle' | 'system' | 'error';
-    level: 'debug' | 'info' | 'warn' | 'error';
-    category?: string;
+    source: LogSource;
+    category: C;
+    level: LogLevel;
     message: string;
-    details?: any;
-}
+    context?: CategoryContextMap[C];
+};
 export declare class LogManager {
     private static instance;
     private logs;
@@ -22,60 +171,68 @@ export declare class LogManager {
      */
     static getInstance(): LogManager;
     /**
-     * Add a new log entry
+     * Core log method - accepts type-safe log entries
      */
-    log(entry: Omit<LogEntry, 'id' | 'timestamp'>): void;
+    log<C extends LogCategory>(entry: Omit<LogEntry<C>, 'id' | 'timestamp'>): void;
     /**
-     * Convenience methods for different log levels
+     * Convenience methods with type-safe contexts
      */
-    debug(source: LogEntry['source'], message: string, category?: string, details?: any): void;
-    info(source: LogEntry['source'], message: string, category?: string, details?: any): void;
-    warn(source: LogEntry['source'], message: string, category?: string, details?: any): void;
-    error(source: LogEntry['source'], message: string, category?: string, details?: any): void;
+    debug<C extends LogCategory>(source: LogSource, category: C, message: string, context?: CategoryContextMap[C]): void;
+    info<C extends LogCategory>(source: LogSource, category: C, message: string, context?: CategoryContextMap[C]): void;
+    warn<C extends LogCategory>(source: LogSource, category: C, message: string, context?: CategoryContextMap[C]): void;
+    error<C extends LogCategory>(source: LogSource, category: C, message: string, context?: CategoryContextMap[C]): void;
     /**
-     * Get logs with optional filtering
+     * Specialized convenience method for function execution
      */
-    getLogs(options?: {
-        limit?: number;
-        source?: LogEntry['source'];
-        level?: LogEntry['level'];
-        since?: string;
-        category?: string;
-    }): LogEntry[];
+    logFunctionExecution(functionId: string, status: 'started' | 'success' | 'error', details?: Partial<FunctionLogContext>): void;
     /**
-     * Clear all logs
+     * Specialized convenience method for lifecycle execution
      */
-    clearLogs(): void;
+    logLifecycleExecution(hookName: string, status: 'started' | 'success' | 'error', details?: Partial<LifecycleLogContext>): void;
     /**
-     * Add a listener for new log entries
+     * Specialized convenience method for destination execution
      */
-    addListener(listener: (log: LogEntry) => void): () => void;
+    logDestinationExecution(destinationId: string, operation: 'ready' | 'deliver' | 'schema', status: 'started' | 'success' | 'error', details?: Partial<DestinationLogContext>): void;
     /**
-     * Log function execution
+     * Specialized convenience method for build events
      */
-    logFunctionExecution(functionId: string, status: 'started' | 'success' | 'error', details?: any): void;
+    logBuildEvent(status: 'started' | 'success' | 'error', details?: any): void;
     /**
      * Log function output/console logs
      */
     logFunctionOutput(functionId: string, output: string, isError?: boolean): void;
     /**
-     * Log lifecycle execution
+     * Log build output
      */
-    logLifecycleExecution(hookName: string, status: 'started' | 'success' | 'error', details?: any): void;
+    logBuildOutput(output: string, isError?: boolean): void;
     /**
-     * Log build events
+     * Log source execution events
      */
-    logBuildEvent(status: 'started' | 'success' | 'error', details?: any): void;
+    logSourceExecution(sourceId: string, operation: string, status: 'started' | 'success' | 'error', additionalContext?: any): void;
     /**
-     * Log build output
+     * Get logs with optional filtering
      */
-    logBuildOutput(output: string, isError?: boolean): void;
+    getLogs(options?: {
+        limit?: number;
+        source?: LogSource;
+        level?: LogLevel;
+        since?: string;
+        category?: LogCategory;
+    }): LogEntry[];
+    /**
+     * Clear all logs
+     */
+    clearLogs(): void;
+    /**
+     * Add a listener for new log entries
+     */
+    addListener(listener: (log: LogEntry) => void): () => void;
     /**
      * Generate a unique ID for log entries
      */
     private generateId;
     /**
-     * Log to console with appropriate styling
+     * Log to console with new format
      */
     private logToConsole;
     /**

package/dist/src/logging/LogManager.js

@@ -4,7 +4,37 @@
  * Captures logs from builds, function executions, lifecycle hooks, and general operations
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogManager = void 0;
+exports.LogManager = exports.LogCategory = exports.LogSource = void 0;
+// ===== TYPE DEFINITIONS =====
+/**
+ * Log source types - reduced to 2 sources
+ */
+var LogSource;
+(function (LogSource) {
+    LogSource["App"] = "app";
+    LogSource["System"] = "system";
+})(LogSource || (exports.LogSource = LogSource = {}));
+/**
+ * Log category types - specific categories for different log types
+ */
+var LogCategory;
+(function (LogCategory) {
+    // Core application
+    LogCategory["Build"] = "build";
+    LogCategory["Function"] = "function";
+    LogCategory["Lifecycle"] = "lifecycle";
+    LogCategory["Destination"] = "destination";
+    LogCategory["Source"] = "source";
+    LogCategory["Jobs"] = "jobs";
+    LogCategory["Notifications"] = "notifications";
+    // System infrastructure
+    LogCategory["KVStore"] = "kvstore";
+    LogCategory["Settings"] = "settings";
+    LogCategory["Secrets"] = "secrets";
+    LogCategory["Config"] = "config";
+    LogCategory["AppRunner"] = "app-runner";
+})(LogCategory || (exports.LogCategory = LogCategory = {}));
+// ===== LOG MANAGER =====
 class LogManager {
     constructor() {
         this.logs = [];
@@ -22,7 +52,7 @@ class LogManager {
         return this.instance;
     }
     /**
-     * Add a new log entry
+     * Core log method - accepts type-safe log entries
      */
     log(entry) {
         const logEntry = {
@@ -31,11 +61,9 @@ class LogManager {
             timestamp: new Date().toISOString()
         };
         this.logs.push(logEntry);
-        // Keep only the most recent logs
         if (this.logs.length > this.maxLogs) {
             this.logs = this.logs.slice(-this.maxLogs);
         }
-        // Notify listeners
         this.logListeners.forEach(listener => {
             try {
                 listener(logEntry);
@@ -44,150 +72,208 @@ class LogManager {
                 console.error('Error notifying log listener:', error);
             }
         });
-        // Also log to console for debugging
         this.logToConsole(logEntry);
     }
     /**
-     * Convenience methods for different log levels
+     * Convenience methods with type-safe contexts
      */
-    debug(source, message, category, details) {
-        this.log({ source, level: 'debug', message, category, details });
+    debug(source, category, message, context) {
+        this.log({ source, category, level: 'debug', message, context });
     }
-    info(source, message, category, details) {
-        this.log({ source, level: 'info', message, category, details });
+    info(source, category, message, context) {
+        this.log({ source, category, level: 'info', message, context });
     }
-    warn(source, message, category, details) {
-        this.log({ source, level: 'warn', message, category, details });
+    warn(source, category, message, context) {
+        this.log({ source, category, level: 'warn', message, context });
     }
-    error(source, message, category, details) {
-        this.log({ source, level: 'error', message, category, details });
+    error(source, category, message, context) {
+        this.log({ source, category, level: 'error', message, context });
     }
     /**
-     * Get logs with optional filtering
+     * Specialized convenience method for function execution
      */
-    getLogs(options) {
-        let filteredLogs = this.logs;
-        // Apply filters
-        if (options?.source) {
-            filteredLogs = filteredLogs.filter(log => log.source === options.source);
-        }
-        if (options?.level) {
-            const levels = ['debug', 'info', 'warn', 'error'];
-            const minLevelIndex = levels.indexOf(options.level);
-            filteredLogs = filteredLogs.filter(log => levels.indexOf(log.level) >= minLevelIndex);
-        }
-        if (options?.since) {
-            const sinceTime = new Date(options.since).getTime();
-            filteredLogs = filteredLogs.filter(log => new Date(log.timestamp).getTime() >= sinceTime);
-        }
-        if (options?.category) {
-            filteredLogs = filteredLogs.filter(log => log.category === options.category);
-        }
-        // Apply limit
-        const limit = options?.limit || 100;
-        return filteredLogs.slice(-limit);
+    logFunctionExecution(functionId, status, details) {
+        const messages = {
+            started: 'Function execution started',
+            success: 'Function execution completed successfully',
+            error: 'Function execution failed'
+        };
+        this.log({
+            source: LogSource.App,
+            category: LogCategory.Function,
+            level: status === 'error' ? 'error' : 'info',
+            message: messages[status],
+            context: {
+                id: functionId,
+                ...details
+            }
+        });
     }
     /**
-     * Clear all logs
+     * Specialized convenience method for lifecycle execution
      */
-    clearLogs() {
-        this.logs = [];
-        this.info('system', 'Logs cleared');
+    logLifecycleExecution(hookName, status, details) {
+        const messages = {
+            started: 'Lifecycle hook execution started',
+            success: 'Lifecycle hook execution completed successfully',
+            error: 'Lifecycle hook execution failed'
+        };
+        this.log({
+            source: LogSource.App,
+            category: LogCategory.Lifecycle,
+            level: status === 'error' ? 'error' : 'info',
+            message: messages[status],
+            context: {
+                id: hookName,
+                ...details
+            }
+        });
     }
     /**
-     * Add a listener for new log entries
+     * Specialized convenience method for destination execution
      */
-    addListener(listener) {
-        this.logListeners.push(listener);
-        // Return unsubscribe function
-        return () => {
-            const index = this.logListeners.indexOf(listener);
-            if (index > -1) {
-                this.logListeners.splice(index, 1);
+    logDestinationExecution(destinationId, operation, status, details) {
+        const messages = {
+            started: {
+                ready: 'Executing ready() for destination',
+                deliver: 'Delivering batch to destination',
+                schema: 'Loading schema for destination'
+            },
+            success: {
+                ready: 'Destination ready() completed successfully',
+                deliver: 'Batch delivered successfully',
+                schema: 'Schema loaded successfully'
+            },
+            error: {
+                ready: 'Destination ready() failed',
+                deliver: 'Batch delivery failed',
+                schema: 'Schema loading failed'
             }
         };
+        this.log({
+            source: LogSource.System,
+            category: LogCategory.AppRunner,
+            level: status === 'error' ? 'error' : 'info',
+            message: messages[status][operation],
+            context: {
+                id: destinationId,
+                operation,
+                ...details
+            }
+        });
     }
     /**
-     * Log function execution
+     * Specialized convenience method for build events
      */
-    logFunctionExecution(functionId, status, details) {
+    logBuildEvent(status, details) {
         const messages = {
-            started: `Function execution started`,
-            success: `Function execution completed successfully`,
-            error: `Function execution failed`
+            started: 'Build started',
+            success: 'Build completed successfully',
+            error: 'Build failed'
         };
-        const level = status === 'error' ? 'error' : 'info';
         this.log({
-            source: 'function',
-            level,
+            source: LogSource.System,
+            category: LogCategory.Build,
+            level: status === 'error' ? 'error' : 'info',
             message: messages[status],
-            category: functionId,
-            details
+            context: {
+                id: 'build',
+                ...details
+            }
         });
     }
     /**
      * Log function output/console logs
      */
     logFunctionOutput(functionId, output, isError = false) {
-        // Split output into lines and log each line
         const lines = output.split('\n').filter(line => line.trim());
         lines.forEach(line => {
             this.log({
-                source: 'function',
+                source: LogSource.App,
+                category: LogCategory.Function,
                 level: isError ? 'error' : 'info',
                 message: line.trim(),
-                category: functionId
+                context: { id: functionId }
             });
         });
     }
     /**
-     * Log lifecycle execution
+     * Log build output
      */
-    logLifecycleExecution(hookName, status, details) {
-        const messages = {
-            started: `Lifecycle hook execution started`,
-            success: `Lifecycle hook execution completed successfully`,
-            error: `Lifecycle hook execution failed`
-        };
-        const level = status === 'error' ? 'error' : 'info';
-        this.log({
-            source: 'lifecycle',
-            level,
-            message: messages[status],
-            category: hookName,
-            details
+    logBuildOutput(output, isError = false) {
+        const lines = output.split('\n').filter(line => line.trim());
+        lines.forEach(line => {
+            this.log({
+                source: LogSource.System,
+                category: LogCategory.Build,
+                level: isError ? 'error' : 'info',
+                message: line.trim(),
+                context: { id: 'build' }
+            });
         });
     }
     /**
-     * Log build events
+     * Log source execution events
      */
-    logBuildEvent(status, details) {
-        const messages = {
-            started: `Build started`,
-            success: `Build completed successfully`,
-            error: `Build failed`
-        };
+    logSourceExecution(sourceId, operation, status, additionalContext) {
         const level = status === 'error' ? 'error' : 'info';
+        const message = `Source ${operation} ${status}`;
         this.log({
-            source: 'build',
+            source: LogSource.System,
+            category: LogCategory.Source,
             level,
-            message: messages[status],
-            details
+            message,
+            context: {
+                id: sourceId,
+                operation,
+                ...additionalContext
+            }
         });
     }
     /**
-     * Log build output
+     * Get logs with optional filtering
      */
-    logBuildOutput(output, isError = false) {
-        // Split output into lines and log each line
-        const lines = output.split('\n').filter(line => line.trim());
-        lines.forEach(line => {
-            this.log({
-                source: 'build',
-                level: isError ? 'error' : 'info',
-                message: line.trim()
-            });
-        });
+    getLogs(options) {
+        let filteredLogs = this.logs;
+        // Apply filters
+        if (options?.source) {
+            filteredLogs = filteredLogs.filter(log => log.source === options.source);
+        }
+        if (options?.level) {
+            const levels = ['debug', 'info', 'warn', 'error'];
+            const minLevelIndex = levels.indexOf(options.level);
+            filteredLogs = filteredLogs.filter(log => levels.indexOf(log.level) >= minLevelIndex);
+        }
+        if (options?.since) {
+            const sinceTime = new Date(options.since).getTime();
+            filteredLogs = filteredLogs.filter(log => new Date(log.timestamp).getTime() >= sinceTime);
+        }
+        if (options?.category) {
+            filteredLogs = filteredLogs.filter(log => log.category === options.category);
+        }
+        // Apply limit
+        const limit = options?.limit || 100;
+        return filteredLogs.slice(-limit);
+    }
+    /**
+     * Clear all logs
+     */
+    clearLogs() {
+        this.logs = [];
+        this.info(LogSource.System, LogCategory.AppRunner, 'Logs cleared', { id: 'unknown' });
+    }
+    /**
+     * Add a listener for new log entries
+     */
+    addListener(listener) {
+        this.logListeners.push(listener);
+        // Return unsubscribe function
+        return () => {
+            const index = this.logListeners.indexOf(listener);
+            if (index > -1) {
+                this.logListeners.splice(index, 1);
+            }
+        };
     }
     /**
      * Generate a unique ID for log entries
@@ -196,23 +282,43 @@ class LogManager {
         return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     }
     /**
-     * Log to console with appropriate styling
+     * Log to console with new format
      */
     logToConsole(entry) {
-        const prefix = `[${entry.source.toUpperCase()}${entry.category ? `:${entry.category}` : ''}]`;
-        const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+        if (process.env.DISABLE_LOGMANAGER_CONSOLE === 'true') {
+            return;
+        }
+        // New format: [timestamp] - [source:category:id] - [level] - [message]
+        const timestamp = entry.timestamp;
+        const id = entry.context?.id || 'unknown';
+        const sourceCategoryId = `${entry.source}:${entry.category}:${id}`;
+        const level = entry.level;
+        const prefix = `[${timestamp}] - [${sourceCategoryId}] - [${level}]`;
+        // Escape newlines for single-line console output
+        const escapedMessage = entry.message
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r');
+        // Include context if present (excluding id since it's in the prefix)
+        let contextStr = '';
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            const { id: _, ...contextWithoutId } = entry.context;
+            if (Object.keys(contextWithoutId).length > 0) {
+                contextStr = ` ${JSON.stringify(contextWithoutId)}`;
+            }
+        }
+        const fullMessage = `${prefix} - ${escapedMessage}${contextStr}`;
         switch (entry.level) {
             case 'error':
-                console.error(`${timestamp} ${prefix} ${entry.message}`, entry.details || '');
+                console.error(fullMessage);
                 break;
             case 'warn':
-                console.warn(`${timestamp} ${prefix} ${entry.message}`, entry.details || '');
+                console.warn(fullMessage);
                 break;
             case 'debug':
-                console.debug(`${timestamp} ${prefix} ${entry.message}`, entry.details || '');
+                console.debug(fullMessage);
                 break;
             default:
-                console.log(`${timestamp} ${prefix} ${entry.message}`, entry.details || '');
+                console.log(fullMessage);
         }
     }
     /**