@swirepay-developer/common-logging-nodejs 1.0.0

package/README.md

@@ -0,0 +1,37 @@
+# Swirepay Common Logging - Node.js SDK
+
+## Installation
+
+```bash
+npm install @swirepay/common-logging-nodejs
+```
+
+## Quick Start
+
+```javascript
+const { initializeLogger, getLogger } = require('@swirepay/common-logging-nodejs');
+
+// OpenTelemetry is automatically initialized
+initializeLogger({
+  environment: 'staging',
+  serviceName: 'my-service',
+  serviceVersion: '1.0.0',
+});
+
+const logger = getLogger();
+logger.info('Service started');
+```
+
+## Complete Documentation
+
+See [../USAGE_GUIDE.md](../USAGE_GUIDE.md) for complete examples including:
+- Basic logging
+- Express.js integration
+- API call logging
+- Request logging
+- Webhook logging
+- TypeScript examples
+
+## License
+
+Proprietary - Swirepay

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+export interface LoggingConfig {
+    environment: 'staging' | 'production';
+    serviceName: string;
+    serviceVersion: string;
+    lokiUrl?: string;
+    enableConsole?: boolean;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+}
+export declare function getLokiUrl(environment: 'staging' | 'production'): string;
+export declare function getDefaultConfig(): Partial<LoggingConfig>;

package/dist/config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLokiUrl = getLokiUrl;
+exports.getDefaultConfig = getDefaultConfig;
+const STAG_LOKI_URL = 'https://stag-loki.swirepay.com:443/loki/api/v1/push';
+const PROD_LOKI_URL = 'https://loki.swirepay.com:443/loki/api/v1/push';
+function getLokiUrl(environment) {
+    return environment === 'production' ? PROD_LOKI_URL : STAG_LOKI_URL;
+}
+function getDefaultConfig() {
+    return {
+        environment: process.env.ENVIRONMENT || 'staging',
+        serviceName: process.env.SERVICE_NAME || 'swirepay-service',
+        serviceVersion: process.env.SERVICE_VERSION || '1.0.0',
+        enableConsole: process.env.ENABLE_CONSOLE_LOG === 'true',
+        logLevel: process.env.LOG_LEVEL || 'info',
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { SwirepayLogger, initializeLogger, getLogger, TraceContext } from './logger';
+export { LoggingConfig, getLokiUrl, getDefaultConfig } from './config';
+export { LokiTransport } from './loki-transport';
+export { OTEL_ENDPOINTS, getOtelEndpoint } from './otel-config';
+export { initOpenTelemetry, OpenTelemetryConfig } from './otel-init';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initOpenTelemetry = exports.getOtelEndpoint = exports.OTEL_ENDPOINTS = exports.LokiTransport = exports.getDefaultConfig = exports.getLokiUrl = exports.getLogger = exports.initializeLogger = exports.SwirepayLogger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "SwirepayLogger", { enumerable: true, get: function () { return logger_1.SwirepayLogger; } });
+Object.defineProperty(exports, "initializeLogger", { enumerable: true, get: function () { return logger_1.initializeLogger; } });
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return logger_1.getLogger; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "getLokiUrl", { enumerable: true, get: function () { return config_1.getLokiUrl; } });
+Object.defineProperty(exports, "getDefaultConfig", { enumerable: true, get: function () { return config_1.getDefaultConfig; } });
+var loki_transport_1 = require("./loki-transport");
+Object.defineProperty(exports, "LokiTransport", { enumerable: true, get: function () { return loki_transport_1.LokiTransport; } });
+var otel_config_1 = require("./otel-config");
+Object.defineProperty(exports, "OTEL_ENDPOINTS", { enumerable: true, get: function () { return otel_config_1.OTEL_ENDPOINTS; } });
+Object.defineProperty(exports, "getOtelEndpoint", { enumerable: true, get: function () { return otel_config_1.getOtelEndpoint; } });
+var otel_init_1 = require("./otel-init");
+Object.defineProperty(exports, "initOpenTelemetry", { enumerable: true, get: function () { return otel_init_1.initOpenTelemetry; } });

package/dist/logger.d.ts

