@ngn-net/nestjs-telescope 0.3.2 → 0.3.3

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.2",
-  "builtAt": "2026-06-13T10:27:41.954Z"
+  "version": "0.3.3",
+  "builtAt": "2026-06-13T10:32:49.119Z"
 }

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.2",
+  "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
     },