@dex-monit/observability-sdk-node 1.0.6 → 1.0.8

package/dist/lib/dex-logger.service.d.ts

@@ -0,0 +1,88 @@
+import { LoggerService } from '@nestjs/common';
+import { MonitoringClient } from './monitoring-client.js';
+/**
+ * Token for injecting DexLoggerService
+ */
+export declare const DEX_LOGGER_TOKEN = "DEX_LOGGER_SERVICE";
+/**
+ * DexLoggerService - NestJS compatible logger that sends logs to monitoring
+ *
+ * Usage:
+ * 1. Inject in any service/controller: constructor(private logger: DexLoggerService)
+ * 2. Use as app logger: app.useLogger(app.get(DexLoggerService))
+ *
+ * Example:
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   constructor(private readonly logger: DexLoggerService) {
+ *     this.logger.setContext('MyService');
+ *   }
+ *
+ *   doSomething() {
+ *     this.logger.log('Doing something');
+ *     this.logger.warn('This is a warning');
+ *     this.logger.error('This is an error');
+ *   }
+ * }
+ * ```
+ */
+export declare class DexLoggerService implements LoggerService {
+    private context?;
+    private monitoringClient?;
+    /**
+     * Set the monitoring client (called by module)
+     */
+    setMonitoringClient(client?: MonitoringClient): void;
+    /**
+     * Set the context (usually the class name)
+     */
+    setContext(context: string): this;
+    /**
+     * Log a message (info level)
+     */
+    log(message: string, context?: string): void;
+    log(message: string, ...optionalParams: unknown[]): void;
+    /**
+     * Log an error message
+     */
+    error(message: string, stackOrContext?: string): void;
+    error(message: string, stack?: string, context?: string): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string, context?: string): void;
+    warn(message: string, ...optionalParams: unknown[]): void;
+    /**
+     * Log a debug message
+     */
+    debug(message: string, context?: string): void;
+    debug(message: string, ...optionalParams: unknown[]): void;
+    /**
+     * Log a verbose message (maps to debug)
+     */
+    verbose(message: string, context?: string): void;
+    verbose(message: string, ...optionalParams: unknown[]): void;
+    /**
+     * Log a fatal message
+     */
+    fatal(message: string, context?: string): void;
+    fatal(message: string, ...optionalParams: unknown[]): void;
+    /**
+     * Internal: write log to console and send to monitoring
+     */
+    private writeLog;
+    /**
+     * Get the appropriate console method for the log level
+     */
+    private getConsoleMethod;
+    /**
+     * Extract context from optional params
+     */
+    private extractContext;
+    /**
+     * Extract context and stack from error params
+     */
+    private extractErrorParams;
+}
+//# sourceMappingURL=dex-logger.service.d.ts.map

package/dist/lib/dex-logger.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dex-logger.service.d.ts","sourceRoot":"","sources":["../../src/lib/dex-logger.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,aAAa,EAAS,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI1D;;GAEG;AACH,eAAO,MAAM,gBAAgB,uBAAuB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBACa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAE5C;;OAEG;IACH,mBAAmB,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAIpD;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAC5C,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,IAAI;IAMxD;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IACrD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAM9D;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAC7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,IAAI;IAMzD;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,IAAI;IAM1D;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAChD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,IAAI;IAM5D;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,IAAI;IAM1D;;OAEG;IACH,OAAO,CAAC,QAAQ;IAsChB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACH,OAAO,CAAC,kBAAkB;CA4B3B"}

package/dist/lib/dex-logger.service.js

