@gratheon/log-lib 2.2.7 → 3.0.0

package/README.md

@@ -1,25 +1,24 @@
 # log-lib
 
-A TypeScript logging library with console output and MySQL database persistence support.
+A TypeScript logging library with console output and Loki persistence support.
 
 ## Features
 
-- **Dual Output**: Logs to both console and MySQL database
+- **Dual Output**: Logs to both console and Loki
 - **Color-Coded Console**: ANSI colored output for different log levels
 - **Automatic Stacktrace Capture**: Every log includes file:line information
   - **CLI Output**: Shows the most relevant TypeScript file:line in gray color
-  - **Database Storage**: Stores full stacktrace filtered to TypeScript files only
+  - **Loki Storage**: Stores full stacktrace filtered to TypeScript files only
 - **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
+- **Non-blocking Delivery**: App starts even if Loki is unavailable
+- **Service Labels**: Emits structured logs with `service`/`env` labels for Loki queries
 - **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
-- **Multiple Log Levels**: info, error, warn, debug (debug logs are not persisted to DB)
+- **Multiple Log Levels**: info, error, warn, debug (debug logs are not persisted)
 - **Log Level Filtering**: Configure minimum log level via config or LOG_LEVEL env var
 
 ## Installation
@@ -28,16 +27,13 @@ A TypeScript logging library with console output and MySQL database persistence
 npm install @gratheon/log-lib
 ```
 
-## Database Setup
+## Loki Setup
 
-The logger automatically creates the database and table on first initialization. No manual setup required!
+By default the logger pushes to `http://loki:3100/loki/api/v1/push`.
 
-**Automatic Migrations**: When updating from older versions, the logger automatically runs migrations on initialization:
-- Checks if the `stacktrace` column exists
-- Adds it if missing (for v2.2.0+ compatibility)
-- Non-blocking: app starts even if migration fails
-
-For reference, migration scripts are available in the `migrations/` directory.
+You can override with:
+- `config.loki.url`
+- `LOKI_URL` environment variable
 
 ## Usage
 
