@ngn-net/nestjs-telescope 0.3.1 → 0.3.3

package/README.md

@@ -4,7 +4,7 @@
 
 A full-featured developer assistant and application monitoring suite for NestJS, inspired by Laravel Telescope. It monitors incoming HTTP requests, database queries, cache operations, background queue jobs, application events, outgoing mail, logs, unhandled exceptions, cron job schedules, Redis commands, CLI commands, ORM model lifecycle events, notifications, and authorization gate checks.
 
-All telemetry records are persisted to **MongoDB** (via Mongoose) for zero-impact storage that never touches your production database.
+All telemetry records are persisted to a **dedicated MongoDB** (via Mongoose) and accessible via a modern, high-fidelity dark-themed single-page application dashboard. Telescope uses its own MongoDB connection — completely separate from your project's database.
 
 ---
 
@@ -41,18 +41,18 @@ Telescope stores its telemetry data in a **dedicated MongoDB collection** (`tele
 
 ### MongoDB Connection
 
-Telescope connects to MongoDB using the `MONGO_URI` environment variable, or falls back to `mongodb://localhost:27017/telescope`.
+Telescope connects to its own dedicated MongoDB using the `TELESCOPE_MONGO_URI` environment variable, or falls back to `mongodb://localhost:27017/telescope`.
 
 ```bash
 # .env
-MONGO_URI=mongodb://localhost:27017/telescope
+TELESCOPE_MONGO_URI=mongodb://localhost:27017/telescope
 ```
 
 Or pass the URI directly in configuration:
 
 ```typescript
 TelescopeModule.forRoot({
-  mongoUri: 'mongodb://localhost:27017/telescope',
+  mongoUri: 'mongodb://your-mongo-host:27017/telescope',
   // ... other options
 })
 ```
@@ -64,10 +64,10 @@ TelescopeModule.forRoot({
 Install the package:
 
 ```bash
-npm install @ngn-net/nestjs-telescope @nestjs/mongoose mongoose @nestjs/jwt @nestjs/passport passport-jwt
+npm install @ngn-net/nestjs-telescope @nestjs/jwt @nestjs/passport passport-jwt
 ```
 
-Ensure you have `MongooseModule` initialized in your NestJS application.
+No need to install `mongoose` or configure `MongooseModule` — Telescope handles its own MongoDB connection internally.
 
 ---
 
@@ -75,25 +75,23 @@ Ensure you have `MongooseModule` initialized in your NestJS application.
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { MongooseModule } from '@nestjs/mongoose';
 import { TelescopeModule } from '@ngn-net/nestjs-telescope';
 
 @Module({
   imports: [
-    MongooseModule.forRoot(process.env.MONGO_URI || 'mongodb://localhost:27017/telescope'),
     TelescopeModule.forRoot({
       path: 'telescope',
       jwtSecret: 'your-secret-key',
       password: 'your-password',
+      // Telescope connects to its own MongoDB automatically
+      // Default: mongodb://localhost:27017/telescope
     }),
   ],
 })
 export class AppModule {}
 ```
 
----
-
-## Optional & Peer Dependencies
+Your app's database (TypeORM/Prisma/Sequelize/etc.) stays completely separate — Telescope never touches it.
 
 All watchers are dynamically activated. If your application does not use certain modules, Telescope will safely boot without them. Simply install the peer dependencies for the watchers you want to enable:
 
@@ -147,35 +145,22 @@ You can pass configuration options into `TelescopeModule.forRoot(options)`:
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { MongooseModule } from '@nestjs/mongoose';
+import { TypeOrmModule } from '@nestjs/typeorm';
 import { TelescopeModule, EntryType } from '@ngn-net/nestjs-telescope';
 
 @Module({
   imports: [
-    MongooseModule.forRoot(process.env.MONGO_URI || 'mongodb://localhost:27017/myapp'),
+    // Your project database — completely separate from Telescope
+    TypeOrmModule.forRoot({
+      type: 'postgres',
+      database: 'myapp_db',
+    }),
     TelescopeModule.forRoot({
       path: 'telescope',
       password: 'my-secure-password',
       jwtSecret: 'my-jwt-secret',
       maxEntries: 500,
-      ignorePaths: ['/health-check'],
-      enabledEntryTypes: [
-        EntryType.REQUEST,
-        EntryType.HTTP_CLIENT,
-        EntryType.QUERY,
-        EntryType.CACHE,
-        EntryType.JOB,
-        EntryType.EVENT,
-        EntryType.LOG,
-        EntryType.EXCEPTION,
-        EntryType.SCHEDULED_TASK,
-        EntryType.REDIS,
-        EntryType.MAIL,
-        EntryType.GATE,
-        EntryType.COMMAND,
-        EntryType.MODEL,
-        EntryType.NOTIFICATION,
-      ],
+      // Telescope uses its own MongoDB: mongodb://localhost:27017/telescope
     }),
   ],
 })
@@ -277,14 +262,14 @@ npm run test
 
 If upgrading from v0.2.x (which used TypeORM/SQL):
 
-1. Install the new dependencies:
+1. Update the package:
    ```bash
-   npm install @ngn-net/nestjs-telescope @nestjs/mongoose mongoose
+   npm install @ngn-net/nestjs-telescope@latest
    ```
 
-2. Add `MongooseModule.forRoot()` to your root module (if not already present).
+2. Ensure MongoDB is available at `mongodb://localhost:27017/telescope` (or configure `mongoUri`).
 
-3. Remove the old TypeORM-based telescope entity — Telescope now manages its own MongoDB collection automatically.
+3. Remove the old `TypeOrmModule` import if it was only added for Telescope.
 
 4. The old `telescope_entries` SQL table can be dropped after migration.
 

package/dist/enums/entry-type.enum.d.ts

@@ -14,5 +14,6 @@ export declare enum EntryType {
     COMMAND = "command",
     MODEL = "model",
     NOTIFICATION = "notification",
-    DUMP = "dump"
+    DUMP = "dump",
+    RABBITMQ = "rabbitmq"
 }

package/dist/enums/entry-type.enum.js

@@ -20,4 +20,5 @@ var EntryType;
     EntryType["MODEL"] = "model";
     EntryType["NOTIFICATION"] = "notification";
     EntryType["DUMP"] = "dump";
+    EntryType["RABBITMQ"] = "rabbitmq";
 })(EntryType || (exports.EntryType = EntryType = {}));

package/dist/index.d.ts

@@ -13,3 +13,4 @@ export * from './watchers/model.watcher';
 export * from './watchers/notification.watcher';
 export * from './watchers/gate.watcher';
 export * from './watchers/http-client.watcher';
+export * from './watchers/rabbitmq.watcher';

package/dist/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./watchers/model.watcher"), exports);
 __exportStar(require("./watchers/notification.watcher"), exports);
 __exportStar(require("./watchers/gate.watcher"), exports);
 __exportStar(require("./watchers/http-client.watcher"), exports);
+__exportStar(require("./watchers/rabbitmq.watcher"), exports);

package/dist/telescope.module.js

@@ -42,6 +42,7 @@ const command_watcher_1 = require("./watchers/command.watcher");
 const model_watcher_1 = require("./watchers/model.watcher");
 const notification_watcher_1 = require("./watchers/notification.watcher");
 const gate_watcher_1 = require("./watchers/gate.watcher");
+const rabbitmq_watcher_1 = require("./watchers/rabbitmq.watcher");
 const constants_1 = require("./constants");
 const entry_type_enum_1 = require("./enums/entry-type.enum");
 let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
@@ -295,6 +296,13 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
             }
         }
         catch (e) { }
