@dex-monit/observability-sdk-node 1.0.5 → 1.0.7

package/dist/lib/console-capture.d.ts

@@ -0,0 +1,14 @@
+import { MonitoringClient } from './monitoring-client.js';
+/**
+ * Start capturing console output and sending to monitoring
+ */
+export declare function startConsoleCapture(monitoringClient: MonitoringClient): void;
+/**
+ * Stop capturing console output
+ */
+export declare function stopConsoleCapture(): void;
+/**
+ * Check if console capture is active
+ */
+export declare function isConsoleCaptureActive(): boolean;
+//# sourceMappingURL=console-capture.d.ts.map

package/dist/lib/console-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-capture.d.ts","sourceRoot":"","sources":["../../src/lib/console-capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAwB1D;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAyC5E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAazC;AAqBD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD"}

package/dist/lib/console-capture.js

@@ -0,0 +1,87 @@
+const CONSOLE_TO_SEVERITY = {
+    debug: 'debug',
+    log: 'info',
+    info: 'info',
+    warn: 'warning',
+    error: 'error',
+};
+let originalMethods = null;
+let isCapturing = false;
+/**
+ * Start capturing console output and sending to monitoring
+ */
+export function startConsoleCapture(monitoringClient) {
+    if (isCapturing) {
+        return;
+    }
+    // Store original methods
+    originalMethods = {
+        log: console.log.bind(console),
+        info: console.info.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        debug: console.debug.bind(console),
+    };
+    const methods = ['log', 'info', 'warn', 'error', 'debug'];
+    for (const method of methods) {
+        const original = originalMethods[method];
+        const severity = CONSOLE_TO_SEVERITY[method];
+        console[method] = (...args) => {
+            // Call original console method first
+            original(...args);
+            // Skip if it's our own SDK log to avoid infinite loops
+            const message = formatConsoleArgs(args);
+            if (message.startsWith('[DEX SDK]') || message.startsWith('[MonitoringClient]') || message.startsWith('[RemoteLogger]')) {
+                return;
+            }
+            // Send to monitoring (fire and forget)
+            monitoringClient.captureLog(severity, message, {
+                source: 'console',
+                method,
+            }).catch(() => {
+                // Silently ignore - don't use console.error here to avoid loops
+            });
+        };
+    }
+    isCapturing = true;
+}
+/**
+ * Stop capturing console output
+ */
+export function stopConsoleCapture() {
+    if (!isCapturing || !originalMethods) {
+        return;
+    }
+    console.log = originalMethods.log;
+    console.info = originalMethods.info;
+    console.warn = originalMethods.warn;
+    console.error = originalMethods.error;
+    console.debug = originalMethods.debug;
+    originalMethods = null;
+    isCapturing = false;
+}
+/**
+ * Format console arguments into a single message string
+ */
+function formatConsoleArgs(args) {
+    return args.map(arg => {
+        if (typeof arg === 'string') {
+            return arg;
+        }
+        if (arg instanceof Error) {
+            return `${arg.name}: ${arg.message}\n${arg.stack || ''}`;
+        }
+        try {
+            return JSON.stringify(arg, null, 2);
+        }
+        catch {
+            return String(arg);
+        }
+    }).join(' ');
+}
+/**
+ * Check if console capture is active
+ */
+export function isConsoleCaptureActive() {
+    return isCapturing;
+}

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/sdk-node.d.ts

@@ -3,4 +3,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';
 //# 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"}
+{"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"}

package/dist/lib/sdk-node.js

@@ -4,3 +4,6 @@ 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';

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

