autotel-devtools 0.1.0

package/dist/index.js

@@ -0,0 +1,1234 @@
+import { createServer } from 'http';
+import { WebSocketServer, WebSocket } from 'ws';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { ExportResultCode } from '@opentelemetry/core';
+
+// src/index.ts
+
+// src/server/error-aggregator.ts
+var ErrorAggregator = class {
+  errorGroups = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = {
+      maxGroups: options.maxGroups ?? 100,
+      maxAffectedTraces: options.maxAffectedTraces ?? 10,
+      maxAffectedSpans: options.maxAffectedSpans ?? 5,
+      stackFramesForFingerprint: options.stackFramesForFingerprint ?? 5
+    };
+  }
+  /**
+   * Add an error occurrence to the aggregator
+   */
+  addError(occurrence) {
+    const fingerprint = this.generateFingerprint(occurrence);
+    const existing = this.errorGroups.get(fingerprint);
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = occurrence.timestamp;
+      if (!existing.affectedTraces.includes(occurrence.traceId)) {
+        existing.affectedTraces.push(occurrence.traceId);
+        if (existing.affectedTraces.length > this.options.maxAffectedTraces) {
+          existing.affectedTraces.shift();
+        }
+      }
+      if (!existing.affectedSpans.includes(occurrence.spanName)) {
+        existing.affectedSpans.push(occurrence.spanName);
+        if (existing.affectedSpans.length > this.options.maxAffectedSpans) {
+          existing.affectedSpans.shift();
+        }
+      }
+      return existing;
+    }
+    const newGroup = {
+      fingerprint,
+      type: occurrence.error.type,
+      message: occurrence.error.message,
+      stackTrace: this.normalizeStackTrace(occurrence.error.stackTrace),
+      count: 1,
+      firstSeen: occurrence.timestamp,
+      lastSeen: occurrence.timestamp,
+      affectedTraces: [occurrence.traceId],
+      affectedSpans: [occurrence.spanName],
+      service: occurrence.service,
+      attributes: occurrence.attributes
+    };
+    if (this.errorGroups.size >= this.options.maxGroups) {
+      this.evictOldestGroup();
+    }
+    this.errorGroups.set(fingerprint, newGroup);
+    return newGroup;
+  }
+  /**
+   * Extract errors from a trace and add them to the aggregator
+   */
+  addErrorsFromTrace(trace) {
+    const addedGroups = [];
+    for (const span of trace.spans) {
+      if (span.status.code === "ERROR") {
+        const occurrence = this.extractErrorFromSpan(span, trace);
+        if (occurrence) {
+          const group = this.addError(occurrence);
+          addedGroups.push(group);
+        }
+      }
+    }
+    return addedGroups;
+  }
+  /**
+   * Extract error occurrence from a span
+   */
+  extractErrorFromSpan(span, trace) {
+    const exceptionEvent = span.events?.find((e) => e.name === "exception");
+    const errorType = span.attributes["exception.type"] || span.attributes["error.type"] || exceptionEvent?.attributes?.["exception.type"] || "Error";
+    const errorMessage = span.status.message || span.attributes["exception.message"] || span.attributes["error.message"] || "Unknown error";
+    const stackTrace = span.attributes["exception.stacktrace"] || span.attributes["exception.stack"] || this.extractStackFromEvents(span);
+    return {
+      traceId: trace.traceId,
+      spanId: span.spanId,
+      spanName: span.name,
+      service: trace.service,
+      timestamp: span.endTime,
+      error: {
+        type: errorType,
+        message: errorMessage,
+        stackTrace
+      },
+      attributes: this.extractRelevantAttributes(span.attributes)
+    };
+  }
+  /**
+   * Extract stack trace from span events (exception events)
+   */
+  extractStackFromEvents(span) {
+    if (!span.events) return void 0;
+    const exceptionEvent = span.events.find((e) => e.name === "exception");
+    if (exceptionEvent?.attributes) {
+      return exceptionEvent.attributes["exception.stacktrace"] || exceptionEvent.attributes["exception.stack"];
+    }
+    return void 0;
+  }
+  /**
+   * Extract relevant attributes for error context
+   */
+  extractRelevantAttributes(attributes) {
+    const relevant = {};
+    const keepKeys = [
+      "http.method",
+      "http.url",
+      "http.route",
+      "http.status_code",
+      "db.system",
+      "db.operation",
+      "rpc.method",
+      "rpc.service",
+      "code.function",
+      "code.filepath",
+      "user.id",
+      "operation.name"
+    ];
+    for (const key of keepKeys) {
+      if (key in attributes) {
+        relevant[key] = attributes[key];
+      }
+    }
+    return relevant;
+  }
+  /**
+   * Generate a fingerprint for error grouping
+   *
+   * Uses error type + first N stack frames (normalized)
+   */
+  generateFingerprint(occurrence) {
+    const parts = [occurrence.error.type];
+    if (occurrence.error.stackTrace) {
+      const frames = this.extractStackFrames(
+        occurrence.error.stackTrace,
+        this.options.stackFramesForFingerprint
+      );
+      parts.push(...frames);
+    } else {
+      parts.push(this.normalizeMessage(occurrence.error.message));
+    }
+    return this.simpleHash(parts.join("|"));
+  }
+  /**
+   * Extract and normalize stack frames from a stack trace
+   */
+  extractStackFrames(stackTrace, count) {
+    const lines = stackTrace.split("\n");
+    const frames = [];
+    for (const line of lines) {
+      if (frames.length >= count) break;
+      const trimmed = line.trim();
+      const nodeMatch = trimmed.match(/^at\s+(.+?)\s+\((.+?):(\d+):\d+\)$/);
+      if (nodeMatch) {
+        frames.push(`${nodeMatch[1]}@${this.normalizeFilePath(nodeMatch[2])}`);
+        continue;
+      }
+      const anonMatch = trimmed.match(/^at\s+(.+?):(\d+):\d+$/);
+      if (anonMatch) {
+        frames.push(`anonymous@${this.normalizeFilePath(anonMatch[1])}`);
+        continue;
+      }
+      const browserMatch = trimmed.match(/^(.+?)@(.+?):(\d+):\d+$/);
+      if (browserMatch) {
+        frames.push(
+          `${browserMatch[1]}@${this.normalizeFilePath(browserMatch[2])}`
+        );
+        continue;
+      }
+    }
+    return frames;
+  }
+  /**
+   * Normalize file path by removing absolute path prefixes and node_modules paths
+   */
+  normalizeFilePath(filePath) {
+    const nodeModulesMatch = filePath.match(
+      /node_modules\/(@[^/]+\/[^/]+|[^/]+)/
+    );
+    if (nodeModulesMatch) {
+      return `[npm]/${nodeModulesMatch[1]}`;
+    }
+    return filePath.replace(/^.*?\/src\//, "src/").replace(/^.*?\/dist\//, "dist/").replace(/^.*?\/lib\//, "lib/").replace(/^file:\/\//, "");
+  }
+  /**
+   * Normalize error message by removing dynamic parts
+   */
+  normalizeMessage(message) {
+    return message.replaceAll(
+      /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi,
+      "[UUID]"
+    ).replaceAll(/\b[0-9a-f]{16,}\b/gi, "[ID]").replaceAll(/\b\d+\b/g, "[N]").replaceAll(/"[^"]*"/g, '"[STR]"').replaceAll(/'[^']*'/g, "'[STR]'").slice(0, 200);
+  }
+  /**
+   * Normalize stack trace for display
+   */
+  normalizeStackTrace(stackTrace) {
+    if (!stackTrace) return void 0;
+    const lines = stackTrace.split("\n").slice(0, 10);
+    return lines.join("\n");
+  }
+  /**
+   * Simple hash function for fingerprinting
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+  /**
+   * Evict the oldest error group
+   */
+  evictOldestGroup() {
+    let oldest = null;
+    for (const [fingerprint, group] of this.errorGroups) {
+      if (!oldest || group.lastSeen < oldest.lastSeen) {
+        oldest = { fingerprint, lastSeen: group.lastSeen };
+      }
+    }
+    if (oldest) {
+      this.errorGroups.delete(oldest.fingerprint);
+    }
+  }
+  /**
+   * Get all error groups, sorted by most recent
+   */
+  getErrorGroups() {
+    return [...this.errorGroups.values()].sort(
+      (a, b) => b.lastSeen - a.lastSeen
+    );
+  }
+  /**
+   * Get error groups sorted by count (most frequent first)
+   */
+  getErrorGroupsByFrequency() {
+    return [...this.errorGroups.values()].sort(
+      (a, b) => b.count - a.count
+    );
+  }
+  /**
+   * Get a specific error group by fingerprint
+   */
+  getErrorGroup(fingerprint) {
+    return this.errorGroups.get(fingerprint);
+  }
+  /**
+   * Get error groups for a specific service
+   */
+  getErrorGroupsByService(service) {
+    return this.getErrorGroups().filter((g) => g.service === service);
+  }
+  /**
+   * Get total error count across all groups
+   */
+  getTotalErrorCount() {
+    let total = 0;
+    for (const group of this.errorGroups.values()) {
+      total += group.count;
+    }
+    return total;
+  }
+  /**
+   * Get error statistics
+   */
+  getStats() {
+    const now = Date.now();
+    const oneHourAgo = now - 60 * 60 * 1e3;
+    let recentErrors = 0;
+    const typeCount = /* @__PURE__ */ new Map();
+    for (const group of this.errorGroups.values()) {
+      if (group.lastSeen > oneHourAgo) {
+        recentErrors += group.count;
+      }
+      typeCount.set(group.type, (typeCount.get(group.type) || 0) + group.count);
+    }
+    const topErrorTypes = [...typeCount.entries()].map(([type, count]) => ({ type, count })).sort((a, b) => b.count - a.count).slice(0, 5);
+    return {
+      totalGroups: this.errorGroups.size,
+      totalErrors: this.getTotalErrorCount(),
+      recentErrors,
+      topErrorTypes
+    };
+  }
+  /**
+   * Clear all error groups
+   */
+  clear() {
+    this.errorGroups.clear();
+  }
+  /**
+   * Clear old error groups (not seen in given time window)
+   */
+  clearOlderThan(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    let cleared = 0;
+    for (const [fingerprint, group] of this.errorGroups) {
+      if (group.lastSeen < cutoff) {
+        this.errorGroups.delete(fingerprint);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+};
+
+// src/server/telemetry-limits.ts
+var defaultLimit = 100;
+function parseLimit(value) {
+  if (!value) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function resolveTelemetryLimits(args = {}) {
+  const env = args.env ?? process.env;
+  const fallback = args.maxHistory ?? defaultLimit;
+  return {
+    maxTraceCount: args.maxTraceCount ?? parseLimit(env.AUTOTEL_MAX_TRACE_COUNT) ?? fallback,
+    maxLogCount: args.maxLogCount ?? parseLimit(env.AUTOTEL_MAX_LOG_COUNT) ?? fallback,
+    maxMetricCount: args.maxMetricCount ?? parseLimit(env.AUTOTEL_MAX_METRIC_COUNT) ?? fallback
+  };
+}
+function appendWithLimit(items, item, limit) {
+  if (limit <= 0) return [];
+  const next = [...items, item];
+  return next.length > limit ? next.slice(next.length - limit) : next;
+}
+function appendManyWithLimit(items, incoming, limit) {
+  if (limit <= 0 || incoming.length === 0) return limit <= 0 ? [] : items;
+  const next = [...items, ...incoming];
+  return next.length > limit ? next.slice(next.length - limit) : next;
+}
+
+// src/server/server.ts
+var DevtoolsServer = class {
+  wss;
+  clients = /* @__PURE__ */ new Set();
+  httpServer;
+  traces = [];
+  logs = [];
+  metrics = [];
+  errorAggregator = new ErrorAggregator();
+  limits;
+  verbose;
+  _port;
+  constructor(options = {}) {
+    this.limits = resolveTelemetryLimits(options);
+    this.verbose = options.verbose ?? false;
+    this._port = options.port ?? 4318;
+    this.httpServer = options.server ?? createServer();
+    this.wss = new WebSocketServer({ server: this.httpServer, path: options.path ?? "/ws" });
+    this.wss.on("connection", (ws) => {
+      this.clients.add(ws);
+      this.log(`Client connected (${this.clients.size} total)`);
+      const data = this.getCurrentData();
+      if (data.traces.length > 0 || data.logs.length > 0 || data.errors.length > 0) {
+        ws.send(JSON.stringify(data));
+      }
+      ws.on("close", () => {
+        this.clients.delete(ws);
+        this.log(`Client disconnected (${this.clients.size} total)`);
+      });
+    });
+    if (!options.server) {
+      this.httpServer.listen(this._port, () => {
+        const addr = this.httpServer.address();
+        if (addr && typeof addr === "object") this._port = addr.port;
+        this.log(`WebSocket server listening on port ${this._port}`);
+      });
+    }
+  }
+  get port() {
+    const addr = this.httpServer.address();
+    if (addr && typeof addr === "object") return addr.port;
+    return this._port;
+  }
+  get clientCount() {
+    return this.clients.size;
+  }
+  addTrace(trace) {
+    const existing = this.traces.find((t) => t.traceId === trace.traceId);
+    if (existing) {
+      const existingSpanIds = new Set(existing.spans.map((s) => s.spanId));
+      for (const span of trace.spans) {
+        if (!existingSpanIds.has(span.spanId)) {
+          existing.spans.push(span);
+        }
+      }
+      existing.startTime = Math.min(existing.startTime, trace.startTime);
+      existing.endTime = Math.max(existing.endTime, trace.endTime);
+      existing.duration = existing.endTime - existing.startTime;
+      if (trace.status === "ERROR") existing.status = "ERROR";
+    } else {
+      this.traces = appendWithLimit(
+        this.traces,
+        trace,
+        this.limits.maxTraceCount
+      );
+    }
+    this.errorAggregator.addErrorsFromTrace(trace);
+    this.broadcast({ traces: [trace], metrics: [], logs: [], errors: this.errorAggregator.getErrorGroups() });
+  }
+  addTraces(traces) {
+    for (const trace of traces) this.addTrace(trace);
+  }
+  addLog(log) {
+    this.logs = appendWithLimit(this.logs, log, this.limits.maxLogCount);
+    this.broadcast({ traces: [], metrics: [], logs: [log], errors: [] });
+  }
+  addLogs(logs) {
+    this.logs = appendManyWithLimit(this.logs, logs, this.limits.maxLogCount);
+    this.broadcast({ traces: [], metrics: [], logs, errors: [] });
+  }
+  addMetric(metric) {
+    this.metrics = appendWithLimit(
+      this.metrics,
+      metric,
+      this.limits.maxMetricCount
+    );
+    this.broadcast({ traces: [], metrics: [metric], logs: [], errors: [] });
+  }
+  getCurrentData() {
+    return {
+      traces: this.traces,
+      metrics: this.metrics,
+      logs: this.logs,
+      errors: this.errorAggregator.getErrorGroups()
+    };
+  }
+  clearData() {
+    this.traces = [];
+    this.logs = [];
+    this.metrics = [];
+    this.errorAggregator.clear();
+  }
+  broadcast(data) {
+    const msg = JSON.stringify(data);
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(msg);
+      }
+    }
+  }
+  log(message) {
+    if (this.verbose) console.log(`[autotel-devtools] ${message}`);
+  }
+  async close() {
+    for (const client of this.clients) client.close();
+    this.clients.clear();
+    this.wss.close();
+    await new Promise((resolve2) => this.httpServer.close(() => resolve2()));
+  }
+};
+
+// src/server/resource-utils.ts
+function getResourceName(resource, fallback = "unknown") {
+  if (!resource) return fallback;
+  const candidates = [
+    resource["service.name"],
+    resource["service.namespace"],
+    resource["deployment.environment.name"],
+    resource["host.name"],
+    resource["container.name"],
+    resource["process.executable.name"]
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return fallback;
+}
+
+// src/server/otlp.ts
+function resolveOtlpValue(v) {
+  if (!v) return void 0;
+  if (v.stringValue !== void 0) return v.stringValue;
+  if (v.boolValue !== void 0) return v.boolValue;
+  if (v.intValue !== void 0) return typeof v.intValue === "string" ? Number(v.intValue) : v.intValue;
+  if (v.doubleValue !== void 0) return v.doubleValue;
+  if (v.bytesValue !== void 0) return v.bytesValue;
+  if (v.arrayValue?.values) return v.arrayValue.values.map(resolveOtlpValue);
+  if (v.kvlistValue?.values) return flattenAttributes(v.kvlistValue.values);
+  return void 0;
+}
+function flattenAttributes(attrs) {
+  const out = {};
+  if (!attrs) return out;
+  for (const { key, value } of attrs) {
+    out[key] = resolveOtlpValue(value);
+  }
+  return out;
+}
+function nanoToMs(nano) {
+  if (!nano) return 0;
+  return Number(BigInt(nano) / 1000000n);
+}
+var SPAN_KIND_MAP = {
+  0: "INTERNAL",
+  1: "INTERNAL",
+  2: "SERVER",
+  3: "CLIENT",
+  4: "PRODUCER",
+  5: "CONSUMER",
+  SPAN_KIND_INTERNAL: "INTERNAL",
+  SPAN_KIND_SERVER: "SERVER",
+  SPAN_KIND_CLIENT: "CLIENT",
+  SPAN_KIND_PRODUCER: "PRODUCER",
+  SPAN_KIND_CONSUMER: "CONSUMER"
+};
+function normalizeHexId(id) {
+  if (!id) return "";
+  const isBase64Like = /^[A-Za-z0-9+/=]+$/.test(id) && !/^[0-9a-f]+$/i.test(id);
+  const isLikelyBase64Id = isBase64Like && (id.length === 24 || id.length === 28 || id.length === 44 || id.length === 48);
+  if (isLikelyBase64Id) {
+    try {
+      const bytes = Buffer.from(id, "base64");
+      return bytes.toString("hex");
+    } catch {
+    }
+  }
+  return id;
+}
+function parseOtlpTraces(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const { resourceSpans } = payload;
+  if (!Array.isArray(resourceSpans) || resourceSpans.length === 0) return [];
+  const traceMap = /* @__PURE__ */ new Map();
+  for (const rs of resourceSpans) {
+    const resourceAttrs = flattenAttributes(rs.resource?.attributes);
+    const service = String(resourceAttrs["service.name"] || "unknown");
+    const scopeSpans = rs.scopeSpans || [];
+    for (const ss of scopeSpans) {
+      for (const span of ss.spans || []) {
+        const traceId = normalizeHexId(span.traceId);
+        if (!traceId) continue;
+        const startMs = nanoToMs(span.startTimeUnixNano);
+        const endMs = nanoToMs(span.endTimeUnixNano);
+        const statusCode = span.status?.code;
+        let status = "UNSET";
+        if (statusCode === 1 || statusCode === "STATUS_CODE_OK") status = "OK";
+        if (statusCode === 2 || statusCode === "STATUS_CODE_ERROR") status = "ERROR";
+        const spanData = {
+          traceId,
+          spanId: normalizeHexId(span.spanId),
+          parentSpanId: normalizeHexId(span.parentSpanId) || void 0,
+          name: span.name || "unknown",
+          kind: SPAN_KIND_MAP[span.kind ?? 0] || "INTERNAL",
+          startTime: startMs,
+          endTime: endMs,
+          duration: endMs - startMs,
+          attributes: { ...resourceAttrs, ...flattenAttributes(span.attributes) },
+          status: { code: status, message: span.status?.message },
+          events: (span.events || []).map((e) => ({
+            name: e.name || "",
+            timestamp: nanoToMs(e.timeUnixNano),
+            attributes: flattenAttributes(e.attributes)
+          }))
+        };
+        const existing = traceMap.get(traceId);
+        if (existing) {
+          existing.spans.push(spanData);
+        } else {
+          traceMap.set(traceId, { spans: [spanData], service });
+        }
+      }
+    }
+  }
+  const traces = [];
+  for (const [traceId, { spans, service }] of traceMap) {
+    const sorted = spans.sort((a, b) => a.startTime - b.startTime);
+    const rootSpan = sorted.find((s) => !s.parentSpanId) || sorted[0];
+    const startTime = Math.min(...sorted.map((s) => s.startTime));
+    const endTime = Math.max(...sorted.map((s) => s.endTime));
+    const hasError = sorted.some((s) => s.status.code === "ERROR");
+    traces.push({
+      traceId,
+      correlationId: traceId.slice(0, 16),
+      rootSpan,
+      spans: sorted,
+      startTime,
+      endTime,
+      duration: endTime - startTime,
+      status: hasError ? "ERROR" : "OK",
+      service
+    });
+  }
+  return traces;
+}
+function parseOtlpLogs(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const { resourceLogs } = payload;
+  if (!Array.isArray(resourceLogs)) return [];
+  const logs = [];
+  for (const rl of resourceLogs) {
+    const resourceAttrs = flattenAttributes(rl.resource?.attributes);
+    for (const sl of rl.scopeLogs || []) {
+      for (const rec of sl.logRecords || []) {
+        const timestamp = nanoToMs(rec.timeUnixNano || rec.observedTimeUnixNano);
+        const traceId = normalizeHexId(rec.traceId) || void 0;
+        const spanId = normalizeHexId(rec.spanId) || void 0;
+        const body = rec.body ? resolveOtlpValue(rec.body) : "";
+        logs.push({
+          id: `${traceId || "no-trace"}:${spanId || "no-span"}:${timestamp}:${rec.severityNumber || 0}`,
+          traceId,
+          spanId,
+          resourceName: getResourceName(resourceAttrs),
+          severityText: rec.severityText,
+          severityNumber: rec.severityNumber,
+          body: typeof body === "string" ? body : body,
+          timestamp,
+          attributes: flattenAttributes(rec.attributes),
+          resource: resourceAttrs
+        });
+      }
+    }
+  }
+  return logs;
+}
+function countOtlpMetrics(payload) {
+  if (!payload || typeof payload !== "object") return 0;
+  const { resourceMetrics } = payload;
+  if (!Array.isArray(resourceMetrics)) return 0;
+  let count = 0;
+  for (const rm of resourceMetrics) {
+    for (const sm of rm.scopeMetrics || []) {
+      count += (sm.metrics || []).length;
+    }
+  }
+  return count;
+}
+async function readJsonBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        resolve2(JSON.parse(Buffer.concat(chunks).toString()));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) });
+  res.end(body);
+}
+
+// src/server/http.ts
+function findPackageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    if (existsSync(resolve(dir, "package.json"))) return dir;
+    dir = dirname(dir);
+  }
+  return dir;
+}
+var FULLPAGE_HTML = `<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>autotel-devtools</title><style>*{margin:0;padding:0;box-sizing:border-box}html,body{height:100%;width:100%;overflow:hidden}</style></head><body><script src="/widget.js?mode=fullpage"></script></body></html>`;
+var cachedWidgetJs = null;
+function getWidgetJs() {
+  if (!cachedWidgetJs) {
+    const pkgRoot = findPackageRoot();
+    const candidates = [
+      resolve(pkgRoot, "dist", "widget.global.js"),
+      resolve(pkgRoot, "widget.global.js")
+    ];
+    for (const candidate of candidates) {
+      try {
+        cachedWidgetJs = readFileSync(candidate, "utf8");
+        break;
+      } catch {
+      }
+    }
+    if (!cachedWidgetJs) {
+      cachedWidgetJs = "// widget bundle not found - run pnpm build first";
+    }
+  }
+  return cachedWidgetJs;
+}
+function attachDevtoolsRoutes(httpServer, devtools) {
+  httpServer.on("request", async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = req.url || "/";
+    if (req.method === "GET" && url === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Content-Length": Buffer.byteLength(FULLPAGE_HTML) });
+      res.end(FULLPAGE_HTML);
+      return;
+    }
+    if (req.method === "GET" && url.startsWith("/widget.js")) {
+      const js = getWidgetJs();
+      res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8", "Content-Length": Buffer.byteLength(js) });
+      res.end(js);
+      return;
+    }
+    if (req.method === "GET" && url === "/healthz") {
+      sendJson(res, 200, { ok: true, clients: devtools.clientCount });
+      return;
+    }
+    if (req.method === "POST" && url === "/v1/traces") {
+      try {
+        const payload = await readJsonBody(req);
+        const traces = parseOtlpTraces(payload);
+        devtools.addTraces(traces);
+        sendJson(res, 200, { acceptedTraces: traces.length });
+      } catch (e) {
+        sendJson(res, 400, { error: "Invalid OTLP JSON", message: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (req.method === "POST" && url === "/v1/logs") {
+      try {
+        const payload = await readJsonBody(req);
+        const logs = parseOtlpLogs(payload);
+        devtools.addLogs(logs);
+        sendJson(res, 200, { acceptedLogs: logs.length });
+      } catch (e) {
+        sendJson(res, 400, { error: "Invalid OTLP JSON", message: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (req.method === "POST" && url === "/v1/metrics") {
+      try {
+        const payload = await readJsonBody(req);
+        const count = countOtlpMetrics(payload);
+        sendJson(res, 200, { acceptedMetrics: count });
+      } catch (e) {
+        sendJson(res, 400, { error: "Invalid OTLP JSON", message: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    sendJson(res, 404, { error: "Not found" });
+  });
+}
+
+// src/server/exporter.ts
+var DevtoolsSpanExporter = class {
+  server;
+  serviceName;
+  constructor(server, serviceName = "unknown-service") {
+    this.server = server;
+    this.serviceName = serviceName;
+  }
+  /**
+   * Export spans to the WebSocket server
+   */
+  async export(spans, resultCallback) {
+    resultCallback({ code: 0 });
+    Promise.resolve().then(() => {
+      try {
+        console.log(`[Autotel Exporter] Exporting ${spans.length} span(s)`);
+        const traceMap = /* @__PURE__ */ new Map();
+        for (const span of spans) {
+          const traceId = span.spanContext().traceId;
+          if (!traceMap.has(traceId)) {
+            traceMap.set(traceId, []);
+          }
+          traceMap.get(traceId).push(span);
+        }
+        for (const [traceId, traceSpans] of traceMap) {
+          const trace = this.convertToTraceData(traceId, traceSpans);
+          console.log(
+            `[Autotel Exporter] Adding trace ${traceId.slice(0, 16)} with ${traceSpans.length} spans`
+          );
+          this.server.addTrace(trace);
+        }
+      } catch (error) {
+        console.error("[Autotel Exporter] Export error:", error);
+      }
+    });
+  }
+  /**
+   * Shutdown the exporter
+   */
+  async shutdown() {
+  }
+  /**
+   * Force flush any buffered spans
+   */
+  async forceFlush() {
+  }
+  /**
+   * Convert OpenTelemetry spans to TraceData
+   */
+  convertToTraceData(traceId, spans) {
+    const spanData = spans.map((span) => this.convertSpan(span));
+    const rootSpan = spanData.find((s) => !s.parentSpanId) || spanData[0];
+    spanData.sort((a, b) => a.startTime - b.startTime);
+    const startTime = Math.min(...spanData.map((s) => s.startTime));
+    const endTime = Math.max(...spanData.map((s) => s.endTime));
+    const hasError = spanData.some((s) => s.status.code === "ERROR");
+    const status = hasError ? "ERROR" : "OK";
+    return {
+      traceId,
+      correlationId: traceId.slice(0, 16),
+      // First 16 chars
+      rootSpan,
+      spans: spanData,
+      startTime,
+      endTime,
+      duration: endTime - startTime,
+      status,
+      service: this.serviceName
+    };
+  }
+  /**
+   * Convert OpenTelemetry span to SpanData
+   */
+  convertSpan(span) {
+    const spanContext = span.spanContext();
+    const startTime = span.startTime[0] * 1e3 + span.startTime[1] / 1e6;
+    const endTime = span.endTime[0] * 1e3 + span.endTime[1] / 1e6;
+    const attributes = {};
+    for (const [key, value] of Object.entries(span.attributes)) {
+      attributes[key] = value;
+    }
+    const statusCode = span.status.code;
+    let status;
+    switch (statusCode) {
+      case 0: {
+        status = "UNSET";
+        break;
+      }
+      case 1: {
+        status = "OK";
+        break;
+      }
+      case 2: {
+        status = "ERROR";
+        break;
+      }
+      default: {
+        status = "UNSET";
+      }
+    }
+    const events = span.events.map((event) => ({
+      name: event.name,
+      timestamp: event.time[0] * 1e3 + event.time[1] / 1e6,
+      attributes: event.attributes ? Object.fromEntries(Object.entries(event.attributes)) : void 0
+    }));
+    return {
+      traceId: spanContext.traceId,
+      spanId: spanContext.spanId,
+      parentSpanId: span.parentSpanId,
+      name: span.name,
+      kind: this.convertSpanKind(span.kind),
+      startTime,
+      endTime,
+      duration: endTime - startTime,
+      attributes,
+      status: {
+        code: status,
+        message: span.status.message
+      },
+      events: events.length > 0 ? events : void 0
+    };
+  }
+  /**
+   * Convert OpenTelemetry SpanKind to string
+   */
+  convertSpanKind(kind) {
+    switch (kind) {
+      case 0: {
+        return "INTERNAL";
+      }
+      case 1: {
+        return "SERVER";
+      }
+      case 2: {
+        return "CLIENT";
+      }
+      case 3: {
+        return "PRODUCER";
+      }
+      case 4: {
+        return "CONSUMER";
+      }
+      default: {
+        return "INTERNAL";
+      }
+    }
+  }
+};
+var defaultTimeout = 5e3;
+function hrTimeToMs(hrTime) {
+  return hrTime[0] * 1e3 + hrTime[1] / 1e6;
+}
+function bodyToPayload(body) {
+  if (body === void 0) return "";
+  if (typeof body === "string") return body;
+  if (typeof body === "object" && body !== null) return body;
+  return String(body);
+}
+function recordToLogData(record, index) {
+  const id = `log-${Date.now()}-${index}-${Math.random().toString(36).slice(2, 9)}`;
+  const timestamp = hrTimeToMs(record.hrTime);
+  const body = bodyToPayload(record.body);
+  const attributes = record.attributes && Object.keys(record.attributes).length > 0 ? record.attributes : void 0;
+  const resource = record.resource?.attributes && Object.keys(record.resource.attributes).length > 0 ? record.resource.attributes : void 0;
+  const log = {
+    id,
+    resourceName: getResourceName(resource),
+    severityText: record.severityText,
+    severityNumber: record.severityNumber,
+    body,
+    timestamp,
+    attributes,
+    resource
+  };
+  if (record.spanContext) {
+    log.traceId = record.spanContext.traceId;
+    log.spanId = record.spanContext.spanId;
+  }
+  return log;
+}
+var DevtoolsLogExporter = class {
+  endpoint;
+  apiKey;
+  timeout;
+  isShutdown = false;
+  constructor(options) {
+    this.endpoint = options.endpoint.replace(/\/$/, "");
+    this.apiKey = options.apiKey ?? "";
+    this.timeout = options.timeout ?? defaultTimeout;
+  }
+  export(logs, resultCallback) {
+    if (this.isShutdown || logs.length === 0) {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+    const payload = { logs: logs.map((r, i) => recordToLogData(r, i)) };
+    const url = `${this.endpoint}/ingest/logs`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    }).then((res) => {
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        throw new Error(`Devtools log ingest failed: ${res.status} ${res.statusText}`);
+      }
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    }).catch((err) => {
+      clearTimeout(timeoutId);
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    });
+  }
+  shutdown() {
+    this.isShutdown = true;
+    return Promise.resolve();
+  }
+};
+
+// src/server/remote-exporter.ts
+var DevtoolsRemoteExporter = class {
+  options;
+  pendingExports = [];
+  constructor(options) {
+    this.options = {
+      endpoint: options.endpoint.replace(/\/$/, ""),
+      // Remove trailing slash
+      apiKey: options.apiKey ?? "",
+      serviceName: options.serviceName ?? "unknown-service",
+      timeout: options.timeout ?? 5e3,
+      retry: options.retry ?? true,
+      retryCount: options.retryCount ?? 3,
+      retryDelay: options.retryDelay ?? 1e3,
+      verbose: options.verbose ?? false
+    };
+  }
+  /**
+   * Export spans to the remote server
+   */
+  async export(spans, resultCallback) {
+    const exportPromise = this.doExport(spans).then(() => {
+      resultCallback({ code: 0 });
+    }).catch((error) => {
+      this.log(`Export failed: ${error.message}`);
+      resultCallback({ code: 1 });
+    });
+    this.pendingExports.push(exportPromise);
+    exportPromise.finally(() => {
+      const index = this.pendingExports.indexOf(exportPromise);
+      if (index !== -1) {
+        this.pendingExports.splice(index, 1);
+      }
+    });
+  }
+  async doExport(spans) {
+    if (spans.length === 0) return;
+    this.log(`Exporting ${spans.length} span(s) to ${this.options.endpoint}`);
+    const traceMap = /* @__PURE__ */ new Map();
+    for (const span of spans) {
+      const traceId = span.spanContext().traceId;
+      if (!traceMap.has(traceId)) {
+        traceMap.set(traceId, []);
+      }
+      traceMap.get(traceId).push(span);
+    }
+    const traces = [];
+    for (const [traceId, traceSpans] of traceMap) {
+      traces.push(this.convertToTraceData(traceId, traceSpans));
+    }
+    await this.sendWithRetry({ traces });
+  }
+  async sendWithRetry(payload) {
+    let lastError = null;
+    const maxAttempts = this.options.retry ? this.options.retryCount : 1;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await this.send(payload);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        this.log(
+          `Attempt ${attempt}/${maxAttempts} failed: ${lastError.message}`
+        );
+        if (attempt < maxAttempts) {
+          await this.sleep(this.options.retryDelay * attempt);
+        }
+      }
+    }
+    throw lastError || new Error("Export failed");
+  }
+  async send(payload) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      this.options.timeout
+    );
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.options.apiKey) {
+        headers["Authorization"] = `Bearer ${this.options.apiKey}`;
+      }
+      const response = await fetch(`${this.options.endpoint}/ingest/traces`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status}: ${text}`);
+      }
+      const result = await response.json();
+      this.log(`Successfully sent ${result.processed} trace(s)`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Shutdown the exporter, waiting for pending exports
+   */
+  async shutdown() {
+    this.log("Shutting down, waiting for pending exports...");
+    await Promise.allSettled(this.pendingExports);
+    this.log("Shutdown complete");
+  }
+  /**
+   * Force flush pending exports
+   */
+  async forceFlush() {
+    await Promise.allSettled(this.pendingExports);
+  }
+  convertToTraceData(traceId, spans) {
+    const spanData = spans.map((span) => this.convertSpan(span));
+    const rootSpan = spanData.find((s) => !s.parentSpanId) || spanData[0];
+    spanData.sort((a, b) => a.startTime - b.startTime);
+    const startTime = Math.min(...spanData.map((s) => s.startTime));
+    const endTime = Math.max(...spanData.map((s) => s.endTime));
+    const hasError = spanData.some((s) => s.status.code === "ERROR");
+    const status = hasError ? "ERROR" : "OK";
+    return {
+      traceId,
+      correlationId: traceId.slice(0, 16),
+      rootSpan,
+      spans: spanData,
+      startTime,
+      endTime,
+      duration: endTime - startTime,
+      status,
+      service: this.options.serviceName
+    };
+  }
+  convertSpan(span) {
+    const spanContext = span.spanContext();
+    const startTime = span.startTime[0] * 1e3 + span.startTime[1] / 1e6;
+    const endTime = span.endTime[0] * 1e3 + span.endTime[1] / 1e6;
+    const attributes = {};
+    for (const [key, value] of Object.entries(span.attributes)) {
+      attributes[key] = value;
+    }
+    let status;
+    switch (span.status.code) {
+      case 0: {
+        status = "UNSET";
+        break;
+      }
+      case 1: {
+        status = "OK";
+        break;
+      }
+      case 2: {
+        status = "ERROR";
+        break;
+      }
+      default: {
+        status = "UNSET";
+      }
+    }
+    const events = span.events.map((event) => ({
+      name: event.name,
+      timestamp: event.time[0] * 1e3 + event.time[1] / 1e6,
+      attributes: event.attributes ? Object.fromEntries(Object.entries(event.attributes)) : void 0
+    }));
+    return {
+      traceId: spanContext.traceId,
+      spanId: spanContext.spanId,
+      parentSpanId: span.parentSpanId,
+      name: span.name,
+      kind: this.convertSpanKind(span.kind),
+      startTime,
+      endTime,
+      duration: endTime - startTime,
+      attributes,
+      status: {
+        code: status,
+        message: span.status.message
+      },
+      events: events.length > 0 ? events : void 0
+    };
+  }
+  convertSpanKind(kind) {
+    switch (kind) {
+      case 0: {
+        return "INTERNAL";
+      }
+      case 1: {
+        return "SERVER";
+      }
+      case 2: {
+        return "CLIENT";
+      }
+      case 3: {
+        return "PRODUCER";
+      }
+      case 4: {
+        return "CONSUMER";
+      }
+      default: {
+        return "INTERNAL";
+      }
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  log(message) {
+    if (this.options.verbose) {
+      console.log(`[Devtools Remote Exporter] ${message}`);
+    }
+  }
+};
+
+// src/index.ts
+function createDevtools(options = {}) {
+  const port = options.port ?? 4318;
+  const host = options.host ?? "127.0.0.1";
+  const httpServer = createServer();
+  const wsServer = new DevtoolsServer({
+    server: httpServer,
+    verbose: options.verbose,
+    maxHistory: options.maxHistory,
+    maxTraceCount: options.maxTraceCount,
+    maxLogCount: options.maxLogCount,
+    maxMetricCount: options.maxMetricCount
+  });
+  attachDevtoolsRoutes(httpServer, wsServer);
+  httpServer.listen(port, host);
+  const exporter = new DevtoolsSpanExporter(wsServer);
+  return {
+    server: wsServer,
+    httpServer,
+    exporter,
+    port,
+    close: async () => {
+      await wsServer.close();
+    }
+  };
+}
+
+export { DevtoolsLogExporter, DevtoolsRemoteExporter, DevtoolsServer, DevtoolsSpanExporter, ErrorAggregator, createDevtools };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map