@@ -0,0 +1,172 @@
+import { __esDecorate, __runInitializers } from "tslib";
+import { Injectable, Scope } from '@nestjs/common';
+import { RequestContextService } from '@dex-monit/observability-request-context';
+/**
+ * Token for injecting DexLoggerService
+ */
+export const DEX_LOGGER_TOKEN = 'DEX_LOGGER_SERVICE';
+/**
+ * DexLoggerService - NestJS compatible logger that sends logs to monitoring
+ *
+ * Usage:
+ * 1. Inject in any service/controller: constructor(private logger: DexLoggerService)
+ * 2. Use as app logger: app.useLogger(app.get(DexLoggerService))
+ *
+ * Example:
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   constructor(private readonly logger: DexLoggerService) {
+ *     this.logger.setContext('MyService');
+ *   }
+ *
+ *   doSomething() {
+ *     this.logger.log('Doing something');
+ *     this.logger.warn('This is a warning');
+ *     this.logger.error('This is an error');
+ *   }
+ * }
+ * ```
+ */
+let DexLoggerService = (() => {
+    let _classDecorators = [Injectable({ scope: Scope.TRANSIENT })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var DexLoggerService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DexLoggerService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        context;
+        monitoringClient;
+        /**
+         * Set the monitoring client (called by module)
+         */
+        setMonitoringClient(client) {
+            this.monitoringClient = client;
+        }
+        /**
+         * Set the context (usually the class name)
+         */
+        setContext(context) {
+            this.context = context;
+            return this;
+        }
+        log(message, ...optionalParams) {
+            const ctx = this.extractContext(optionalParams);
+            this.writeLog('info', message, ctx);
+        }
+        error(message, ...optionalParams) {
+            const { context, stack } = this.extractErrorParams(optionalParams);
+            this.writeLog('error', message, context, { stack });
+        }
+        warn(message, ...optionalParams) {
+            const ctx = this.extractContext(optionalParams);
+            this.writeLog('warning', message, ctx);
+        }
+        debug(message, ...optionalParams) {
+            const ctx = this.extractContext(optionalParams);
+            this.writeLog('debug', message, ctx);
+        }
+        verbose(message, ...optionalParams) {
+            const ctx = this.extractContext(optionalParams);
+            this.writeLog('debug', message, ctx);
+        }
+        fatal(message, ...optionalParams) {
+            const ctx = this.extractContext(optionalParams);
+            this.writeLog('fatal', message, ctx);
+        }
+        /**
+         * Internal: write log to console and send to monitoring
+         */
+        writeLog(level, message, context, extra) {
+            const ctx = context || this.context || 'Application';
+            const requestContext = RequestContextService.get();
+            const timestamp = new Date().toISOString();
+            // Format for console output
+            const logData = {
+                timestamp,
+                level: level.toUpperCase(),
+                context: ctx,
+                message,
+                requestId: requestContext?.requestId,
+                transactionId: requestContext?.transactionId,
+                ...extra,
+            };
+            // Write to console (JSON format)
+            const consoleMethod = this.getConsoleMethod(level);
+            consoleMethod(JSON.stringify(logData));
+            // Send to monitoring (fire and forget)
+            if (this.monitoringClient) {
+                this.monitoringClient.captureLog(level, message, {
+                    context: ctx,
+                    requestId: requestContext?.requestId,
+                    transactionId: requestContext?.transactionId,
+                    ...extra,
+                }).catch(() => {
+                    // Silently fail
+                });
+            }
+        }
+        /**
+         * Get the appropriate console method for the log level
+         */
+        getConsoleMethod(level) {
+            switch (level) {
+                case 'debug':
+                    return console.debug.bind(console);
+                case 'info':
+                    return console.log.bind(console);
+                case 'warning':
+                    return console.warn.bind(console);
+                case 'error':
+                case 'fatal':
+                    return console.error.bind(console);
+                default:
+                    return console.log.bind(console);
+            }
+        }
+        /**
+         * Extract context from optional params
+         */
+        extractContext(optionalParams) {
+            const lastParam = optionalParams[optionalParams.length - 1];
+            if (typeof lastParam === 'string') {
+                return lastParam;
+            }
+            return undefined;
+        }
+        /**
+         * Extract context and stack from error params
+         */
+        extractErrorParams(optionalParams) {
+            if (optionalParams.length === 0) {
+                return {};
+            }
+            if (optionalParams.length === 1) {
+                const param = optionalParams[0];
+                if (typeof param === 'string') {
+                    // Could be stack or context - check if it looks like a stack
+                    if (param.includes('\n') && param.includes('at ')) {
+                        return { stack: param };
+                    }
+                    return { context: param };
+                }
+            }
+            if (optionalParams.length >= 2) {
+                return {
+                    stack: typeof optionalParams[0] === 'string' ? optionalParams[0] : undefined,
+                    context: typeof optionalParams[1] === 'string' ? optionalParams[1] : undefined,
+                };
+            }
+            return {};
+        }
+    };
+    return DexLoggerService = _classThis;
+})();
+export { DexLoggerService };

