@onlineapps/infra-logger 1.0.0

package/index.js

@@ -0,0 +1,270 @@
+'use strict';
+
+/**
+ * Structured logging helper for infrastructure services
+ * 
+ * Format: [context_id:service:layer:action] {JSON}
+ * 
+ * Context can be:
+ * - workflow_id for workflow-related logs
+ * - serviceName for lifecycle logs
+ * 
+ * NOTE: Health checks are NOT logged (too verbose). All other infrastructure
+ * operations should be logged with appropriate detail (input, output, process, fail).
+ * 
+ * Usage:
+ *   const { createLogger } = require('@onlineapps/infra-logger');
+ *   const log = createLogger('api_gateway', 'router');
+ *   
+ *   // Workflow logs
+ *   log.input('wf-123', 'WORKFLOW_RECEIVED', { 
+ *     handler: 'POST /api/workflow/start',
+ *     function: 'initWorkflowRoutes',
+ *     input: { method: 'POST', path: '/api/workflow/start', cookbook_summary: {...} }
+ *   });
+ *   
+ *   log.output('wf-123', 'WORKFLOW_PUBLISHED', {
+ *     handler: 'publishToQueue',
+ *     function: 'mqClient.publish',
+ *     input: { queue: 'workflow.init', message_size: 1234 },
+ *     output: { workflow_id: 'wf-123', status: 'published' }
+ *   });
+ *   
+ *   // Lifecycle logs
+ *   log.lifecycle('hello-service', 'HEARTBEAT_RECEIVED', {
+ *     handler: 'processHeartbeatMessage',
+ *     function: 'registryModel.touchHeartbeat',
+ *     input: { serviceName: 'hello-service', version: '1.0.0' }
+ *   });
+ */
+
+/**
+ * Sanitize input/output for logging (keep it concise, not full payload)
+ * @param {*} value - Value to sanitize
+ * @param {number} maxDepth - Maximum depth for nested objects
+ * @returns {*} Sanitized value
+ */
+function sanitizeValue(value, maxDepth = 2) {
+  if (maxDepth <= 0) {
+    return { _truncated: true };
+  }
+  
+  if (value === null || value === undefined) {
+    return value;
+  }
+  
+  if (typeof value === 'string') {
+    // Truncate long strings
+    if (value.length > 500) {
+      return value.substring(0, 500) + '... (truncated)';
+    }
+    return value;
+  }
+  
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  
+  if (Buffer.isBuffer(value)) {
+    return { type: 'Buffer', size: value.length };
+  }
+  
+  if (Array.isArray(value)) {
+    if (value.length > 10) {
+      return { type: 'array', length: value.length, first_3: value.slice(0, 3).map(v => sanitizeValue(v, maxDepth - 1)) };
+    }
+    return value.map(v => sanitizeValue(v, maxDepth - 1));
+  }
+  
+  if (typeof value === 'object') {
+    const keys = Object.keys(value);
+    if (keys.length > 20) {
+      return { type: 'object', keys_count: keys.length, keys: keys.slice(0, 10) };
+    }
+    const result = {};
+    for (const key of keys) {
+      result[key] = sanitizeValue(value[key], maxDepth - 1);
+    }
+    return result;
+  }
+  
+  return String(value);
+}
+
+/**
+ * Create a structured logger for an infrastructure service
+ * @param {string} service - Service name (e.g., 'api_gateway', 'api_monitoring')
+ * @param {string} layer - Layer name (e.g., 'router', 'consumer', 'dispatcher')
+ * @returns {Object} Logger with input, output, process, fail, lifecycle methods
+ */
+function createLogger(service, layer) {
+  const formatLog = (contextId, action, data = {}) => {
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      workflow_id: contextId, // For workflow logs
+      context: contextId,     // Generic context (can be workflow_id or serviceName)
+      service,
+      layer,
+      action,
+      ...data
+    };
+    const prefix = `[${contextId}:${service}:${layer}:${action}]`;
+    return { prefix, logEntry };
+  };
+
+  return {
+    /**
+     * Log input (what was received)
+     * @param {string} contextId - Workflow ID or service name
+     * @param {string} action - Action name
+     * @param {Object} data - Data with handler, function, input
+     */
+    input: (contextId, action, data = {}) => {
+      const { handler, function: fn, input, ...rest } = data;
+      const { prefix, logEntry } = formatLog(contextId, action, {
+        handler,
+        function: fn,
+        input: sanitizeValue(input),
+        ...rest
+      });
+      console.log(prefix, JSON.stringify(logEntry));
+    },
+    
+    /**
+     * Log output (what was returned/sent)
+     * @param {string} contextId - Workflow ID or service name
+     * @param {string} action - Action name
+     * @param {Object} data - Data with handler, function, input, output
+     */
+    output: (contextId, action, data = {}) => {
+      const { handler, function: fn, input, output, ...rest } = data;
+      const { prefix, logEntry } = formatLog(contextId, action, {
+        handler,
+        function: fn,
+        input: sanitizeValue(input),
+        output: sanitizeValue(output),
+        ...rest
+      });
+      console.log(prefix, JSON.stringify(logEntry));
+    },
+    
+    /**
+     * Log process (transformation/processing)
+     * @param {string} contextId - Workflow ID or service name
+     * @param {string} action - Action name
+     * @param {Object} data - Data with handler, function, input, output
+     */
+    process: (contextId, action, data = {}) => {
+      const { handler, function: fn, input, output, ...rest } = data;
+      const { prefix, logEntry } = formatLog(contextId, action, {
+        handler,
+        function: fn,
+        input: sanitizeValue(input),
+        output: sanitizeValue(output),
+        ...rest
+      });
+      console.log(prefix, JSON.stringify(logEntry));
+    },
+    
+    /**
+     * Log failure (errors)
+     * @param {string} contextId - Workflow ID or service name
+     * @param {string} action - Action name
+     * @param {Object} data - Data with handler, function, error, expected, received, input
+     */
+    fail: (contextId, action, data = {}) => {
+      const { handler, function: fn, error, expected, received, input, ...rest } = data;
+      const { prefix, logEntry } = formatLog(contextId, action, {
+        handler,
+        function: fn,
+        error: error?.message || error || 'Unknown error',
+        error_type: error?.constructor?.name || typeof error,
+        expected,
+        received,
+        input: sanitizeValue(input),
+        ...rest
+      });
+      console.error(prefix, JSON.stringify(logEntry));
+    },
+    
+    /**
+     * Log lifecycle events (service registration, heartbeats, etc.)
+     * @param {string} serviceName - Service name (context)
+     * @param {string} action - Action name
+     * @param {Object} data - Data with handler, function, input, output
+     */
+    lifecycle: (serviceName, action, data = {}) => {
+      const { handler, function: fn, input, output, ...rest } = data;
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        context: serviceName,
+        service,
+        layer,
+        action,
+        handler,
+        function: fn,
+        input: sanitizeValue(input),
+        output: sanitizeValue(output),
+        ...rest
+      };
+      const prefix = `[${serviceName}:${service}:${layer}:${action}]`;
+      console.log(prefix, JSON.stringify(logEntry));
+    },
+    
+    /**
+     * Generic log (backward compatibility)
+     * @param {string} contextId - Workflow ID or service name
+     * @param {string} action - Action name
+     * @param {Object} data - Additional data
+     */
+    info: (contextId, action, data = {}) => {
+      const { prefix, logEntry } = formatLog(contextId, action, data);
+      console.log(prefix, JSON.stringify(logEntry));
+    },
+    
+    warn: (contextId, action, data = {}) => {
+      const { prefix, logEntry } = formatLog(contextId, action, data);
+      console.warn(prefix, JSON.stringify(logEntry));
+    },
+    
+    error: (contextId, action, data = {}) => {
+      const { prefix, logEntry } = formatLog(contextId, action, data);
+      console.error(prefix, JSON.stringify(logEntry));
+    }
+  };
+}
+
+/**
+ * Standalone structured log function (for inline use without creating logger)
+ * @param {string} workflowId - Workflow ID
+ * @param {string} service - Service name
+ * @param {string} layer - Layer name
+ * @param {string} action - Action name
+ * @param {Object} data - Additional data
+ * @param {string} level - Log level (info, warn, error)
+ */
+function structuredLog(workflowId, service, layer, action, data = {}, level = 'info') {
+  const logEntry = {
+    timestamp: new Date().toISOString(),
+    workflow_id: workflowId,
+    service,
+    layer,
+    action,
+    ...data
+  };
+  const prefix = `[${workflowId}:${service}:${layer}:${action}]`;
+  
+  if (level === 'error') {
+    console.error(prefix, JSON.stringify(logEntry));
+  } else if (level === 'warn') {
+    console.warn(prefix, JSON.stringify(logEntry));
+  } else {
+    console.log(prefix, JSON.stringify(logEntry));
+  }
+}
+
+module.exports = {
+  createLogger,
+  structuredLog
+};
+

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@onlineapps/infra-logger",
+  "version": "1.0.0",
+  "description": "Structured logging helper for infrastructure services",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": ["logging", "infrastructure", "structured"],
+  "author": "OnlineApps",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}
+