@@ -0,0 +1,64 @@
+import { LoggingConfig } from './config';
+export interface TraceContext {
+    traceId: string;
+    spanId: string;
+}
+export declare class SwirepayLogger {
+    private logger;
+    private config;
+    constructor(config?: Partial<LoggingConfig>);
+    /**
+     * Generate a new trace context with unique trace-id and span-id
+     * @returns New trace context with 32-char hex trace-id and 16-char hex span-id
+     */
+    generateTraceContext(): TraceContext;
+    /**
+     * Get trace context from OpenTelemetry active span or create a new span
+     * @param customTraceContext Optional custom trace context to use instead of OpenTelemetry
+     * @returns Trace context object
+     */
+    private getTraceContext;
+    private log;
+    debug(message: string, meta?: any, traceContext?: TraceContext): void;
+    info(message: string, meta?: any, traceContext?: TraceContext): void;
+    warn(message: string, meta?: any, traceContext?: TraceContext): void;
+    error(message: string, error?: Error | any, meta?: any, traceContext?: TraceContext): void;
+    logApiCall(options: {
+        method: string;
+        url: string;
+        statusCode?: number;
+        duration?: number;
+        requestBody?: any;
+        responseBody?: any;
+        headers?: Record<string, string>;
+        error?: Error;
+        traceContext?: TraceContext;
+    }): void;
+    logRequest(options: {
+        method: string;
+        path: string;
+        statusCode?: number;
+        duration?: number;
+        userId?: string;
+        ip?: string;
+        userAgent?: string;
+        requestBody?: any;
+        responseBody?: any;
+        headers?: Record<string, string>;
+        error?: Error;
+        traceContext?: TraceContext;
+    }): void;
+    logWebhook(options: {
+        source: string;
+        event: string;
+        webhookId?: string;
+        status: 'received' | 'processed' | 'failed';
+        payload?: any;
+        error?: Error;
+        processingTime?: number;
+        traceContext?: TraceContext;
+    }): void;
+    private sanitizeBody;
+}
+export declare function initializeLogger(config?: Partial<LoggingConfig>): SwirepayLogger;
+export declare function getLogger(): SwirepayLogger;

package/dist/logger.js