@@ -1,4 +1,4 @@
-import { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common';
+import { DynamicModule, MiddlewareConsumer, NestModule, OnModuleDestroy } from '@nestjs/common';
 import { MonitoringClientConfig } from './monitoring-client.js';
 import { LoggerConfig, LOGGER_TOKEN } from '@dex-monit/observability-logger';
 import { Severity } from '@dex-monit/observability-contracts';
@@ -12,8 +12,10 @@ export interface SdkNodeModuleConfig {
     monitoring?: MonitoringClientConfig;
     /** Whether to apply middleware globally */
     global?: boolean;
-    /** Minimum log level to send remotely (default: 'info') */
+    /** Minimum log level to send remotely (default: 'debug' = capture all) */
     remoteLogLevel?: Severity;
+    /** Whether to capture console.log/warn/error (default: true) */
+    captureConsole?: boolean;
 }
 export { LOGGER_TOKEN };
 /**
@@ -27,10 +29,12 @@ 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)
  * - Monitoring client instance
  */
-export declare class SdkNodeModule implements NestModule {
+export declare class SdkNodeModule implements NestModule, OnModuleDestroy {
+    private static remoteLogger;
     /**
      * Register the module with configuration
      */
@@ -39,5 +43,9 @@ export declare class SdkNodeModule implements NestModule {
      * Configure middleware
      */
     configure(consumer: MiddlewareConsumer): void;
+    /**
+     * Cleanup on module destroy
+     */
+    onModuleDestroy(): Promise<void>;
 }
 //# sourceMappingURL=sdk-node.module.d.ts.map

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,EACX,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAEL,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAEhC,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,2DAA2D;IAC3D,cAAc,CAAC,EAAE,QAAQ,CAAC;CAC3B;AAGD,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,uBAAuB,oCAAoC,CAAC;AAEzE;;;;;;;;;GASG;AACH,qBAEa,aAAc,YAAW,UAAU;IAC9C;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa;IA4D1D;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;CAI9C"}
+{"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;AAIhC,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;IAwF1D;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAK7C;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;CASvC"}

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

@@ -6,6 +6,8 @@ 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 { Logger, LOGGER_TOKEN, } from '@dex-monit/observability-logger';
 // Re-export LOGGER_TOKEN for convenience
 export { LOGGER_TOKEN };
@@ -20,7 +22,8 @@ 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)
  * - Monitoring client instance
  */
 let SdkNodeModule = (() => {
@@ -35,8 +38,8 @@ let SdkNodeModule = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             SdkNodeModule = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static remoteLogger = null;
         /**
          * Register the module with configuration
          */
@@ -44,17 +47,48 @@ let SdkNodeModule = (() => {
             const monitoringClient = config.monitoring
                 ? createMonitoringClient(config.monitoring)
                 : undefined;
-            // Use RemoteLogger if monitoring is configured, otherwise use base Logger
-            const logger = monitoringClient
-                ? createRemoteLogger({
-                    ...config.logger,
-                    monitoringClient,
-                    remoteLevel: config.remoteLogLevel || 'info',
-                })
-                : createRemoteLogger(config.logger);
+            // Use RemoteLogger if monitoring is configured
+            const logger = createRemoteLogger({
+                ...config.logger,
+                monitoringClient,
+                remoteLevel: config.remoteLogLevel || 'debug', // Default: capture ALL logs
+            });
+            // Store reference for cleanup
+            SdkNodeModule.remoteLogger = logger;
+            // Start console capture if enabled (default: true)
+            if (monitoringClient && (config.captureConsole ?? true)) {
+                startConsoleCapture(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,
@@ -67,16 +101,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),
@@ -89,11 +114,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,
                 ],
             };
         }
@@ -104,6 +133,20 @@ let SdkNodeModule = (() => {
             // Apply RequestIdMiddleware to all routes
             consumer.apply(RequestIdMiddleware).forRoutes('*');
         }
+        /**
+         * Cleanup on module destroy
+         */
+        async onModuleDestroy() {
+            // Stop console capture
+            stopConsoleCapture();
+            // Flush remaining logs
+            if (SdkNodeModule.remoteLogger) {
+                await SdkNodeModule.remoteLogger.close();
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return SdkNodeModule = _classThis;
 })();