@angelitosystems/nest-devtools 0.1.0

package/dist/index.js

@@ -0,0 +1,722 @@
+// src/sdk.ts
+import { hostname } from "os";
+import { devtools as coreDevtools2, resolveConfig } from "@angelitosystems/devtools-core";
+
+// src/instrumentation/http.ts
+import { Redactor, randomId } from "@angelitosystems/devtools-protocol";
+import { requestContext } from "@angelitosystems/devtools-core";
+
+// src/emitter.ts
+import { devtools as coreDevtools } from "@angelitosystems/devtools-core";
+function emit(event, payload) {
+  try {
+    coreDevtools.send(event, payload);
+  } catch {
+  }
+}
+
+// src/instrumentation/timeline.ts
+var recorders = /* @__PURE__ */ new Map();
+function trackSpans(requestId, spans) {
+  recorders.set(requestId, spans);
+  return () => recorders.delete(requestId);
+}
+
+// src/instrumentation/http.ts
+var INTERESTING_HEADERS = [
+  "content-type",
+  "content-length",
+  "accept",
+  "origin",
+  "referer",
+  "user-agent",
+  "x-forwarded-for",
+  "x-request-id"
+];
+var WRAPPED = /* @__PURE__ */ Symbol("nest-devtools.wrapped");
+var HttpInstrumentation = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.redactor = new Redactor({
+      redact: ctx.config.redact,
+      allow: ctx.config.allow,
+      maxBytes: ctx.config.maxPayloadBytes
+    });
+  }
+  ctx;
+  redactor;
+  /** Begin capturing HTTP requests. Returns a cleanup function. */
+  attach(app) {
+    try {
+      const adapter = app.getHttpAdapter();
+      if (!adapter || !["http", "express"].includes(adapter.getType())) return () => {
+      };
+      const getServer = () => adapter.getHttpServer?.();
+      const existing = getServer();
+      if (existing) {
+        this.wrapServer(existing);
+        return () => {
+        };
+      }
+      const appLike = app;
+      const originalListen = appLike.listen.bind(app);
+      const self = this;
+      const patchedListen = (...args) => {
+        const result = originalListen(...args);
+        Promise.resolve(result).then(() => {
+          const server = getServer();
+          if (server) self.wrapServer(server);
+        }).catch(() => {
+        });
+        return result;
+      };
+      appLike.listen = patchedListen;
+      return () => {
+        appLike.listen = originalListen;
+      };
+    } catch {
+      return () => {
+      };
+    }
+  }
+  /** Wrap the 'request' listeners of a server exactly once. */
+  wrapServer(server) {
+    const target = server;
+    if (target[WRAPPED]) return;
+    target[WRAPPED] = true;
+    const self = this;
+    const originalListeners = server.rawListeners("request");
+    server.removeAllListeners("request");
+    server.on("request", (req, res) => {
+      self.instrumentRequest(req, res, () => {
+        for (const listener of originalListeners) {
+          listener.call(server, req, res);
+        }
+      });
+    });
+  }
+  /** Wrap a single request lifecycle. */
+  instrumentRequest(req, res, next) {
+    if (!this.ctx.config.capture.requests) {
+      next();
+      return;
+    }
+    const startedAt = Date.now();
+    const requestId = randomId("req");
+    const method = (req.method ?? "GET").toUpperCase();
+    const rawUrl = req.url ?? "/";
+    const url = safeUrlPath(rawUrl);
+    const spans = [];
+    const unregister = trackSpans(requestId, spans);
+    res.once("finish", unregister);
+    const started = {
+      requestId,
+      projectId: this.ctx.projectInfo.projectId,
+      method,
+      url,
+      headers: this.collectHeaders(req),
+      query: parseQuery(rawUrl),
+      ip: clientIp(req),
+      userAgent: asString(req.headers["user-agent"]) || void 0,
+      startedAt
+    };
+    const middlewareSpan = {
+      layer: "middleware",
+      label: `${method} ${url}`,
+      duration: 0,
+      startedAt,
+      status: "ok"
+    };
+    spans.push(middlewareSpan);
+    const onFinished = () => {
+      const finishedAt = Date.now();
+      middlewareSpan.duration = Math.max(0, finishedAt - middlewareSpan.startedAt);
+      middlewareSpan.status = res.statusCode >= 500 ? "error" : "ok";
+      const responseSpan = {
+        layer: "response",
+        label: "response",
+        duration: 0,
+        startedAt: finishedAt,
+        status: "ok"
+      };
+      spans.push(responseSpan);
+      const errored = res.statusCode >= 500;
+      const completed = {
+        requestId,
+        projectId: this.ctx.projectInfo.projectId,
+        method,
+        url,
+        statusCode: res.statusCode,
+        duration: finishedAt - startedAt,
+        startedAt,
+        timeline: spans,
+        query: parseQuery(rawUrl),
+        errored
+      };
+      emit("request.completed", completed);
+      if (errored) {
+        emit("error.created", {
+          requestId,
+          projectId: this.ctx.projectInfo.projectId,
+          name: "HttpError",
+          message: `${method} ${url} failed with status ${res.statusCode}`,
+          fingerprint: httpErrorFingerprint(method, url, res.statusCode),
+          request: { method, url, statusCode: res.statusCode },
+          timestamp: finishedAt
+        });
+      }
+    };
+    const context = requestContext();
+    context.run({ requestId, method, url, startedAt }, () => {
+      emit("request.started", started);
+      res.once("finish", onFinished);
+      next();
+    });
+  }
+  collectHeaders(req) {
+    const out = {};
+    for (const key of INTERESTING_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;
+  }
+};
+function asString(value) {
+  if (Array.isArray(value)) return value.join(", ");
+  return value ?? "";
+}
+function httpErrorFingerprint(method, url, statusCode) {
+  const route = url.replace(/\/\d+(?=\/|$)/g, "/:id");
+  const raw = `${method}::${route}::${statusCode}`;
+  let hash = 0;
+  for (let i = 0; i < raw.length; i++) {
+    hash = hash * 31 + raw.charCodeAt(i) >>> 0;
+  }
+  return hash.toString(36).padStart(7, "0");
+}
+function safeUrlPath(raw) {
+  const index = raw.indexOf("?");
+  return index === -1 ? raw : raw.slice(0, index);
+}
+function parseQuery(raw) {
+  const index = raw.indexOf("?");
+  if (index === -1) return {};
+  const out = {};
+  for (const [key, value] of new URLSearchParams(raw.slice(index + 1))) {
+    out[key] = value;
+  }
+  return out;
+}
+function clientIp(req) {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (typeof forwarded === "string") return forwarded.split(",")[0]?.trim();
+  return req.socket?.remoteAddress ?? void 0;
+}
+
+// src/instrumentation/console.ts
+import { Console } from "console";
+import { Redactor as Redactor2 } from "@angelitosystems/devtools-protocol";
+import { resolveSourceLocation } from "@angelitosystems/devtools-core";
+import { requestContext as requestContext2 } from "@angelitosystems/devtools-core";
+var METHODS = ["log", "info", "warn", "error", "debug"];
+var LEVEL_BY_METHOD = {
+  log: "info",
+  info: "info",
+  warn: "warn",
+  error: "error",
+  debug: "debug"
+};
+var originalConsole = new Console({
+  stdout: process.stdout,
+  stderr: process.stderr,
+  colorMode: "auto"
+});
+var ConsoleInstrumentation = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.redactor = new Redactor2({
+      redact: ctx.config.redact,
+      allow: ctx.config.allow,
+      maxBytes: ctx.config.maxPayloadBytes
+    });
+  }
+  ctx;
+  redactor;
+  /** Patch console methods. Returns a restore function. */
+  attach() {
+    const self = this;
+    const restores = [];
+    for (const method of METHODS) {
+      const original = console[method];
+      if (typeof original !== "function") continue;
+      const patched = (...args) => {
+        try {
+          original.apply(console, args);
+        } catch {
+        }
+        self.capture(method, args);
+      };
+      console[method] = patched;
+      restores.push(() => {
+        console[method] = original;
+      });
+    }
+    return () => {
+      for (const restore of restores.splice(0)) restore();
+    };
+  }
+  capture(method, args) {
+    if (!this.ctx.config.capture.logs) return;
+    try {
+      const level = LEVEL_BY_METHOD[method];
+      const payload = {
+        projectId: this.ctx.projectInfo.projectId,
+        level,
+        message: formatMessage(args, this.redactor),
+        arguments: args.length > 0 ? this.redactor.redact(args) : void 0,
+        stack: method === "error" ? captureStack() : void 0,
+        source: resolveSourceLocation(captureStack() ?? "", { skip: 0 }),
+        context: void 0,
+        processId: process.pid,
+        requestId: requestContext2().requestId(),
+        timestamp: Date.now()
+      };
+      if (method === "error") payload.level = "error";
+      emit("log.created", payload);
+    } catch {
+    }
+  }
+};
+function formatMessage(args, redactor) {
+  if (args.length === 0) return "";
+  const first = args[0];
+  if (typeof first === "string") {
+    return args.length === 1 ? redactor.redactString(first) : `${first} ${redactor.serialize(args.slice(1))}`;
+  }
+  return redactor.serialize(args);
+}
+function captureStack() {
+  const err = new Error();
+  const stack = err.stack;
+  if (!stack) return void 0;
+  return stack.split("\n").slice(3).join("\n");
+}
+
+// src/instrumentation/nest-logger.ts
+import { Logger } from "@nestjs/common";
+import { Redactor as Redactor3 } from "@angelitosystems/devtools-protocol";
+import { requestContext as requestContext3, resolveSourceLocation as resolveSourceLocation2 } from "@angelitosystems/devtools-core";
+var activeRedactor = new Redactor3();
+var activeConfig = null;
+var activeProjectId = "";
+function capture(level, message, context, stack) {
+  try {
+    if (!activeConfig?.capture.logs) return;
+    const text = typeof message === "string" ? message : activeRedactor.serialize(message);
+    const payload = {
+      projectId: activeProjectId,
+      level,
+      message: activeRedactor.redactString(text),
+      source: stack ? void 0 : resolveSdkAwareLocation(),
+      context,
+      stack,
+      processId: process.pid,
+      requestId: requestContext3().requestId(),
+      timestamp: Date.now()
+    };
+    emit("log.created", payload);
+  } catch {
+  }
+}
+var LoggerInstrumentation = class {
+  constructor(ctx) {
+    activeRedactor = new Redactor3({
+      redact: ctx.config.redact,
+      allow: ctx.config.allow,
+      maxBytes: ctx.config.maxPayloadBytes
+    });
+    activeConfig = ctx.config;
+    activeProjectId = ctx.projectInfo.projectId;
+  }
+  /** Patch Logger.prototype and the static Logger methods. Returns a restore function. */
+  attach() {
+    const restores = [];
+    const patch = (owner, method, level, instance) => {
+      const original = owner[method];
+      if (typeof original !== "function") return;
+      owner[method] = function(message, ...rest) {
+        const context = instance ? this?.context ?? rest[0] : rest[0];
+        const stack = rest[1];
+        try {
+          const result = original.apply(this, [message, ...rest]);
+          capture(level, message, context, stack);
+          return result;
+        } catch (err) {
+          capture(level, message, context, stack);
+          throw err;
+        }
+      };
+      restores.push(() => {
+        owner[method] = original;
+      });
+    };
+    const proto = Logger.prototype;
+    patch(proto, "log", "info", true);
+    patch(proto, "error", "error", true);
+    patch(proto, "warn", "warn", true);
+    patch(proto, "debug", "debug", true);
+    patch(proto, "verbose", "verbose", true);
+    const statics = Logger;
+    patch(statics, "log", "info", false);
+    patch(statics, "error", "error", false);
+    patch(statics, "warn", "warn", false);
+    patch(statics, "debug", "debug", false);
+    patch(statics, "verbose", "verbose", false);
+    return () => {
+      for (const restore of restores.splice(0)) restore();
+    };
+  }
+};
+function resolveSdkAwareLocation() {
+  try {
+    const err = new Error();
+    const stack = err.stack?.split("\n").slice(3).join("\n");
+    return resolveSourceLocation2(stack ?? "", { skip: 0 });
+  } catch {
+    return void 0;
+  }
+}
+
+// src/instrumentation/exceptions.ts
+import { basename } from "path";
+import { requestContext as requestContext4, safeStringify, resolveSourceLocation as resolveSourceLocation3 } from "@angelitosystems/devtools-core";
+var ExceptionsInstrumentation = class {
+  /** Attach process-level hooks. Returns a detach function. */
+  static attach(ctx) {
+    const onUncaught = (error) => {
+      reportError(error, ctx, { source: "uncaughtException" });
+    };
+    const onRejection = (reason) => {
+      reportError(reason, ctx, { source: "unhandledRejection" });
+    };
+    process.on("uncaughtException", onUncaught);
+    process.on("unhandledRejection", onRejection);
+    return () => {
+      process.off("uncaughtException", onUncaught);
+      process.off("unhandledRejection", onRejection);
+    };
+  }
+};
+function captureError(error, options) {
+  reportError(error, void 0, options);
+}
+function reportError(error, ctx, options) {
+  try {
+    if (ctx && !ctx.config.capture.errors) return;
+    const normalized = normalizeError(error);
+    const location = resolveSourceLocation3(normalized.error ?? normalized.message, { skip: 1 });
+    const projectId = ctx?.projectInfo.projectId ?? basename(process.cwd());
+    const payload = {
+      requestId: requestContext4().requestId(),
+      projectId,
+      name: normalized.name,
+      message: normalized.message,
+      stack: normalized.error?.stack,
+      source: location,
+      fingerprint: fingerprint(normalized.name, normalized.message, location),
+      context: options?.context ?? options?.source,
+      request: currentRequestSummary(),
+      controller: options?.controller,
+      service: options?.service,
+      timestamp: Date.now()
+    };
+    emit("error.created", payload);
+  } catch {
+  }
+}
+function normalizeError(error) {
+  if (error instanceof Error) {
+    return { error, name: error.name, message: error.message };
+  }
+  if (typeof error === "string") {
+    return { error: void 0, name: "Unknown", message: error };
+  }
+  if (error !== null && typeof error === "object" && "message" in error) {
+    const record = error;
+    return {
+      error: void 0,
+      name: typeof record["name"] === "string" ? record["name"] : "Error",
+      message: String(record["message"])
+    };
+  }
+  return { error: void 0, name: "Unknown", message: safeStringify(error) };
+}
+function fingerprint(name, message, location) {
+  const raw = name + "::" + message + "::" + (location?.file ?? "") + ":" + String(location?.line ?? "");
+  let hash = 0;
+  for (let i = 0; i < raw.length; i++) {
+    hash = hash * 31 + raw.charCodeAt(i) >>> 0;
+  }
+  return hash.toString(36).padStart(7, "0");
+}
+function currentRequestSummary() {
+  const context = requestContext4().current();
+  if (!context?.method || !context?.url) return void 0;
+  return { method: context.method, url: context.url };
+}
+
+// src/instrumentation/performance.ts
+var PerformanceInstrumentation = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** No-op: sampling is owned by core. Returns a no-op cleanup. */
+  attach() {
+    void this.ctx;
+    return () => {
+    };
+  }
+};
+
+// src/instrumentation/app-explorer.ts
+var AppExplorer = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Walk the container and emit app.snapshot. Returns a no-op cleanup. */
+  attach(app) {
+    try {
+      const snapshot = this.buildSnapshot(app);
+      emit("app.snapshot", snapshot);
+    } catch {
+    }
+    return () => {
+    };
+  }
+  buildSnapshot(app) {
+    const internal = app.container;
+    const modules = [];
+    const modulesMap = internal?.getModules?.();
+    if (modulesMap) {
+      for (const [id, node] of modulesMap) {
+        const moduleName = node.metatype?.name ?? String(id);
+        const members = this.extractMembers(node);
+        modules.push({
+          name: moduleName,
+          imports: [],
+          controllers: members.controllers,
+          providers: members.providers,
+          exports: []
+        });
+      }
+    }
+    return {
+      projectId: this.ctx.projectInfo.projectId,
+      projectName: this.ctx.projectInfo.projectName,
+      modules,
+      nestjsVersion: this.ctx.projectInfo.nestjsVersion,
+      capturedAt: Date.now()
+    };
+  }
+  extractMembers(node) {
+    const controllers = [];
+    const providers = [];
+    const providersMap = node.providers;
+    if (providersMap instanceof Map) {
+      for (const [id, wrapper] of providersMap) {
+        const member = this.memberFromWrapper(id, wrapper);
+        if (!member) continue;
+        if (wrapper && wrapper.subtype === "httpController") {
+          controllers.push(member);
+        } else {
+          providers.push(member);
+        }
+      }
+    }
+    return { controllers, providers };
+  }
+  memberFromWrapper(id, wrapper) {
+    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 };
+  }
+};
+function classify(name, instance) {
+  if (name.endsWith("Gateway")) return "gateway";
+  if (name.endsWith("Guard")) return "guard";
+  if (name.endsWith("Interceptor")) return "interceptor";
+  if (name.endsWith("Pipe")) return "pipe";
+  if (name.endsWith("Filter")) return "filter";
+  if (instance && typeof instance.canActivate === "function") return "guard";
+  if (instance && typeof instance.intercept === "function") return "interceptor";
+  if (instance && typeof instance.transform === "function") return "pipe";
+  if (instance && typeof instance.catch === "function") return "filter";
+  return "provider";
+}
+
+// src/instrumentation/websockets.ts
+var WebsocketInstrumentation = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** No-op for now. Returns a no-op cleanup. */
+  attach() {
+    void this.ctx;
+    return () => {
+    };
+  }
+};
+
+// src/instrumentation/database.ts
+var DatabaseInstrumentation = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** No-op for now. Returns a no-op cleanup. */
+  attach() {
+    void this.ctx;
+    return () => {
+    };
+  }
+};
+
+// src/detect.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var cached;
+function detectNestJsVersion() {
+  if (cached !== void 0) return cached;
+  cached = null;
+  try {
+    const candidates = [
+      resolve(process.cwd(), "node_modules/@nestjs/core/package.json"),
+      // bun/pnpm layouts: walk up a couple of levels
+      resolve(process.cwd(), "../../node_modules/@nestjs/core/package.json")
+    ];
+    for (const path of candidates) {
+      if (!existsSync(path)) continue;
+      const pkg = JSON.parse(readFileSync(path, "utf8"));
+      if (pkg.version) {
+        cached = pkg.version;
+        break;
+      }
+    }
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/sdk.ts
+var NestDevTools = class {
+  static cleanups = [];
+  static initialized = false;
+  /** Initialize DevTools for a NestJS application. One active instance per process. */
+  static init(app, userConfig) {
+    const config = resolveConfig(userConfig);
+    const disabled = {
+      enabled: false,
+      reason: "disabled-by-config",
+      projectId: config.projectId,
+      projectName: config.project ?? config.projectId,
+      server: config.server
+    };
+    if (this.initialized) return { ...disabled, reason: "already-initialized" };
+    if (!config.enabled) return disabled;
+    this.initialized = true;
+    const registerCleanup = (fn) => this.cleanups.push(fn);
+    const projectInfo = {
+      projectId: config.projectId,
+      projectName: config.project ?? config.projectId,
+      environment: config.environment,
+      hostname: safeHostname(),
+      port: null,
+      pid: process.pid,
+      runtime: detectRuntime(),
+      runtimeVersion: detectRuntimeVersion(),
+      nodeVersion: process.version,
+      nestjsVersion: detectNestJsVersion(),
+      sdkVersion: SDK_VERSION
+    };
+    coreDevtools2.initialize({ config, projectInfo, registerCleanup });
+    const adapter = app.getHttpAdapter();
+    const httpReady = Boolean(adapter && ["http", "express"].includes(adapter.getType()));
+    const http = new HttpInstrumentation({ config, projectInfo });
+    registerCleanup(http.attach(app));
+    registerCleanup(new ConsoleInstrumentation({ config, projectInfo }).attach());
+    registerCleanup(new LoggerInstrumentation({ config, projectInfo }).attach());
+    registerCleanup(ExceptionsInstrumentation.attach({ config, projectInfo }));
+    registerCleanup(new PerformanceInstrumentation({ config, projectInfo }).attach());
+    registerCleanup(new AppExplorer({ config, projectInfo }).attach(app));
+    if (config.capture.websockets) {
+      registerCleanup(new WebsocketInstrumentation({ config, projectInfo }).attach());
+    }
+    if (config.capture.database) {
+      registerCleanup(new DatabaseInstrumentation({ config, projectInfo }).attach());
+    }
+    return {
+      enabled: true,
+      projectId: config.projectId,
+      projectName: projectInfo.projectName,
+      server: config.server,
+      ...httpReady ? {} : { reason: "no-http-adapter" }
+    };
+  }
+  /** Teardown everything (mostly useful in tests). */
+  static destroy() {
+    for (const cleanup of this.cleanups.splice(0)) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+    this.initialized = false;
+    coreDevtools2.shutdown();
+  }
+  /** Whether the SDK is currently active in this process. */
+  static isActive() {
+    return this.initialized;
+  }
+};
+var devtools = {
+  init: NestDevTools.init.bind(NestDevTools),
+  destroy: NestDevTools.destroy.bind(NestDevTools),
+  isActive: NestDevTools.isActive.bind(NestDevTools)
+};
+function safeHostname() {
+  try {
+    return hostname();
+  } catch {
+    return "unknown";
+  }
+}
+function detectRuntime() {
+  const versions = process.versions;
+  if (versions["bun"]) return "bun";
+  if (versions["deno"]) return "deno";
+  return "node";
+}
+function detectRuntimeVersion() {
+  const versions = process.versions;
+  return versions["bun"] ?? versions["deno"] ?? process.version;
+}
+
+// src/index.ts
+import { requestContext as requestContext5 } from "@angelitosystems/devtools-core";
+export {
+  NestDevTools,
+  captureError,
+  devtools,
+  requestContext5 as requestContext
+};
+//# sourceMappingURL=index.js.map