unnbound-logger-sdk 2.0.10 → 3.0.1

package/dist/index.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearTraceId = exports.UnnboundLogger = void 0;
-/**
- * unnbound-logger
- *
- * A structured logging library built on Pino with TypeScript support.
- * Provides consistent, well-typed logging across different operational contexts.
- */
-const unnbound_logger_1 = require("./unnbound-logger");
-Object.defineProperty(exports, "UnnboundLogger", { enumerable: true, get: function () { return unnbound_logger_1.UnnboundLogger; } });
-const logger_utils_1 = require("./utils/logger-utils");
-Object.defineProperty(exports, "clearTraceId", { enumerable: true, get: function () { return logger_utils_1.clearTraceId; } });
+exports.traceMiddleware = exports.traceAxios = exports.startSpan = exports.logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+var span_1 = require("./span");
+Object.defineProperty(exports, "startSpan", { enumerable: true, get: function () { return span_1.startSpan; } });
+var axios_1 = require("./axios");
+Object.defineProperty(exports, "traceAxios", { enumerable: true, get: function () { return axios_1.traceAxios; } });
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "traceMiddleware", { enumerable: true, get: function () { return middleware_1.traceMiddleware; } });

package/dist/logger.d.ts

@@ -0,0 +1,15 @@
+import pino from 'pino';
+export interface UnnboundLogger extends Omit<pino.Logger, 'trace' | 'debug' | 'error' | 'info' | 'warn'> {
+    trace(object: {}, message: string): void;
+    trace(message: string): void;
+    debug(object: {}, message: string): void;
+    debug(message: string): void;
+    info(object: {}, message: string): void;
+    info(message: string): void;
+    warn(object: {}, message: string): void;
+    warn(message: string): void;
+    error<O extends {
+        err: unknown;
+    }>(object: O, message: string): void;
+}
+export declare const logger: UnnboundLogger;

package/dist/logger.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const storage_1 = require("./storage");
+exports.logger = (0, pino_1.default)({
+    level: process.env.LOG_LEVEL ?? 'info',
+    base: {
+        environment: process.env.ENVIRONMENT,
+        workflowId: process.env.UNNBOUND_WORKFLOW_ID,
+        workflowUrl: process.env.UNNBOUND_WORKFLOW_URL,
+        serviceId: process.env.UNNBOUND_SERVICE_ID,
+        deploymentId: process.env.UNNBOUND_DEPLOYMENT_ID,
+    },
+    mixin: () => ({ ...storage_1.storage.getStore() }),
+    serializers: {
+        req: pino_1.default.stdSerializers.req,
+        res: pino_1.default.stdSerializers.res,
+        err: pino_1.default.stdSerializers.err,
+    },
+    // Let CloudWatch handle timestamps
+    timestamp: false,
+    // Change message field from 'msg' to 'message'
+    messageKey: 'message',
+    formatters: {
+        level: (level) => ({ level }),
+    },
+    redact: {
+        paths: [
+            'http.request.headers.authorization',
+            'http.response.headers.authorization',
+            'http.request.headers.Authorization',
+            'http.response.headers.Authorization',
+            'err.config',
+        ],
+        remove: true,
+    },
+});
+process.on('uncaughtException', (err, origin) => {
+    exports.logger.error({ err, origin }, `Uncaught exception.`);
+});

package/dist/middleware.d.ts

@@ -0,0 +1,3 @@
+import { RequestHandler } from 'express';
+import { HttpOptions } from './types';
+export declare const traceMiddleware: ({ ignoreTraceRoutes, traceHeaderKey, }?: HttpOptions) => RequestHandler;