+        try {
+            require('@golevelup/nestjs-rabbitmq');
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.RABBITMQ)) {
+                providers.push(rabbitmq_watcher_1.RabbitMQWatcher);
+            }
+        }
+        catch (e) { }
     }
     static registerWatchersAndModulesAsync(providers, imports) {
         providers.push({ provide: core_1.APP_INTERCEPTOR, useClass: http_request_watcher_1.HttpRequestWatcher });
@@ -344,6 +352,11 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
             providers.push(mail_watcher_1.MailWatcher);
         }
         catch (e) { }
+        try {
+            require('@golevelup/nestjs-rabbitmq');
+            providers.push(rabbitmq_watcher_1.RabbitMQWatcher);
+        }
+        catch (e) { }
     }
 };
 exports.TelescopeModule = TelescopeModule;

package/dist/ui/manifest.json

@@ -1,5 +1,5 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.3.1",
-  "builtAt": "2026-06-13T09:06:28.974Z"
+  "version": "0.3.3",
+  "builtAt": "2026-06-13T10:32:49.119Z"
 }

package/dist/watchers/exception.watcher.js

@@ -10,7 +10,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExceptionWatcher = void 0;
-// src/watchers/exception.watcher.ts
 const common_1 = require("@nestjs/common");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
@@ -22,11 +21,14 @@ 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();
+        const url = request.originalUrl || request.url || '';
+        if (this.telescope.shouldIgnorePath(url)) {
+            return next.handle();
+        }
         return next.handle().pipe((0, operators_1.catchError)((err) => {
             this.telescope.record({
                 type: entry_type_enum_1.EntryType.EXCEPTION,
@@ -35,10 +37,9 @@ let ExceptionWatcher = class ExceptionWatcher {
                     message: err.message || String(err),
                     stack: err.stack || null,
                     status: err.status || err.statusCode || 500,
-                    // Include request context for easier debugging
                     request: {
                         method: request?.method,
-                        url: request?.originalUrl || request?.url,
+                        url,
                         ip: request?.ip,
                     },
                 },

package/dist/watchers/gate.watcher.js

@@ -24,6 +24,10 @@ let GateWatcher = class GateWatcher {
             return next.handle();
         }
         const request = context.switchToHttp().getRequest();
+        const url = request.originalUrl || request.url || '';
+        if (this.telescope.shouldIgnorePath(url)) {
+            return next.handle();
+        }
         const user = request.user || request.auth || null;
         return next.handle().pipe((0, rxjs_1.tap)({
             next: () => {
@@ -34,7 +38,7 @@ let GateWatcher = class GateWatcher {
                         allowed: true,
                         user: user ? { id: user.sub || user.id || user.username } : null,
                         method: request.method,
-                        url: request.originalUrl || request.url,
+                        url,
                     },
                 }).catch(() => { });
             },
@@ -50,7 +54,7 @@ let GateWatcher = class GateWatcher {
                             reason: err.message || err.constructor?.name || 'Access denied',
                             user: user ? { id: user.sub || user.id || user.username } : null,
                             method: request.method,
-                            url: request.originalUrl || request.url,
+                            url,
                         },
                     }).catch(() => { });
                 }

package/dist/watchers/log.watcher.js

@@ -41,7 +41,7 @@ let LogWatcher = class LogWatcher {
                 rawMessage = chunk.toString(encoding || 'utf8');
             }
             // Skip telescope internal queries or module logs
-            if (rawMessage.includes('telescope_entries') || rawMessage.includes('TelescopeModule')) {
+            if (rawMessage.includes('telescope_entries') || rawMessage.includes('TelescopeModule') || rawMessage.includes('Telescope')) {
                 return;
             }
             // Parse the log message

package/dist/watchers/rabbitmq.watcher.d.ts

@@ -0,0 +1,11 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+export declare class RabbitMQWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly logger;
+    constructor(telescope: TelescopeService);
+    onModuleInit(): void;
+    private patchAmqpConnection;
+    private patchRabbitSubscribe;
+    private sanitizeMessage;
+}

package/dist/watchers/rabbitmq.watcher.js

@@ -0,0 +1,231 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var RabbitMQWatcher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQWatcher = 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");
+let RabbitMQWatcher = RabbitMQWatcher_1 = class RabbitMQWatcher {
+    telescope;
+    logger = new common_1.Logger(RabbitMQWatcher_1.name);
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        this.patchAmqpConnection();
+        this.patchRabbitSubscribe();
+    }
+    patchAmqpConnection() {
+        try {
+            const { AmqpConnection } = require('@golevelup/nestjs-rabbitmq');
+            if (!AmqpConnection || !AmqpConnection.prototype)
+                return;
+            const originalPublish = AmqpConnection.prototype.publish;
+            if (!originalPublish)
+                return;
+            const self = this;
+            AmqpConnection.prototype.publish = async function (exchange, routingKey, msg, ...args) {
+                const startTime = Date.now();
+                const result = await originalPublish.call(this, exchange, routingKey, msg, ...args);
+                const duration = Date.now() - startTime;
+                const sanitizedMsg = self.sanitizeMessage(msg);
+                self.telescope.record({
+                    type: entry_type_enum_1.EntryType.RABBITMQ,
+                    content: {
+                        direction: 'outgoing',
+                        exchange,
+                        routingKey,
+                        message: sanitizedMsg,
+                        duration,
+                        status: 'sent',
+                    },
+                }).catch(() => { });
+                return result;
+            };
+        }
+        catch { }
+    }
+    patchRabbitSubscribe() {
+        try {
+            const rabbitmq = require('@golevelup/nestjs-rabbitmq');
+            if (!rabbitmq)
+                return;
+            const self = this;
+            const RabbitSubscribeHandler = rabbitmq.RabbitSubscribe;
+            if (RabbitSubscribeHandler) {
+                const originalHandler = RabbitSubscribeHandler;
+                rabbitmq.RabbitSubscribe = function (options) {
+                    const decorator = originalHandler(options);
+                    return function (target, propertyKey, descriptor) {
+                        const originalMethod = descriptor.value;
+                        const exchange = options?.exchange || '';
+                        const routingKey = options?.routingKey || '';
+                        const queue = options?.queue || '';
+                        descriptor.value = async function (...args) {
+                            const startTime = Date.now();
+                            const incomingMsg = args[0];
+                            self.telescope.record({
+                                type: entry_type_enum_1.EntryType.RABBITMQ,
+                                content: {
+                                    direction: 'incoming',
+                                    exchange,
+                                    routingKey,
+                                    queue,
+                                    message: self.sanitizeMessage(incomingMsg),
+                                    handler: `${target.constructor?.name || 'Unknown'}.${propertyKey}`,
+                                    timestamp: new Date().toISOString(),
+                                },
+                            }).catch(() => { });
+                            try {
+                                const result = await originalMethod.apply(this, args);
+                                const duration = Date.now() - startTime;
+                                self.telescope.record({
+                                    type: entry_type_enum_1.EntryType.RABBITMQ,
+                                    content: {
+                                        direction: 'incoming_response',
+                                        exchange,
+                                        routingKey,
+                                        queue,
+                                        handler: `${target.constructor?.name || 'Unknown'}.${propertyKey}`,
+                                        duration,
+                                        status: 'completed',
+                                    },
+                                }).catch(() => { });
+                                return result;
+                            }
+                            catch (err) {
+                                const duration = Date.now() - startTime;
+                                self.telescope.record({
+                                    type: entry_type_enum_1.EntryType.RABBITMQ,
+                                    content: {
+                                        direction: 'incoming_response',
+                                        exchange,
+                                        routingKey,
+                                        queue,
+                                        handler: `${target.constructor?.name || 'Unknown'}.${propertyKey}`,
+                                        duration,
+                                        status: 'failed',
+                                        error: err.message || String(err),
+                                    },
+                                }).catch(() => { });
+                                throw err;
+                            }
+                        };
+                        return descriptor;
+                    };
+                };
+            }
+            const RabbitRPCHandler = rabbitmq.RabbitRPC;
+            if (RabbitRPCHandler) {
+                const originalRPCHandler = RabbitRPCHandler;
+                rabbitmq.RabbitRPC = function (options) {
+                    const decorator = originalRPCHandler(options);
+                    return function (target, propertyKey, descriptor) {
+                        const originalMethod = descriptor.value;
+                        const exchange = options?.exchange || '';
+                        const routingKey = options?.routingKey || '';
+                        const queue = options?.queue || '';
+                        descriptor.value = async function (...args) {
+                            const startTime = Date.now();
+                            const incomingMsg = args[0];
+                            self.telescope.record({
+                                type: entry_type_enum_1.EntryType.RABBITMQ,
+                                content: {
+                                    direction: 'incoming_rpc',
+                                    exchange,
+                                    routingKey,
+                                    queue,
+                                    message: self.sanitizeMessage(incomingMsg),
+                                    handler: `${target.constructor?.name || 'Unknown'}.${propertyKey}`,
+                                    timestamp: new Date().toISOString(),
+                                },
+                            }).catch(() => { });
+                            try {
+                                const result = await originalMethod.apply(this, args);
+                                const duration = Date.now() - startTime;
+                                self.telescope.record({
+                                    type: entry_type_enum_1.EntryType.RABBITMQ,
+                                    content: {
+                                        direction: 'incoming_rpc_response',
+                                        exchange,
+                                        routingKey,
+                                        queue,
+                                        handler: `${target.constructor?.name || 'Unknown'}.${propertyKey}`,
+                                        duration,
+                                        status: 'completed',
+                                    },
+                                }).catch(() => { });
+                                return result;
+                            }
+                            catch (err) {
+                                const duration = Date.now() - startTime;
+                                self.telescope.record({
+                                    type: entry_type_enum_1.EntryType.RABBITMQ,
+                                    content: {
+                                        direction: 'incoming_rpc_response',
+                                        exchange,
+                                        routingKey,
+                                        queue,
+                                        handler: `${target.constructor?.name || 'Unknown'}.${propertyKey}`,
+                                        duration,
+                                        status: 'failed',
+                                        error: err.message || String(err),
+                                    },
+                                }).catch(() => { });
+                                throw err;
+                            }
+                        };
+                        return descriptor;
+                    };
+                };
+            }
+        }
+        catch { }
+    }
+    sanitizeMessage(msg) {
+        if (!msg)
+            return null;
+        if (typeof msg === 'string') {
+            try {
+                const parsed = JSON.parse(msg);
+                return this.sanitizeMessage(parsed);
+            }
+            catch {
+                return msg.length > 1000 ? msg.substring(0, 1000) + '...[truncated]' : msg;
+            }
+        }
+        if (Buffer.isBuffer(msg)) {
+            return '[Buffer]';
+        }
+        if (typeof msg === 'object') {
+            const sanitized = {};
+            for (const [key, value] of Object.entries(msg)) {
+                if (key.toLowerCase().includes('password') || key.toLowerCase().includes('secret') || key.toLowerCase().includes('token')) {
+                    sanitized[key] = '[REDACTED]';
+                }
+                else if (typeof value === 'string' && value.length > 500) {
+                    sanitized[key] = value.substring(0, 500) + '...[truncated]';
+                }
+                else {
+                    sanitized[key] = value;
+                }
+            }
+            return sanitized;
+        }
+        return msg;
+    }
+};
+exports.RabbitMQWatcher = RabbitMQWatcher;
+exports.RabbitMQWatcher = RabbitMQWatcher = RabbitMQWatcher_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], RabbitMQWatcher);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "publishConfig": {
     "access": "public"
   },
@@ -30,6 +30,7 @@
     "reflect-metadata": "^0.2"
   },
   "peerDependencies": {
+    "@golevelup/nestjs-rabbitmq": "^9",
     "@nestjs/bullmq": "^11",
     "@nestjs/cache-manager": "^3",
     "@nestjs/common": "^11",
@@ -45,6 +46,9 @@
     "typeorm": "^0.3"
   },
   "peerDependenciesMeta": {
+    "@golevelup/nestjs-rabbitmq": {
+      "optional": true
+    },
     "@nestjs/bullmq": {
       "optional": true
     },