package/dist/lib/nest-logger-capture.d.ts

@@ -0,0 +1,14 @@
+import { MonitoringClient } from './monitoring-client.js';
+/**
+ * Start capturing NestJS native Logger output
+ */
+export declare function startNestLoggerCapture(monitoringClient: MonitoringClient): void;
+/**
+ * Stop capturing NestJS native Logger output
+ */
+export declare function stopNestLoggerCapture(): void;
+/**
+ * Check if NestJS Logger capture is active
+ */
+export declare function isNestLoggerCaptureActive(): boolean;
+//# sourceMappingURL=nest-logger-capture.d.ts.map

package/dist/lib/nest-logger-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nest-logger-capture.d.ts","sourceRoot":"","sources":["../../src/lib/nest-logger-capture.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AA2B1D;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAsD/E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAe5C;AAcD;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD"}

package/dist/lib/nest-logger-capture.js

@@ -0,0 +1,92 @@
+import { Logger as NestLogger } from '@nestjs/common';
+import { RequestContextService } from '@dex-monit/observability-request-context';
+const NEST_TO_SEVERITY = {
+    debug: 'debug',
+    verbose: 'debug',
+    log: 'info',
+    warn: 'warning',
+    error: 'error',
+    fatal: 'fatal',
+};
+let originalMethods = null;
+let isCapturing = false;
+/**
+ * Start capturing NestJS native Logger output
+ */
+export function startNestLoggerCapture(monitoringClient) {
+    if (isCapturing) {
+        return;
+    }
+    // Store original static methods
+    originalMethods = {
+        log: NestLogger.log.bind(NestLogger),
+        error: NestLogger.error.bind(NestLogger),
+        warn: NestLogger.warn.bind(NestLogger),
+        debug: NestLogger.debug.bind(NestLogger),
+        verbose: NestLogger.verbose.bind(NestLogger),
+        fatal: NestLogger.fatal.bind(NestLogger),
+    };
+    const methods = ['log', 'error', 'warn', 'debug', 'verbose', 'fatal'];
+    for (const method of methods) {
+        const original = originalMethods[method];
+        const severity = NEST_TO_SEVERITY[method];
+        // Override the static method
+        NestLogger[method] = function (message, ...optionalParams) {
+            // Call original method first
+            original(message, ...optionalParams);
+            // Extract context from params
+            const context = extractContext(optionalParams);
+            const messageStr = typeof message === 'string' ? message : JSON.stringify(message);
+            // Skip SDK internal logs to avoid loops
+            if (context?.startsWith('DEX') || messageStr.startsWith('[DEX')) {
+                return;
+            }
+            // Get request context
+            const requestContext = RequestContextService.get();
+            // Send to monitoring (fire and forget)
+            monitoringClient.captureLog(severity, messageStr, {
+                source: 'nest-logger',
+                context,
+                requestId: requestContext?.requestId,
+                transactionId: requestContext?.transactionId,
+            }).catch(() => {
+                // Silently ignore
+            });
+        };
+    }
+    isCapturing = true;
+}
+/**
+ * Stop capturing NestJS native Logger output
+ */
+export function stopNestLoggerCapture() {
+    if (!isCapturing || !originalMethods) {
+        return;
+    }
+    // Restore original methods
+    NestLogger.log = originalMethods.log;
+    NestLogger.error = originalMethods.error;
+    NestLogger.warn = originalMethods.warn;
+    NestLogger.debug = originalMethods.debug;
+    NestLogger.verbose = originalMethods.verbose;
+    NestLogger.fatal = originalMethods.fatal;
+    originalMethods = null;
+    isCapturing = false;
+}
+/**
+ * Extract context from optional params
+ */
+function extractContext(optionalParams) {
+    // Last param is usually the context
+    const lastParam = optionalParams[optionalParams.length - 1];
+    if (typeof lastParam === 'string') {
+        return lastParam;
+    }
+    return undefined;
+}
+/**
+ * Check if NestJS Logger capture is active
+ */
+export function isNestLoggerCaptureActive() {
+    return isCapturing;
+}

