@ngn-net/nestjs-telescope 0.2.8 → 0.2.10

package/dist/ui/manifest.json

@@ -1,5 +1,5 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.2.8",
-  "builtAt": "2026-06-08T12:41:45.083Z"
+  "version": "0.2.10",
+  "builtAt": "2026-06-08T12:50:24.624Z"
 }

package/dist/watchers/exception.watcher.js

@@ -22,6 +22,10 @@ let ExceptionWatcher = class ExceptionWatcher {
         this.telescope = telescope;
     }
     intercept(context, next) {
+        // Skip non-HTTP execution contexts (e.g. RPC/RabbitMQ or WebSockets)
+        if (context.getType() !== 'http') {
+            return next.handle();
+        }
         const request = context.switchToHttp().getRequest();
         return next.handle().pipe((0, operators_1.catchError)((err) => {
             this.telescope.record({
@@ -38,7 +42,7 @@ let ExceptionWatcher = class ExceptionWatcher {
                         ip: request?.ip,
                     },
                 },
-            });
+            }).catch(() => { });
             return (0, rxjs_1.throwError)(() => err);
         }));
     }

package/dist/watchers/http-request.watcher.js

@@ -27,6 +27,10 @@ let HttpRequestWatcher = class HttpRequestWatcher {
         this.options = options;
     }
     intercept(context, next) {
+        // Skip non-HTTP execution contexts (e.g. RPC/RabbitMQ or WebSockets)
+        if (context.getType() !== 'http') {
+            return next.handle();
+        }
         const request = context.switchToHttp().getRequest();
         const response = context.switchToHttp().getResponse();
         const url = request.originalUrl || request.url || '/';
@@ -43,20 +47,40 @@ let HttpRequestWatcher = class HttpRequestWatcher {
             query: request.query,
             ip: request.ip,
         };
-        return next.handle().pipe((0, operators_1.tap)((responseBody) => {
-            const duration = Date.now() - start;
-            const statusCode = response.statusCode || 200;
-            this.telescope.record({
-                type: entry_type_enum_1.EntryType.REQUEST,
-                content: {
-                    request: requestData,
-                    response: {
-                        statusCode,
-                        body: responseBody,
+        return next.handle().pipe((0, operators_1.tap)({
+            next: (responseBody) => {
+                const duration = Date.now() - start;
+                const statusCode = response.statusCode || 200;
+                this.telescope.record({
+                    type: entry_type_enum_1.EntryType.REQUEST,
+                    content: {
+                        request: requestData,
+                        response: {
+                            statusCode,
+                            body: responseBody,
+                        },
+                        duration,
+                    },
+                }).catch(() => { });
+            },
+            error: (error) => {
+                const duration = Date.now() - start;
+                const statusCode = error.status || error.statusCode || 500;
+                this.telescope.record({
+                    type: entry_type_enum_1.EntryType.REQUEST,
+                    content: {
+                        request: requestData,
+                        response: {
+                            statusCode,
+                            body: {
+                                message: error.message || String(error),
+                                error: error.name || 'Error',
+                            },
+                        },
+                        duration,
                     },
-                    duration,
-                },
-            });
+                }).catch(() => { });
+            },
         }));
     }
 };

package/dist/watchers/log.watcher.js

@@ -14,6 +14,44 @@ exports.LogWatcher = void 0;
 const common_1 = require("@nestjs/common");
 const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
+class TelescopeLoggerWrapper {
+    original;
+    recordLog;
+    constructor(original, recordLog) {
+        this.original = original;
+        this.recordLog = recordLog;
+    }
+    log(message, ...optionalParams) {
+        this.recordLog('log', message, ...optionalParams);
+        this.original.log(message, ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        this.recordLog('error', message, ...optionalParams);
+        this.original.error(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this.recordLog('warn', message, ...optionalParams);
+        this.original.warn(message, ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        this.recordLog('debug', message, ...optionalParams);
+        if (this.original.debug) {
+            this.original.debug(message, ...optionalParams);
+        }
+    }
+    verbose(message, ...optionalParams) {
+        this.recordLog('verbose', message, ...optionalParams);
+        if (this.original.verbose) {
+            this.original.verbose(message, ...optionalParams);
+        }
+    }
+    fatal(message, ...optionalParams) {
+        this.recordLog('fatal', message, ...optionalParams);
+        if (this.original.fatal) {
+            this.original.fatal(message, ...optionalParams);
+        }
+    }
+}
 let LogWatcher = class LogWatcher {
     telescope;
     isRecording = false; // Guard against infinite recursion
@@ -27,38 +65,76 @@ let LogWatcher = class LogWatcher {
         const originalDebug = console.debug.bind(console);
         const self = this;
         const formatArgs = (args) => args.map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ');
-        const recordLog = (level, args) => {
-            // Guard: if we're already recording, skip to prevent infinite recursion
-            // (recording a log → save to DB → TypeORM logs → recording again → ...)
+        const recordConsoleLog = (level, args) => {
             if (self.isRecording)
                 return;
+            const message = formatArgs(args);
+            // Skip telescope queries, logs, or dashboard routes to prevent recursion
+            if (message.includes('telescope_entries') || message.includes('TelescopeModule')) {
+                return;
+            }
             self.isRecording = true;
             try {
                 self.telescope.record({
                     type: entry_type_enum_1.EntryType.LOG,
-                    content: { level, message: formatArgs(args) },
-                });
+                    content: { level, message },
+                }).catch(() => { });
             }
             finally {
                 self.isRecording = false;
             }
         };
+        // 1. Intercept raw console logs
         console.log = function (...args) {
-            recordLog('log', args);
+            recordConsoleLog('log', args);
             return originalLog(...args);
         };
         console.error = function (...args) {
-            recordLog('error', args);
+            recordConsoleLog('error', args);
             return originalError(...args);
         };
         console.warn = function (...args) {
-            recordLog('warn', args);
+            recordConsoleLog('warn', args);
             return originalWarn(...args);
         };
         console.debug = function (...args) {
-            recordLog('debug', args);
+            recordConsoleLog('debug', args);
             return originalDebug(...args);
         };
+        // 2. Intercept NestJS Logger Service logs
+        try {
+            const activeLogger = common_1.Logger.logger;
+            if (activeLogger && !(activeLogger instanceof TelescopeLoggerWrapper)) {
+                const wrapper = new TelescopeLoggerWrapper(activeLogger, (level, message, ...optionalParams) => {
+                    if (self.isRecording)
+                        return;
+                    let formattedMessage = typeof message === 'object' ? JSON.stringify(message) : String(message);
+                    if (optionalParams.length > 0) {
+                        // Get context (usually the last parameter, e.g. [PurchaseService])
+                        const context = optionalParams[optionalParams.length - 1];
+                        const contextStr = typeof context === 'string' ? `[${context}] ` : '';
+                        formattedMessage = contextStr + formattedMessage;
+                    }
+                    if (formattedMessage.includes('telescope_entries') || formattedMessage.includes('TelescopeModule')) {
+                        return;
+                    }
+                    self.isRecording = true;
+                    try {
+                        self.telescope.record({
+                            type: entry_type_enum_1.EntryType.LOG,
+                            content: { level, message: formattedMessage },
+                        }).catch(() => { });
+                    }
+                    finally {
+                        self.isRecording = false;
+                    }
+                });
+                common_1.Logger.overrideLogger(wrapper);
+            }
+        }
+        catch {
+            // Ignore errors if overrideLogger doesn't exist or fails
+        }
     }
 };
 exports.LogWatcher = LogWatcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "publishConfig": {
     "access": "public"
   },