@gratheon/log-lib 1.0.1 → 2.0.1

package/README.md

@@ -6,10 +6,16 @@ A TypeScript logging library with console output and MySQL database persistence
 
 - **Dual Output**: Logs to both console and MySQL database
 - **Color-Coded Console**: ANSI colored output for different log levels
+- **Enhanced Stack Traces**: Shows code frames with 5 lines of context around errors (dev mode)
+- **Error Cause Chain Tracking**: Traverses and displays the full error.cause chain
+- **Callsite Capture**: Captures where logger.error was called when error lacks stack frames
+- **Automatic Database Creation**: Creates logs database and table if they don't exist
+- **Non-blocking Initialization**: App starts even if logging DB fails
+- **Connection Pool Optimization**: Suppresses known MySQL warnings for cleaner logs
+- **Global Exception Handlers**: Captures uncaught exceptions and unhandled rejections
 - **TypeScript Support**: Full type definitions included
 - **Fastify Integration**: Special logger interface for Fastify framework
 - **Flexible Metadata**: Support for structured metadata in logs
-- **Error Handling**: Graceful handling of database connection failures
 - **Multiple Log Levels**: info, error, warn, debug (debug logs are not persisted to DB)
 
 ## Installation
@@ -20,15 +26,9 @@ npm install @gratheon/log-lib
 
 ## Database Setup
 
-Before using the logger, you need to set up the MySQL database. Run the migration script:
+The logger automatically creates the database and table on first initialization. No manual setup required!
 
-```bash
-mysql -u root -p < migrations/001-create-logs-table.sql
-```
-
-This will create:
-- A `logs` database
-- A `logs` table with fields: id, level, message, meta, timestamp
+For reference, the migration script is available at `migrations/001-create-logs-table.sql`.
 
 ## Usage
 
@@ -55,17 +55,44 @@ logger.warn('Low memory warning', { available: '100MB' });
 logger.error('Failed to connect to API', { endpoint: '/api/users' });
 logger.debug('Processing item', { id: 123 }); // Not stored in DB
 