package/dist/lib/sdk-node.d.ts

@@ -3,5 +3,8 @@ export * from './request-id.middleware.js';
 export * from './global-exception.filter.js';
 export * from './error-capture.interceptor.js';
 export * from './monitoring-client.js';
+export * from './remote-logger.js';
+export * from './dex-logger.service.js';
 export * from './console-capture.js';
+export * from './nest-logger-capture.js';
 //# sourceMappingURL=sdk-node.d.ts.map

package/dist/lib/sdk-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk-node.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-node.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"sdk-node.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-node.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC"}

package/dist/lib/sdk-node.js

@@ -4,4 +4,7 @@ export * from './request-id.middleware.js';
 export * from './global-exception.filter.js';
 export * from './error-capture.interceptor.js';
 export * from './monitoring-client.js';
+export * from './remote-logger.js';
+export * from './dex-logger.service.js';
 export * from './console-capture.js';
+export * from './nest-logger-capture.js';

package/dist/lib/sdk-node.module.d.ts

@@ -16,6 +16,8 @@ export interface SdkNodeModuleConfig {
     remoteLogLevel?: Severity;
     /** Whether to capture console.log/warn/error (default: true) */
     captureConsole?: boolean;
+    /** Whether to capture NestJS native Logger (default: true) */
+    captureNestLogger?: boolean;
 }
 export { LOGGER_TOKEN };
 /**
@@ -29,8 +31,9 @@ export declare const MONITORING_CLIENT_TOKEN = "OBSERVABILITY_MONITORING_CLIENT"
  * - Request ID middleware for tracing
  * - Error capture interceptor (captures ALL errors, even if other filters exist)
  * - Global exception filter for error capture
- * - Logger instance (with automatic remote log capture if monitoring is configured)
+ * - DexLoggerService (NestJS compatible logger with remote capture)
  * - Console capture (intercepts console.log/warn/error)
+ * - NestJS Logger capture (intercepts Logger.log/warn/error)
  * - Monitoring client instance
  */
 export declare class SdkNodeModule implements NestModule, OnModuleDestroy {

package/dist/lib/sdk-node.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk-node.module.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-node.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEb,kBAAkB,EAClB,UAAU,EACV,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAEL,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAEL,YAAY,EACZ,YAAY,EACb,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2BAA2B;IAC3B,MAAM,EAAE,YAAY,CAAC;IACrB,yFAAyF;IACzF,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAGD,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AAEzE;;;;;;;;;;GAUG;AACH,qBAEa,aAAc,YAAW,UAAU,EAAE,eAAe;IAC/D,OAAO,CAAC,MAAM,CAAC,YAAY,CAA6B;IAExD;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa;IAkE1D;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAK7C;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;CASvC"}
+{"version":3,"file":"sdk-node.module.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-node.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEb,kBAAkB,EAClB,UAAU,EACV,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAEL,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EAEL,YAAY,EACZ,YAAY,EACb,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2BAA2B;IAC3B,MAAM,EAAE,YAAY,CAAC;IACrB,yFAAyF;IACzF,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,8DAA8D;IAC9D,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAGD,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AAEzE;;;;;;;;;;;GAWG;AACH,qBAEa,aAAc,YAAW,UAAU,EAAE,eAAe;IAC/D,OAAO,CAAC,MAAM,CAAC,YAAY,CAA6B;IAExD;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa;IAgG1D;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAK7C;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;CAUvC"}

package/dist/lib/sdk-node.module.js

@@ -6,7 +6,9 @@ import { GlobalExceptionFilter } from './global-exception.filter.js';
 import { ErrorCaptureInterceptor } from './error-capture.interceptor.js';
 import { MonitoringClient, createMonitoringClient, } from './monitoring-client.js';
 import { RemoteLogger, createRemoteLogger } from './remote-logger.js';
+import { DexLoggerService, DEX_LOGGER_TOKEN } from './dex-logger.service.js';
 import { startConsoleCapture, stopConsoleCapture } from './console-capture.js';
+import { startNestLoggerCapture, stopNestLoggerCapture } from './nest-logger-capture.js';
 import { Logger, LOGGER_TOKEN, } from '@dex-monit/observability-logger';
 // Re-export LOGGER_TOKEN for convenience
 export { LOGGER_TOKEN };
@@ -21,8 +23,9 @@ export const MONITORING_CLIENT_TOKEN = 'OBSERVABILITY_MONITORING_CLIENT';
  * - Request ID middleware for tracing
  * - Error capture interceptor (captures ALL errors, even if other filters exist)
  * - Global exception filter for error capture
- * - Logger instance (with automatic remote log capture if monitoring is configured)
+ * - DexLoggerService (NestJS compatible logger with remote capture)
  * - Console capture (intercepts console.log/warn/error)
+ * - NestJS Logger capture (intercepts Logger.log/warn/error)
  * - Monitoring client instance
  */
 let SdkNodeModule = (() => {
@@ -54,13 +57,47 @@ let SdkNodeModule = (() => {
             });
             // Store reference for cleanup
             SdkNodeModule.remoteLogger = logger;
-            // Start console capture if enabled (default: true)
-            if (monitoringClient && (config.captureConsole ?? true)) {
-                startConsoleCapture(monitoringClient);
+            // Start captures if monitoring is configured
+            if (monitoringClient) {
+                // Console capture (default: true)
+                if (config.captureConsole ?? true) {
+                    startConsoleCapture(monitoringClient);
+                }
+                // NestJS Logger capture (default: true)
+                if (config.captureNestLogger ?? true) {
+                    startNestLoggerCapture(monitoringClient);
+                }
             }
             return {
                 module: SdkNodeModule,
                 providers: [
+                    // Monitoring Client
+                    {
+                        provide: MONITORING_CLIENT_TOKEN,
+                        useValue: monitoringClient,
+                    },
+                    {
+                        provide: MonitoringClient,
+                        useValue: monitoringClient,
+                    },
+                    // DexLoggerService - the main logger to use
+                    {
+                        provide: DEX_LOGGER_TOKEN,
+                        useFactory: () => {
+                            const dexLogger = new DexLoggerService();
+                            dexLogger.setMonitoringClient(monitoringClient);
+                            return dexLogger;
+                        },
+                    },
+                    {
+                        provide: DexLoggerService,
+                        useFactory: () => {
+                            const dexLogger = new DexLoggerService();
+                            dexLogger.setMonitoringClient(monitoringClient);
+                            return dexLogger;
+                        },
+                    },
+                    // Legacy Logger support
                     {
                         provide: LOGGER_TOKEN,
                         useValue: logger,
@@ -73,16 +110,7 @@ let SdkNodeModule = (() => {
                         provide: RemoteLogger,
                         useValue: logger,
                     },
-                    {
-                        provide: MONITORING_CLIENT_TOKEN,
-                        useValue: monitoringClient,
-                    },
-                    {
-                        provide: MonitoringClient,
-                        useValue: monitoringClient,
-                    },
                     // Interceptor captures errors BEFORE any exception filter
-                    // This ensures we capture errors even if another filter handles them
                     {
                         provide: APP_INTERCEPTOR,
                         useFactory: () => new ErrorCaptureInterceptor(monitoringClient),
@@ -95,11 +123,15 @@ let SdkNodeModule = (() => {
                     RequestIdMiddleware,
                 ],
                 exports: [
+                    // Main exports
+                    DexLoggerService,
+                    DEX_LOGGER_TOKEN,
+                    MONITORING_CLIENT_TOKEN,
+                    MonitoringClient,
+                    // Legacy exports
                     LOGGER_TOKEN,
                     Logger,
                     RemoteLogger,
-                    MONITORING_CLIENT_TOKEN,
-                    MonitoringClient,
                 ],
             };
         }
@@ -114,8 +146,9 @@ let SdkNodeModule = (() => {
          * Cleanup on module destroy
          */
         async onModuleDestroy() {
-            // Stop console capture
+            // Stop captures
             stopConsoleCapture();
+            stopNestLoggerCapture();
             // Flush remaining logs
             if (SdkNodeModule.remoteLogger) {
                 await SdkNodeModule.remoteLogger.close();