@angelitosystems/nest-devtools 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -23,13 +23,13 @@ __export(index_exports, {
   NestDevTools: () => NestDevTools,
   captureError: () => captureError,
   devtools: () => devtools,
-  requestContext: () => import_devtools_core8.requestContext
+  requestContext: () => import_devtools_core12.requestContext
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/sdk.ts
 var import_os = require("os");
-var import_devtools_core7 = require("@angelitosystems/devtools-core");
+var import_devtools_core11 = require("@angelitosystems/devtools-core");
 
 // src/instrumentation/http.ts
 var import_devtools_protocol = require("@angelitosystems/devtools-protocol");
@@ -45,14 +45,37 @@ function emit(event, payload) {
 }
 
 // src/instrumentation/timeline.ts
+function startSpan(spans, layer, label, options) {
+  const span = {
+    layer,
+    label,
+    duration: 0,
+    startedAt: Date.now(),
+    status: options?.status ?? "ok",
+    ...options?.detail !== void 0 ? { detail: options.detail } : {},
+    ...options?.source !== void 0 ? { source: options.source } : {}
+  };
+  spans.push(span);
+  return span;
+}
+function endSpan(span, status) {
+  span.duration = Math.max(0, Date.now() - span.startedAt);
+  if (status) span.status = status;
+}
 var recorders = /* @__PURE__ */ new Map();
 function trackSpans(requestId, spans) {
   recorders.set(requestId, spans);
   return () => recorders.delete(requestId);
 }
+function recordSpan(requestId, layer, label, options) {
+  const spans = recorders.get(requestId);
+  if (!spans) return;
+  const span = startSpan(spans, layer, label, options);
+  endSpan(span, options?.status);
+}
 
 // src/instrumentation/http.ts
-var INTERESTING_HEADERS = [
+var REQUEST_HEADERS = [
   "content-type",
   "content-length",
   "accept",
@@ -60,7 +83,16 @@ var INTERESTING_HEADERS = [
   "referer",
   "user-agent",
   "x-forwarded-for",
-  "x-request-id"
+  "x-request-id",
+  "x-forwarded-proto"
+];
+var RESPONSE_HEADERS = [
+  "content-type",
+  "content-length",
+  "location",
+  "set-cookie",
+  "x-request-id",
+  "x-response-time"
 ];
 var WRAPPED = /* @__PURE__ */ Symbol("nest-devtools.wrapped");
 var HttpInstrumentation = class {
@@ -143,7 +175,8 @@ var HttpInstrumentation = class {
       projectId: this.ctx.projectInfo.projectId,
       method,
       url,
-      headers: this.collectHeaders(req),
+      route: routeFromReq(req),
+      headers: this.collectRequestHeaders(req),
       query: parseQuery(rawUrl),
       ip: clientIp(req),
       userAgent: asString(req.headers["user-agent"]) || void 0,
@@ -157,6 +190,7 @@ var HttpInstrumentation = class {
       status: "ok"
     };
     spans.push(middlewareSpan);
+    const capturedBody = this.ctx.config.capture.requests && this.ctx.config.maxPayloadBytes > 0 ? captureRequestPreview(req, this.redactor) : void 0;
     const onFinished = () => {
       const finishedAt = Date.now();
       middlewareSpan.duration = Math.max(0, finishedAt - middlewareSpan.startedAt);
@@ -166,20 +200,26 @@ var HttpInstrumentation = class {
         label: "response",
         duration: 0,
         startedAt: finishedAt,
-        status: "ok"
+        status: res.statusCode >= 400 ? "error" : "ok"
       };
       spans.push(responseSpan);
+      const responseHeaders = this.collectResponseHeaders(res);
+      const responsePreview = this.ctx.config.capture.requests && this.ctx.config.maxPayloadBytes > 0 ? captureResponsePreview(res, this.redactor) : void 0;
       const errored = res.statusCode >= 500;
       const completed = {
         requestId,
         projectId: this.ctx.projectInfo.projectId,
         method,
         url,
+        route: routeFromReq(req),
         statusCode: res.statusCode,
         duration: finishedAt - startedAt,
         startedAt,
         timeline: spans,
         query: parseQuery(rawUrl),
+        headers: responseHeaders,
+        responsePreview,
+        requestBody: capturedBody,
         errored
       };
       emit("request.completed", completed);
@@ -190,7 +230,7 @@ var HttpInstrumentation = class {
           name: "HttpError",
           message: `${method} ${url} failed with status ${res.statusCode}`,
           fingerprint: httpErrorFingerprint(method, url, res.statusCode),
-          request: { method, url, statusCode: res.statusCode },
+          request: { method, url: String(url), statusCode: res.statusCode },
           timestamp: finishedAt
         });
       }
@@ -202,15 +242,30 @@ var HttpInstrumentation = class {
       next();
     });
   }
-  collectHeaders(req) {
+  collectRequestHeaders(req) {
     const out = {};
-    for (const key of INTERESTING_HEADERS) {
+    for (const key of REQUEST_HEADERS) {
       const value = req.headers[key];
       if (value === void 0) continue;
       out[key] = this.redactor.isSensitive(key) ? "[REDACTED]" : asString(value).slice(0, 200);
     }
     return out;
   }
+  collectResponseHeaders(res) {
+    const out = {};
+    const headers = res._headers;
+    if (!headers || typeof headers !== "object") return out;
+    for (const rawKey of Object.keys(headers)) {
+      const key = rawKey.toLowerCase();
+      const ok = RESPONSE_HEADERS.some((h) => h.toLowerCase() === key);
+      if (!ok) continue;
+      const raw = headers[rawKey] ?? "";
+      const value = String(raw);
+      if (value === "") continue;
+      out[key] = this.redactor.isSensitive(key) ? "[REDACTED]" : value.slice(0, 200);
+    }
+    return out;
+  }
 };
 function asString(value) {
   if (Array.isArray(value)) return value.join(", ");
@@ -243,6 +298,54 @@ function clientIp(req) {
   if (typeof forwarded === "string") return forwarded.split(",")[0]?.trim();
   return req.socket?.remoteAddress ?? void 0;
 }
+function routeFromReq(req) {
+  try {
+    const http = req;
+    const out = {
+      requestId: "",
+      projectId: "",
+      method: "",
+      url: "",
+      route: void 0,
+      headers: {},
+      query: {},
+      ip: void 0,
+      userAgent: void 0,
+      startedAt: 0
+    };
+    const routeRaw = req.route;
+    if (routeRaw && typeof routeRaw === "object" && routeRaw !== null) {
+      const route = routeRaw;
+      const name = route.name;
+      if (typeof name === "string" && name.length > 0) return name;
+    }
+    const path = req.baseUrl ?? req.path;
+    if (typeof path === "string" && path.length > 0) return path;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function captureRequestPreview(req, redactor) {
+  try {
+    const body = req.body;
+    if (body === void 0 || body === null) return void 0;
+    return redactor.redact(body);
+  } catch {
+    return void 0;
+  }
+}
+function captureResponsePreview(res, redactor) {
+  try {
+    const resLike = res;
+    const body = resLike.body;
+    if (body === void 0 || body === null) return void 0;
+    if (typeof body === "string") return redactor.redactString(body);
+    return redactor.serialize(body);
+  } catch {
+    return void 0;
+  }
+}
 
 // src/instrumentation/console.ts
 var import_console = require("console");
@@ -576,7 +679,8 @@ var AppExplorer = class {
     const w = wrapper;
     const name = w?.metatype?.name ?? (typeof id === "string" ? id.replace(/^[A-Z_0-9]+:/, "") : "unknown");
     const type = classify(name, w?.instance);
-    return { name, type };
+    const routes = type === "controller" ? extractControllerRoutes(w?.metatype) : void 0;
+    return { name, type, routes };
   }
 };
 function classify(name, instance) {
@@ -591,33 +695,610 @@ function classify(name, instance) {
   if (instance && typeof instance.catch === "function") return "filter";
   return "provider";
 }
+function extractControllerRoutes(metatype) {
+  if (!metatype) return [];
+  try {
+    const proto = metatype.prototype;
+    if (!proto) return [];
+    const props = Object.getOwnPropertyNames(proto).filter((name) => name !== "constructor");
+    const routes = [];
+    for (const key of props) {
+      const desc = Object.getOwnPropertyDescriptor(proto, key);
+      if (!desc?.value) continue;
+      const value = desc.value;
+      const routesForMethod = gatherHttpRoutes(value);
+      for (const r of routesForMethod) {
+        if (typeof r === "string" && r.length > 0) routes.push(r);
+      }
+    }
+    return routes;
+  } catch {
+    return [];
+  }
+}
+function gatherHttpRoutes(value) {
+  try {
+    const decorators = Reflect.getMetadata?.("design:http:method", {}, void 0, void 0) ?? [];
+    const out = [];
+    if (decorators.length > 0) {
+      for (const d of decorators) {
+        if (d && typeof d === "object" && d.method && d.path) {
+          out.push(`${String(d.method).toUpperCase()} ${String(d.path)}`);
+        }
+      }
+    }
+    if (typeof value === "function") {
+      const fn = value;
+      const path = fn.PATH ?? void 0;
+      const method = fn.METHOD ?? void 0;
+      if (typeof path === "string" && typeof method === "string") {
+        out.push(`${method.toUpperCase()} ${path}`);
+      } else if (typeof path === "string") {
+        out.push(path);
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
 
 // src/instrumentation/websockets.ts
+var import_devtools_core7 = require("@angelitosystems/devtools-core");
+var import_devtools_protocol4 = require("@angelitosystems/devtools-protocol");
 var WebsocketInstrumentation = class {
+  redactor;
+  config;
+  projectId;
+  ctxRaw;
   constructor(ctx) {
-    this.ctx = ctx;
+    this.ctxRaw = ctx;
+    this.config = ctx.config;
+    this.projectId = ctx.projectInfo.projectId;
+    this.redactor = new import_devtools_protocol4.Redactor({
+      redact: this.config.redact,
+      allow: this.config.allow,
+      maxBytes: this.config.maxPayloadBytes
+    });
   }
-  ctx;
-  /** No-op for now. Returns a no-op cleanup. */
+  /** Attach gateway hooks. Returns cleanup. */
   attach() {
-    void this.ctx;
-    return () => {
+    const cleanup = [];
+    if (!this.config.capture.websockets) return () => cleanup.forEach((fn) => fn());
+    const gateways = this.detectGateways();
+    for (const gw of gateways) {
+      cleanup.push(this.wrapGateway(gw));
+    }
+    return () => cleanup.forEach((fn) => fn());
+  }
+  detectGateways() {
+    try {
+      const app = this.getApp();
+      if (!app) return [];
+      const container = app.container;
+      if (!container) return [];
+      const modules = container.getModules?.() ?? /* @__PURE__ */ new Map();
+      const out = [];
+      for (const [id, node] of modules) {
+        const providers = node.providers;
+        if (!providers || !(providers instanceof Map)) continue;
+        for (const [key, wrapper] of providers) {
+          const w = wrapper;
+          if (!w || !w.instance) continue;
+          const subtype = w.subtype ?? (node.subtype ?? null);
+          if (subtype === "gateway" || w.instance && w.instance.constructor?.name?.endsWith("Gateway")) {
+            out.push({ name: w.name ?? key, instance: w.instance });
+          }
+        }
+      }
+      return out;
+    } catch {
+      return [];
+    }
+  }
+  wrapGateway(gw) {
+    const instance = gw.instance;
+    if (!instance || typeof instance !== "object") return () => {
     };
+    const hooks = [];
+    const methods = [
+      "handleConnection",
+      "handleDisconnect",
+      "handleEvent",
+      "handleMessage",
+      "afterInit",
+      "beforeHandle"
+    ];
+    for (const method of methods) {
+      if (typeof instance[method] !== "function") continue;
+      const orig = instance[method];
+      const wrapped = this.buildGatewayWrapper(instance, method, orig);
+      instance[method] = wrapped;
+      hooks.push(() => {
+        instance[method] = orig;
+      });
+    }
+    return () => hooks.forEach((fn) => fn());
+  }
+  buildGatewayWrapper(instance, method, original) {
+    return async (...args) => {
+      const started = Date.now();
+      const requestId = (0, import_devtools_core7.requestContext)().requestId() ?? (0, import_devtools_protocol4.randomId)("ws");
+      if (method === "handleConnection" || method === "afterInit") {
+        emit("websocket.connected", {
+          projectId: this.projectId,
+          gateway: instance.constructor?.name ?? this.estimateGatewayName(instance),
+          namespace: this.estimateNamespace(args),
+          connections: this.countConnections(instance),
+          timestamp: Date.now()
+        });
+      }
+      if (method === "handleMessage" || method === "handleEvent") {
+        const payload = this.extractPayload(args);
+        recordSpan(requestId, "websocket", `ws.receive:${this.estimateEvent(args)}`, {
+          detail: `gateway=${instance.constructor?.name} payload=${this.redactor.serialize(payload)}`
+        });
+      }
+      try {
+        const result = await Promise.resolve(original.call(instance, ...args));
+        if (method === "handleMessage" || method === "handleEvent") {
+          const payload = this.extractPayload(args);
+          recordSpan(requestId, "websocket", `ws.send:${this.estimateEvent(args)}`, {
+            detail: `gateway=${instance.constructor?.name} payload=${this.redactor.serialize(payload)}`,
+            status: "ok"
+          });
+        }
+        return result;
+      } catch (err) {
+        if (method === "handleMessage" || method === "handleEvent") {
+          recordSpan(requestId, "websocket", `ws.send:${this.estimateEvent(args)}`, {
+            detail: `gateway=${instance.constructor?.name} error=${this.redactor.serialize(err)}`,
+            status: "error"
+          });
+        }
+        throw err;
+      }
+    };
+  }
+  extractPayload(args) {
+    for (const arg of args) {
+      if (arg && typeof arg === "object" && !Buffer.isBuffer(arg) && !ArrayBuffer.isView(arg)) {
+        return arg;
+      }
+    }
+    return args[0];
+  }
+  estimateEvent(args) {
+    const payload = this.extractPayload(args);
+    if (!payload || typeof payload !== "object") return "message";
+    return payload.event ?? payload.type ?? "message";
+  }
+  estimateNamespace(args) {
+    if (args.length > 0) {
+      const first = args[0];
+      if (first && typeof first === "object" && first.namespace) return first.namespace;
+    }
+    return "/";
+  }
+  countConnections(instance) {
+    try {
+      if (instance.connections && typeof instance.connections === "function") return instance.connections();
+      if (instance.clients && typeof instance.clients === "function") return instance.clients().size ?? 0;
+      return 0;
+    } catch {
+      return 0;
+    }
+  }
+  estimateGatewayName(instance) {
+    return instance.constructor?.name ?? "Gateway";
+  }
+  getApp() {
+    try {
+      const ctx = this.ctxRaw;
+      if (ctx.getHttpAdapter) return ctx;
+      if (ctx.app) return ctx.app;
+      return null;
+    } catch {
+      return null;
+    }
   }
 };
 
 // src/instrumentation/database.ts
+var import_devtools_core8 = require("@angelitosystems/devtools-core");
+var import_devtools_protocol5 = require("@angelitosystems/devtools-protocol");
 var DatabaseInstrumentation = class {
+  redactor;
+  config;
+  projectId;
+  ctxRaw;
   constructor(ctx) {
-    this.ctx = ctx;
+    this.ctxRaw = ctx;
+    this.config = ctx.config;
+    this.projectId = ctx.projectInfo.projectId;
+    this.redactor = new import_devtools_protocol5.Redactor({
+      redact: this.config.redact,
+      allow: this.config.allow,
+      maxBytes: this.config.maxPayloadBytes
+    });
+  }
+  /** Attach database hooks for detected clients. Returns cleanup. */
+  attach() {
+    const cleanup = [];
+    if (!this.config.capture.database) return () => cleanup.forEach((fn) => fn());
+    if (this.tryAttachTypeOrm()) cleanup.push(this.detachTypeOrm());
+    if (this.tryAttachPrisma()) cleanup.push(this.detachPrisma());
+    if (this.tryAttachMongoose()) cleanup.push(this.detachMongoose());
+    return () => cleanup.forEach((fn) => fn());
   }
+  tryAttachTypeOrm() {
+    try {
+      const app = this.getApp();
+      if (!app) return false;
+      const dataSource = this.resolveTypeOrmDataSource(app);
+      if (!dataSource) return false;
+      const listener = {
+        beforeQuery: (query, parameters) => {
+          this.startQuery(query, parameters);
+        },
+        afterQuery: (query, parameters, durationMs) => {
+          this.endQuery(query, parameters, durationMs);
+        }
+      };
+      const sub = dataSource.subscriber;
+      if (sub) {
+        const before = sub.beforeQuery;
+        const after = sub.afterQuery;
+        sub.beforeQuery = (q, p) => {
+          try {
+            before?.(q, p);
+          } catch {
+          }
+          listener.beforeQuery(q, p);
+        };
+        sub.afterQuery = (q, p, d) => {
+          try {
+            after?.(q, p, d);
+          } catch {
+          }
+          listener.afterQuery(q, p, d);
+        };
+      } else {
+        dataSource.subscriber = listener;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  detachTypeOrm() {
+    return () => {
+      try {
+        const app = this.getApp();
+        if (!app) return;
+        const ds = this.resolveTypeOrmDataSource(app);
+        if (!ds || !ds.subscriber) return;
+        ds.subscriber = null;
+      } catch {
+      }
+    };
+  }
+  tryAttachPrisma() {
+    try {
+      const app = this.getApp();
+      if (!app) return false;
+      const prisma = this.resolvePrismaClient(app);
+      if (!prisma) return false;
+      const original = prisma.$queryRaw ?? prisma.$executeRaw ?? null;
+      if (!original) return false;
+      const wrapped = (query, parameters) => {
+        const started = Date.now();
+        this.startQuery(String(query), parameters ? [parameters] : []);
+        try {
+          const result = original.call(prisma, query, parameters);
+          if (result instanceof Promise) {
+            return result.then((r) => {
+              this.endQuery(String(query), parameters ? [parameters] : [], Date.now() - started);
+              return r;
+            });
+          }
+          this.endQuery(String(query), parameters ? [parameters] : [], Date.now() - started);
+          return result;
+        } catch (err) {
+          this.endQuery(String(query), parameters ? [parameters] : [], Date.now() - started, err);
+          throw err;
+        }
+      };
+      prisma.$queryRaw = wrapped;
+      prisma.$executeRaw = wrapped;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  detachPrisma() {
+    return () => {
+      try {
+        const app = this.getApp();
+        if (!app) return;
+        const prisma = this.resolvePrismaClient(app);
+        if (!prisma) return;
+        if (typeof prisma.$extends === "function") prisma.$extends(prisma);
+      } catch {
+      }
+    };
+  }
+  tryAttachMongoose() {
+    try {
+      const app = this.getApp();
+      if (!app) return false;
+      const mongoose = this.resolveMongoose(app);
+      if (!mongoose) return false;
+      const instrumentation = this;
+      const hook = mongoose.plugin((schema, _name) => {
+        if (!schema || typeof schema !== "object") return;
+        const hooks = schema.pre ?? null;
+        if (typeof hooks !== "function") return;
+        const bound = hooks.bind(schema);
+        if (!bound) return;
+        const originalPre = bound;
+        schema.pre = function(method, fn) {
+          if (method === "find" || method === "findOne" || method === "findById" || method === "aggregate" || method === "countDocuments" || method === "count") {
+            const wrapped = async function(...args) {
+              const started = Date.now();
+              const sql = `[Mongoose:${method}]`;
+              instrumentation.startQuery(sql, args);
+              try {
+                const handler = fn;
+                if (!handler) return;
+                const result = await handler.apply(this, args);
+                instrumentation.endQuery(sql, args, Date.now() - started);
+                return result;
+              } catch (err) {
+                instrumentation.endQuery(sql, args, Date.now() - started, err);
+                throw err;
+              }
+            };
+            originalPre(method, wrapped);
+          } else {
+            originalPre(method, fn);
+          }
+        };
+      });
+      if (typeof mongoose.plugin === "function") mongoose.plugin(hook);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  detachMongoose() {
+    return () => {
+      try {
+        const app = this.getApp();
+        if (!app) return;
+        const mongoose = this.resolveMongoose(app);
+        if (!mongoose || typeof mongoose.plugin !== "function") return;
+      } catch {
+      }
+    };
+  }
+  startQuery(sql, parameters) {
+    if (!this.config.capture.database) return;
+    const requestId = (0, import_devtools_core8.requestContext)().requestId() ?? (0, import_devtools_protocol5.randomId)("db");
+    recordSpan(requestId, "database", sql.slice(0, 120), {
+      detail: `provider=${this.providerLabel()} parameters=${this.redactor.serialize(parameters)}`
+    });
+  }
+  endQuery(sql, parameters, durationMs, error) {
+    if (!this.config.capture.database) return;
+    const requestId = (0, import_devtools_core8.requestContext)().requestId() ?? (0, import_devtools_protocol5.randomId)("db");
+    const payload = {
+      requestId,
+      projectId: this.projectId,
+      provider: this.providerLabel(),
+      sql: sql.slice(0, 2e3),
+      duration: durationMs,
+      parameters: this.redactor.redact(parameters),
+      timestamp: Date.now()
+    };
+    emit("query.executed", payload);
+  }
+  providerLabel() {
+    if (this.isTypeOrm()) return "typeorm";
+    if (this.isPrisma()) return "prisma";
+    if (this.isMongoose()) return "mongoose";
+    return "other";
+  }
+  isTypeOrm() {
+    return !!this.resolveTypeOrmDataSource(this.getApp());
+  }
+  isPrisma() {
+    return !!this.resolvePrismaClient(this.getApp());
+  }
+  isMongoose() {
+    return !!this.resolveMongoose(this.getApp());
+  }
+  getApp() {
+    try {
+      const ctx = this.ctxRaw;
+      if (ctx && typeof ctx === "object" && ctx.app) return ctx.app;
+      if (ctx && typeof ctx === "object" && ctx.getHttpAdapter) {
+        return ctx;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  resolveTypeOrmDataSource(app) {
+    try {
+      const dataSource = app.get(require("@nestjs/typeorm").TypeOrmModule)?.options?.DataSource ?? null;
+      if (dataSource && typeof dataSource.query === "function") return dataSource;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  resolvePrismaClient(app) {
+    try {
+      const prisma = app.get("PrismaService") ?? app.get("PrismaClient") ?? app.get("prisma") ?? null;
+      if (prisma && typeof prisma.$queryRaw === "function") return prisma;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  resolveMongoose(app) {
+    try {
+      const mongoose = app.get("MongooseService") ?? app.get("Mongoose") ?? app.get("mongoose") ?? null;
+      if (mongoose && typeof mongoose.plugin === "function") return mongoose;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/instrumentation/queue.ts
+var import_devtools_core9 = require("@angelitosystems/devtools-core");
+var import_devtools_protocol6 = require("@angelitosystems/devtools-protocol");
+var import_devtools_core10 = require("@angelitosystems/devtools-core");
+var QueueEventInstrumentation = class _QueueEventInstrumentation {
+  redactor;
+  config;
+  projectId;
   ctx;
-  /** No-op for now. Returns a no-op cleanup. */
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.config = ctx.config;
+    this.projectId = ctx.projectInfo.projectId;
+    this.redactor = new import_devtools_protocol6.Redactor({
+      redact: this.config.redact,
+      allow: this.config.allow,
+      maxBytes: this.config.maxPayloadBytes
+    });
+  }
+  /** Attach queue hooks if a supported client is detected. Returns cleanup. */
   attach() {
-    void this.ctx;
+    const cleanup = [];
+    if (!this.config.capture.requests && !this.config.capture.logs && !this.config.capture.errors) {
+      return () => cleanup.forEach((fn) => fn());
+    }
+    if (this.tryAttachBull()) cleanup.push(this.detachBull());
+    return () => cleanup.forEach((fn) => fn());
+  }
+  /** Register a queue span correlated with the active request, if any. */
+  static recordJobSpan(queueName, jobId, label, options) {
+    const requestId = (0, import_devtools_core9.requestContext)().requestId() ?? (0, import_devtools_protocol6.randomId)("queue");
+    recordSpan(requestId, "queue", `${queueName}:${label} (${jobId})`, {
+      detail: `queue=${queueName} job=${jobId}`,
+      source: options?.source,
+      status: options?.status
+    });
+  }
+  /** Emit a log for queue events, correlated with the active request if any. */
+  static emitJobLog(queueName, jobId, level, message, options) {
+    const requestId = (0, import_devtools_core9.requestContext)().requestId();
+    emit("log.created", {
+      requestId,
+      projectId: void 0,
+      level,
+      message: `[${queueName}] ${message} (${jobId})`,
+      source: options?.source,
+      context: queueName,
+      processId: process.pid,
+      timestamp: Date.now()
+    });
+  }
+  tryAttachBull() {
+    try {
+      const app = this.getApp();
+      if (!app) return false;
+      const bull = this.resolveBull(app);
+      if (!bull) return false;
+      const origProcess = bull.prototype?.process ?? bull.process;
+      if (typeof origProcess === "function") {
+        const wrapped = this.wrapProcess(origProcess, bull);
+        if (bull.prototype) bull.prototype.process = wrapped;
+        bull.process = wrapped;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  detachBull() {
     return () => {
+      try {
+        const app = this.getApp();
+        if (!app) return;
+        const bull = this.resolveBull(app);
+        if (!bull) return;
+      } catch {
+      }
+    };
+  }
+  wrapProcess(original, bull) {
+    return async function(...args) {
+      const handler = args[0];
+      if (!handler || typeof handler !== "function") return original.apply(this, args);
+      const wrapped = async (...handlerArgs) => {
+        const job = handlerArgs[0];
+        if (!job || typeof job !== "object") return handler.apply(this, handlerArgs);
+        const jobId = job.id ?? job.data?.jobId ?? (0, import_devtools_protocol6.randomId)("job");
+        const queueName = job.queueName ?? this.estimateQueueName(bull);
+        const started = Date.now();
+        _QueueEventInstrumentation.recordJobSpan(queueName, jobId, "process", { status: "ok" });
+        try {
+          const result = await Promise.resolve(handler.apply(this, handlerArgs));
+          _QueueEventInstrumentation.recordJobSpan(queueName, jobId, "process", {
+            status: "ok"
+          });
+          _QueueEventInstrumentation.emitJobLog(queueName, jobId, "info", "job completed", {
+            source: (0, import_devtools_core10.resolveSourceLocation)(new Error(), { skip: 2 })
+          });
+          return result;
+        } catch (err) {
+          _QueueEventInstrumentation.recordJobSpan(queueName, jobId, "process", {
+            status: "error"
+          });
+          _QueueEventInstrumentation.emitJobLog(queueName, jobId, "error", String(err), {
+            source: (0, import_devtools_core10.resolveSourceLocation)(err instanceof Error ? err : new Error(), { skip: 2 })
+          });
+          throw err;
+        }
+      };
+      return original.apply(this, [wrapped, ...args.slice(1)]);
     };
   }
+  estimateQueueName(bull) {
+    try {
+      if (bull.name) return bull.name;
+      if (typeof bull === "function") return bull.name;
+      return "queue";
+    } catch {
+      return "queue";
+    }
+  }
+  resolveBull(app) {
+    try {
+      const bull = app.get("BullService") ?? app.get("Bull") ?? app.get("bull") ?? app.get("Queue") ?? null;
+      if (bull && (typeof bull.process === "function" || typeof bull.prototype?.process === "function")) return bull;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  getApp() {
+    try {
+      const ctx = this.ctx;
+      if (ctx.getHttpAdapter) return ctx;
+      if (ctx.app) return ctx.app;
+      return null;
+    } catch {
+      return null;
+    }
+  }
 };
 
 // src/detect.ts
@@ -700,7 +1381,7 @@ var NestDevTools = class {
   static initialized = false;
   /** Initialize DevTools for a NestJS application. One active instance per process. */
   static init(app, userConfig) {
-    const config = (0, import_devtools_core7.resolveConfig)(userConfig);
+    const config = (0, import_devtools_core11.resolveConfig)(userConfig);
     const disabled = {
       enabled: false,
       reason: "disabled-by-config",
@@ -726,7 +1407,7 @@ var NestDevTools = class {
       sdkVersion: SDK_VERSION
     };
     let hasWarnedOffline = false;
-    import_devtools_core7.devtools.initialize({
+    import_devtools_core11.devtools.initialize({
       config,
       projectInfo,
       registerCleanup,
@@ -754,6 +1435,7 @@ var NestDevTools = class {
     if (config.capture.database) {
       registerCleanup(new DatabaseInstrumentation({ config, projectInfo }).attach());
     }
+    registerCleanup(new QueueEventInstrumentation({ config, projectInfo }).attach());
     printStartupBanner({
       endpoint: config.server,
       dashboard: dashboardUrl(config.server),
@@ -776,7 +1458,7 @@ var NestDevTools = class {
       }
     }
     this.initialized = false;
-    import_devtools_core7.devtools.shutdown();
+    import_devtools_core11.devtools.shutdown();
   }
   /** Whether the SDK is currently active in this process. */
   static isActive() {
@@ -821,7 +1503,7 @@ function dashboardUrl(server) {
 }
 
 // src/index.ts
-var import_devtools_core8 = require("@angelitosystems/devtools-core");
+var import_devtools_core12 = require("@angelitosystems/devtools-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   NestDevTools,