package/dist/middleware.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceMiddleware = void 0;
+const uuid_1 = require("uuid");
+const storage_1 = require("./storage");
+const span_1 = require("./span");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const getFullUrl = (req) => {
+    const url = req.originalUrl || req.url;
+    if (url?.startsWith('http://') || url?.startsWith('https://'))
+        return url;
+    // Check if we have a workflow URL configured (preferred method)
+    if (process.env.UNNBOUND_WORKFLOW_URL) {
+        // Use workflow URL as the base URL
+        return `${process.env.UNNBOUND_WORKFLOW_URL.replace(/\/$/, '')}${url}`;
+    }
+    // Fallback to constructing from request info for incoming requests
+    const protocol = req.protocol || (req.secure ? 'https' : 'http');
+    const host = req.get('host') || req.get('x-forwarded-host') || 'localhost';
+    return `${protocol}://${host}${url}`;
+};
+const buildIncomingHttpPayload = (req, res, body) => ({
+    type: 'http',
+    http: {
+        url: getFullUrl(req),
+        method: req.method,
+        ip: (0, utils_1.normalizeIp)(req.ip),
+        incoming: true,
+        request: {
+            headers: req.headers,
+            body: (0, utils_1.safeJsonParse)(req.body),
+        },
+        response: res
+            ? {
+                headers: res?.headers,
+                status: res.statusCode,
+                body: (0, utils_1.safeJsonParse)(body),
+            }
+            : undefined,
+    },
+});
+const traceMiddleware = ({ ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, } = {
+    ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
+    traceHeaderKey: types_1.defaultTraceHeaderKey,
+}) => async (req, res, next) => {
+    if ((0, utils_1.shouldIgnorePath)(req.path, ignoreTraceRoutes))
+        return next();
+    const traceId = req.header(traceHeaderKey) || (0, uuid_1.v4)();
+    res.setHeader(traceHeaderKey, traceId);
+    return await storage_1.storage.run({ [storage_1.ContextAttribute.TraceId]: traceId }, async () => {
+        return await (0, span_1.startSpan)('Incoming HTTP request', async () => {
+            return new Promise((resolve) => {
+                // Capture response body for logging
+                const send = res.send.bind(res);
+                res.send = (body) => {
+                    res.locals.body = body;
+                    return send(body);
+                };
+                res.on('finish', () => resolve());
+                return next();
+            });
+        }, (o) => {
+            return buildIncomingHttpPayload(req, o
+                ? { statusCode: res.statusCode, headers: res.getHeaders() }
+                : undefined, res.locals.body);
+        });
+    });
+};
+exports.traceMiddleware = traceMiddleware;

package/dist/sftp.d.ts

@@ -0,0 +1,10 @@
+import { SftpPayload } from './types';
+/**
+ * Builds a SFTP payload
+ * @param payload - SFTP payload
+ * @returns The SFTP payload
+ */
+export declare const buildSftpPayload: (payload: SftpPayload) => {
+    type: string;
+    sftp: SftpPayload;
+};

package/dist/sftp.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSftpPayload = void 0;
+/**
+ * Builds a SFTP payload
+ * @param payload - SFTP payload
+ * @returns The SFTP payload
+ */
+const buildSftpPayload = (payload) => ({
+    type: 'sftp',
+    sftp: payload,
+});
+exports.buildSftpPayload = buildSftpPayload;

package/dist/span.d.ts

@@ -0,0 +1,16 @@
+type LogPayloadGetterOptions<T> = {
+    error: unknown;
+    result?: never;
+} | {
+    error?: never;
+    result: T;
+};
+type LogPayloadGetter<T> = object | ((o?: LogPayloadGetterOptions<T>) => object);
+/**
+ * Starts a span that tracks the duration of a callback
+ * @param spanName - The span name to use for logging
+ * @param callback - The async callback to execute
+ * @returns The result of the callback
+ */
+export declare const startSpan: <T>(spanName: string, callback: () => Promise<T>, getter?: LogPayloadGetter<T>) => Promise<T>;
+export {};

package/dist/span.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSpan = void 0;
+const uuid_1 = require("uuid");
+const storage_1 = require("./storage");
+const logger_1 = require("./logger");
+/**
+ * Starts a span that tracks the duration of a callback
+ * @param spanName - The span name to use for logging
+ * @param callback - The async callback to execute
+ * @returns The result of the callback
+ */
+const startSpan = async (spanName, callback, getter) => {
+    const spanId = (0, uuid_1.v4)();
+    const start = performance.now();
+    const previous = storage_1.storage.getStore();
+    return storage_1.storage.run({
+        ...previous,
+        [storage_1.ContextAttribute.SpanId]: previous?.[storage_1.ContextAttribute.SpanId]
+            ? `${spanId} ${previous?.[storage_1.ContextAttribute.SpanId]}`
+            : spanId,
+    }, async () => {
+        logger_1.logger.info({ ...getLogPayload(getter) }, `${spanName} started.`);
+        try {
+            const result = await callback();
+            logger_1.logger.info({ ...getLogPayload(getter, { result }), duration: getDuration(start) }, `${spanName} completed.`);
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error({ ...getLogPayload(getter, { error }), err: error, duration: getDuration(start) }, `${spanName} failed.`);
+            throw error;
+        }
+    });
+};
+exports.startSpan = startSpan;
+const getLogPayload = (getter, o) => {
+    if (typeof getter !== 'function')
+        return getter;
+    return getter(o);
+};
+const getDuration = (start) => Math.round(performance.now() - start);