@@ -0,0 +1,305 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwirepayLogger = void 0;
+exports.initializeLogger = initializeLogger;
+exports.getLogger = getLogger;
+const winston_1 = __importDefault(require("winston"));
+const config_1 = require("./config");
+const loki_transport_1 = require("./loki-transport");
+const otel_transport_1 = require("./otel-transport");
+const api_1 = require("@opentelemetry/api");
+const otel_init_1 = require("./otel-init");
+const crypto_1 = require("crypto");
+class SwirepayLogger {
+    constructor(config = {}) {
+        const defaultConfig = (0, config_1.getDefaultConfig)();
+        this.config = { ...defaultConfig, ...config };
+        const lokiUrl = this.config.lokiUrl || (0, config_1.getLokiUrl)(this.config.environment);
+        const transports = [
+            // Always send to Loki
+            new loki_transport_1.LokiTransport({
+                lokiUrl,
+                environment: this.config.environment,
+                serviceName: this.config.serviceName,
+                serviceVersion: this.config.serviceVersion,
+            }),
+            // Automatically send to OpenTelemetry if initialized
+            new otel_transport_1.OtelTransport({
+                environment: this.config.environment,
+                serviceName: this.config.serviceName,
+                serviceVersion: this.config.serviceVersion,
+            }),
+        ];
+        if (this.config.enableConsole) {
+            transports.push(new winston_1.default.transports.Console({
+                format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
+            }));
+        }
+        this.logger = winston_1.default.createLogger({
+            level: this.config.logLevel || 'info',
+            format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
+            transports,
+            defaultMeta: {
+                service: this.config.serviceName,
+                version: this.config.serviceVersion,
+                environment: this.config.environment,
+            },
+        });
+    }
+    /**
+     * Generate a new trace context with unique trace-id and span-id
+     * @returns New trace context with 32-char hex trace-id and 16-char hex span-id
+     */
+    generateTraceContext() {
+        return {
+            traceId: (0, crypto_1.randomBytes)(16).toString('hex'), // 32 character hex string
+            spanId: (0, crypto_1.randomBytes)(8).toString('hex'), // 16 character hex string
+        };
+    }
+    /**
+     * Get trace context from OpenTelemetry active span or create a new span
+     * @param customTraceContext Optional custom trace context to use instead of OpenTelemetry
+     * @returns Trace context object
+     */
+    getTraceContext(customTraceContext) {
+        // If custom trace context is provided, use it
+        if (customTraceContext) {
+            return customTraceContext;
+        }
+        // Try to get from OpenTelemetry active span
+        const activeSpan = api_1.trace.getActiveSpan();
+        if (activeSpan) {
+            const spanContext = activeSpan.spanContext();
+            // Check if trace ID is valid (not all zeros)
+            if (spanContext.traceId && spanContext.traceId !== '00000000000000000000000000000000') {
+                return {
+                    traceId: spanContext.traceId,
+                    spanId: spanContext.spanId,
+                };
+            }
+        }
+        // If no active span, create a new one for this log
+        // This ensures we always have trace context even if called outside a request context
+        try {
+            const tracer = api_1.trace.getTracer(this.config.serviceName, this.config.serviceVersion);
+            const span = tracer.startSpan('swirepay-log');
+            const spanContext = span.spanContext();
+            span.end();
+            if (spanContext.traceId && spanContext.traceId !== '00000000000000000000000000000000') {
+                return {
+                    traceId: spanContext.traceId,
+                    spanId: spanContext.spanId,
+                };
+            }
+        }
+        catch (error) {
+            // If OpenTelemetry isn't ready yet, fall back to generated trace context
+        }
+        // Fallback: generate new trace context
+        return this.generateTraceContext();
+    }
+    log(level, message, meta = {}, traceContext) {
+        const trace = this.getTraceContext(traceContext);
+        this.logger.log(level, message, {
+            ...meta,
+            ...trace,
+        });
+    }
+    debug(message, meta, traceContext) {
+        this.log('debug', message, meta, traceContext);
+    }
+    info(message, meta, traceContext) {
+        this.log('info', message, meta, traceContext);
+    }
+    warn(message, meta, traceContext) {
+        this.log('warn', message, meta, traceContext);
+    }
+    error(message, error, meta, traceContext) {
+        const errorMeta = {
+            ...meta,
+            error: {
+                message: error?.message || String(error),
+                stack: error?.stack,
+                name: error?.name,
+            },
+        };
+        this.log('error', message || error?.message || 'Error occurred', errorMeta, traceContext);
+    }
+    logApiCall(options) {
+        const { method, url, statusCode, duration, requestBody, responseBody, headers, error, traceContext } = options;
+        const trace = this.getTraceContext(traceContext);
+        const logData = {
+            method: method.toUpperCase(),
+            url,
+            eventType: 'api_call',
+            apiCall: {
+                method: method.toUpperCase(),
+                url,
+                statusCode,
+                duration,
+                timestamp: new Date().toISOString(),
+            },
+        };
+        if (statusCode)
+            logData.statusCode = statusCode;
+        if (duration !== undefined)
+            logData.apiCall.duration_ms = duration;
+        if (headers)
+            logData.apiCall.headers = headers;
+        if (requestBody)
+            logData.apiCall.request_body = this.sanitizeBody(requestBody);
+        if (responseBody)
+            logData.apiCall.response_body = this.sanitizeBody(responseBody);
+        if (error) {
+            logData.error = {
+                message: error.message,
+                stack: error.stack,
+                name: error.name,
+            };
+        }
+        const level = error || (statusCode && statusCode >= 400) ? 'error' : 'info';
+        const message = `API Call: ${method.toUpperCase()} ${url}${statusCode ? ` - ${statusCode}` : ''}${duration ? ` (${duration}ms)` : ''}`;
+        this.logger.log(level, message, {
+            ...logData,
+            ...trace,
+        });
+    }
+    logRequest(options) {
+        const { method, path, statusCode, duration, userId, ip, userAgent, requestBody, responseBody, headers, error, traceContext } = options;
+        const trace = this.getTraceContext(traceContext);
+        const logData = {
+            method: method.toUpperCase(),
+            url: path,
+            eventType: 'request',
+            request: {
+                method: method.toUpperCase(),
+                path,
+                statusCode,
+                duration,
+                timestamp: new Date().toISOString(),
+            },
+        };
+        if (statusCode)
+            logData.statusCode = statusCode;
+        if (duration !== undefined)
+            logData.request.duration_ms = duration;
+        if (userId)
+            logData.request.user_id = userId;
+        if (ip)
+            logData.request.ip = ip;
+        if (userAgent)
+            logData.request.user_agent = userAgent;
+        if (headers)
+            logData.request.headers = headers;
+        if (requestBody)
+            logData.request.request_body = this.sanitizeBody(requestBody);
+        if (responseBody)
+            logData.request.response_body = this.sanitizeBody(responseBody);
+        if (error) {
+            logData.error = {
+                message: error.message,
+                stack: error.stack,
+                name: error.name,
+            };
+        }
+        const level = error || (statusCode && statusCode >= 400) ? 'error' : 'info';
+        const message = `Request: ${method.toUpperCase()} ${path}${statusCode ? ` - ${statusCode}` : ''}${duration ? ` (${duration}ms)` : ''}`;
+        this.logger.log(level, message, {
+            ...logData,
+            ...trace,
+        });
+    }
+    logWebhook(options) {
+        const { source, event, webhookId, status, payload, error, processingTime, traceContext } = options;
+        const trace = this.getTraceContext(traceContext);
+        const logData = {
+            eventType: 'webhook',
+            webhook: {
+                source,
+                event,
+                status,
+                timestamp: new Date().toISOString(),
+            },
+        };
+        if (webhookId)
+            logData.webhook.webhook_id = webhookId;
+        if (processingTime !== undefined)
+            logData.webhook.processing_time_ms = processingTime;
+        if (payload)
+            logData.webhook.payload = this.sanitizeBody(payload);
+        if (error) {
+            logData.error = {
+                message: error.message,
+                stack: error.stack,
+                name: error.name,
+            };
+        }
+        const level = error || status === 'failed' ? 'error' : 'info';
+        const message = `Webhook: ${source} - ${event} (${status})`;
+        this.logger.log(level, message, {
+            ...logData,
+            ...trace,
+        });
+    }
+    sanitizeBody(body) {
+        if (!body)
+            return body;
+        if (typeof body !== 'object')
+            return body;
+        const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'api_key', 'authorization', 'creditCard', 'credit_card', 'cvv', 'ssn'];
+        const sanitized = { ...body };
+        for (const key in sanitized) {
+            if (sensitiveFields.some(field => key.toLowerCase().includes(field.toLowerCase()))) {
+                sanitized[key] = '***REDACTED***';
+            }
+            else if (typeof sanitized[key] === 'object' && sanitized[key] !== null) {
+                sanitized[key] = this.sanitizeBody(sanitized[key]);
+            }
+        }
+        return sanitized;
+    }
+}
+exports.SwirepayLogger = SwirepayLogger;
+let defaultLogger = null;
+function initializeLogger(config) {
+    // Get config with defaults
+    const defaultConfig = (0, config_1.getDefaultConfig)();
+    const finalConfig = { ...defaultConfig, ...config };
+    // Automatically initialize OpenTelemetry (SDK handles this internally)
+    try {
+        (0, otel_init_1.initOpenTelemetry)({
+            serviceName: finalConfig.serviceName,
+            serviceVersion: finalConfig.serviceVersion,
+            environment: finalConfig.environment,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize OpenTelemetry: ${error instanceof Error ? error.message : String(error)}. ` +
+            'OpenTelemetry is required for SwirepayLogger.');
+    }
+    defaultLogger = new SwirepayLogger(config);
+    return defaultLogger;
+}
+function getLogger() {
+    if (!defaultLogger) {
+        // Automatically initialize with defaults if not already initialized
+        // This ensures OpenTelemetry is initialized automatically
+        const defaultConfig = (0, config_1.getDefaultConfig)();
+        try {
+            (0, otel_init_1.initOpenTelemetry)({
+                serviceName: defaultConfig.serviceName || 'swirepay-service',
+                serviceVersion: defaultConfig.serviceVersion || '1.0.0',
+                environment: defaultConfig.environment || 'staging',
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize OpenTelemetry: ${error instanceof Error ? error.message : String(error)}. ` +
+                'OpenTelemetry is required for SwirepayLogger.');
+        }
+        defaultLogger = new SwirepayLogger();
+    }
+    return defaultLogger;
+}

