@koderlabs/tasks-sdk-nestjs 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1030 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  INSTANTTASKS_OPTIONS: () => INSTANTTASKS_OPTIONS,
+  InstantTasksExceptionFilter: () => InstantTasksExceptionFilter,
+  InstantTasksModule: () => InstantTasksModule,
+  InstantTasksReportInterceptor: () => InstantTasksReportInterceptor,
+  InstantTasksReporter: () => InstantTasksReporter,
+  InstantTasksRequestContextMiddleware: () => InstantTasksRequestContextMiddleware,
+  InstantTasksSpanInterceptor: () => InstantTasksSpanInterceptor,
+  InstantTasksTypeOrmLogger: () => InstantTasksTypeOrmLogger,
+  RequestContextRing: () => RequestContextRing,
+  getCurrentContext: () => getCurrentContext,
+  installConsoleCapture: () => installConsoleCapture,
+  installHttpTracing: () => installHttpTracing,
+  installTypeOrmTracing: () => installTypeOrmTracing,
+  leaveBreadcrumb: () => leaveBreadcrumb,
+  requestContextStorage: () => requestContextStorage
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/module.ts
+var import_common6 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/reporter.service.ts
+var import_common = require("@nestjs/common");
+
+// src/types.ts
+var INSTANTTASKS_OPTIONS = /* @__PURE__ */ Symbol("INSTANTTASKS_OPTIONS");
+
+// src/breadcrumb-ring.ts
+var import_async_hooks = require("async_hooks");
+var RequestContextRing = class {
+  static {
+    __name(this, "RequestContextRing");
+  }
+  buf = [];
+  spans = [];
+  request;
+  max;
+  constructor(request, max = 50) {
+    this.request = request;
+    this.max = max;
+  }
+  add(crumb) {
+    this.buf.push(crumb);
+    if (this.buf.length > this.max) this.buf.shift();
+  }
+  addSpan(span) {
+    this.spans.push(span);
+    if (this.spans.length > this.max) this.spans.shift();
+  }
+  getBreadcrumbs() {
+    return [
+      ...this.buf
+    ];
+  }
+  getSpans() {
+    return [
+      ...this.spans
+    ];
+  }
+  setUser(userId) {
+    this.request.userId = userId;
+  }
+};
+var requestContextStorage = new import_async_hooks.AsyncLocalStorage();
+function leaveBreadcrumb(crumb) {
+  const store = requestContextStorage.getStore();
+  if (!store) return;
+  store.add({
+    ts: crumb.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...crumb
+  });
+}
+__name(leaveBreadcrumb, "leaveBreadcrumb");
+function getCurrentContext() {
+  return requestContextStorage.getStore() ?? null;
+}
+__name(getCurrentContext, "getCurrentContext");
+
+// src/reporter.service.ts
+function _ts_decorate(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;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var installedUncaught = null;
+var installedRejection = null;
+var InstantTasksReporter = class _InstantTasksReporter {
+  static {
+    __name(this, "InstantTasksReporter");
+  }
+  opts;
+  logger = new import_common.Logger(_InstantTasksReporter.name);
+  apiUrl = "";
+  projectId = "";
+  managementKey = "";
+  environment = "production";
+  release = "prod";
+  debug = false;
+  dryRun = false;
+  beforeSend;
+  recent = /* @__PURE__ */ new Map();
+  RECENT_WINDOW_MS = 6e4;
+  RECENT_LIMIT = 50;
+  uncaughtHandler = null;
+  rejectionHandler = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  onModuleInit() {
+    const { apiUrl, projectId, managementKey } = this.opts;
+    if (!apiUrl || !projectId || !managementKey) {
+      this.logger.warn("InstantTasks reporter disabled (missing apiUrl/projectId/managementKey)");
+      return;
+    }
+    this.apiUrl = apiUrl.replace(/\/+$/, "").replace(/\/api\/v\d+$/, "");
+    this.projectId = projectId;
+    this.managementKey = managementKey;
+    this.environment = this.opts.environment ?? process.env.NODE_ENV ?? "production";
+    this.release = this.opts.release ?? "prod";
+    this.debug = this.opts.debug ?? false;
+    this.dryRun = this.opts.dryRun ?? false;
+    this.beforeSend = this.opts.beforeSend;
+    if (installedUncaught) process.off("uncaughtException", installedUncaught);
+    if (installedRejection) process.off("unhandledRejection", installedRejection);
+    this.uncaughtHandler = (err) => {
+      void this.reportError(err, {
+        mechanism: "uncaughtException",
+        level: "fatal"
+      });
+    };
+    this.rejectionHandler = (reason) => {
+      const err = reason instanceof Error ? reason : new Error(String(reason));
+      void this.reportError(err, {
+        mechanism: "unhandledrejection",
+        level: "error"
+      });
+    };
+    process.on("uncaughtException", this.uncaughtHandler);
+    process.on("unhandledRejection", this.rejectionHandler);
+    installedUncaught = this.uncaughtHandler;
+    installedRejection = this.rejectionHandler;
+    this.logger.log(`InstantTasks reporter wired \u2192 ${this.apiUrl} project=${this.projectId}`);
+  }
+  onModuleDestroy() {
+    if (this.uncaughtHandler) {
+      process.off("uncaughtException", this.uncaughtHandler);
+      if (installedUncaught === this.uncaughtHandler) installedUncaught = null;
+    }
+    if (this.rejectionHandler) {
+      process.off("unhandledRejection", this.rejectionHandler);
+      if (installedRejection === this.rejectionHandler) installedRejection = null;
+    }
+  }
+  get enabled() {
+    return !!(this.apiUrl && this.projectId && this.managementKey);
+  }
+  reportError(err, ctx) {
+    if (!this.enabled) return;
+    const fingerprint = `${err.name}:${err.message}`.slice(0, 200);
+    if (this.shouldSuppress(fingerprint)) return;
+    const reqCtx = getCurrentContext();
+    const reqInfo = reqCtx?.request;
+    const breadcrumbs = reqCtx?.getBreadcrumbs();
+    const spans = reqCtx?.getSpans();
+    const inferredUserId = ctx.userId ?? reqInfo?.userId;
+    const inferredUrl = ctx.url ?? reqInfo?.url ?? `node://${process.env.HOSTNAME ?? "api"}`;
+    const userAgent = reqInfo?.userAgent ?? `node/${process.version}`;
+    let event = {
+      kind: "error",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      release: this.release,
+      environment: this.environment,
+      url: inferredUrl,
+      userAgent,
+      viewport: {
+        width: 0,
+        height: 0
+      },
+      payload: {
+        exception: {
+          type: err.name || "Error",
+          value: err.message || String(err),
+          stack: err.stack,
+          mechanism: ctx.mechanism
+        },
+        level: ctx.level ?? "error"
+      },
+      user: inferredUserId ? {
+        id: inferredUserId
+      } : void 0,
+      ...reqInfo && {
+        request: reqInfo
+      },
+      ...breadcrumbs && breadcrumbs.length && {
+        breadcrumbs
+      },
+      ...spans && spans.length && {
+        spans
+      }
+    };
+    if (this.beforeSend) {
+      try {
+        event = this.beforeSend(event);
+      } catch (e) {
+        if (this.debug) this.logger.warn(`beforeSend threw: ${e.message}`);
+      }
+      if (!event) return;
+    }
+    if (this.dryRun) {
+      if (this.debug) this.logger.log(`[dryRun] would send: ${event.payload.exception.type}: ${event.payload.exception.value}`);
+      return;
+    }
+    void fetch(`${this.apiUrl}/api/v1/sdk/events`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.managementKey}`,
+        "Content-Type": "application/json",
+        "X-Project-Id": this.projectId
+      },
+      body: JSON.stringify(event),
+      signal: AbortSignal.timeout(1e4)
+    }).then((res) => {
+      if (!res.ok) {
+        this.logger.warn(`InstantTasks report rejected: HTTP ${res.status}`);
+      }
+    }).catch((reportErr) => {
+      this.logger.warn(`InstantTasks report failed: ${reportErr.message}`);
+    });
+  }
+  shouldSuppress(fingerprint) {
+    const now = Date.now();
+    for (const [fp, ts] of this.recent) {
+      if (now - ts > this.RECENT_WINDOW_MS) this.recent.delete(fp);
+    }
+    if (this.recent.size >= this.RECENT_LIMIT && !this.recent.has(fingerprint)) {
+      return true;
+    }
+    const last = this.recent.get(fingerprint);
+    if (last && now - last < 5e3) return true;
+    this.recent.set(fingerprint, now);
+    return false;
+  }
+};
+InstantTasksReporter = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Inject)(INSTANTTASKS_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof InstantTasksOptions === "undefined" ? Object : InstantTasksOptions
+  ])
+], InstantTasksReporter);
+
+// src/exception.filter.ts
+var import_common2 = require("@nestjs/common");
+function _ts_decorate2(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;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var InstantTasksExceptionFilter = class _InstantTasksExceptionFilter {
+  static {
+    __name(this, "InstantTasksExceptionFilter");
+  }
+  reporter;
+  logger = new import_common2.Logger(_InstantTasksExceptionFilter.name);
+  constructor(reporter) {
+    this.reporter = reporter;
+  }
+  catch(exception, host) {
+    let shouldReport = true;
+    if (exception instanceof import_common2.HttpException) {
+      shouldReport = exception.getStatus() >= 500;
+    }
+    if (shouldReport && this.reporter.enabled) {
+      const err = exception instanceof Error ? exception : new Error(String(exception));
+      let url;
+      try {
+        const req = host.switchToHttp().getRequest();
+        url = req?.originalUrl ?? req?.url;
+      } catch {
+      }
+      this.reporter.reportError(err, {
+        mechanism: "http",
+        level: "error",
+        url
+      });
+    }
+    throw exception;
+  }
+};
+InstantTasksExceptionFilter = _ts_decorate2([
+  (0, import_common2.Catch)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InstantTasksReporter === "undefined" ? Object : InstantTasksReporter
+  ])
+], InstantTasksExceptionFilter);
+
+// src/report.interceptor.ts
+var import_common3 = require("@nestjs/common");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+function _ts_decorate3(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;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var InstantTasksReportInterceptor = class _InstantTasksReportInterceptor {
+  static {
+    __name(this, "InstantTasksReportInterceptor");
+  }
+  reporter;
+  logger = new import_common3.Logger(_InstantTasksReportInterceptor.name);
+  constructor(reporter) {
+    this.reporter = reporter;
+  }
+  intercept(context, next) {
+    return next.handle().pipe((0, import_operators.catchError)((exception) => {
+      let shouldReport = true;
+      if (exception instanceof import_common3.HttpException) {
+        shouldReport = exception.getStatus() >= 500;
+      }
+      if (shouldReport && this.reporter.enabled) {
+        const err = exception instanceof Error ? exception : new Error(String(exception));
+        let url;
+        try {
+          const req = context.switchToHttp().getRequest();
+          url = req?.originalUrl ?? req?.url;
+        } catch {
+        }
+        this.reporter.reportError(err, {
+          mechanism: "http",
+          level: "error",
+          url
+        });
+      }
+      return (0, import_rxjs.throwError)(() => exception);
+    }));
+  }
+};
+InstantTasksReportInterceptor = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof InstantTasksReporter === "undefined" ? Object : InstantTasksReporter
+  ])
+], InstantTasksReportInterceptor);
+
+// src/request-context.middleware.ts
+var import_common4 = require("@nestjs/common");
+function _ts_decorate4(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;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+function extractIp(req) {
+  const xff = req.headers?.["x-forwarded-for"];
+  if (typeof xff === "string" && xff.length) return xff.split(",")[0].trim();
+  if (Array.isArray(xff) && xff.length) return String(xff[0]).split(",")[0].trim();
+  return req.ip ?? req.connection?.remoteAddress ?? req.socket?.remoteAddress;
+}
+__name(extractIp, "extractIp");
+var InstantTasksRequestContextMiddleware = class {
+  static {
+    __name(this, "InstantTasksRequestContextMiddleware");
+  }
+  max;
+  constructor(opts) {
+    this.max = opts.maxBreadcrumbs ?? 50;
+  }
+  use(req, res, next) {
+    const ring = new RequestContextRing({
+      method: req.method,
+      route: req.route?.path ?? req.path,
+      url: req.originalUrl ?? req.url,
+      userAgent: req.headers?.["user-agent"],
+      ip: extractIp(req),
+      userId: req.user?.id
+    }, this.max);
+    res?.on?.("finish", () => {
+      ring.request.statusCode = res.statusCode;
+    });
+    requestContextStorage.run(ring, () => next());
+  }
+};
+InstantTasksRequestContextMiddleware = _ts_decorate4([
+  (0, import_common4.Injectable)(),
+  _ts_param2(0, (0, import_common4.Inject)(INSTANTTASKS_OPTIONS)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof InstantTasksOptions === "undefined" ? Object : InstantTasksOptions
+  ])
+], InstantTasksRequestContextMiddleware);
+
+// src/span.interceptor.ts
+var import_common5 = require("@nestjs/common");
+var import_operators2 = require("rxjs/operators");
+function _ts_decorate5(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;
+}
+__name(_ts_decorate5, "_ts_decorate");
+var InstantTasksSpanInterceptor = class {
+  static {
+    __name(this, "InstantTasksSpanInterceptor");
+  }
+  intercept(context, next) {
+    if (context.getType() !== "http") return next.handle();
+    const ctx = getCurrentContext();
+    const req = context.switchToHttp().getRequest();
+    const res = context.switchToHttp().getResponse();
+    const method = String(req?.method ?? "GET").toUpperCase();
+    const route = req?.route?.path ?? req?.path ?? req?.url ?? "unknown";
+    const start = Date.now();
+    const startIso = new Date(start).toISOString();
+    const recordSpan = /* @__PURE__ */ __name((status, extraAttrs) => {
+      if (!ctx) return;
+      const end = Date.now();
+      const span = {
+        name: `http.${method.toLowerCase()}.${route}`,
+        startTime: startIso,
+        endTime: new Date(end).toISOString(),
+        durationMs: end - start,
+        status,
+        attrs: {
+          "http.method": method,
+          "http.route": route,
+          "http.status_code": res?.statusCode,
+          "user.id": req?.user?.id,
+          ...extraAttrs
+        }
+      };
+      ctx.addSpan(span);
+    }, "recordSpan");
+    return next.handle().pipe((0, import_operators2.tap)({
+      next: /* @__PURE__ */ __name(() => recordSpan("ok"), "next"),
+      error: /* @__PURE__ */ __name((err) => recordSpan("error", {
+        "error.message": err?.message
+      }), "error")
+    }));
+  }
+};
+InstantTasksSpanInterceptor = _ts_decorate5([
+  (0, import_common5.Injectable)()
+], InstantTasksSpanInterceptor);
+
+// src/sanitize.ts
+var TOKEN_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "access_token",
+  "apikey",
+  "api_key",
+  "secret"
+]);
+function sanitizeUrl(url) {
+  if (!url || typeof url !== "string") return String(url);
+  const qIdx = url.indexOf("?");
+  if (qIdx === -1) return url;
+  const base = url.slice(0, qIdx);
+  const qs = url.slice(qIdx + 1);
+  const parts = qs.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq === -1) return pair;
+    const key = pair.slice(0, eq);
+    if (TOKEN_QUERY_KEYS.has(key.toLowerCase())) return `${key}=[Filtered]`;
+    return pair;
+  });
+  return `${base}?${parts.join("&")}`;
+}
+__name(sanitizeUrl, "sanitizeUrl");
+function shouldIgnoreUrl(url, ignoreUrls = []) {
+  for (const pattern of ignoreUrls) {
+    if (typeof pattern === "string" && url.includes(pattern)) return true;
+    if (pattern instanceof RegExp && pattern.test(url)) return true;
+  }
+  return false;
+}
+__name(shouldIgnoreUrl, "shouldIgnoreUrl");
+
+// src/wrap-sentinel.ts
+var INSTANT_TASKS_WRAPPED = /* @__PURE__ */ Symbol.for("@koderlabs/tasks-sdk-nestjs.wrapped");
+function isWrapped(fn) {
+  return !!fn && typeof fn === "function" && fn[INSTANT_TASKS_WRAPPED];
+}
+__name(isWrapped, "isWrapped");
+function markWrapped(wrapper, original) {
+  wrapper[INSTANT_TASKS_WRAPPED] = {
+    original
+  };
+  return wrapper;
+}
+__name(markWrapped, "markWrapped");
+function unwrap(fn) {
+  let cur = fn;
+  while (cur && cur[INSTANT_TASKS_WRAPPED]) cur = cur[INSTANT_TASKS_WRAPPED].original;
+  return cur;
+}
+__name(unwrap, "unwrap");
+
+// src/http-tracing.ts
+var installed = null;
+function installHttpTracing(opts = {}) {
+  if (installed) return installed;
+  const ignoreUrls = opts.ignoreUrls ?? [];
+  const restorers = [];
+  if (typeof globalThis.fetch === "function" && !isWrapped(globalThis.fetch)) {
+    const originalFetch = globalThis.fetch.bind(globalThis);
+    const wrapped = /* @__PURE__ */ __name(async (input, init) => {
+      const start = Date.now();
+      const inputMethod = typeof input === "object" && input !== null && "method" in input ? input.method : void 0;
+      const method = String(init?.method ?? inputMethod ?? "GET").toUpperCase();
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input?.url ?? "";
+      const safeUrl = sanitizeUrl(url);
+      if (shouldIgnoreUrl(url, ignoreUrls)) {
+        return originalFetch(input, init);
+      }
+      try {
+        const res = await originalFetch(input, init);
+        leaveBreadcrumb({
+          category: "http",
+          level: res.status >= 400 ? "error" : "info",
+          message: `${method} ${safeUrl} \u2192 ${res.status}`,
+          data: {
+            method,
+            url: safeUrl,
+            status: res.status,
+            durationMs: Date.now() - start
+          }
+        });
+        return res;
+      } catch (err) {
+        leaveBreadcrumb({
+          category: "http",
+          level: "error",
+          message: `${method} ${safeUrl} \u2192 ERR`,
+          data: {
+            method,
+            url: safeUrl,
+            error: err?.message ?? String(err),
+            durationMs: Date.now() - start
+          }
+        });
+        throw err;
+      }
+    }, "wrapped");
+    markWrapped(wrapped, originalFetch);
+    globalThis.fetch = wrapped;
+    restorers.push(() => {
+      if (globalThis.fetch === wrapped) globalThis.fetch = unwrap(wrapped);
+    });
+  }
+  for (const mod of [
+    "http",
+    "https"
+  ]) {
+    try {
+      const lib = require(mod);
+      if (!lib || typeof lib.request !== "function" || isWrapped(lib.request)) continue;
+      const originalRequest = lib.request.bind(lib);
+      const wrapped = /* @__PURE__ */ __name(function(...args) {
+        const start = Date.now();
+        let url = "";
+        let method = "GET";
+        try {
+          const first = args[0];
+          if (typeof first === "string") {
+            url = first;
+          } else if (first instanceof URL) {
+            url = first.toString();
+          } else if (first && typeof first === "object") {
+            const host = first.host ?? first.hostname ?? "";
+            const path = first.path ?? "";
+            url = `${mod}://${host}${path}`;
+            method = (first.method ?? "GET").toUpperCase();
+          }
+          const optsArg = args.find((a, i) => i > 0 && a && typeof a === "object" && !("on" in a));
+          if (optsArg?.method) method = String(optsArg.method).toUpperCase();
+        } catch {
+        }
+        const safeUrl = sanitizeUrl(url);
+        const req = originalRequest(...args);
+        if (!shouldIgnoreUrl(url, ignoreUrls)) {
+          req.once?.("response", (res) => {
+            leaveBreadcrumb({
+              category: "http",
+              level: (res.statusCode ?? 0) >= 400 ? "error" : "info",
+              message: `${method} ${safeUrl} \u2192 ${res.statusCode}`,
+              data: {
+                method,
+                url: safeUrl,
+                status: res.statusCode,
+                durationMs: Date.now() - start
+              }
+            });
+          });
+          req.once?.("error", (err) => {
+            leaveBreadcrumb({
+              category: "http",
+              level: "error",
+              message: `${method} ${safeUrl} \u2192 ERR`,
+              data: {
+                method,
+                url: safeUrl,
+                error: err.message,
+                durationMs: Date.now() - start
+              }
+            });
+          });
+        }
+        return req;
+      }, "wrapped");
+      markWrapped(wrapped, originalRequest);
+      lib.request = wrapped;
+      restorers.push(() => {
+        if (lib.request === wrapped) lib.request = unwrap(wrapped);
+      });
+    } catch {
+    }
+  }
+  installed = {
+    restore() {
+      for (const r of restorers) r();
+      installed = null;
+    }
+  };
+  return installed;
+}
+__name(installHttpTracing, "installHttpTracing");
+
+// src/console-capture.ts
+var installed2 = null;
+var NEST_LOGGER_HINTS = [
+  "[Nest]",
+  "NestApplication",
+  "NestFactory",
+  "InstanceLoader",
+  "RoutesResolver",
+  "RouterExplorer"
+];
+function looksLikeNestLogger(args) {
+  if (!args.length) return false;
+  const first = String(args[0] ?? "");
+  return NEST_LOGGER_HINTS.some((h) => first.includes(h));
+}
+__name(looksLikeNestLogger, "looksLikeNestLogger");
+function format(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    if (a instanceof Error) return `${a.name}: ${a.message}`;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ").slice(0, 1e3);
+}
+__name(format, "format");
+function installConsoleCapture() {
+  if (installed2) return installed2;
+  const restorers = [];
+  const levels = [
+    [
+      "log",
+      "info"
+    ],
+    [
+      "warn",
+      "warning"
+    ],
+    [
+      "error",
+      "error"
+    ]
+  ];
+  for (const [method, level] of levels) {
+    const fn = console[method];
+    if (typeof fn !== "function" || isWrapped(fn)) continue;
+    const original = fn.bind(console);
+    const wrapped = /* @__PURE__ */ __name(function(...args) {
+      try {
+        if (!looksLikeNestLogger(args)) {
+          leaveBreadcrumb({
+            category: "console",
+            level,
+            message: format(args)
+          });
+        }
+      } catch {
+      }
+      return original(...args);
+    }, "wrapped");
+    markWrapped(wrapped, original);
+    console[method] = wrapped;
+    restorers.push(() => {
+      if (console[method] === wrapped) {
+        console[method] = unwrap(wrapped);
+      }
+    });
+  }
+  installed2 = {
+    restore() {
+      for (const r of restorers) r();
+      installed2 = null;
+    }
+  };
+  return installed2;
+}
+__name(installConsoleCapture, "installConsoleCapture");
+
+// src/typeorm-tracing.ts
+function parseQueryType(sql) {
+  const m = /^\s*(\w+)/.exec(sql);
+  return (m?.[1] ?? "UNKNOWN").toUpperCase();
+}
+__name(parseQueryType, "parseQueryType");
+function parseTable(sql) {
+  const re = /\b(?:FROM|INTO|UPDATE|JOIN)\s+["']?(\w+)/i;
+  const m = re.exec(sql);
+  return m?.[1];
+}
+__name(parseTable, "parseTable");
+var InstantTasksTypeOrmLogger = class {
+  static {
+    __name(this, "InstantTasksTypeOrmLogger");
+  }
+  slowQueryMs;
+  constructor(slowQueryMs = 200) {
+    this.slowQueryMs = slowQueryMs;
+  }
+  emit(sql, durationMs, status, extraAttrs = {}) {
+    const ctx = getCurrentContext();
+    const queryType = parseQueryType(sql);
+    const table = parseTable(sql);
+    const truncated = sql.length > 300 ? `${sql.slice(0, 300)}\u2026` : sql;
+    leaveBreadcrumb({
+      category: "db",
+      level: status === "error" ? "error" : durationMs && durationMs > this.slowQueryMs ? "warning" : "info",
+      message: `${queryType}${table ? ` ${table}` : ""}${durationMs != null ? ` (${durationMs}ms)` : ""}`,
+      data: {
+        sql: truncated,
+        queryType,
+        table,
+        durationMs,
+        status,
+        ...extraAttrs
+      }
+    });
+    if (ctx && durationMs != null) {
+      const end = Date.now();
+      const span = {
+        name: "db.query",
+        startTime: new Date(end - durationMs).toISOString(),
+        endTime: new Date(end).toISOString(),
+        durationMs,
+        status,
+        attrs: {
+          "db.statement": truncated,
+          "db.operation": queryType,
+          "db.table": table,
+          ...extraAttrs
+        }
+      };
+      ctx.addSpan(span);
+    }
+  }
+  // ── TypeORM Logger interface ─────────────────────────────────────
+  logQuery(sql) {
+    this.emit(sql, null, "ok");
+  }
+  logQueryError(error, sql) {
+    this.emit(sql, null, "error", {
+      "error.message": error instanceof Error ? error.message : String(error)
+    });
+  }
+  logQuerySlow(time, sql) {
+    this.emit(sql, time, "ok", {
+      slow: true
+    });
+  }
+  logSchemaBuild() {
+  }
+  logMigration() {
+  }
+  log() {
+  }
+};
+function installTypeOrmTracing(dataSource) {
+  if (!dataSource || typeof dataSource.setOptions !== "function") return null;
+  const existing = dataSource.options?.logger;
+  if (existing instanceof InstantTasksTypeOrmLogger) return existing;
+  const logger = new InstantTasksTypeOrmLogger();
+  dataSource.setOptions({
+    logger
+  });
+  return logger;
+}
+__name(installTypeOrmTracing, "installTypeOrmTracing");
+
+// src/module.ts
+function _ts_decorate6(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;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var InstantTasksLifecycle = class InstantTasksLifecycle2 {
+  static {
+    __name(this, "InstantTasksLifecycle");
+  }
+  opts;
+  restorers = [];
+  constructor(opts) {
+    this.opts = opts;
+  }
+  onModuleInit() {
+    if (this.opts.captureHttp) {
+      const ignoreUrls = [
+        ...this.opts.ignoreUrls ?? [],
+        `${(this.opts.apiUrl ?? "").replace(/\/+$/, "").replace(/\/api\/v\d+$/, "")}/api/v1/sdk/`
+      ];
+      const { restore } = installHttpTracing({
+        ignoreUrls
+      });
+      this.restorers.push(restore);
+    }
+    if (this.opts.captureConsole) {
+      const { restore } = installConsoleCapture();
+      this.restorers.push(restore);
+    }
+    if (this.opts.captureTypeOrm && this.opts.dataSource) {
+      installTypeOrmTracing(this.opts.dataSource);
+    }
+  }
+  onModuleDestroy() {
+    for (const r of this.restorers) {
+      try {
+        r();
+      } catch {
+      }
+    }
+    this.restorers = [];
+  }
+};
+InstantTasksLifecycle = _ts_decorate6([
+  _ts_param3(0, (0, import_common6.Inject)(INSTANTTASKS_OPTIONS)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof InstantTasksOptions === "undefined" ? Object : InstantTasksOptions
+  ])
+], InstantTasksLifecycle);
+var InstantTasksModule = class _InstantTasksModule {
+  static {
+    __name(this, "InstantTasksModule");
+  }
+  opts;
+  static forRoot(options) {
+    return _InstantTasksModule.build({
+      provide: INSTANTTASKS_OPTIONS,
+      useValue: options
+    }, options);
+  }
+  static forRootAsync(opts) {
+    const optsProvider = {
+      provide: INSTANTTASKS_OPTIONS,
+      useFactory: opts.useFactory,
+      inject: opts.inject ?? []
+    };
+    const conditional = [
+      // Span interceptor self-checks for context — safe to always register.
+      {
+        provide: import_core.APP_INTERCEPTOR,
+        useClass: InstantTasksSpanInterceptor
+      }
+    ];
+    return {
+      module: _InstantTasksModule,
+      imports: opts.imports ?? [],
+      providers: [
+        optsProvider,
+        InstantTasksReporter,
+        InstantTasksExceptionFilter,
+        InstantTasksReportInterceptor,
+        InstantTasksRequestContextMiddleware,
+        InstantTasksLifecycle,
+        ...conditional
+      ],
+      exports: [
+        InstantTasksReporter,
+        InstantTasksExceptionFilter,
+        InstantTasksReportInterceptor
+      ],
+      global: true
+    };
+  }
+  static build(optsProvider, options) {
+    const conditional = [];
+    if (options.captureSpans) {
+      conditional.push({
+        provide: import_core.APP_INTERCEPTOR,
+        useClass: InstantTasksSpanInterceptor
+      });
+    }
+    return {
+      module: _InstantTasksModule,
+      providers: [
+        optsProvider,
+        InstantTasksReporter,
+        InstantTasksExceptionFilter,
+        InstantTasksReportInterceptor,
+        InstantTasksRequestContextMiddleware,
+        InstantTasksLifecycle,
+        ...conditional
+      ],
+      exports: [
+        InstantTasksReporter,
+        InstantTasksExceptionFilter,
+        InstantTasksReportInterceptor
+      ],
+      global: true
+    };
+  }
+  constructor(opts) {
+    this.opts = opts;
+  }
+  configure(consumer) {
+    if (this.opts.captureRequestContext) {
+      consumer.apply(InstantTasksRequestContextMiddleware).forRoutes("*");
+    }
+  }
+};
+InstantTasksModule = _ts_decorate6([
+  (0, import_common6.Module)({}),
+  _ts_param3(0, (0, import_common6.Inject)(INSTANTTASKS_OPTIONS)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof InstantTasksOptions === "undefined" ? Object : InstantTasksOptions
+  ])
+], InstantTasksModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INSTANTTASKS_OPTIONS,
+  InstantTasksExceptionFilter,
+  InstantTasksModule,
+  InstantTasksReportInterceptor,
+  InstantTasksReporter,
+  InstantTasksRequestContextMiddleware,
+  InstantTasksSpanInterceptor,
+  InstantTasksTypeOrmLogger,
+  RequestContextRing,
+  getCurrentContext,
+  installConsoleCapture,
+  installHttpTracing,
+  installTypeOrmTracing,
+  leaveBreadcrumb,
+  requestContextStorage
+});
+//# sourceMappingURL=index.cjs.map