package/dist/storage.d.ts

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from 'async_hooks';
+export declare enum ContextAttribute {
+    TraceId = "traceId",
+    SpanId = "spanId"
+}
+export interface Context {
+    [ContextAttribute.TraceId]?: string;
+    [ContextAttribute.SpanId]?: string;
+}
+export declare const storage: AsyncLocalStorage<Context>;

package/dist/storage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = exports.ContextAttribute = void 0;
+const async_hooks_1 = require("async_hooks");
+var ContextAttribute;
+(function (ContextAttribute) {
+    ContextAttribute["TraceId"] = "traceId";
+    ContextAttribute["SpanId"] = "spanId";
+})(ContextAttribute || (exports.ContextAttribute = ContextAttribute = {}));
+exports.storage = new async_hooks_1.AsyncLocalStorage();

package/dist/types.d.ts

@@ -4,129 +4,60 @@
 /**
  * Available log levels
  */
-export type LogLevel = "info" | "debug" | "error" | "warn";
+export type LogLevel = 'info' | 'debug' | 'error' | 'warn';
 /**
  * Available log types
  */
-export type LogType = "general" | "httpRequest" | "httpResponse" | "sftpTransaction" | "dbQueryTransaction";
+export type LogType = 'general' | 'http' | 'sftp' | 'dbQueryTransaction';
 /**
  * HTTP methods supported for HTTP logging
  */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
-export interface SerializableError {
-    name: string;
-    message: string;
-    stack?: string;
-}
 export interface Log<T extends LogType = 'general'> {
-    logId: string;
     level: LogLevel;
-    type: T;
     message: string;
+    traceId: string;
+    spanId?: string;
+    type: T;
     serviceId: string;
     deploymentId: string;
     workflowId: string;
-    traceId: string;
-    requestId: string;
-    error?: SerializableError;
+    err?: unknown;
 }
 export interface LogTransaction<T extends LogType> extends Log<T> {
-    duration: number;
-}
-export interface HttpRequestLog extends LogTransaction<'httpRequest'> {
-    httpRequest: {
-        url: string;
-        method: string;
-        headers: Record<string, string>;
-        ip?: string;
-        body?: unknown;
-    };
+    duration?: number;
 }
