@buenojs/bueno 0.8.3 → 0.8.5

package/dist/observability/index.js

@@ -0,0 +1,331 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/observability/breadcrumbs.ts
+class BreadcrumbCollector {
+  _buffer;
+  _maxSize;
+  _head = 0;
+  _size = 0;
+  constructor(maxSize = 20) {
+    if (maxSize < 1)
+      throw new RangeError("maxSize must be at least 1");
+    this._maxSize = maxSize;
+    this._buffer = new Array(maxSize);
+  }
+  add(entry) {
+    const index = (this._head + this._size) % this._maxSize;
+    this._buffer[index] = entry;
+    if (this._size < this._maxSize) {
+      this._size++;
+    } else {
+      this._head = (this._head + 1) % this._maxSize;
+    }
+  }
+  getAll() {
+    const result = [];
+    for (let i = 0;i < this._size; i++) {
+      result.push(this._buffer[(this._head + i) % this._maxSize]);
+    }
+    return result;
+  }
+  clear() {
+    this._head = 0;
+    this._size = 0;
+  }
+  get size() {
+    return this._size;
+  }
+  get maxSize() {
+    return this._maxSize;
+  }
+}
+function httpBreadcrumb(method, path, statusCode, durationMs) {
+  const level = statusCode !== undefined && statusCode >= 400 ? "error" : "info";
+  const data = { method, path };
+  if (statusCode !== undefined)
+    data.statusCode = statusCode;
+  if (durationMs !== undefined)
+    data.durationMs = durationMs;
+  return {
+    timestamp: new Date,
+    type: "http",
+    level,
+    message: `${method} ${path}${statusCode !== undefined ? ` ${statusCode}` : ""}`,
+    data
+  };
+}
+function logBreadcrumb(level, message, data) {
+  return {
+    timestamp: new Date,
+    type: "log",
+    level,
+    message,
+    data
+  };
+}
+
+// src/observability/service.ts
+function generateId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function extractSafeHeaders(req) {
+  const safe = {};
+  const sensitiveHeaders = new Set([
+    "authorization",
+    "cookie",
+    "x-api-key",
+    "x-auth-token",
+    "proxy-authorization"
+  ]);
+  req.headers.forEach((value, key) => {
+    if (!sensitiveHeaders.has(key.toLowerCase())) {
+      safe[key] = value;
+    }
+  });
+  return safe;
+}
+function getStatusCode(error) {
+  const e = error;
+  return e.statusCode ?? e.status;
+}
+
+class ObservabilityService {
+  reporter;
+  breadcrumbs;
+  options;
+  constructor(options) {
+    this.reporter = options.reporter;
+    this.options = {
+      breadcrumbsSize: options.breadcrumbsSize ?? 20,
+      ignoreErrors: options.ignoreErrors ?? [],
+      ignoreStatusCodes: options.ignoreStatusCodes ?? [],
+      tags: options.tags ?? {},
+      captureUnhandled: options.captureUnhandled ?? false
+    };
+    this.breadcrumbs = new BreadcrumbCollector(this.options.breadcrumbsSize);
+    if (this.options.captureUnhandled) {
+      this.setupUnhandledCapture();
+    }
+  }
+  captureFromContext(context, error) {
+    if (this.shouldIgnore(error))
+      return;
+    this.breadcrumbs.add(httpBreadcrumb(context.method, context.path, undefined));
+    const event = this.assembleEvent(error, "error", context);
+    this.dispatchAsync(event);
+  }
+  registerShutdown() {
+    const flush = async () => {
+      if (this.reporter.flush) {
+        try {
+          await this.reporter.flush();
+        } catch (err) {
+          console.error("[ObservabilityService] Reporter flush failed:", err);
+        }
+      }
+    };
+    process.once("beforeExit", () => {
+      flush().catch(console.error);
+    });
+  }
+  captureError(error, level = "error") {
+    if (this.shouldIgnore(error))
+      return;
+    const event = this.assembleEvent(error, level);
+    this.dispatchAsync(event);
+  }
+  captureMessage(message, level = "info", extra) {
+    if (!this.reporter.captureMessage)
+      return;
+    const event = {
+      id: generateId(),
+      timestamp: new Date,
+      message,
+      level,
+      extra
+    };
+    this.dispatchMessageAsync(event);
+  }
+  addBreadcrumb(entry) {
+    this.breadcrumbs.add({
+      ...entry,
+      timestamp: entry.timestamp ?? new Date
+    });
+  }
+  getBreadcrumbCollector() {
+    return this.breadcrumbs;
+  }
+  assembleEvent(error, level, context) {
+    const user = context?.get("user");
+    const traceId = context?.get("traceId") ?? undefined;
+    const spanId = context?.get("spanId") ?? undefined;
+    return {
+      id: generateId(),
+      timestamp: new Date,
+      error,
+      level,
+      request: context ? {
+        method: context.method,
+        path: context.path,
+        headers: extractSafeHeaders(context.req),
+        ip: context.ip ?? "",
+        userAgent: context.getHeader("user-agent")
+      } : undefined,
+      traceId,
+      spanId,
+      user: user ?? undefined,
+      breadcrumbs: this.breadcrumbs.getAll(),
+      tags: { ...this.options.tags }
+    };
+  }
+  shouldIgnore(error) {
+    for (const ErrorClass of this.options.ignoreErrors) {
+      if (error instanceof ErrorClass)
+        return true;
+    }
+    if (this.options.ignoreStatusCodes.length > 0) {
+      const code = getStatusCode(error);
+      if (code !== undefined && this.options.ignoreStatusCodes.includes(code)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  dispatchAsync(event) {
+    Promise.resolve(this.reporter.captureError(event)).catch((err) => {
+      console.error("[ObservabilityService] Reporter.captureError failed:", err);
+    });
+  }
+  dispatchMessageAsync(event) {
+    if (!this.reporter.captureMessage)
+      return;
+    Promise.resolve(this.reporter.captureMessage(event)).catch((err) => {
+      console.error("[ObservabilityService] Reporter.captureMessage failed:", err);
+    });
+  }
+  setupUnhandledCapture() {
+    process.on("unhandledRejection", (reason) => {
+      const error = reason instanceof Error ? reason : new Error(String(reason ?? "Unhandled rejection"));
+      this.captureError(error, "error");
+    });
+    process.on("uncaughtException", (error) => {
+      this.captureError(error, "fatal");
+    });
+  }
+}
+function extractTraceContext(context) {
+  const traceparent = context.getHeader("traceparent");
+  if (!traceparent)
+    return {};
+  const parts = traceparent.split("-");
+  if (parts.length < 4)
+    return {};
+  return { traceId: parts[1], spanId: parts[2] };
+}
+
+// src/observability/trace.ts
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function buildTraceparent(traceId, spanId) {
+  return `00-${traceId}-${spanId}-01`;
+}
+
+// src/observability/interceptor.ts
+function resolveTraceIds(context) {
+  const existing = extractTraceContext(context);
+  if (existing.traceId && existing.spanId) {
+    return { traceId: existing.traceId, spanId: existing.spanId };
+  }
+  return { traceId: generateTraceId(), spanId: generateSpanId() };
+}
+
+class ObservabilityInterceptor {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  async intercept(context, next) {
+    const startMs = Date.now();
+    const { traceId, spanId } = resolveTraceIds(context);
+    context.set("traceId", traceId);
+    context.set("spanId", spanId);
+    this.service.addBreadcrumb({
+      type: "navigation",
+      level: "info",
+      message: `${context.method} ${context.path}`,
+      data: { traceId, spanId }
+    });
+    try {
+      const result = await next.handle();
+      const durationMs = Date.now() - startMs;
+      const response = result;
+      const statusCode = response instanceof Response ? response.status : undefined;
+      this.service.getBreadcrumbCollector().add(httpBreadcrumb(context.method, context.path, statusCode, durationMs));
+      return result;
+    } catch (error) {
+      this.service.captureFromContext(context, error);
+      const durationMs = Date.now() - startMs;
+      this.service.getBreadcrumbCollector().add(httpBreadcrumb(context.method, context.path, undefined, durationMs));
+      throw error;
+    }
+  }
+}
+
+// src/observability/index.ts
+class ObservabilityModule {
+  static setup(app, options) {
+    const service = new ObservabilityService(options);
+    const interceptor = new ObservabilityInterceptor(service);
+    app.useGlobalInterceptors(interceptor);
+    service.registerShutdown();
+    return service;
+  }
+}
+export {
+  logBreadcrumb,
+  httpBreadcrumb,
+  generateTraceId,
+  generateSpanId,
+  extractTraceContext,
+  buildTraceparent,
+  ObservabilityService,
+  ObservabilityModule,
+  ObservabilityInterceptor,
+  BreadcrumbCollector
+};