package/dist/loki-transport.d.ts

@@ -0,0 +1,18 @@
+import Transport from 'winston-transport';
+import { LogEntry } from 'winston';
+export declare class LokiTransport extends Transport {
+    private lokiUrl;
+    private batch;
+    private batchTimeout;
+    private readonly batchSize;
+    private readonly batchInterval;
+    constructor(opts: {
+        lokiUrl: string;
+        environment: string;
+        serviceName: string;
+        serviceVersion: string;
+    });
+    log(info: LogEntry, callback: () => void): void;
+    private flush;
+    close(): Promise<void>;
+}

package/dist/loki-transport.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiTransport = void 0;
+const winston_transport_1 = __importDefault(require("winston-transport"));
+class LokiTransport extends winston_transport_1.default {
+    constructor(opts) {
+        super();
+        this.batch = [];
+        this.batchTimeout = null;
+        this.batchSize = 100;
+        this.batchInterval = 5000; // 5 seconds
+        this.lokiUrl = opts.lokiUrl;
+    }
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+        const timestamp = new Date().toISOString();
+        const nanoTimestamp = `${Date.now()}000000`; // Convert to nanoseconds
+        // Extract log level and message
+        const level = info.level || 'info';
+        const message = info.message || JSON.stringify(info);
+        // Build labels for Loki stream
+        const stream = {
+            level: level.toUpperCase(),
+            service_name: info.service || 'unknown',
+            environment: info.environment || 'unknown',
+            version: info.version || 'unknown',
+        };
+        // Add custom labels from info object
+        if (info.traceId)
+            stream.trace_id = info.traceId;
+        if (info.spanId)
+            stream.span_id = info.spanId;
+        if (info.method)
+            stream.method = info.method;
+        if (info.url)
+            stream.url = info.url;
+        if (info.statusCode)
+            stream.status_code = String(info.statusCode);
+        if (info.eventType)
+            stream.event_type = info.eventType;
+        // Build log line with structured data
+        const logLine = {
+            timestamp,
+            level: level.toUpperCase(),
+            message,
+            service: {
+                name: info.service || 'unknown',
+                version: info.version || 'unknown',
+            },
+            environment: info.environment || 'unknown',
+        };
+        // Add trace context
+        if (info.traceId)
+            logLine.trace_id = info.traceId;
+        if (info.spanId)
+            logLine.span_id = info.spanId;
+        // Add attributes
+        if (info.attributes) {
+            logLine.attributes = info.attributes;
+        }
+        // Add specific fields based on log type
+        if (info.apiCall) {
+            logLine.api_call = info.apiCall;
+        }
+        if (info.request) {
+            logLine.request = info.request;
+        }
+        if (info.webhook) {
+            logLine.webhook = info.webhook;
+        }
+        const logEntry = {
+            stream,
+            values: [[nanoTimestamp, JSON.stringify(logLine)]],
+        };
+        this.batch.push(logEntry);
+        if (this.batch.length >= this.batchSize) {
+            this.flush();
+        }
+        else if (!this.batchTimeout) {
+            this.batchTimeout = setTimeout(() => this.flush(), this.batchInterval);
+        }
+        callback();
+    }
+    async flush() {
+        if (this.batch.length === 0)
+            return;
+        const batchToSend = [...this.batch];
+        this.batch = [];
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        try {
+            const response = await fetch(this.lokiUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ streams: batchToSend }),
+            });
+            if (!response.ok) {
+                console.error(`Failed to send logs to Loki: ${response.status} ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            console.error('Error sending logs to Loki:', error);
+        }
+    }
+    async close() {
+        await this.flush();
+    }
+}
+exports.LokiTransport = LokiTransport;

package/dist/otel-config.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OpenTelemetry Configuration
+ * Centralized configuration for OpenTelemetry Collector endpoints
+ *
+ * Endpoints can be overridden via environment variables:
+ * - OTEL_EXPORTER_OTLP_ENDPOINT (base URL, e.g., "http://localhost:4318")
+ * - OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (full traces URL)
+ * - OTEL_EXPORTER_OTLP_LOGS_ENDPOINT (full logs URL)
+ * - OTEL_EXPORTER_OTLP_METRICS_ENDPOINT (full metrics URL)
+ */
+export declare const OTEL_ENDPOINTS: {
+    readonly STAGING: {
+        readonly base: "https://stag-otel.swirepay.com";
+        readonly traces: "https://stag-otel.swirepay.com/v1/traces";
+        readonly logs: "https://stag-otel.swirepay.com/v1/logs";
+        readonly metrics: "https://stag-otel.swirepay.com/v1/metrics";
+    };
+    readonly PRODUCTION: {
+        readonly base: "https://otel.swirepay.com";
+        readonly traces: "https://otel.swirepay.com/v1/traces";
+        readonly logs: "https://otel.swirepay.com/v1/logs";
+        readonly metrics: "https://otel.swirepay.com/v1/metrics";
+    };
+};
+export declare function getOtelEndpoint(environment: "staging" | "production", type?: "base" | "traces" | "logs" | "metrics"): string;

package/dist/otel-config.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * OpenTelemetry Configuration
+ * Centralized configuration for OpenTelemetry Collector endpoints
+ *
+ * Endpoints can be overridden via environment variables:
+ * - OTEL_EXPORTER_OTLP_ENDPOINT (base URL, e.g., "http://localhost:4318")
+ * - OTEL_EXPORTER_OTLP_TRACES_ENDPOINT (full traces URL)
+ * - OTEL_EXPORTER_OTLP_LOGS_ENDPOINT (full logs URL)
+ * - OTEL_EXPORTER_OTLP_METRICS_ENDPOINT (full metrics URL)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTEL_ENDPOINTS = void 0;
+exports.getOtelEndpoint = getOtelEndpoint;
+exports.OTEL_ENDPOINTS = {
+    STAGING: {
+        base: "https://stag-otel.swirepay.com",
+        traces: "https://stag-otel.swirepay.com/v1/traces",
+        logs: "https://stag-otel.swirepay.com/v1/logs",
+        metrics: "https://stag-otel.swirepay.com/v1/metrics",
+    },
+    PRODUCTION: {
+        base: "https://otel.swirepay.com",
+        traces: "https://otel.swirepay.com/v1/traces",
+        logs: "https://otel.swirepay.com/v1/logs",
+        metrics: "https://otel.swirepay.com/v1/metrics",
+    },
+};
+function getOtelEndpoint(environment, type = "base") {
+    // Check for environment variable overrides first
+    const envVarMap = {
+        base: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+        traces: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
+        logs: process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+        metrics: process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+    };
+    // If specific endpoint type is set, use it
+    if (envVarMap[type]) {
+        return envVarMap[type];
+    }
+    // If base endpoint is set, construct the full URL
+    if (type !== "base" && envVarMap.base) {
+        const base = envVarMap.base.replace(/\/$/, ""); // Remove trailing slash
+        return `${base}/v1/${type}`;
+    }
+    // Fallback to default endpoints
+    const endpoints = environment === "production" ? exports.OTEL_ENDPOINTS.PRODUCTION : exports.OTEL_ENDPOINTS.STAGING;
+    return endpoints[type];
+}

package/dist/otel-init.d.ts

@@ -0,0 +1,14 @@
+import { NodeSDK } from "@opentelemetry/sdk-node";
+export interface OpenTelemetryConfig {
+    serviceName?: string;
+    serviceVersion?: string;
+    environment?: string;
+}
+/**
+ * Initialize OpenTelemetry with automatic instrumentation and log export
+ * This is called automatically by the SDK - users don't need to call this
+ * @param config Configuration options for OpenTelemetry
+ * @returns NodeSDK instance
+ * @throws Error if initialization fails
+ */
+export declare function initOpenTelemetry({ serviceName, serviceVersion, environment, }?: OpenTelemetryConfig): NodeSDK;

package/dist/otel-init.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initOpenTelemetry = initOpenTelemetry;
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const auto_instrumentations_node_1 = require("@opentelemetry/auto-instrumentations-node");
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const exporter_otlp_proto_1 = require("@opentelemetry/exporter-otlp-proto");
+const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const otel_config_1 = require("./otel-config");
+let isInitialized = false;
+/**
+ * Initialize OpenTelemetry with automatic instrumentation and log export
+ * This is called automatically by the SDK - users don't need to call this
+ * @param config Configuration options for OpenTelemetry
+ * @returns NodeSDK instance
+ * @throws Error if initialization fails
+ */
+function initOpenTelemetry({ serviceName = "unknown-service", serviceVersion = "0.0.0", environment = process.env.ENVIRONMENT || "staging", } = {}) {
+    // Only initialize once
+    if (isInitialized) {
+        return global.__swirepayOtelSdk;
+    }
+    try {
+        // Ensure environment is valid type
+        const env = environment === "production" ? "production" : "staging";
+        // Get OpenTelemetry endpoints from centralized config
+        const otelTracesEndpoint = (0, otel_config_1.getOtelEndpoint)(env, "traces");
+        const otelLogsEndpoint = (0, otel_config_1.getOtelEndpoint)(env, "logs");
+        // Configure OpenTelemetry Logger Provider for logs
+        const logResource = new resources_1.Resource({
+            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_VERSION]: serviceVersion,
+            [semantic_conventions_1.SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: env,
+        });
+        const loggerProvider = new sdk_logs_1.LoggerProvider({
+            resource: logResource,
+        });
+        const logExporter = new exporter_logs_otlp_proto_1.OTLPLogExporter({
+            url: otelLogsEndpoint,
+        });
+        // Use BatchLogRecordProcessor for better performance
+        const { BatchLogRecordProcessor } = require("@opentelemetry/sdk-logs");
+        loggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(logExporter));
+        api_logs_1.logs.setGlobalLoggerProvider(loggerProvider);
+        // Configure OpenTelemetry SDK
+        const sdk = new sdk_node_1.NodeSDK({
+            resource: new resources_1.Resource({
+                [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+                [semantic_conventions_1.SemanticResourceAttributes.SERVICE_VERSION]: serviceVersion,
+                [semantic_conventions_1.SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: env,
+            }),
+            traceExporter: new exporter_otlp_proto_1.OTLPTraceExporter({
+                url: otelTracesEndpoint,
+            }), // Type compatibility workaround for version mismatch
+            instrumentations: [
+                (0, auto_instrumentations_node_1.getNodeAutoInstrumentations)({
+                    // Disable fs instrumentation in production for performance
+                    "@opentelemetry/instrumentation-fs": {
+                        enabled: environment !== "production",
+                    },
+                    // Enable HTTP instrumentation (automatic)
+                    "@opentelemetry/instrumentation-http": {
+                        enabled: true,
+                    },
+                }),
+            ],
+        });
+        sdk.start();
+        isInitialized = true;
+        global.__swirepayOtelSdk = sdk;
+        // Create an initial span so there's always an active span available
+        const { trace } = require("@opentelemetry/api");
+        const tracer = trace.getTracer(serviceName, serviceVersion);
+        const span = tracer.startSpan("swirepay-logger-init");
+        span.setAttribute("init", true);
+        span.end();
+        // Graceful shutdown
+        process.on("SIGTERM", () => {
+            sdk.shutdown().finally(() => process.exit(0));
+        });
+        return sdk;
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize OpenTelemetry: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/otel-transport.d.ts

@@ -0,0 +1,18 @@
+import Transport from 'winston-transport';
+import { LogEntry } from 'winston';
+/**
+ * OpenTelemetry Transport for Winston
+ * Automatically sends logs to OpenTelemetry when initialized
+ */
+export declare class OtelTransport extends Transport {
+    private logger;
+    private environment;
+    constructor(opts: {
+        environment: string;
+        serviceName: string;
+        serviceVersion: string;
+    });
+    log(info: LogEntry, callback: () => void): void;
+    private mapLogLevel;
+    private getSeverityNumber;
+}

package/dist/otel-transport.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelTransport = void 0;
+const winston_transport_1 = __importDefault(require("winston-transport"));
+const api_logs_1 = require("@opentelemetry/api-logs");
+/**
+ * OpenTelemetry Transport for Winston
+ * Automatically sends logs to OpenTelemetry when initialized
+ */
+class OtelTransport extends winston_transport_1.default {
+    constructor(opts) {
+        super();
+        this.environment = opts.environment;
+        // OpenTelemetry is REQUIRED - get logger from OpenTelemetry API
+        try {
+            const loggerProvider = api_logs_1.logs.getLoggerProvider();
+            if (!loggerProvider) {
+                throw new Error('OpenTelemetry LoggerProvider is not available. Please initialize OpenTelemetry first.');
+            }
+            this.logger = loggerProvider.getLogger(opts.serviceName, opts.serviceVersion);
+            if (!this.logger) {
+                throw new Error('Failed to get OpenTelemetry logger. Please ensure OpenTelemetry is properly initialized.');
+            }
+        }
+        catch (error) {
+            // OpenTelemetry is required - throw error instead of silently failing
+            throw new Error(`OpenTelemetry is required for SwirepayLogger. ${error instanceof Error ? error.message : 'Please initialize OpenTelemetry before using the logger.'}`);
+        }
+    }
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+        // OpenTelemetry logger is required (checked in constructor)
+        if (!this.logger) {
+            callback();
+            return;
+        }
+        try {
+            const level = this.mapLogLevel(info.level || 'info');
+            const message = info.message || JSON.stringify(info);
+            // Build log record body
+            const body = {
+                stringValue: message,
+            };
+            // Build attributes
+            const attributes = {
+                'log.level': level,
+                'service.name': info.service || 'unknown',
+                'service.version': info.version || 'unknown',
+                'deployment.environment': info.environment || 'unknown',
+            };
+            // Add trace context if available
+            if (info.traceId) {
+                attributes['trace_id'] = info.traceId;
+            }
+            if (info.spanId) {
+                attributes['span_id'] = info.spanId;
+            }
+            // Add custom attributes
+            if (info.attributes) {
+                Object.assign(attributes, info.attributes);
+            }
+            // Add specific fields based on log type
+            if (info.apiCall) {
+                attributes['api_call.method'] = info.apiCall.method;
+                attributes['api_call.url'] = info.apiCall.url;
+                attributes['api_call.status_code'] = info.apiCall.statusCode;
+                if (info.apiCall.duration) {
+                    attributes['api_call.duration_ms'] = info.apiCall.duration;
+                }
+            }
+            if (info.request) {
+                attributes['http.method'] = info.request.method;
+                attributes['http.route'] = info.request.path;
+                attributes['http.status_code'] = info.request.statusCode;
+                if (info.request.duration) {
+                    attributes['http.duration_ms'] = info.request.duration;
+                }
+            }
+            if (info.webhook) {
+                attributes['webhook.source'] = info.webhook.source;
+                attributes['webhook.event'] = info.webhook.event;
+                attributes['webhook.status'] = info.webhook.status;
+            }
+            // Emit log record
+            this.logger.emit({
+                body,
+                severityNumber: this.getSeverityNumber(level),
+                severityText: level.toUpperCase(),
+                attributes,
+                timestamp: Date.now() * 1000000, // Convert to nanoseconds
+            });
+        }
+        catch (error) {
+            // Silently fail - don't break logging if OpenTelemetry has issues
+            console.error('Error sending log to OpenTelemetry:', error);
+        }
+        callback();
+    }
+    mapLogLevel(level) {
+        const levelMap = {
+            error: 'error',
+            warn: 'warn',
+            info: 'info',
+            debug: 'debug',
+        };
+        return levelMap[level.toLowerCase()] || 'info';
+    }
+    getSeverityNumber(level) {
+        const severityMap = {
+            trace: 1,
+            debug: 5,
+            info: 9,
+            warn: 13,
+            error: 17,
+            fatal: 21,
+        };
+        return severityMap[level.toLowerCase()] || 9; // Default to INFO
+    }
+}
+exports.OtelTransport = OtelTransport;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@swirepay-developer/common-logging-nodejs",
+  "version": "1.0.0",
+  "description": "Swirepay Common Logging SDK for Node.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://bitbucket.org/zetametrics/open_telementry.git",
+    "directory": "nodejs"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "example": "npm run build && cd examples && node express-with-otel.js",
+    "start:example": "npm run build && cd examples && node express-with-otel.js",
+    "example:ts": "npm run build && node -r ts-node/register examples/with-opentelemetry.ts"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.8.0",
+    "@opentelemetry/api-logs": "^0.49.1",
+    "@opentelemetry/auto-instrumentations-node": "^0.67.3",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.208.0",
+    "@opentelemetry/exporter-otlp-proto": "^0.26.0",
+    "@opentelemetry/instrumentation": "^0.49.1",
+    "@opentelemetry/instrumentation-http": "^0.49.1",
+    "@opentelemetry/resources": "^1.30.1",
+    "@opentelemetry/sdk-logs": "^0.49.1",
+    "@opentelemetry/sdk-node": "^0.49.1",
+    "@opentelemetry/semantic-conventions": "^1.38.0",
+    "winston": "^3.11.0",
+    "winston-transport": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.27",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "logging",
+    "opentelemetry",
+    "loki",
+    "swirepay",
+    "nodejs"
+  ],
+  "author": "Swirepay",
+  "license": "UNLICENSED"
+}