-export interface HttpResponseLog extends LogTransaction<'httpResponse'> {
-    httpResponse: {
+export interface HttpLog extends LogTransaction<'http'> {
+    http: {
         url: string;
         method: string;
-        headers: Record<string, string>;
         ip?: string;
-        status: number;
-        body?: unknown;
+        request: {
+            headers: Record<string, string>;
+            body?: unknown;
+        };
+        response?: {
+            headers: Record<string, string>;
+            status: number;
+            body?: unknown;
+        };
     };
 }
-export interface SftpTransactionLog extends LogTransaction<'sftpTransaction'> {
-    sftp: {
-        host: string;
-        username: string;
-        operation: 'upload' | 'download' | 'list' | 'delete' | 'rename' | 'stat';
-        path: string;
-        status: 'success' | 'failure';
-        bytesTransferred?: number;
-        filesListed?: number;
-        sourcePath?: string;
-    };
+export type SftpOperation = 'connect' | 'upload' | 'download' | 'list' | 'delete' | 'rename' | 'stat' | 'exists' | 'realPath' | 'get' | 'put' | 'cwd' | 'mkdir' | 'rmdir' | 'chmod' | 'append' | 'uploadDir' | 'downloadDir' | 'end';
+export interface SftpPayload {
+    host: string;
+    operation: SftpOperation;
+    path?: string;
+    bytes?: number;
+    destinationPath?: string;
+    files?: number;
 }
-export interface DbQueryTransactionLog extends LogTransaction<'dbQueryTransaction'> {
-    db: {
-        instance: string;
-        vendor: 'postgres' | 'mysql' | 'mssql' | 'mongodb';
-        query?: string;
-        status: 'success' | 'failure';
-        rowsReturned?: number;
-        rowsAffected?: number;
-    };
+export interface SftpLog extends LogTransaction<'sftp'> {
+    sftp: SftpPayload;
 }
-/**
- * Configuration options for the logger
- */
-export interface LoggerOptions {
-    /** Optional trace header key */
-    traceHeaderKey?: string;
-    /** Routes to ignore in trace middleware (supports glob patterns) */
+export interface HttpOptions {
     ignoreTraceRoutes?: string[];
-    /** Routes to ignore in axios trace middleware (supports glob patterns) */
-    ignoreAxiosTraceRoutes?: string[];
-}
-/**
- * Options for general logs
- */
-export interface GeneralLogOptions {
-    /** Log level override */
-    level?: LogLevel;
-    /** Custom trace ID */
-    traceId?: string;
-    /** Custom request ID */
-    requestId?: string;
-    /** Custom metadata */
-    [key: string]: unknown;
-}
-/**
- * Options for HTTP request logs
- */
-export interface HttpRequestLogOptions extends GeneralLogOptions {
-    /** Start time of the request for duration calculation */
-    startTime?: number;
-}
-/**
- * Options for HTTP response logs
- */
-export interface HttpResponseLogOptions extends HttpRequestLogOptions {
-    /** Duration of the request in milliseconds */
-    duration?: number;
-}
-/**
- * Options for SFTP transaction logs
- */
-export interface SftpTransactionLogOptions extends GeneralLogOptions {
-    /** Start time of the transaction for duration calculation */
-    startTime?: number;
-    /** Duration of the transaction in milliseconds */
-    duration?: number;
-}
-/**
- * Options for database query transaction logs
- */
-export interface DbQueryTransactionLogOptions extends GeneralLogOptions {
-    /** Start time of the query for duration calculation */
-    startTime?: number;
-    /** Duration of the query in milliseconds */
-    duration?: number;
+    traceHeaderKey?: string;
 }
+export declare const defaultIgnoreTraceRoutes: string[];
+export declare const defaultTraceHeaderKey = "x-unnbound-trace-id";

package/dist/types.js

@@ -3,3 +3,6 @@
  * Type definitions for structured logging library
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTraceHeaderKey = exports.defaultIgnoreTraceRoutes = void 0;
+exports.defaultIgnoreTraceRoutes = ['/health', '/healthcheck'];
+exports.defaultTraceHeaderKey = 'x-unnbound-trace-id';

package/dist/unnbound-logger.d.ts

@@ -1,4 +1,8 @@
-import { LogLevel, LoggerOptions, GeneralLogOptions, HttpRequestLogOptions, HttpResponseLogOptions, SftpTransactionLogOptions, DbQueryTransactionLogOptions, Log, HttpRequestLog, HttpResponseLog, SftpTransactionLog, DbQueryTransactionLog } from './types';
+/**
+ * Core logger implementation
+ */
+import pino from 'pino';
+import { LogLevel, LoggerOptions, GeneralLogOptions, HttpRequestLogOptions, HttpResponseLogOptions, DbQueryTransactionLogOptions, Log, HttpRequestLog, HttpResponseLog, DbQueryTransactionLog } from './types';
 import { Request, Response, NextFunction } from 'express';
 import { InternalAxiosRequestConfig } from 'axios';
 declare module 'axios' {
@@ -9,6 +13,7 @@ declare module 'axios' {
         };
     }
 }
+export declare const logger: pino.Logger;
 /**
  * UnnboundLogger provides typed, structured logging using Pino
  */
@@ -84,21 +89,6 @@ export declare class UnnboundLogger {
      * @param options - Additional logging options
      */
     httpResponse(res: Response, req: Request, options?: HttpResponseLogOptions): HttpResponseLog;
-    /**
-     * Logs an SFTP transaction
-     * @param operation - SFTP operation details
-     * @param options - Additional logging options
-     */
-    sftpTransaction(operation: {
-        host: string;
-        username: string;
-        operation: 'upload' | 'download' | 'list' | 'delete' | 'rename' | 'stat';
-        path: string;
-        status: 'success' | 'failure';
-        bytesTransferred?: number;
-        filesListed?: number;
-        sourcePath?: string;
-    }, options?: SftpTransactionLogOptions): SftpTransactionLog;
     /**
      * Logs a database query transaction
      * @param query - Database query details