@deeptracer/core 0.2.0

package/dist/chunk-LSMMIS4A.js

@@ -0,0 +1,382 @@
+// src/batcher.ts
+var Batcher = class {
+  constructor(config, onFlush) {
+    this.onFlush = onFlush;
+    this.batchSize = config.batchSize ?? 50;
+    this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
+    this.startTimer();
+  }
+  buffer = [];
+  timer = null;
+  batchSize;
+  flushIntervalMs;
+  add(entry) {
+    this.buffer.push(entry);
+    if (this.buffer.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  flush() {
+    if (this.buffer.length === 0) return;
+    const entries = [...this.buffer];
+    this.buffer = [];
+    this.onFlush(entries);
+  }
+  startTimer() {
+    this.timer = setInterval(() => this.flush(), this.flushIntervalMs);
+  }
+  destroy() {
+    if (this.timer) clearInterval(this.timer);
+    this.flush();
+  }
+};
+
+// src/transport.ts
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async sendLogs(logs) {
+    try {
+      const res = await fetch(`${this.config.endpoint}/ingest/logs`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          product: this.config.product,
+          service: this.config.service,
+          environment: this.config.environment,
+          logs
+        })
+      });
+      if (!res.ok) {
+        console.warn(
+          `[@deeptracer/core] Failed to send logs: ${res.status} ${res.statusText}`
+        );
+      }
+    } catch {
+      console.warn(
+        "[@deeptracer/core] Failed to send logs, falling back to console"
+      );
+    }
+  }
+  async sendError(error) {
+    try {
+      const res = await fetch(`${this.config.endpoint}/ingest/errors`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          ...error,
+          product: this.config.product,
+          service: this.config.service,
+          environment: this.config.environment
+        })
+      });
+      if (!res.ok) {
+        console.warn(
+          `[@deeptracer/core] Failed to send error: ${res.status} ${res.statusText}`
+        );
+      }
+    } catch {
+      console.warn("[@deeptracer/core] Failed to send error report");
+      console.error(error.error_message);
+    }
+  }
+  async sendTrace(span) {
+    try {
+      const res = await fetch(`${this.config.endpoint}/ingest/traces`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          ...span,
+          product: this.config.product,
+          service: this.config.service,
+          environment: this.config.environment
+        })
+      });
+      if (!res.ok) {
+        console.warn(
+          `[@deeptracer/core] Failed to send trace: ${res.status} ${res.statusText}`
+        );
+      }
+    } catch {
+      console.warn("[@deeptracer/core] Failed to send trace span");
+    }
+  }
+  async sendLLMUsage(report) {
+    try {
+      const res = await fetch(`${this.config.endpoint}/ingest/llm`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          ...report,
+          product: this.config.product,
+          service: this.config.service,
+          environment: this.config.environment
+        })
+      });
+      if (!res.ok) {
+        console.warn(
+          `[@deeptracer/core] Failed to send LLM usage: ${res.status} ${res.statusText}`
+        );
+      }
+    } catch {
+      console.warn("[@deeptracer/core] Failed to send LLM usage report");
+    }
+  }
+};
+
+// src/logger.ts
+function generateId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var _originalConsole = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+var Logger = class _Logger {
+  batcher;
+  transport;
+  contextName;
+  config;
+  requestMeta;
+  constructor(config, contextName, requestMeta) {
+    this.config = config;
+    this.contextName = contextName;
+    this.requestMeta = requestMeta;
+    this.transport = new Transport(config);
+    this.batcher = new Batcher(
+      { batchSize: config.batchSize, flushIntervalMs: config.flushIntervalMs },
+      (entries) => {
+        this.transport.sendLogs(entries);
+      }
+    );
+  }
+  log(level, message, dataOrError, maybeError) {
+    let metadata;
+    let error;
+    if (dataOrError instanceof Error) {
+      error = dataOrError;
+    } else if (dataOrError && typeof dataOrError === "object" && !Array.isArray(dataOrError)) {
+      metadata = dataOrError;
+      error = maybeError;
+    } else if (dataOrError !== void 0) {
+      error = dataOrError;
+    }
+    if (error instanceof Error) {
+      metadata = {
+        ...metadata,
+        error: {
+          message: error.message,
+          name: error.name,
+          stack: error.stack
+        }
+      };
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      metadata,
+      context: this.contextName,
+      trace_id: this.requestMeta?.trace_id,
+      span_id: this.requestMeta?.span_id,
+      request_id: this.requestMeta?.request_id,
+      vercel_id: this.requestMeta?.vercel_id
+    };
+    if (this.config.debug) {
+      const prefix = this.contextName ? `[${this.contextName}]` : "";
+      const lvl = level.toUpperCase().padEnd(5);
+      const consoleFn = level === "error" ? _originalConsole.error : level === "warn" ? _originalConsole.warn : level === "debug" ? _originalConsole.debug : _originalConsole.log;
+      if (metadata) {
+        consoleFn(`${lvl} ${prefix} ${message}`, metadata);
+      } else {
+        consoleFn(`${lvl} ${prefix} ${message}`);
+      }
+    }
+    this.batcher.add(entry);
+  }
+  /** Log a debug message. */
+  debug(message, dataOrError, error) {
+    this.log("debug", message, dataOrError, error);
+  }
+  /** Log an informational message. */
+  info(message, dataOrError, error) {
+    this.log("info", message, dataOrError, error);
+  }
+  /** Log a warning. */
+  warn(message, dataOrError, error) {
+    this.log("warn", message, dataOrError, error);
+  }
+  /** Log an error. */
+  error(message, dataOrError, error) {
+    this.log("error", message, dataOrError, error);
+  }
+  /** Create a context-scoped logger. All logs include the context name. */
+  withContext(name) {
+    return new _Logger(this.config, name, this.requestMeta);
+  }
+  /** Create a request-scoped logger that extracts trace context from headers. */
+  forRequest(request) {
+    const vercelId = request.headers.get("x-vercel-id") || void 0;
+    const requestId = request.headers.get("x-request-id") || void 0;
+    const traceId = request.headers.get("x-trace-id") || void 0;
+    const spanId = request.headers.get("x-span-id") || void 0;
+    return new _Logger(this.config, this.contextName, {
+      trace_id: traceId,
+      span_id: spanId,
+      request_id: requestId || (vercelId ? vercelId.split("::").pop() : void 0),
+      vercel_id: vercelId
+    });
+  }
+  /** Capture and report an error immediately (not batched). */
+  captureError(error, context) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const report = {
+      error_message: err.message,
+      stack_trace: err.stack || "",
+      severity: context?.severity || "medium",
+      context: context?.context,
+      trace_id: this.requestMeta?.trace_id,
+      user_id: context?.userId,
+      breadcrumbs: context?.breadcrumbs
+    };
+    this.transport.sendError(report);
+  }
+  /** Track LLM usage. Sends to /ingest/llm and logs for visibility. */
+  llmUsage(report) {
+    this.transport.sendLLMUsage({
+      model: report.model,
+      provider: report.provider,
+      operation: report.operation,
+      input_tokens: report.inputTokens,
+      output_tokens: report.outputTokens,
+      cost_usd: report.costUsd || 0,
+      latency_ms: report.latencyMs,
+      metadata: report.metadata
+    });
+    this.log("info", `LLM call: ${report.model} (${report.operation})`, {
+      llm_usage: {
+        model: report.model,
+        provider: report.provider,
+        operation: report.operation,
+        input_tokens: report.inputTokens,
+        output_tokens: report.outputTokens,
+        latency_ms: report.latencyMs
+      }
+    });
+  }
+  /** Start a span with automatic lifecycle (callback-based, recommended). */
+  startSpan(operation, fn) {
+    const inactive = this.startInactiveSpan(operation);
+    const span = {
+      traceId: inactive.traceId,
+      spanId: inactive.spanId,
+      parentSpanId: inactive.parentSpanId,
+      operation: inactive.operation,
+      getHeaders: () => inactive.getHeaders()
+    };
+    let result;
+    try {
+      result = fn(span);
+    } catch (err) {
+      inactive.end({ status: "error" });
+      throw err;
+    }
+    if (result instanceof Promise) {
+      return result.then(
+        (value) => {
+          inactive.end({ status: "ok" });
+          return value;
+        },
+        (err) => {
+          inactive.end({ status: "error" });
+          throw err;
+        }
+      );
+    }
+    inactive.end({ status: "ok" });
+    return result;
+  }
+  /** Start a span with manual lifecycle. You must call span.end(). */
+  startInactiveSpan(operation) {
+    const traceId = this.requestMeta?.trace_id || generateId();
+    const parentSpanId = this.requestMeta?.span_id || "";
+    const spanId = generateId();
+    const startTime = (/* @__PURE__ */ new Date()).toISOString();
+    const startMs = Date.now();
+    const childMeta = { ...this.requestMeta, trace_id: traceId, span_id: spanId };
+    const span = {
+      traceId,
+      spanId,
+      parentSpanId,
+      operation,
+      end: (options) => {
+        const durationMs = Date.now() - startMs;
+        const spanData = {
+          trace_id: traceId,
+          span_id: spanId,
+          parent_span_id: parentSpanId,
+          operation,
+          start_time: startTime,
+          duration_ms: durationMs,
+          status: options?.status || "ok",
+          metadata: options?.metadata
+        };
+        this.transport.sendTrace(spanData);
+      },
+      startSpan: (childOp, fn) => {
+        const childLogger = new _Logger(this.config, this.contextName, childMeta);
+        return childLogger.startSpan(childOp, fn);
+      },
+      startInactiveSpan: (childOp) => {
+        const childLogger = new _Logger(this.config, this.contextName, childMeta);
+        return childLogger.startInactiveSpan(childOp);
+      },
+      getHeaders: () => ({
+        "x-trace-id": traceId,
+        "x-span-id": spanId
+      })
+    };
+    return span;
+  }
+  /** Wrap a function with automatic tracing and error capture. */
+  wrap(operation, fn) {
+    return (...args) => {
+      return this.startSpan(operation, () => fn(...args));
+    };
+  }
+  /** Immediately flush all batched log entries. */
+  flush() {
+    this.batcher.flush();
+  }
+  /** Stop the batch timer and flush remaining logs. */
+  destroy() {
+    this.batcher.destroy();
+  }
+};
+function createLogger(config) {
+  return new Logger(config);
+}
+
+export {
+  _originalConsole,
+  Logger,
+  createLogger
+};