-// Error with stack trace
+// Error with stack trace and code frame (in dev mode)
 try {
   throw new Error('Something went wrong');
 } catch (err) {
-  logger.error(err); // Logs error with stack trace
+  logger.error(err); // Logs error with stack trace, cause chain, and code frame
 }
 
 // Enriched error logging
 logger.errorEnriched('Database query failed', err, { query: 'SELECT * FROM users' });
 ```
 
+### Development Mode Features
+
+Set `ENV_ID=dev` to enable enhanced error diagnostics:
+
+```bash
+ENV_ID=dev node app.js
+```
+
+In dev mode, you get:
+- **Code frames**: Shows 5 lines of source code around the error location
+- **Column markers**: Caret (^) pointing to the exact error position
+- **Callsite capture**: When error lacks project stack frames, shows where logger was called
+- **Enhanced debugging**: More verbose error output
+
+Example dev mode output:
+```
+12:34:56 [error]: Something went wrong {"stack":"Error: Something went wrong\n  at /app/src/user.ts:42:15\n..."}
+
+Code frame:
+  40 | function processUser(user) {
+  41 |   if (!user.id) {
+> 42 |     throw new Error('Something went wrong');
+     |               ^
+  43 |   }
+  44 |   return user;
+```
+
 ### Fastify Integration
 
 ```typescript
@@ -131,10 +158,42 @@ Compatible with Fastify's logger interface:
 - `error(message: string | Error, meta?: LogMetadata)`
 - `warn(msg: any)`
 - `debug(msg: any)`
-- `fatal(msg: any)` - Logs error and calls `process.exit(1)`
+- `fatal(msg: any)` - Logs error and calls `process.exit(1)` after 100ms delay
 - `trace(msg: any)` - No-op
 - `child(meta: any)` - Returns the same logger instance
 
+## Advanced Features
+
+### Connection Pool Configuration
+
+The logger uses an optimized connection pool:
+- Pool size: 3 connections
+- Max uses per connection: 200
+- Idle timeout: 30 seconds
+- Queue timeout: 60 seconds
+- Automatic error suppression for known MySQL warnings
+
+### Message Truncation
+
+To prevent database bloat:
+- Messages are truncated to 2000 characters
+- Metadata is truncated to 2000 characters
+- JSON stringification uses `fast-safe-stringify` for circular reference handling
+
+### Async Initialization
+
+The logger initializes asynchronously in the background:
+```typescript
+const { logger } = createLogger(config);
+logger.info('App starting'); // Works immediately, DB writes happen when ready
+```
+
+### Environment-Specific Behavior
+
+Set `ENV_ID` to control behavior:
+- `ENV_ID=dev`: Enhanced diagnostics, code frames, callsite capture
+- `ENV_ID=prod`: Production mode with minimal overhead
+
 ## Console Output Colors
 
 - **Time**: Blue
@@ -157,11 +216,43 @@ CREATE TABLE `logs` (
 
 ## Error Handling
 
-The logger gracefully handles database connection failures:
+The logger provides comprehensive error handling:
+
+### Automatic Database Creation
+- Creates the `logs` database if it doesn't exist
+- Creates the `logs` table with proper schema and indexes
+- Non-blocking initialization - app starts even if DB fails
+
+### Graceful Degradation
 - Logs are always written to console
-- Database errors are logged to console only
-- Application continues running even if database is unavailable
-- Connection errors (ECONNREFUSED, ENOTFOUND, ETIMEDOUT) are handled with warnings
+- Database errors are logged but don't crash the application
+- Connection pool errors are suppressed (packets out of order, inactivity warnings)
+- Fire-and-forget database logging (no await in hot path)
+
+### Enhanced Error Diagnostics
+- **Error Cause Chain**: Automatically traverses and displays `error.cause` chains
+- **Stack Trace Enhancement**: Formats and colorizes stack traces
+- **Code Frames** (dev mode): Shows source code context around errors
+- **Callsite Capture** (dev mode): Shows where logger was called when error lacks stack
+
+### Global Exception Handling
+The logger automatically registers handlers for:
+- `uncaughtException`: Logs the error and exits gracefully (100ms delay for log flush)
+- `unhandledRejection`: Logs the rejection and continues running
+
+Example with error cause chain:
+```typescript
+try {
+  const dbError = new Error('Connection refused');
+  throw new Error('Failed to fetch user', { cause: dbError });
+} catch (err) {
+  logger.error(err);
+  // Output:
+  // [error]: Failed to fetch user
+  // [stack trace]
+  // Cause chain: Error: Connection refused
+}
+```
 
 ## TypeScript Types
 

package/dist/logger.js

@@ -29,10 +29,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLogger = void 0;
 const mysql_1 = __importStar(require("@databases/mysql"));
 const fast_safe_stringify_1 = __importDefault(require("fast-safe-stringify"));
-let conn;
-function initializeConnection(config) {
-    const database = config.mysql.database || 'logs';
-    conn = (0, mysql_1.default)(`mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/${database}`);
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let conn = null;
+let dbInitialized = false;
+async function initializeConnection(config) {
+    if (dbInitialized)
+        return;
+    try {
+        const database = config.mysql.database || 'logs';
+        // First connect without database to create it if needed
+        const tempConn = (0, mysql_1.default)({
+            connectionString: `mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/?connectionLimit=1&waitForConnections=true`,
+            bigIntMode: 'number',
+        });
+        await tempConn.query((0, mysql_1.sql) `CREATE DATABASE IF NOT EXISTS \`${database}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;`);
+        await tempConn.dispose();
+        // Now create the main connection pool with the logs database
+        conn = (0, mysql_1.default)({
+            connectionString: `mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/${database}?connectionLimit=3&waitForConnections=true`,
+            bigIntMode: 'number',
+            poolSize: 3,
+            maxUses: 200,
+            idleTimeoutMilliseconds: 30000,
+            queueTimeoutMilliseconds: 60000,
+            onError: (err) => {
+                // Suppress "packets out of order" and inactivity warnings
+                if (!err.message?.includes('packets out of order') &&
+                    !err.message?.includes('inactivity') &&
+                    !err.message?.includes('wait_timeout')) {
+                    console.error(`MySQL logger connection pool error: ${err.message}`);
+                }
+            },
+        });
+        // Create logs table if it doesn't exist
+        await conn.query((0, mysql_1.sql) `
+      CREATE TABLE IF NOT EXISTS \`logs\` (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        level VARCHAR(50),
+        message TEXT,
+        meta TEXT,
+        timestamp DATETIME,
+        INDEX idx_timestamp (timestamp),
+        INDEX idx_level (level)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+    `);
+        dbInitialized = true;
+    }
+    catch (err) {
+        console.error('Failed to initialize logs database:', err);
+        // Don't throw - allow the service to start even if logging DB fails
+    }
 }
 function log(level, message, meta) {
     let time = new Date().toISOString();
@@ -60,70 +107,212 @@ function log(level, message, meta) {
     }
     console.log(`${hhMMTime} [${level}]: ${message} ${meta}`);
 }
-function storeInDB(level, message, meta) {
-    if (!conn) {
-        console.error(`\x1b[31m[Logger DB Error] Logger not initialized. Call createLogger() first.\x1b[0m`);
+function formatStack(stack) {
+    if (!stack)
+        return '';
+    // Remove first line if it duplicates the error message already printed.
+    const lines = stack.split('\n');
+    if (lines.length > 1 && lines[0].startsWith('Error')) {
+        lines.shift();
+    }
+    // Grey color for stack lines
+    return lines.map(l => `\x1b[90m${l}\x1b[0m`).join('\n');
+}
+function extractFirstProjectFrame(stack) {
+    if (!stack)
+        return {};
+    const lines = stack.split('\n');
+    for (const l of lines) {
+        // Match: at FunctionName (/app/src/some/file.ts:123:45)
+        const m = l.match(/\(([^()]+\.ts):(\d+):(\d+)\)/);
+        if (m) {
+            return { file: m[1], line: parseInt(m[2], 10), column: parseInt(m[3], 10) };
+        }
+        // Alternate format: at /app/src/file.ts:123:45
+        const m2 = l.match(/\s(at\s)?([^()]+\.ts):(\d+):(\d+)/);
+        if (m2) {
+            return { file: m2[2], line: parseInt(m2[3], 10), column: parseInt(m2[4], 10) };
+        }
+    }
+    return {};
+}
+function buildCodeFrame(frame) {
+    if (!frame.file || frame.line == null)
+        return '';
+    try {
+        const filePath = frame.file.startsWith('/') ? frame.file : path.join(process.cwd(), frame.file);
+        if (!fs.existsSync(filePath))
+            return '';
+        const content = fs.readFileSync(filePath, 'utf8').split(/\r?\n/);
+        const start = Math.max(0, frame.line - 3);
+        const end = Math.min(content.length, frame.line + 2);
+        const lines = [];
+        for (let i = start; i < end; i++) {
+            const prefix = (i + 1 === frame.line) ? '\x1b[31m>\x1b[0m' : ' '; // highlight culprit line
+            const num = String(i + 1).padStart(4, ' ');
+            let codeLine = content[i];
+            if (i + 1 === frame.line && frame.column) {
+                // Add caret marker under column
+                const caretPad = ' '.repeat(frame.column - 1);
+                codeLine += `\n     ${caretPad}\x1b[31m^\x1b[0m`;
+            }
+            lines.push(`${prefix} ${num} | ${codeLine}`);
+        }
+        return lines.join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+function hasProjectTsFrame(stack) {
+    if (!stack)
+        return false;
+    return stack.split('\n').some(l => l.includes('/src/') && l.includes('.ts'));
+}
+function printStackEnhanced(possibleError) {
+    if (!possibleError)
+        return;
+    const stack = possibleError.stack;
+    if (typeof stack !== 'string')
         return;
+    let outputStack = stack;
+    if (process.env.ENV_ID === 'dev' && !hasProjectTsFrame(stack)) {
+        // Capture a callsite stack to show where logger.error was invoked
+        const callsite = new Error('__callsite__');
+        if (callsite.stack) {
+            const filtered = callsite.stack
+                .split('\n')
+                .filter(l => l.includes('/src/') && l.includes('.ts'))
+                .slice(0, 5) // keep it short
+                .join('\n');
+            if (filtered) {
+                outputStack += '\n\nCaptured callsite (added by logger):\n' + filtered;
+            }
+        }
     }
-    if (!meta)
-        meta = "";
-    // Use the logger's dedicated connection pool
-    conn.query((0, mysql_1.sql) `
-        INSERT INTO \`logs\` (\`level\`, \`message\`, \`meta\`, \`timestamp\`)
-        VALUES (${level}, ${message}, ${JSON.stringify(meta)}, NOW())
-    `).catch(err => {
-        // Log connection errors to console only, don't crash
-        console.error(`\x1b[31m[Logger DB Error] Failed to store log in DB:\x1b[0m ${err.message}`);
-        // Optionally check if it's a connection error vs. other query error
-        if (err.code && (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT')) {
-            console.warn(`\x1b[33m[Logger DB Warning] Logger DB connection failed (${err.code}). Is the DB ready?\x1b[0m`);
+    console.log(formatStack(outputStack));
+    if (process.env.ENV_ID === 'dev') {
+        const frame = extractFirstProjectFrame(outputStack);
+        const codeFrame = buildCodeFrame(frame);
+        if (codeFrame) {
+            console.log('\n\x1b[36mCode frame:\x1b[0m\n' + codeFrame + '\n');
         }
-    });
+    }
+}
+function buildCauseChain(err) {
+    const chain = [];
+    const visited = new Set();
+    let current = err;
+    while (current && typeof current === 'object' && !visited.has(current)) {
+        visited.add(current);
+        if (current !== err) {
+            const title = current.name ? `${current.name}: ${current.message}` : safeToStringMessage(current);
+            chain.push(title);
+        }
+        current = current.cause;
+    }
+    return chain;
+}
+function safeToStringMessage(message) {
+    if (typeof message === 'string')
+        return message;
+    if (message && typeof message === 'object') {
+        if (message.message && typeof message.message === 'string')
+            return message.message;
+        try {
+            return (0, fast_safe_stringify_1.default)(message).slice(0, 2000);
+        }
+        catch {
+            return String(message);
+        }
+    }
+    return String(message);
+}
+function safeMeta(meta) {
+    if (!meta)
+        return {};
+    return meta;
+}
+function storeInDB(level, message, meta) {
+    if (!conn || !dbInitialized) {
+        // Database not ready yet, skip DB logging
+        return;
+    }
+    try {
+        const msg = safeToStringMessage(message);
+        const metaObj = safeMeta(meta);
+        const metaStr = (0, fast_safe_stringify_1.default)(metaObj).slice(0, 2000);
+        // Fire and forget; avoid awaiting in hot path. Catch errors to avoid unhandled rejection.
+        conn.query((0, mysql_1.sql) `INSERT INTO \`logs\` (level, message, meta, timestamp) VALUES (${level}, ${msg}, ${metaStr}, NOW())`).catch(e => {
+            // fallback console output only - but don't spam
+            if (process.env.ENV_ID === 'dev') {
+                console.error('Failed to persist log to DB', e);
+            }
+        });
+    }
+    catch (e) {
+        console.error('Unexpected failure preparing log for DB', e);
+    }
 }
 function createLogger(config) {
-    initializeConnection(config);
+    // Start initialization asynchronously but don't wait for it
+    initializeConnection(config).catch(err => {
+        console.error('Error during log database initialization:', err);
+    });
     const logger = {
         info: (message, meta) => {
-            log("info", message, meta);
-            storeInDB("info", message, meta);
+            const metaObj = safeMeta(meta);
+            log('info', safeToStringMessage(message), metaObj);
+            storeInDB('info', message, metaObj);
         },
         error: (message, meta) => {
-            if (message.message && message.stack) {
-                // Pass the error message string, not the whole object, to storeInDB
-                storeInDB("error", message.message, meta);
-                return log("error", message.message, {
-                    stack: message.stack,
-                    ...meta,
-                });
+            const metaObj = safeMeta(meta);
+            if (message instanceof Error) {
+                const causeChain = buildCauseChain(message);
+                const enrichedMeta = { stack: message.stack, name: message.name, causeChain, ...metaObj };
+                log('error', message.message, enrichedMeta);
+                if (message.stack) {
+                    printStackEnhanced(message);
+                }
+                if (causeChain.length) {
+                    console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
+                }
+                storeInDB('error', message.message, enrichedMeta);
+                return;
             }
-            // If message is not an Error object, check if it's another type of object
-            const messageString = typeof message === 'object' && message !== null && !Array.isArray(message)
-                ? (0, fast_safe_stringify_1.default)(message) // Stringify if it's a plain object
-                : String(message); // Otherwise, convert to string as before
-            log("error", messageString, meta);
-            // Store the original message or its stringified form in DB
-            storeInDB("error", typeof message === 'object' ? (0, fast_safe_stringify_1.default)(message) : message, meta);
+            const msgStr = safeToStringMessage(message);
+            log('error', msgStr, metaObj);
+            printStackEnhanced(message);
+            storeInDB('error', msgStr, metaObj);
         },
         errorEnriched: (message, error, meta) => {
-            const enrichedMessage = `${message}: ${error.message}`;
-            if (error.message && error.stack) {
-                // Store the combined error message in the DB
-                storeInDB("error", enrichedMessage, meta);
-                return log("error", enrichedMessage, {
-                    stack: error.stack,
-                    ...meta,
-                });
+            const metaObj = safeMeta(meta);
+            if (error instanceof Error) {
+                const causeChain = buildCauseChain(error);
+                const enrichedMeta = { stack: error.stack, name: error.name, causeChain, ...metaObj };
+                log('error', `${message}: ${error.message}`, enrichedMeta);
+                if (error.stack) {
+                    printStackEnhanced(error);
+                }
+                if (causeChain.length) {
+                    console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
+                }
+                storeInDB('error', `${message}: ${error.message}`, enrichedMeta);
+                return;
             }
-            log("error", String(message), meta);
-            storeInDB("error", message, meta);
+            const errStr = safeToStringMessage(error);
+            log('error', `${message}: ${errStr}`, metaObj);
+            printStackEnhanced(error);
+            storeInDB('error', `${message}: ${errStr}`, metaObj);
         },
         warn: (message, meta) => {
-            log("warn", message, meta);
-            storeInDB("warn", message, meta);
+            const metaObj = safeMeta(meta);
+            log('warn', safeToStringMessage(message), metaObj);
+            storeInDB('warn', message, metaObj);
         },
         // do not store debug logs in DB
         debug: (message, meta) => {
-            log("debug", message, meta);
+            log('debug', safeToStringMessage(message), safeMeta(meta));
         },
     };
     const fastifyLogger = {
@@ -153,16 +342,46 @@ function createLogger(config) {
             const messageString = typeof msg === 'object' ? (0, fast_safe_stringify_1.default)(msg) : String(msg);
             log("error", messageString);
             storeInDB("error", messageString);
-            process.exit(1);
+            // Exit after a brief delay to allow logs to flush
+            setTimeout(() => process.exit(1), 100);
         },
         trace: (msg, ...args) => { },
         child: (bindings) => {
             return fastifyLogger;
         },
     };
-    // Set up uncaught exception handler
-    process.on("uncaughtException", function (err) {
-        logger.errorEnriched("UncaughtException processing: %s", err);
+    // Set up global exception handlers
+    process.on('uncaughtException', function (err) {
+        // Use console.error directly to ensure we see the error even if logger fails
+        console.error('=== UNCAUGHT EXCEPTION ===');
+        console.error(err);
+        if (err && err.stack) {
+            console.error(err.stack);
+        }
+        // Also try to log through logger if available
+        try {
+            logger.error('UncaughtException', err);
+        }
+        catch (logErr) {
+            console.error('Failed to log uncaught exception:', logErr);
+        }
+        // Exit after a brief delay to allow logs to flush
+        setTimeout(() => process.exit(1), 100);
+    });
+    process.on('unhandledRejection', function (reason) {
+        // Use console.error directly
+        console.error('=== UNHANDLED REJECTION ===');
+        console.error(reason);
+        if (reason && reason.stack) {
+            console.error(reason.stack);
+        }
+        // Also try to log through logger
+        try {
+            logger.error('UnhandledRejection', reason);
+        }
+        catch (logErr) {
+            console.error('Failed to log unhandled rejection:', logErr);
+        }
     });
     return { logger, fastifyLogger };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gratheon/log-lib",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "Logging library with console and MySQL database persistence",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@databases/mysql": "^6.0.0",
+    "@databases/mysql": "^7.0.0",
     "fast-safe-stringify": "^2.1.1"
   },
   "devDependencies": {

package/src/logger.ts

@@ -1,14 +1,63 @@
 import createConnectionPool, { sql, ConnectionPool } from "@databases/mysql";
 import jsonStringify from "fast-safe-stringify";
+import * as fs from 'fs';
+import * as path from 'path';
 import { LoggerConfig, Logger, FastifyLogger, LogMetadata } from "./types";
 
-let conn: ConnectionPool;
+let conn: ConnectionPool | null = null;
+let dbInitialized = false;
 
-function initializeConnection(config: LoggerConfig) {
-  const database = config.mysql.database || 'logs';
-  conn = createConnectionPool(
-    `mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/${database}`,
-  );
+async function initializeConnection(config: LoggerConfig) {
+  if (dbInitialized) return;
+  
+  try {
+    const database = config.mysql.database || 'logs';
+    
+    // First connect without database to create it if needed
+    const tempConn = createConnectionPool({
+      connectionString: `mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/?connectionLimit=1&waitForConnections=true`,
+      bigIntMode: 'number',
+    });
+    
+    await tempConn.query(sql`CREATE DATABASE IF NOT EXISTS \`${database}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;`);
+    await tempConn.dispose();
+    
+    // Now create the main connection pool with the logs database
+    conn = createConnectionPool({
+      connectionString: `mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/${database}?connectionLimit=3&waitForConnections=true`,
+      bigIntMode: 'number',
+      poolSize: 3,
+      maxUses: 200,
+      idleTimeoutMilliseconds: 30_000,
+      queueTimeoutMilliseconds: 60_000,
+      onError: (err) => {
+        // Suppress "packets out of order" and inactivity warnings
+        if (!err.message?.includes('packets out of order') && 
+            !err.message?.includes('inactivity') &&
+            !err.message?.includes('wait_timeout')) {
+          console.error(`MySQL logger connection pool error: ${err.message}`);
+        }
+      },
+    });
+    
+    // Create logs table if it doesn't exist
+    await conn.query(sql`
+      CREATE TABLE IF NOT EXISTS \`logs\` (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        level VARCHAR(50),
+        message TEXT,
+        meta TEXT,
+        timestamp DATETIME,
+        INDEX idx_timestamp (timestamp),
+        INDEX idx_level (level)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+    `);
+    
+    dbInitialized = true;
+  } catch (err) {
+    console.error('Failed to initialize logs database:', err);
+    // Don't throw - allow the service to start even if logging DB fails
+  }
 }
 
 function log(level: string, message: string, meta?: any) {
@@ -38,73 +87,208 @@ function log(level: string, message: string, meta?: any) {
   console.log(`${hhMMTime} [${level}]: ${message} ${meta}`);
 }
 
-function storeInDB(level: string, message: string, meta?: any) {
-  if (!conn) {
-    console.error(`\x1b[31m[Logger DB Error] Logger not initialized. Call createLogger() first.\x1b[0m`);
+function formatStack(stack?: string): string {
+  if (!stack) return '';
+  // Remove first line if it duplicates the error message already printed.
+  const lines = stack.split('\n');
+  if (lines.length > 1 && lines[0].startsWith('Error')) {
+    lines.shift();
+  }
+  // Grey color for stack lines
+  return lines.map(l => `\x1b[90m${l}\x1b[0m`).join('\n');
+}
+
+function extractFirstProjectFrame(stack?: string): {file?: string, line?: number, column?: number} {
+  if (!stack) return {};
+  const lines = stack.split('\n');
+  for (const l of lines) {
+    // Match: at FunctionName (/app/src/some/file.ts:123:45)
+    const m = l.match(/\(([^()]+\.ts):(\d+):(\d+)\)/);
+    if (m) {
+      return {file: m[1], line: parseInt(m[2], 10), column: parseInt(m[3], 10)};
+    }
+    // Alternate format: at /app/src/file.ts:123:45
+    const m2 = l.match(/\s(at\s)?([^()]+\.ts):(\d+):(\d+)/);
+    if (m2) {
+      return {file: m2[2], line: parseInt(m2[3], 10), column: parseInt(m2[4], 10)};
+    }
+  }
+  return {};
+}
+
+function buildCodeFrame(frame: {file?: string, line?: number, column?: number}): string {
+  if (!frame.file || frame.line == null) return '';
+  try {
+    const filePath = frame.file.startsWith('/') ? frame.file : path.join(process.cwd(), frame.file);
+    if (!fs.existsSync(filePath)) return '';
+    const content = fs.readFileSync(filePath, 'utf8').split(/\r?\n/);
+    const start = Math.max(0, frame.line - 3);
+    const end = Math.min(content.length, frame.line + 2);
+    const lines: string[] = [];
+    for (let i = start; i < end; i++) {
+      const prefix = (i + 1 === frame.line) ? '\x1b[31m>\x1b[0m' : ' '; // highlight culprit line
+      const num = String(i + 1).padStart(4,' ');
+      let codeLine = content[i];
+      if (i + 1 === frame.line && frame.column) {
+        // Add caret marker under column
+        const caretPad = ' '.repeat(frame.column - 1);
+        codeLine += `\n     ${caretPad}\x1b[31m^\x1b[0m`;
+      }
+      lines.push(`${prefix} ${num} | ${codeLine}`);
+    }
+    return lines.join('\n');
+  } catch {return '';}
+}
+
+function hasProjectTsFrame(stack?: string): boolean {
+  if (!stack) return false;
+  return stack.split('\n').some(l => l.includes('/src/') && l.includes('.ts'));
+}
+
+function printStackEnhanced(possibleError: any) {
+  if (!possibleError) return;
+  const stack = possibleError.stack;
+  if (typeof stack !== 'string') return;
+  let outputStack = stack;
+  if (process.env.ENV_ID === 'dev' && !hasProjectTsFrame(stack)) {
+    // Capture a callsite stack to show where logger.error was invoked
+    const callsite = new Error('__callsite__');
+    if (callsite.stack) {
+      const filtered = callsite.stack
+        .split('\n')
+        .filter(l => l.includes('/src/') && l.includes('.ts'))
+        .slice(0, 5) // keep it short
+        .join('\n');
+      if (filtered) {
+        outputStack += '\n\nCaptured callsite (added by logger):\n' + filtered;
+      }
+    }
+  }
+  console.log(formatStack(outputStack));
+  if (process.env.ENV_ID === 'dev') {
+    const frame = extractFirstProjectFrame(outputStack);
+    const codeFrame = buildCodeFrame(frame);
+    if (codeFrame) {
+      console.log('\n\x1b[36mCode frame:\x1b[0m\n' + codeFrame + '\n');
+    }
+  }
+}
+
+function buildCauseChain(err: any): string[] {
+  const chain: string[] = [];
+  const visited = new Set<any>();
+  let current = err;
+  while (current && typeof current === 'object' && !visited.has(current)) {
+    visited.add(current);
+    if (current !== err) {
+      const title = current.name ? `${current.name}: ${current.message}` : safeToStringMessage(current);
+      chain.push(title);
+    }
+    current = current.cause;
+  }
+  return chain;
+}
+
+function safeToStringMessage(message: any): string {
+  if (typeof message === 'string') return message;
+  if (message && typeof message === 'object') {
+    if (message.message && typeof message.message === 'string') return message.message;
+    try {
+      return jsonStringify(message).slice(0, 2000);
+    } catch {
+      return String(message);
+    }
+  }
+  return String(message);
+}
+
+function safeMeta(meta: any): any {
+  if (!meta) return {};
+  return meta;
+}
+
+function storeInDB(level: string, message: any, meta?: any) {
+  if (!conn || !dbInitialized) {
+    // Database not ready yet, skip DB logging
     return;
   }
-  
-  if (!meta) meta = "";
-  // Use the logger's dedicated connection pool
-  conn.query(sql`
-        INSERT INTO \`logs\` (\`level\`, \`message\`, \`meta\`, \`timestamp\`)
-        VALUES (${level}, ${message}, ${JSON.stringify(meta)}, NOW())
-    `).catch(err => {
-      // Log connection errors to console only, don't crash
-      console.error(`\x1b[31m[Logger DB Error] Failed to store log in DB:\x1b[0m ${err.message}`);
-      // Optionally check if it's a connection error vs. other query error
-      if (err.code && (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT')) {
-          console.warn(`\x1b[33m[Logger DB Warning] Logger DB connection failed (${err.code}). Is the DB ready?\x1b[0m`);
+  try {
+    const msg = safeToStringMessage(message);
+    const metaObj = safeMeta(meta);
+    const metaStr = jsonStringify(metaObj).slice(0, 2000);
+    // Fire and forget; avoid awaiting in hot path. Catch errors to avoid unhandled rejection.
+    conn.query(sql`INSERT INTO \`logs\` (level, message, meta, timestamp) VALUES (${level}, ${msg}, ${metaStr}, NOW())`).catch(e => {
+      // fallback console output only - but don't spam
+      if (process.env.ENV_ID === 'dev') {
+        console.error('Failed to persist log to DB', e);
       }
     });
+  } catch (e) {
+    console.error('Unexpected failure preparing log for DB', e);
+  }
 }
 
 export function createLogger(config: LoggerConfig): { logger: Logger; fastifyLogger: FastifyLogger } {
-  initializeConnection(config);
+  // Start initialization asynchronously but don't wait for it
+  initializeConnection(config).catch(err => {
+    console.error('Error during log database initialization:', err);
+  });
 
   const logger: Logger = {
     info: (message: string, meta?: LogMetadata) => {
-      log("info", message, meta);
-      storeInDB("info", message, meta);
+      const metaObj = safeMeta(meta);
+      log('info', safeToStringMessage(message), metaObj);
+      storeInDB('info', message, metaObj);
     },
     error: (message: string | Error | any, meta?: LogMetadata) => {
-      if (message.message && message.stack) {
-        // Pass the error message string, not the whole object, to storeInDB
-        storeInDB("error", message.message, meta);
-        return log("error", message.message, {
-          stack: message.stack,
-          ...meta,
-        });
+      const metaObj = safeMeta(meta);
+      if (message instanceof Error) {
+        const causeChain = buildCauseChain(message);
+        const enrichedMeta = {stack: message.stack, name: message.name, causeChain, ...metaObj};
+        log('error', message.message, enrichedMeta);
+        if (message.stack) {
+          printStackEnhanced(message);
+        }
+        if (causeChain.length) {
+          console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
+        }
+        storeInDB('error', message.message, enrichedMeta);
+        return;
       }
-      // If message is not an Error object, check if it's another type of object
-      const messageString = typeof message === 'object' && message !== null && !Array.isArray(message)
-        ? jsonStringify(message) // Stringify if it's a plain object
-        : String(message);      // Otherwise, convert to string as before
-      log("error", messageString, meta);
-      // Store the original message or its stringified form in DB
-      storeInDB("error", typeof message === 'object' ? jsonStringify(message) : message, meta);
+      const msgStr = safeToStringMessage(message);
+      log('error', msgStr, metaObj);
+      printStackEnhanced(message);
+      storeInDB('error', msgStr, metaObj);
     },
     errorEnriched: (message: string, error: Error | any, meta?: LogMetadata) => {
-      const enrichedMessage = `${message}: ${error.message}`;
-      if (error.message && error.stack) {
-        // Store the combined error message in the DB
-        storeInDB("error", enrichedMessage, meta);
-        return log("error", enrichedMessage, {
-          stack: error.stack,
-          ...meta,
-        });
+      const metaObj = safeMeta(meta);
+      if (error instanceof Error) {
+        const causeChain = buildCauseChain(error);
+        const enrichedMeta = {stack: error.stack, name: error.name, causeChain, ...metaObj};
+        log('error', `${message}: ${error.message}`, enrichedMeta);
+        if (error.stack) {
+          printStackEnhanced(error);
+        }
+        if (causeChain.length) {
+          console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
+        }
+        storeInDB('error', `${message}: ${error.message}`, enrichedMeta);
+        return;
       }
-      log("error", String(message), meta);
-      storeInDB("error", message, meta);
+      const errStr = safeToStringMessage(error);
+      log('error', `${message}: ${errStr}`, metaObj);
+      printStackEnhanced(error);
+      storeInDB('error', `${message}: ${errStr}`, metaObj);
     },
     warn: (message: string, meta?: LogMetadata) => {
-      log("warn", message, meta);
-      storeInDB("warn", message, meta);
+      const metaObj = safeMeta(meta);
+      log('warn', safeToStringMessage(message), metaObj);
+      storeInDB('warn', message, metaObj);
     },
 
     // do not store debug logs in DB
     debug: (message: string, meta?: LogMetadata) => {
-      log("debug", message, meta);
+      log('debug', safeToStringMessage(message), safeMeta(meta));
     },
   };
 
@@ -137,7 +321,8 @@ export function createLogger(config: LoggerConfig): { logger: Logger; fastifyLog
       const messageString = typeof msg === 'object' ? jsonStringify(msg) : String(msg);
       log("error", messageString);
       storeInDB("error", messageString);
-      process.exit(1);
+      // Exit after a brief delay to allow logs to flush
+      setTimeout(() => process.exit(1), 100);
     },
 
     trace: (msg: any, ...args: any[]) => {},
@@ -146,9 +331,37 @@ export function createLogger(config: LoggerConfig): { logger: Logger; fastifyLog
     },
   };
 
-  // Set up uncaught exception handler
-  process.on("uncaughtException", function (err) {
-    logger.errorEnriched("UncaughtException processing: %s", err);
+  // Set up global exception handlers
+  process.on('uncaughtException', function (err) {
+    // Use console.error directly to ensure we see the error even if logger fails
+    console.error('=== UNCAUGHT EXCEPTION ===');
+    console.error(err);
+    if (err && err.stack) {
+      console.error(err.stack);
+    }
+    // Also try to log through logger if available
+    try {
+      logger.error('UncaughtException', err);
+    } catch (logErr) {
+      console.error('Failed to log uncaught exception:', logErr);
+    }
+    // Exit after a brief delay to allow logs to flush
+    setTimeout(() => process.exit(1), 100);
+  });
+
+  process.on('unhandledRejection', function (reason: any) {
+    // Use console.error directly
+    console.error('=== UNHANDLED REJECTION ===');
+    console.error(reason);
+    if (reason && reason.stack) {
+      console.error(reason.stack);
+    }
+    // Also try to log through logger
+    try {
+      logger.error('UnhandledRejection', reason);
+    } catch (logErr) {
+      console.error('Failed to log unhandled rejection:', logErr);
+    }
   });
 
   return { logger, fastifyLogger };