@@ -47,12 +43,10 @@ For reference, migration scripts are available in the `migrations/` directory.
 import { createLogger, LoggerConfig } from '@gratheon/log-lib';
 
 const config: LoggerConfig = {
-  mysql: {
-    host: 'localhost',
-    port: 3306,
-    user: 'your_user',
-    password: 'your_password',
-    database: 'logs' // optional, defaults to 'logs'
+  loki: {
+    url: 'http://loki:3100/loki/api/v1/push', // optional
+    service: 'user-cycle', // optional, defaults from env/current folder
+    labels: { team: 'platform' } // optional extra labels
   },
   logLevel: 'info' // optional, defaults to 'debug' in dev, 'info' in prod
 };
@@ -67,7 +61,7 @@ logger.warn('Low memory warning', { available: '100MB' });
 // Output: 12:34:56 [warn]: Low memory warning {"available":"100MB"} src/memory.ts:15
 
 logger.error('Failed to connect to API', { endpoint: '/api/users' });
-logger.debug('Processing item', { id: 123 }); // Not stored in DB
+logger.debug('Processing item', { id: 123 }); // Not persisted
 
 // Error with stack trace and code frame (in dev mode)
 try {
@@ -114,11 +108,9 @@ import Fastify from 'fastify';
 import { createLogger, LoggerConfig } from '@gratheon/log-lib';
 
 const config: LoggerConfig = {
-  mysql: {
-    host: 'localhost',
-    port: 3306,
-    user: 'your_user',
-    password: 'your_password'
+  loki: {
+    url: 'http://loki:3100/loki/api/v1/push',
+    service: 'my-fastify-service'
   }
 };
 
@@ -138,7 +130,7 @@ fastify.listen(3000);
 Creates and returns logger instances.
 
 **Parameters:**
-- `config`: Configuration object with MySQL connection details
+- `config`: Configuration object with Loki details
 
 **Returns:**
 ```typescript
@@ -151,16 +143,16 @@ Creates and returns logger instances.
 ### Logger Methods
 
 #### `logger.info(message: string, meta?: LogMetadata)`
-Logs informational messages (console + DB)
+Logs informational messages (console + Loki)
 
 #### `logger.error(message: string | Error, meta?: LogMetadata)`
-Logs errors with automatic Error object detection (console + DB)
+Logs errors with automatic Error object detection (console + Loki)
 
 #### `logger.errorEnriched(message: string, error: Error, meta?: LogMetadata)`
-Logs enriched error messages with context (console + DB)
+Logs enriched error messages with context (console + Loki)
 
 #### `logger.warn(message: string, meta?: LogMetadata)`
-Logs warning messages (console + DB)
+Logs warning messages (console + Loki)
 
 #### `logger.debug(message: string, meta?: LogMetadata)`
 Logs debug messages (console only, not persisted)
@@ -178,30 +170,16 @@ Compatible with Fastify's logger interface:
 
 ## Advanced Features
 
-### Connection Pool Configuration
+### Loki Delivery
 
-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
+The logger sends logs directly to Loki's HTTP push API (`/loki/api/v1/push`) in fire-and-forget mode.
 
 ### Message Truncation
 
-To prevent database bloat:
-- Messages are truncated to 2000 characters
-- Metadata is truncated to 2000 characters
+To control payload size:
+- Large log payloads are truncated before push
 - 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:
@@ -217,35 +195,24 @@ Set `ENV_ID` to control behavior:
 - **Warn**: Yellow (level) + Magenta (metadata) + Gray (file:line)
 - **File Location**: Gray (file:line) - automatically captured from call stack
 
-## Database Schema
-
-```sql
-CREATE TABLE `logs` (
-    `id`         int auto_increment primary key,
-    `level`      varchar(16)   not null,
-    `message`    varchar(2048) not null,
-    `meta`       varchar(2048) not null,
-    `stacktrace` text,
-    `timestamp`  datetime      not null
-);
-```
+## Loki Payload
 
-The `stacktrace` column stores the full call stack filtered to TypeScript files only, making it easy to trace the origin of each log entry.
+Each persisted entry is sent as JSON line data with:
+- `timestamp`
+- `level`
+- `service`
+- `message`
+- `meta`
+- `stacktrace`
 
 ## Error Handling
 
 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 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)
+- Loki delivery errors are logged but don't crash the application
+- Fire-and-forget Loki logging (no await in hot path)
 
 ### Enhanced Error Diagnostics
 - **Error Cause Chain**: Automatically traverses and displays `error.cause` chains
@@ -276,12 +243,14 @@ try {
 
 ```typescript
 interface LoggerConfig {
-  mysql?: {
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-    database?: string; // defaults to 'logs'
+  loki?: {
+    url?: string; // defaults to process.env.LOKI_URL or http://loki:3100/loki/api/v1/push
+    service?: string; // defaults to process.env.SERVICE_NAME or cwd folder name
+    labels?: Record<string, string>;
+    username?: string;
+    password?: string;
+    tenantId?: string;
+    enabled?: boolean;
   };
   logLevel?: LogLevel; // 'debug' | 'info' | 'warn' | 'error', defaults to 'debug' in dev, 'info' in prod
 }

package/dist/logger.js

@@ -28,13 +28,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLogger = void 0;
 require("source-map-support/register");
-const mysql_1 = __importStar(require("@databases/mysql"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
 const fast_safe_stringify_1 = __importDefault(require("fast-safe-stringify"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-let conn = null;
-let dbInitialized = false;
-let initPromise = null;
+let lokiConfig = null;
 const LOG_LEVELS = {
     debug: 0,
     info: 1,
@@ -66,71 +65,33 @@ function cleanStackTrace(stack) {
         });
     }).join('\n');
 }
-async function initializeConnection(config) {
-    if (dbInitialized || !config.mysql)
-        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 ${mysql_1.sql.ident(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,
-        stacktrace TEXT,
-        timestamp DATETIME,
-        INDEX idx_timestamp (timestamp),
-        INDEX idx_level (level)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-    `);
-        // Run migrations: Add stacktrace column if it doesn't exist (for existing tables created before v2.2.0)
-        try {
-            const columns = await conn.query((0, mysql_1.sql) `SHOW COLUMNS FROM \`logs\` LIKE 'stacktrace'`);
-            if (columns.length === 0) {
-                console.log('[log-lib] Running migration: Adding stacktrace column...');
-                await conn.query((0, mysql_1.sql) `ALTER TABLE \`logs\` ADD COLUMN \`stacktrace\` TEXT AFTER \`meta\``);
-                console.log('[log-lib] Migration complete: stacktrace column added');
-            }
-            else {
-                console.log('[log-lib] Migration check: stacktrace column already exists');
-            }
-        }
-        catch (migrationErr) {
-            console.error('[log-lib] Migration failed (non-critical):', migrationErr);
-            // Don't fail initialization if migration fails
-        }
-        dbInitialized = true;
-        console.log('[log-lib] Database initialization complete');
-    }
-    catch (err) {
-        console.error('Failed to initialize logs database:', err);
-        // Don't throw - allow the service to start even if logging DB fails
+function resolveLokiConfig(config) {
+    const explicit = config.loki ?? {};
+    const enabled = explicit.enabled ?? true;
+    if (!enabled) {
+        return null;
     }
+    const url = explicit.url || process.env.LOKI_URL || 'http://loki:3100/loki/api/v1/push';
+    const service = explicit.service ||
+        process.env.SERVICE_NAME ||
+        process.env.COMPOSE_SERVICE ||
+        process.env.npm_package_name ||
+        path.basename(process.cwd());
+    const labels = {
+        service,
+        env: process.env.ENV_ID || 'unknown',
+        logger: 'log-lib',
+        ...(explicit.labels || {}),
+    };
+    return {
+        enabled,
+        url,
+        service,
+        labels,
+        username: explicit.username,
+        password: explicit.password,
+        tenantId: explicit.tenantId,
+    };
 }
 function log(level, message, meta, fileLocation) {
     // Check if this log level should be filtered
@@ -316,40 +277,69 @@ function safeMeta(meta) {
         return {};
     return meta;
 }
-function storeInDB(level, message, meta, stacktrace) {
-    if (!conn) {
-        // Database not configured, skip DB logging
+function storeInLoki(level, message, meta, stacktrace) {
+    if (!lokiConfig || !lokiConfig.enabled) {
         return;
     }
-    // Wait for initialization to complete before writing
-    const doStore = async () => {
-        if (initPromise) {
-            await initPromise.catch(() => { }); // Wait but ignore errors
+    try {
+        const nowNs = `${Date.now()}000000`;
+        const payloadObject = {
+            timestamp: new Date().toISOString(),
+            level,
+            service: lokiConfig.service,
+            message: safeToStringMessage(message),
+            meta: safeMeta(meta),
+            stacktrace: stacktrace || '',
+        };
+        const line = (0, fast_safe_stringify_1.default)(payloadObject).slice(0, 120000);
+        const body = (0, fast_safe_stringify_1.default)({
+            streams: [
+                {
+                    stream: lokiConfig.labels,
+                    values: [[nowNs, line]],
+                },
+            ],
+        });
+        const target = new URL(lokiConfig.url);
+        const isHttps = target.protocol === 'https:';
+        const client = isHttps ? https : http;
+        const headers = {
+            'content-type': 'application/json',
+            'content-length': Buffer.byteLength(body).toString(),
+        };
+        if (lokiConfig.tenantId) {
+            headers['X-Scope-OrgID'] = lokiConfig.tenantId;
         }
-        if (!dbInitialized) {
-            // Initialization failed, skip DB logging
-            return;
+        if (lokiConfig.username && lokiConfig.password) {
+            const basic = Buffer.from(`${lokiConfig.username}:${lokiConfig.password}`).toString('base64');
+            headers['authorization'] = `Basic ${basic}`;
         }
-        try {
-            const msg = safeToStringMessage(message);
-            const metaObj = safeMeta(meta);
-            const metaStr = (0, fast_safe_stringify_1.default)(metaObj).slice(0, 2000);
-            const stackStr = stacktrace || '';
-            await conn.query((0, mysql_1.sql) `INSERT INTO \`logs\` (level, message, meta, stacktrace, timestamp) VALUES (${level}, ${msg}, ${metaStr}, ${stackStr}, NOW())`);
-        }
-        catch (e) {
-            // fallback console output only - but don't spam
+        const req = client.request({
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port || (isHttps ? 443 : 80),
+            path: `${target.pathname}${target.search}`,
+            method: 'POST',
+            headers,
+        }, (res) => {
+            if (res.statusCode && res.statusCode >= 400 && process.env.ENV_ID === 'dev') {
+                console.error(`[log-lib] Failed to persist log to Loki: HTTP ${res.statusCode}`);
+            }
+            res.resume();
+        });
+        req.on('error', (e) => {
             if (process.env.ENV_ID === 'dev') {
-                console.error('Failed to persist log to DB', e);
+                console.error('[log-lib] Failed to persist log to Loki', e?.message || e);
             }
-        }
-    };
-    // Fire and forget
-    doStore().catch(e => {
+        });
+        req.write(body);
+        req.end();
+    }
+    catch (e) {
         if (process.env.ENV_ID === 'dev') {
-            console.error('Unexpected failure preparing log for DB', e);
+            console.error('[log-lib] Unexpected failure preparing log for Loki', e?.message || e);
         }
-    });
+    }
 }
 function createLogger(config = {}) {
     // Set up log level filtering
@@ -358,9 +348,9 @@ function createLogger(config = {}) {
         process.env.LOG_LEVEL ||
         (process.env.ENV_ID === 'dev' ? 'debug' : 'info');
     currentLogLevel = LOG_LEVELS[configuredLevel] ?? LOG_LEVELS.info;
-    // Start initialization asynchronously (only if MySQL config provided)
-    if (config.mysql) {
-        initPromise = initializeConnection(config);
+    lokiConfig = resolveLokiConfig(config);
+    if (config.mysql && process.env.ENV_ID === 'dev') {
+        console.warn('[log-lib] `config.mysql` is deprecated and ignored. Logs are persisted to Loki.');
     }
     const logger = {
         info: (message, meta) => {
@@ -370,7 +360,7 @@ function createLogger(config = {}) {
             const frame = extractFirstProjectFrame(callStack);
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log('info', safeToStringMessage(message), metaObj, fileLocation);
-            storeInDB('info', message, metaObj, fullTsStack);
+            storeInLoki('info', message, metaObj, fullTsStack);
         },
         error: (message, meta) => {
             const metaObj = safeMeta(meta);
@@ -387,9 +377,9 @@ function createLogger(config = {}) {
                 if (causeChain.length) {
                     console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
                 }
-                // For DB: include stack and error details in metadata
+                // For Loki: include stack and error details in metadata
                 const enrichedMeta = { stack: message.stack, name: message.name, causeChain, ...metaObj };
-                storeInDB('error', message.message, enrichedMeta, fullTsStack);
+                storeInLoki('error', message.message, enrichedMeta, fullTsStack);
                 return;
             }
             const msgStr = safeToStringMessage(message);
@@ -399,7 +389,7 @@ function createLogger(config = {}) {
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log('error', msgStr, metaObj, fileLocation);
             printStackEnhanced(message);
-            storeInDB('error', msgStr, metaObj, fullTsStack);
+            storeInLoki('error', msgStr, metaObj, fullTsStack);
         },
         errorEnriched: (message, error, meta) => {
             const metaObj = safeMeta(meta);
@@ -416,9 +406,9 @@ function createLogger(config = {}) {
                 if (causeChain.length) {
                     console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
                 }
-                // For DB: include stack and error details in metadata
+                // For Loki: include stack and error details in metadata
                 const enrichedMeta = { stack: error.stack, name: error.name, causeChain, ...metaObj };
-                storeInDB('error', `${message}: ${error.message}`, enrichedMeta, fullTsStack);
+                storeInLoki('error', `${message}: ${error.message}`, enrichedMeta, fullTsStack);
                 return;
             }
             const errStr = safeToStringMessage(error);
@@ -428,7 +418,7 @@ function createLogger(config = {}) {
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log('error', `${message}: ${errStr}`, metaObj, fileLocation);
             printStackEnhanced(error);
-            storeInDB('error', `${message}: ${errStr}`, metaObj, fullTsStack);
+            storeInLoki('error', `${message}: ${errStr}`, metaObj, fullTsStack);
         },
         warn: (message, meta) => {
             const metaObj = safeMeta(meta);
@@ -437,7 +427,7 @@ function createLogger(config = {}) {
             const frame = extractFirstProjectFrame(callStack);
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log('warn', safeToStringMessage(message), metaObj, fileLocation);
-            storeInDB('warn', message, metaObj, fullTsStack);
+            storeInLoki('warn', message, metaObj, fullTsStack);
         },
         // do not store debug logs in DB
         debug: (message, meta) => {
@@ -455,7 +445,7 @@ function createLogger(config = {}) {
             const frame = extractFirstProjectFrame(callStack);
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log("info", messageString, undefined, fileLocation);
-            // storeInDB("info", messageString); // Keep commented out as original
+            storeInLoki("info", messageString);
         },
         error: (msg, ...args) => {
             const errorMessage = (msg && msg.message) ? msg.message : String(msg);
@@ -465,8 +455,7 @@ function createLogger(config = {}) {
             const frame = extractFirstProjectFrame(callStack);
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log("error", errorMessage, meta, fileLocation);
-            // Ensure string is passed to storeInDB
-            storeInDB("error", typeof msg === 'object' ? (0, fast_safe_stringify_1.default)(msg) : errorMessage, meta, fullTsStack);
+            storeInLoki("error", typeof msg === 'object' ? (0, fast_safe_stringify_1.default)(msg) : errorMessage, meta, fullTsStack);
         },
         warn: (msg, ...args) => {
             const messageString = typeof msg === 'object' ? (0, fast_safe_stringify_1.default)(msg) : String(msg);
@@ -475,7 +464,7 @@ function createLogger(config = {}) {
             const frame = extractFirstProjectFrame(callStack);
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log("warn", messageString, undefined, fileLocation);
-            storeInDB("warn", messageString, undefined, fullTsStack); // Pass stringified message
+            storeInLoki("warn", messageString, undefined, fullTsStack);
         },
         // do not store debug logs in DB
         debug: (msg, ...args) => {
@@ -491,7 +480,7 @@ function createLogger(config = {}) {
             const frame = extractFirstProjectFrame(callStack);
             const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
             log("error", messageString, undefined, fileLocation);
-            storeInDB("error", messageString, undefined, fullTsStack);
+            storeInLoki("error", messageString, undefined, fullTsStack);
             // Exit after a brief delay to allow logs to flush
             setTimeout(() => process.exit(1), 100);
         },

package/dist/types.d.ts

@@ -1,5 +1,19 @@
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LokiConfig {
+    url?: string;
+    username?: string;
+    password?: string;
+    tenantId?: string;
+    service?: string;
+    labels?: Record<string, string>;
+    enabled?: boolean;
+}
 export interface LoggerConfig {
+    loki?: LokiConfig;
+    /**
+     * @deprecated MySQL persistence has been replaced by Loki.
+     * Kept only for backward compatibility and ignored.
+     */
     mysql?: {
         host: string;
         port: number;

package/example.ts

@@ -2,13 +2,11 @@ import { createLogger, LoggerConfig } from './src/index';
 
 // Example configuration
 const config: LoggerConfig = {
-  mysql: {
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: 'test',
-    database: 'logs' // optional, defaults to 'logs'
-  }
+  loki: {
+    url: 'http://loki:3100/loki/api/v1/push',
+    service: 'example-service'
+  },
+  logLevel: 'info'
 };
 
 // Create logger instances

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gratheon/log-lib",
-  "version": "2.2.7",
-  "description": "Logging library with console and MySQL database persistence",
+  "version": "3.0.0",
+  "description": "Logging library with console output and Loki persistence",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -12,13 +12,12 @@
   "keywords": [
     "logging",
     "logger",
-    "mysql",
+    "loki",
     "typescript"
   ],
-  "author": "",
+  "author": "Artjom Kurapov",
   "license": "ISC",
   "dependencies": {
-    "@databases/mysql": "^7.0.0",
     "fast-safe-stringify": "^2.1.1",
     "source-map-support": "^0.5.21"
   },

package/src/logger.ts

@@ -1,13 +1,22 @@
 import 'source-map-support/register';
-import createConnectionPool, { sql, ConnectionPool } from "@databases/mysql";
+import * as http from 'http';
+import * as https from 'https';
 import jsonStringify from "fast-safe-stringify";
 import * as fs from 'fs';
 import * as path from 'path';
 import { LoggerConfig, Logger, FastifyLogger, LogMetadata, LogLevel } from "./types";
 
-let conn: ConnectionPool | null = null;
-let dbInitialized = false;
-let initPromise: Promise<void> | null = null;
+type LokiRuntimeConfig = {
+  enabled: boolean;
+  url: string;
+  service: string;
+  labels: Record<string, string>;
+  username?: string;
+  password?: string;
+  tenantId?: string;
+};
+
+let lokiConfig: LokiRuntimeConfig | null = null;
 
 const LOG_LEVELS: Record<LogLevel, number> = {
   debug: 0,
@@ -45,74 +54,37 @@ function cleanStackTrace(stack: string): string {
   }).join('\n');
 }
 
-async function initializeConnection(config: LoggerConfig) {
-  if (dbInitialized || !config.mysql) 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 ${sql.ident(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,
-        stacktrace TEXT,
-        timestamp DATETIME,
-        INDEX idx_timestamp (timestamp),
-        INDEX idx_level (level)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
-    `);
-    
-    // Run migrations: Add stacktrace column if it doesn't exist (for existing tables created before v2.2.0)
-    try {
-      const columns = await conn.query(sql`SHOW COLUMNS FROM \`logs\` LIKE 'stacktrace'`);
-      if (columns.length === 0) {
-        console.log('[log-lib] Running migration: Adding stacktrace column...');
-        await conn.query(sql`ALTER TABLE \`logs\` ADD COLUMN \`stacktrace\` TEXT AFTER \`meta\``);
-        console.log('[log-lib] Migration complete: stacktrace column added');
-      } else {
-        console.log('[log-lib] Migration check: stacktrace column already exists');
-      }
-    } catch (migrationErr) {
-      console.error('[log-lib] Migration failed (non-critical):', migrationErr);
-      // Don't fail initialization if migration fails
-    }
-    
-    dbInitialized = true;
-    console.log('[log-lib] Database initialization complete');
-  } catch (err) {
-    console.error('Failed to initialize logs database:', err);
-    // Don't throw - allow the service to start even if logging DB fails
+function resolveLokiConfig(config: LoggerConfig): LokiRuntimeConfig | null {
+  const explicit = config.loki ?? {};
+  const enabled = explicit.enabled ?? true;
+  if (!enabled) {
+    return null;
   }
+
+  const url = explicit.url || process.env.LOKI_URL || 'http://loki:3100/loki/api/v1/push';
+  const service =
+    explicit.service ||
+    process.env.SERVICE_NAME ||
+    process.env.COMPOSE_SERVICE ||
+    process.env.npm_package_name ||
+    path.basename(process.cwd());
+
+  const labels: Record<string, string> = {
+    service,
+    env: process.env.ENV_ID || 'unknown',
+    logger: 'log-lib',
+    ...(explicit.labels || {}),
+  };
+
+  return {
+    enabled,
+    url,
+    service,
+    labels,
+    username: explicit.username,
+    password: explicit.password,
+    tenantId: explicit.tenantId,
+  };
 }
 
 function log(level: string, message: string, meta?: any, fileLocation?: string) {
@@ -297,44 +269,78 @@ function safeMeta(meta: any): any {
   return meta;
 }
 
-function storeInDB(level: string, message: any, meta?: any, stacktrace?: string) {
-  if (!conn) {
-    // Database not configured, skip DB logging
+function storeInLoki(level: LogLevel, message: any, meta?: any, stacktrace?: string) {
+  if (!lokiConfig || !lokiConfig.enabled) {
     return;
   }
-  
-  // Wait for initialization to complete before writing
-  const doStore = async () => {
-    if (initPromise) {
-      await initPromise.catch(() => {}); // Wait but ignore errors
+
+  try {
+    const nowNs = `${Date.now()}000000`;
+    const payloadObject = {
+      timestamp: new Date().toISOString(),
+      level,
+      service: lokiConfig.service,
+      message: safeToStringMessage(message),
+      meta: safeMeta(meta),
+      stacktrace: stacktrace || '',
+    };
+
+    const line = jsonStringify(payloadObject).slice(0, 120_000);
+    const body = jsonStringify({
+      streams: [
+        {
+          stream: lokiConfig.labels,
+          values: [[nowNs, line]],
+        },
+      ],
+    });
+
+    const target = new URL(lokiConfig.url);
+    const isHttps = target.protocol === 'https:';
+    const client = isHttps ? https : http;
+    const headers: Record<string, string> = {
+      'content-type': 'application/json',
+      'content-length': Buffer.byteLength(body).toString(),
+    };
+
+    if (lokiConfig.tenantId) {
+      headers['X-Scope-OrgID'] = lokiConfig.tenantId;
     }
-    
-    if (!dbInitialized) {
-      // Initialization failed, skip DB logging
-      return;
+    if (lokiConfig.username && lokiConfig.password) {
+      const basic = Buffer.from(`${lokiConfig.username}:${lokiConfig.password}`).toString('base64');
+      headers['authorization'] = `Basic ${basic}`;
     }
-    
-    try {
-      const msg = safeToStringMessage(message);
-      const metaObj = safeMeta(meta);
-      const metaStr = jsonStringify(metaObj).slice(0, 2000);
-      const stackStr = stacktrace || '';
-      
-      await conn!.query(sql`INSERT INTO \`logs\` (level, message, meta, stacktrace, timestamp) VALUES (${level}, ${msg}, ${metaStr}, ${stackStr}, NOW())`);
-    } catch (e: any) {
-      // fallback console output only - but don't spam
+
+    const req = client.request(
+      {
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port || (isHttps ? 443 : 80),
+        path: `${target.pathname}${target.search}`,
+        method: 'POST',
+        headers,
+      },
+      (res) => {
+        if (res.statusCode && res.statusCode >= 400 && process.env.ENV_ID === 'dev') {
+          console.error(`[log-lib] Failed to persist log to Loki: HTTP ${res.statusCode}`);
+        }
+        res.resume();
+      }
+    );
+
+    req.on('error', (e: any) => {
       if (process.env.ENV_ID === 'dev') {
-        console.error('Failed to persist log to DB', e);
+        console.error('[log-lib] Failed to persist log to Loki', e?.message || e);
       }
-    }
-  };
-  
-  // Fire and forget
-  doStore().catch(e => {
+    });
+
+    req.write(body);
+    req.end();
+  } catch (e: any) {
     if (process.env.ENV_ID === 'dev') {
-      console.error('Unexpected failure preparing log for DB', e);
+      console.error('[log-lib] Unexpected failure preparing log for Loki', e?.message || e);
     }
-  });
+  }
 }
 
 export function createLogger(config: LoggerConfig = {}): { logger: Logger; fastifyLogger: FastifyLogger } {
@@ -346,9 +352,9 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
   
   currentLogLevel = LOG_LEVELS[configuredLevel] ?? LOG_LEVELS.info;
   
-  // Start initialization asynchronously (only if MySQL config provided)
-  if (config.mysql) {
-    initPromise = initializeConnection(config);
+  lokiConfig = resolveLokiConfig(config);
+  if (config.mysql && process.env.ENV_ID === 'dev') {
+    console.warn('[log-lib] `config.mysql` is deprecated and ignored. Logs are persisted to Loki.');
   }
 
   const logger: Logger = {
@@ -360,7 +366,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
       
       log('info', safeToStringMessage(message), metaObj, fileLocation);
-      storeInDB('info', message, metaObj, fullTsStack);
+      storeInLoki('info', message, metaObj, fullTsStack);
     },
     error: (message: string | Error | any, meta?: LogMetadata) => {
       const metaObj = safeMeta(meta);
@@ -379,9 +385,9 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
           console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
         }
         
-        // For DB: include stack and error details in metadata
+        // For Loki: include stack and error details in metadata
         const enrichedMeta = {stack: message.stack, name: message.name, causeChain, ...metaObj};
-        storeInDB('error', message.message, enrichedMeta, fullTsStack);
+        storeInLoki('error', message.message, enrichedMeta, fullTsStack);
         return;
       }
       const msgStr = safeToStringMessage(message);
@@ -392,7 +398,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       
       log('error', msgStr, metaObj, fileLocation);
       printStackEnhanced(message);
-      storeInDB('error', msgStr, metaObj, fullTsStack);
+      storeInLoki('error', msgStr, metaObj, fullTsStack);
     },
     errorEnriched: (message: string, error: Error | any, meta?: LogMetadata) => {
       const metaObj = safeMeta(meta);
@@ -411,9 +417,9 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
           console.log('\x1b[35mCause chain:\x1b[0m ' + causeChain.join(' -> '));
         }
         
-        // For DB: include stack and error details in metadata
+        // For Loki: include stack and error details in metadata
         const enrichedMeta = {stack: error.stack, name: error.name, causeChain, ...metaObj};
-        storeInDB('error', `${message}: ${error.message}`, enrichedMeta, fullTsStack);
+        storeInLoki('error', `${message}: ${error.message}`, enrichedMeta, fullTsStack);
         return;
       }
       const errStr = safeToStringMessage(error);
@@ -424,7 +430,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       
       log('error', `${message}: ${errStr}`, metaObj, fileLocation);
       printStackEnhanced(error);
-      storeInDB('error', `${message}: ${errStr}`, metaObj, fullTsStack);
+      storeInLoki('error', `${message}: ${errStr}`, metaObj, fullTsStack);
     },
     warn: (message: string, meta?: LogMetadata) => {
       const metaObj = safeMeta(meta);
@@ -434,7 +440,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
       
       log('warn', safeToStringMessage(message), metaObj, fileLocation);
-      storeInDB('warn', message, metaObj, fullTsStack);
+      storeInLoki('warn', message, metaObj, fullTsStack);
     },
 
     // do not store debug logs in DB
@@ -456,7 +462,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
       
       log("info", messageString, undefined, fileLocation);
-      // storeInDB("info", messageString); // Keep commented out as original
+      storeInLoki("info", messageString);
     },
     error: (msg: any, ...args: any[]) => {
       const errorMessage = (msg && msg.message) ? msg.message : String(msg);
@@ -467,8 +473,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
       
       log("error", errorMessage, meta, fileLocation);
-      // Ensure string is passed to storeInDB
-      storeInDB("error", typeof msg === 'object' ? jsonStringify(msg) : errorMessage, meta, fullTsStack);
+      storeInLoki("error", typeof msg === 'object' ? jsonStringify(msg) : errorMessage, meta, fullTsStack);
     },
     warn: (msg: any, ...args: any[]) => {
       const messageString = typeof msg === 'object' ? jsonStringify(msg) : String(msg);
@@ -478,7 +483,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
       
       log("warn", messageString, undefined, fileLocation);
-      storeInDB("warn", messageString, undefined, fullTsStack); // Pass stringified message
+      storeInLoki("warn", messageString, undefined, fullTsStack);
     },
 
     // do not store debug logs in DB
@@ -498,7 +503,7 @@ export function createLogger(config: LoggerConfig = {}): { logger: Logger; fasti
       const fileLocation = frame.file && frame.line ? `${frame.file}:${frame.line}` : undefined;
       
       log("error", messageString, undefined, fileLocation);
-      storeInDB("error", messageString, undefined, fullTsStack);
+      storeInLoki("error", messageString, undefined, fullTsStack);
       // Exit after a brief delay to allow logs to flush
       setTimeout(() => process.exit(1), 100);
     },

package/src/types.ts

@@ -1,6 +1,21 @@
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 
+export interface LokiConfig {
+  url?: string; // defaults to process.env.LOKI_URL or http://loki:3100/loki/api/v1/push
+  username?: string;
+  password?: string;
+  tenantId?: string;
+  service?: string; // defaults to process.env.SERVICE_NAME or current folder name
+  labels?: Record<string, string>;
+  enabled?: boolean; // defaults to true
+}
+
 export interface LoggerConfig {
+  loki?: LokiConfig;
+  /**
+   * @deprecated MySQL persistence has been replaced by Loki.
+   * Kept only for backward compatibility and ignored.
+   */
   mysql?: {
     host: string;
     port: number;