@mimik/mim-logger 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+<a name="MimLogger"></a>
+
+## MimLogger
+Logger instance
+
+**Kind**: global class  
+
+* [MimLogger](#MimLogger)
+    * [.init(contextOrConfig)](#MimLogger+init) ⇒ [<code>MimLogger</code>](#MimLogger)
+    * [.getConfig()](#MimLogger+getConfig) ⇒ <code>Object</code>
+    * [._log(level, message, ...args)](#MimLogger+_log)
+    * [.log(level, message, ...args)](#MimLogger+log)
+    * [.error(message, ...args)](#MimLogger+error)
+    * [.warn(message, ...args)](#MimLogger+warn)
+    * [.info(message, ...args)](#MimLogger+info)
+    * [.verbose(message, ...args)](#MimLogger+verbose)
+    * [.debug(message, ...args)](#MimLogger+debug)
+    * [.silly(message, ...args)](#MimLogger+silly)
+    * [.flush()](#MimLogger+flush) ⇒ <code>Promise.&lt;void&gt;</code>
+    * [.flushAndExit(exitCode)](#MimLogger+flushAndExit) ⇒ <code>Promise.&lt;void&gt;</code>
+    * [.serializeError(err)](#MimLogger+serializeError) ⇒ <code>Object</code>
+
+<a name="MimLogger+init"></a>
+
+### mimLogger.init(contextOrConfig) ⇒ [<code>MimLogger</code>](#MimLogger)
+Initializes the logger with context or configuration
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+**Returns**: [<code>MimLogger</code>](#MimLogger) - Logger instance for chaining  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| contextOrConfig | <code>Object</code> | mimik context object or config with env |
+
+<a name="MimLogger+getConfig"></a>
+
+### mimLogger.getConfig() ⇒ <code>Object</code>
+Gets current configuration, refreshing from context if available
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+**Returns**: <code>Object</code> - Current configuration  
+<a name="MimLogger+_log"></a>
+
+### mimLogger.\_log(level, message, ...args)
+Internal log method
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| level | <code>string</code> | Log level |
+| message | <code>string</code> \| <code>Object</code> | Log message or object with message property |
+| ...args | <code>\*</code> | Additional arguments (metadata, correlationId) |
+
+<a name="MimLogger+log"></a>
+
+### mimLogger.log(level, message, ...args)
+Generic log method with explicit level
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| level | <code>string</code> | Log level |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+error"></a>
+
+### mimLogger.error(message, ...args)
+Log error message
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+warn"></a>
+
+### mimLogger.warn(message, ...args)
+Log warning message
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+info"></a>
+
+### mimLogger.info(message, ...args)
+Log info message
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+verbose"></a>
+
+### mimLogger.verbose(message, ...args)
+Log verbose message
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+debug"></a>
+
+### mimLogger.debug(message, ...args)
+Log debug message
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+silly"></a>
+
+### mimLogger.silly(message, ...args)
+Log silly message
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| message | <code>string</code> \| <code>Object</code> | Log message |
+| ...args | <code>\*</code> | Additional arguments |
+
+<a name="MimLogger+flush"></a>
+
+### mimLogger.flush() ⇒ <code>Promise.&lt;void&gt;</code>
+Flush all transports (for graceful shutdown)
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+<a name="MimLogger+flushAndExit"></a>
+
+### mimLogger.flushAndExit(exitCode) ⇒ <code>Promise.&lt;void&gt;</code>
+Flush all transports and exit process
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| exitCode | <code>number</code> | <code>0</code> | Process exit code |
+
+<a name="MimLogger+serializeError"></a>
+
+### mimLogger.serializeError(err) ⇒ <code>Object</code>
+Utility to serialize errors
+
+**Kind**: instance method of [<code>MimLogger</code>](#MimLogger)  
+**Returns**: <code>Object</code> - Serialized error  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| err | <code>Error</code> | Error to serialize |
+

package/configuration/config.js

@@ -0,0 +1,78 @@
+/**
+ * Configuration management for mim-logger
+ * Supports both direct env object and context-based env access
+ */
+
+const { LEVELS, LEVEL_PRIORITY } = require('../lib/common');
+
+const DEFAULT_CONFIG = {
+  level: 'debug',
+  enabled: true,
+  format: 'text',
+  useColors: true,
+  includeStack: false,
+  serverType: null,
+  serverId: null,
+};
+
+/**
+ * Parses a boolean environment variable
+ * @param {string} value - Environment variable value
+ * @param {boolean} defaultValue - Default if not set
+ * @returns {boolean}
+ */
+const parseBoolean = (value, defaultValue) => {
+  if (value === undefined || value === null || value === '') {
+    return defaultValue;
+  }
+  const lower = String(value).toLowerCase();
+  return lower === 'true' || lower === '1' || lower === 'yes';
+};
+
+/**
+ * Creates configuration from environment object
+ * @param {Object} env - Environment variables object
+ * @returns {Object} Logger configuration
+ */
+const createConfig = (env = {}) => {
+  const level = env.LOG_LEVEL || DEFAULT_CONFIG.level;
+
+  // Validate level
+  if (!LEVELS.includes(level)) {
+    console.warn(`[mim-logger] Invalid LOG_LEVEL "${level}", using default "${DEFAULT_CONFIG.level}"`);
+  }
+
+  return {
+    level: LEVELS.includes(level) ? level : DEFAULT_CONFIG.level,
+    enabled: parseBoolean(env.LOG_ENABLED, DEFAULT_CONFIG.enabled),
+    format: env.LOG_FORMAT === 'json' ? 'json' : DEFAULT_CONFIG.format,
+    useColors: parseBoolean(env.LOG_COLORS, DEFAULT_CONFIG.useColors),
+    includeStack: parseBoolean(env.LOG_STACK, DEFAULT_CONFIG.includeStack),
+    serverType: env.SERVER_TYPE || globalThis.serverType || DEFAULT_CONFIG.serverType,
+    serverId: env.SERVER_ID || globalThis.serverId || DEFAULT_CONFIG.serverId,
+  };
+};
+
+/**
+ * Checks if a log level should be logged based on configured minimum level
+ * @param {string} level - Level to check
+ * @param {string} minLevel - Minimum configured level
+ * @returns {boolean}
+ */
+const shouldLog = (level, minLevel) => {
+  const levelPriority = LEVEL_PRIORITY[level];
+  const minPriority = LEVEL_PRIORITY[minLevel];
+
+  if (levelPriority === undefined || minPriority === undefined) {
+    return true;
+  }
+
+  return levelPriority <= minPriority;
+};
+
+module.exports = {
+  DEFAULT_CONFIG,
+  createConfig,
+  shouldLog,
+  parseBoolean,
+};

package/eslint.config.js

@@ -0,0 +1,79 @@
+const loadPlugin = async (name) => {
+  const mod = await import(name);
+  return mod.default ?? mod;
+};
+
+module.exports = (async () => {
+  const js = await loadPlugin('@eslint/js');
+  const importPlugin = await loadPlugin('eslint-plugin-import');
+  const stylistic = await loadPlugin('@stylistic/eslint-plugin');
+  const processDoc = await loadPlugin('@mimik/eslint-plugin-document-env');
+
+  const MAX_LENGTH_LINE = 180;
+  const MAX_FUNCTION_PARAMETERS = 6;
+  const MAX_LINES_IN_FILES = 600;
+  const MAX_LINES_IN_FUNCTION = 150;
+  const MAX_STATEMENTS_IN_FUNCTION = 45;
+  const MIN_KEYS_IN_OBJECT = 10;
+  const MAX_COMPLEXITY = 30;
+
+  return [
+    {
+      ignores: ['mochawesome-report/**', '**/node_modules', 'node_modules/**', 'dist/**', '**/eslint.config.js', '**/webpack.config.js'],
+    },
+
+    // Baseline best-practices
+    js.configs.recommended,
+    importPlugin.flatConfigs.recommended,
+    stylistic.configs.recommended,
+
+    {
+      plugins: { processDoc },
+      languageOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'commonjs',
+        globals: {
+          mimikModule: true,
+          console: 'readonly',
+          describe: 'readonly',
+          it: 'readonly',
+          require: 'readonly',
+          module: 'readonly',
+          __dirname: 'readonly',
+          process: 'readonly',
+        },
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: true,
+      },
+      rules: {
+        '@stylistic/brace-style': ['warn', 'stroustrup', { allowSingleLine: true }],
+        '@stylistic/line-comment-position': 'off',
+        '@stylistic/semi': ['error', 'always'],
+
+        'capitalized-comments': 'off',
+        'complexity': ['error', MAX_COMPLEXITY],
+        'curly': 'off',
+        'id-length': ['error', { exceptions: ['x', 'y', 'z', 'i', 'j', 'k'] }],
+        'import/no-extraneous-dependencies': ['error', { devDependencies: true }],
+        'import/no-unresolved': ['error', { amd: true, caseSensitiveStrict: true, commonjs: true }],
+        'init-declarations': 'off',
+        'linebreak-style': 'off',
+        'max-len': ['warn', MAX_LENGTH_LINE, { ignoreComments: true }],
+        'max-lines': ['warn', { max: MAX_LINES_IN_FILES, skipComments: true }],
+        'max-lines-per-function': ['warn', { max: MAX_LINES_IN_FUNCTION, skipComments: true }],
+        'max-params': ['error', MAX_FUNCTION_PARAMETERS],
+        'max-statements': ['warn', MAX_STATEMENTS_IN_FUNCTION],
+        'no-confusing-arrow': 'off',
+        'no-inline-comments': 'off',
+        'no-process-env': 'error',
+        'no-ternary': 'off',
+        'no-undefined': 'off',
+        'one-var': ['error', 'never'],
+        'processDoc/validate-document-env': 'error',
+        'quotes': ['warn', 'single'],
+        'sort-keys': ['error', 'asc', { caseSensitive: true, minKeys: MIN_KEYS_IN_OBJECT, natural: false }],
+      },
+    },
+  ];
+})();

package/index.js

@@ -0,0 +1,279 @@
+/**
+ * mim-logger - Lightweight logging library for mimOE runtime environment
+ *
+ * Usage:
+ *   const logger = require('@mimik/mim-logger');
+ *
+ *   // Initialize with context (recommended for mimOE)
+ *   logger.init(context);
+ *
+ *   // Or initialize with env object directly
+ *   logger.init({ env: { LOG_LEVEL: 'debug' } });
+ *
+ *   // Log messages
+ *   logger.info('message');
+ *   logger.error('message', { meta: 'data' });
+ *   logger.debug('message', { meta: 'data' }, 'correlationId');
+ *
+ * Environment Variables:
+ *   LOG_ENABLED  - Enable/disable logging ('true'/'false', default: 'true')
+ *   LOG_LEVEL    - Minimum log level (error/warn/info/verbose/debug/silly, default: 'debug')
+ *   LOG_FORMAT   - Output format ('text'/'json', default: 'text')
+ *   LOG_COLORS   - Use ANSI colors ('true'/'false', default: 'true')
+ *   LOG_STACK    - Include stack traces ('true'/'false', default: 'false')
+ *   SERVER_TYPE  - Server type identifier
+ *   SERVER_ID    - Server instance identifier
+ */
+
+const { LEVELS, serializeData, serializeError } = require('./lib/common');
+const { parseCorrelationId, getStackInfo } = require('./lib/formatLib');
+const { createConfig, shouldLog, DEFAULT_CONFIG } = require('./configuration/config');
+const ConsoleTransport = require('./lib/consoleTransport');
+
+/**
+ * Logger instance
+ */
+class MimLogger {
+  constructor() {
+    this.config = { ...DEFAULT_CONFIG };
+    this.transport = new ConsoleTransport();
+    this.initialized = false;
+    this.context = null;
+
+    // Expose LEVELS constant
+    this.LEVELS = LEVELS;
+  }
+
+  /**
+   * Initializes the logger with context or configuration
+   * @param {Object} contextOrConfig - mimik context object or config with env
+   * @returns {MimLogger} Logger instance for chaining
+   */
+  init(contextOrConfig = {}) {
+    this.context = contextOrConfig;
+
+    // Extract env from context or use directly
+    const env = contextOrConfig.env || contextOrConfig || {};
+
+    this.config = createConfig(env);
+    this.transport = new ConsoleTransport({
+      format: this.config.format,
+      useColors: this.config.useColors,
+    });
+
+    this.initialized = true;
+    return this;
+  }
+
+  /**
+   * Gets current configuration, refreshing from context if available
+   * @returns {Object} Current configuration
+   */
+  getConfig() {
+    // If we have a context with env, refresh config each time
+    // This allows dynamic config changes
+    if (this.context && this.context.env) {
+      this.config = createConfig(this.context.env);
+      this.transport = new ConsoleTransport({
+        format: this.config.format,
+        useColors: this.config.useColors,
+      });
+    }
+    return this.config;
+  }
+
+  /**
+   * Internal log method
+   * @param {string} level - Log level
+   * @param {string|Object} message - Log message or object with message property
+   * @param {...*} args - Additional arguments (metadata, correlationId)
+   */
+  _log(level, message, ...args) {
+    const config = this.getConfig();
+
+    // Check if logging is enabled
+    if (!config.enabled) {
+      return;
+    }
+
+    // Check if this level should be logged
+    if (!shouldLog(level, config.level)) {
+      return;
+    }
+
+    // Parse arguments
+    let meta = null;
+    let correlationId = null;
+
+    // Last string argument is correlation ID
+    if (args.length > 0 && typeof args[args.length - 1] === 'string') {
+      correlationId = args.pop();
+    }
+
+    // Remaining arguments are metadata
+    if (args.length > 0) {
+      // Merge all metadata objects
+      meta = args.reduce((acc, arg) => {
+        if (arg && typeof arg === 'object') {
+          return { ...acc, ...serializeData(arg) };
+        }
+        return acc;
+      }, {});
+    }
+
+    // Handle message as object
+    let messageStr = message;
+    if (message && typeof message === 'object') {
+      if (message.message) {
+        messageStr = message.message;
+        // Merge remaining properties into meta
+        // eslint-disable-next-line id-length, no-unused-vars
+        const { message: _, ...rest } = message;
+        meta = { ...meta, ...serializeData(rest) };
+      }
+      else {
+        messageStr = JSON.stringify(serializeData(message));
+      }
+    }
+
+    // Build log info object
+    const info = {
+      level,
+      message: String(messageStr),
+      timestamp: new Date().toISOString(),
+    };
+
+    // Add correlation ID if present
+    if (correlationId) {
+      info.correlationId = correlationId;
+      info.correlationParsed = parseCorrelationId(correlationId);
+    }
+
+    // Add metadata
+    if (meta && Object.keys(meta).length > 0) {
+      info.meta = meta;
+    }
+
+    // Add stack info for errors or if configured
+    if (level === 'error' || config.includeStack) {
+      const stackInfo = getStackInfo();
+      if (stackInfo) {
+        info.stack = stackInfo;
+      }
+    }
+
+    // Add server identification
+    if (config.serverType) {
+      info.serverType = config.serverType;
+    }
+    if (config.serverId) {
+      info.serverId = config.serverId;
+    }
+
+    // Send to transport
+    this.transport.log(info);
+  }
+
+  /**
+   * Generic log method with explicit level
+   * @param {string} level - Log level
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  log(level, message, ...args) {
+    if (!LEVELS.includes(level)) {
+      console.warn(`[mim-logger] Invalid log level "${level}"`);
+      return;
+    }
+    this._log(level, message, ...args);
+  }
+
+  /**
+   * Log error message
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  error(message, ...args) {
+    this._log('error', message, ...args);
+  }
+
+  /**
+   * Log warning message
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  warn(message, ...args) {
+    this._log('warn', message, ...args);
+  }
+
+  /**
+   * Log info message
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  info(message, ...args) {
+    this._log('info', message, ...args);
+  }
+
+  /**
+   * Log verbose message
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  verbose(message, ...args) {
+    this._log('verbose', message, ...args);
+  }
+
+  /**
+   * Log debug message
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  debug(message, ...args) {
+    this._log('debug', message, ...args);
+  }
+
+  /**
+   * Log silly message
+   * @param {string|Object} message - Log message
+   * @param {...*} args - Additional arguments
+   */
+  silly(message, ...args) {
+    this._log('silly', message, ...args);
+  }
+
+  /**
+   * Flush all transports (for graceful shutdown)
+   * @returns {Promise<void>}
+   */
+  flush() {
+    return this.transport.flush();
+  }
+
+  /**
+   * Flush all transports and exit process
+   * @param {number} exitCode - Process exit code
+   * @returns {Promise<void>}
+   */
+  flushAndExit(exitCode = 0) {
+    return this.flush().then(() => {
+      if (typeof process !== 'undefined' && typeof process.exit === 'function') {
+        process.exit(exitCode);
+      }
+    });
+  }
+
+  /**
+   * Utility to serialize errors
+   * @param {Error} err - Error to serialize
+   * @returns {Object} Serialized error
+   */
+  serializeError(err) {
+    return serializeError(err);
+  }
+}
+
+// Export singleton instance
+const logger = new MimLogger();
+
+module.exports = logger;

package/lib/common.js

@@ -0,0 +1,122 @@
+/**
+ * Common constants and utilities for mim-logger
+ */
+
+const LEVELS = ['error', 'warn', 'info', 'verbose', 'debug', 'silly'];
+
+const LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  verbose: 3,
+  debug: 4,
+  silly: 5,
+};
+
+const LEVEL_COLORS = {
+  error: '\x1b[31m', // Red
+  warn: '\x1b[33m', // Yellow
+  info: '\x1b[36m', // Cyan
+  verbose: '\x1b[35m', // Magenta
+  debug: '\x1b[32m', // Green
+  silly: '\x1b[90m', // Gray
+};
+
+const RESET_COLOR = '\x1b[0m';
+
+/**
+ * Serializes an error object into a plain object
+ * @param {Error} err - Error to serialize
+ * @returns {Object} Serialized error
+ */
+const serializeError = (err) => {
+  if (!err) return err;
+  if (!(err instanceof Error)) return err;
+
+  const serialized = {
+    message: err.message,
+    name: err.name,
+  };
+
+  if (err.stack) {
+    serialized.stack = err.stack;
+  }
+
+  if (err.code) {
+    serialized.code = err.code;
+  }
+
+  if (err.status) {
+    serialized.status = err.status;
+  }
+
+  if (err.statusCode) {
+    serialized.statusCode = err.statusCode;
+  }
+
+  // Copy any additional enumerable properties
+  Object.keys(err).forEach((key) => {
+    if (!(key in serialized)) {
+      serialized[key] = err[key];
+    }
+  });
+
+  return serialized;
+};
+
+/**
+ * Deep clones and serializes data, handling errors and circular references
+ * Uses array-based tracking for mimOE runtime compatibility (no WeakSet)
+ * @param {*} data - Data to serialize
+ * @param {Array} seen - Array of seen objects for circular reference detection
+ * @returns {*} Serialized data
+ */
+const serializeData = (data, seen) => {
+  if (data === null || data === undefined) return data;
+  if (typeof data !== 'object') return data;
+
+  if (data instanceof Error) {
+    return serializeError(data);
+  }
+
+  // Initialize seen array on first call
+  var seenArr = seen || [];
+
+  // Check for circular reference using indexOf (works in ES5)
+  if (seenArr.indexOf(data) !== -1) {
+    return '[Circular]';
+  }
+
+  seenArr.push(data);
+
+  if (Array.isArray(data)) {
+    return data.map(function (item) {
+      return serializeData(item, seenArr);
+    });
+  }
+
+  if (data instanceof Date) {
+    return data.toISOString();
+  }
+
+  // Handle Mongoose-like objects with toObject method
+  if (typeof data.toObject === 'function') {
+    return serializeData(data.toObject(), seenArr);
+  }
+
+  var result = {};
+  Object.keys(data).forEach(function (key) {
+    result[key] = serializeData(data[key], seenArr);
+  });
+
+  return result;
+};
+
+module.exports = {
+  LEVELS,
+  LEVEL_PRIORITY,
+  LEVEL_COLORS,
+  RESET_COLOR,
+  serializeError,
+  serializeData,
+};

package/lib/consoleTransport.js

@@ -0,0 +1,66 @@
+/**
+ * Console transport for mim-logger
+ */
+
+const { formatText, formatJson } = require('./formatLib');
+
+/**
+ * Console transport class
+ */
+class ConsoleTransport {
+  /**
+   * Creates a new ConsoleTransport
+   * @param {Object} options - Transport options
+   * @param {string} options.format - Output format ('text' or 'json')
+   * @param {boolean} options.useColors - Use ANSI colors (text format only)
+   */
+  constructor(options = {}) {
+    this.format = options.format || 'text';
+    this.useColors = options.useColors !== false;
+  }
+
+  /**
+   * Logs a message to console
+   * @param {Object} info - Log info object
+   */
+  log(info) {
+    const formatted = this.format === 'json'
+      ? formatJson(info)
+      : formatText(info, this.useColors);
+
+    const { level } = info;
+
+    // Use appropriate console method based on level
+    switch (level) {
+      case 'error':
+        console.error(formatted);
+        break;
+      case 'warn':
+        console.warn(formatted);
+        break;
+      case 'debug':
+      case 'verbose':
+      case 'silly':
+        // console.debug may not be available in all environments
+        if (typeof console.debug === 'function') {
+          console.debug(formatted);
+        }
+        else {
+          console.log(formatted);
+        }
+        break;
+      default:
+        console.log(formatted);
+    }
+  }
+
+  /**
+   * Flush method (no-op for console, included for interface compatibility)
+   * @returns {Promise<void>}
+   */
+  flush() {
+    return Promise.resolve();
+  }
+}
+
+module.exports = ConsoleTransport;

package/lib/formatLib.js

@@ -0,0 +1,198 @@
+/**
+ * Log formatting utilities for mim-logger
+ */
+
+const {
+  LEVEL_COLORS,
+  RESET_COLOR,
+  serializeData,
+} = require('./common');
+
+/**
+ * Pads a string to a target length (ES5 compatible replacement for padEnd)
+ * @param {string} str - String to pad
+ * @param {number} targetLength - Desired length
+ * @param {string} padChar - Character to pad with (default: space)
+ * @returns {string} Padded string
+ */
+function padEnd(str, targetLength, padChar) {
+  var padS = String(str);
+  var pad = padChar || ' ';
+  if (padS.length >= targetLength) {
+    return padS;
+  }
+  var padding = '';
+  for (var i = padS.length; i < targetLength; i++) {
+    padding += pad;
+  }
+  return padS + padding;
+}
+
+/**
+ * Parses correlation ID string into components
+ * Format: correlationId/timestamp or correlationId@step/timestamp
+ * @param {string} correlationId - Correlation ID string
+ * @returns {Object} Parsed correlation components
+ */
+const parseCorrelationId = (correlationId) => {
+  if (!correlationId || typeof correlationId !== 'string') {
+    return null;
+  }
+
+  const result = {
+    correlationId: null,
+    step: null,
+    timestamp: null,
+  };
+
+  // Check for step separator (@)
+  const atIndex = correlationId.indexOf('@');
+  const slashIndex = correlationId.lastIndexOf('/');
+
+  if (slashIndex > 0) {
+    result.timestamp = correlationId.substring(slashIndex + 1);
+    const beforeSlash = correlationId.substring(0, slashIndex);
+
+    if (atIndex > 0 && atIndex < slashIndex) {
+      result.correlationId = beforeSlash.substring(0, atIndex);
+      result.step = beforeSlash.substring(atIndex + 1);
+    }
+    else {
+      result.correlationId = beforeSlash;
+    }
+  }
+  else if (atIndex > 0) {
+    result.correlationId = correlationId.substring(0, atIndex);
+    result.step = correlationId.substring(atIndex + 1);
+  }
+  else {
+    result.correlationId = correlationId;
+  }
+
+  return result;
+};
+
+/**
+ * Extracts stack trace info from the call site
+ * @param {number} depth - Stack depth to extract from
+ * @returns {Object|null} Stack info object
+ */
+const getStackInfo = (depth = 4) => {
+  const stackLines = new Error().stack.split('\n');
+
+  if (stackLines.length <= depth) {
+    return null;
+  }
+
+  const line = stackLines[depth];
+  // Match: at functionName (path:line:col) or at path:line:col
+  const match = line.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+
+  if (!match) {
+    return null;
+  }
+
+  const [, method, path, lineNum, pos] = match;
+  const file = path.split('/').pop();
+
+  return {
+    method: method || '<anonymous>',
+    path,
+    line: parseInt(lineNum, 10),
+    pos: parseInt(pos, 10),
+    file,
+  };
+};
+
+/**
+ * Formats a log entry as text
+ * @param {Object} info - Log info object
+ * @param {boolean} useColors - Whether to use ANSI colors
+ * @returns {string} Formatted log string
+ */
+const formatText = (info, useColors = true) => {
+  const { level, message, timestamp, meta, correlationId, stack } = info;
+
+  const parts = [];
+
+  // Timestamp
+  parts.push(`[${timestamp}]`);
+
+  // Level with optional color
+  var levelStr = padEnd(level.toUpperCase(), 7);
+  if (useColors) {
+    var color = LEVEL_COLORS[level] || '';
+    parts.push(color + levelStr + RESET_COLOR);
+  }
+  else {
+    parts.push(levelStr);
+  }
+
+  // Correlation ID if present
+  if (correlationId) {
+    parts.push(`[${correlationId}]`);
+  }
+
+  // Message
+  parts.push(message);
+
+  // Stack info for errors
+  if (stack && stack.file) {
+    parts.push(`(${stack.file}:${stack.line})`);
+  }
+
+  let result = parts.join(' ');
+
+  // Metadata on separate line if present
+  if (meta && Object.keys(meta).length > 0) {
+    result += `\n  ${JSON.stringify(meta)}`;
+  }
+
+  return result;
+};
+
+/**
+ * Formats a log entry as JSON
+ * @param {Object} info - Log info object
+ * @returns {string} JSON formatted log string
+ */
+const formatJson = (info) => {
+  const output = {
+    timestamp: info.timestamp,
+    level: info.level,
+    message: info.message,
+  };
+
+  if (info.correlationId) {
+    output.correlationId = info.correlationId;
+  }
+
+  if (info.correlationParsed) {
+    output.correlation = info.correlationParsed;
+  }
+
+  if (info.stack) {
+    output.stack = info.stack;
+  }
+
+  if (info.meta && Object.keys(info.meta).length > 0) {
+    output.meta = serializeData(info.meta);
+  }
+
+  if (info.serverType) {
+    output.serverType = info.serverType;
+  }
+
+  if (info.serverId) {
+    output.serverId = info.serverId;
+  }
+
+  return JSON.stringify(output);
+};
+
+module.exports = {
+  parseCorrelationId,
+  getStackInfo,
+  formatText,
+  formatJson,
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@mimik/mim-logger",
+  "version": "1.0.0",
+  "description": "Lightweight logging library for mimOE runtime environment",
+  "main": "index.js",
+  "scripts": {
+    "docs": "jsdoc2md index.js > README.md",
+    "lint": "eslint . --no-error-on-unmatched-pattern",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "mimik",
+    "logger",
+    "edge",
+    "microservice",
+    "mim"
+  ],
+  "author": "mimik",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.2",
+    "@mimik/eslint-plugin-document-env": "2.0.8",
+    "@stylistic/eslint-plugin": "5.7.0",
+    "eslint": "9.39.2",
+    "eslint-plugin-import": "2.32.0",
+    "jsdoc-to-markdown": "9.1.3"
+  }
+}

package/test/logger.spec.js

@@ -0,0 +1,80 @@
+/**
+ * Basic tests for mim-logger
+ */
+
+const logger = require('../index');
+
+// Test initialization
+console.log('\n=== Test 1: Default initialization ===');
+logger.init();
+logger.info('Logger initialized with defaults');
+
+// Test all log levels
+console.log('\n=== Test 2: All log levels ===');
+logger.error('This is an error message');
+logger.warn('This is a warning message');
+logger.info('This is an info message');
+logger.verbose('This is a verbose message');
+logger.debug('This is a debug message');
+logger.silly('This is a silly message');
+
+// Test with metadata
+console.log('\n=== Test 3: With metadata ===');
+logger.info('User logged in', { userId: '123', email: 'test@example.com' });
+logger.error('Request failed', { status: 500, endpoint: '/api/data' });
+
+// Test with correlation ID
+console.log('\n=== Test 4: With correlation ID ===');
+logger.info('Processing request', { action: 'create' }, 'req-abc123/1704067200');
+logger.debug('Cache hit', { key: 'user:123' }, 'req-abc123@step2/1704067200');
+
+// Test with Error object
+console.log('\n=== Test 5: With Error object ===');
+const testError = new Error('Something went wrong');
+testError.code = 'ERR_TEST';
+logger.error('Operation failed', { error: testError });
+
+// Test log level filtering
+console.log('\n=== Test 6: Log level filtering (LOG_LEVEL=warn) ===');
+logger.init({ LOG_LEVEL: 'warn' });
+logger.debug('This should NOT appear (debug < warn)');
+logger.info('This should NOT appear (info < warn)');
+logger.warn('This SHOULD appear');
+logger.error('This SHOULD appear');
+
+// Test disabled logging
+console.log('\n=== Test 7: Disabled logging ===');
+logger.init({ LOG_ENABLED: 'false' });
+logger.error('This should NOT appear (logging disabled)');
+logger.init({ LOG_ENABLED: 'true' }); // Re-enable
+
+// Test JSON format
+console.log('\n=== Test 8: JSON format ===');
+logger.init({ LOG_FORMAT: 'json', LOG_LEVEL: 'debug' });
+logger.info('JSON formatted message', { data: { nested: true } });
+logger.error('JSON error with stack');
+
+// Test with mimik context pattern
+console.log('\n=== Test 9: mimik context pattern ===');
+const mockContext = {
+  env: {
+    LOG_LEVEL: 'info',
+    LOG_FORMAT: 'text',
+    SERVER_TYPE: 'mEHR',
+    SERVER_ID: 'edge-001',
+  },
+  http: {}, // Mock http client
+};
+logger.init(mockContext);
+logger.info('Using mimik context', { feature: 'EHR' });
+
+// Test generic log method
+console.log('\n=== Test 10: Generic log method ===');
+logger.log('debug', 'Using generic log method', { custom: true });
+logger.log('invalid', 'This should show warning'); // Invalid level
+
+// Test LEVELS constant
+console.log('\n=== Test 11: LEVELS constant ===');
+console.log('Available levels:', logger.LEVELS);
+
+console.log('\n=== All tests completed ===\n');