retrace-sdk 0.1.3

package/src/transport.ts

@@ -0,0 +1,133 @@
+import WebSocket from "ws";
+import { getConfig } from "./config.js";
+
+export interface Transport {
+  send(eventType: string, data: Record<string, unknown>): void;
+  close(): void;
+}
+
+export class WSTransport implements Transport {
+  private ws: WebSocket | null = null;
+  private connected = false;
+  private backoff = 1000;
+  private queue: string[] = [];
+
+  connect() {
+    const cfg = getConfig();
+    const url = `${cfg.wsUrl}/ws/v1/stream`;
+    this.ws = new WebSocket(url);
+
+    this.ws.on("open", () => {
+      this.ws!.send(JSON.stringify({ type: "auth", api_key: cfg.apiKey }));
+    });
+
+    this.ws.on("message", (raw) => {
+      const msg = JSON.parse(raw.toString());
+      if (msg.type === "auth_ok") {
+        this.connected = true;
+        this.backoff = 1000;
+        this.flushQueue();
+      } else if (msg.type === "ping") {
+        this.ws?.send(JSON.stringify({ type: "pong" }));
+      }
+    });
+
+    this.ws.on("close", () => {
+      this.connected = false;
+      this.ws = null;
+      setTimeout(() => this.reconnect(), this.backoff);
+      this.backoff = Math.min(this.backoff * 2, 30000);
+    });
+
+    this.ws.on("error", () => {
+      this.ws?.close();
+    });
+  }
+
+  private reconnect() {
+    if (!this.connected && !this.ws) this.connect();
+  }
+
+  private flushQueue() {
+    while (this.queue.length && this.connected) {
+      this.ws?.send(this.queue.shift()!);
+    }
+  }
+
+  send(eventType: string, data: Record<string, unknown>) {
+    const msg = JSON.stringify({ type: eventType, data });
+    if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(msg);
+    } else {
+      this.queue.push(msg);
+      if (!this.ws) this.connect();
+    }
+  }
+
+  close() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+}
+
+export class HTTPTransport implements Transport {
+  private traceData: Record<string, unknown> | null = null;
+  private spans: Record<string, unknown>[] = [];
+
+  send(eventType: string, data: Record<string, unknown>) {
+    if (eventType === "trace_started") {
+      this.traceData = data;
+    } else if (eventType === "span_started" || eventType === "span_ended") {
+      this.spans.push({ ...data, _event: eventType });
+    } else if (eventType === "trace_ended") {
+      if (this.traceData) Object.assign(this.traceData, data);
+      this.flush();
+    }
+  }
+
+  flush() {
+    if (!this.traceData) return;
+    const cfg = getConfig();
+    const url = `${cfg.baseUrl}/api/v1/traces`;
+    const body = { ...this.traceData, spans: this.buildSpans() };
+    fetch(url, {
+      method: "POST",
+      headers: { "x-retrace-key": cfg.apiKey, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }).catch(() => {});
+    this.traceData = null;
+    this.spans = [];
+  }
+
+  private buildSpans(): Record<string, unknown>[] {
+    const merged = new Map<string, Record<string, unknown>>();
+    for (const ev of this.spans) {
+      const { _event, ...rest } = ev;
+      const id = rest.id as string;
+      if (_event === "span_started") {
+        merged.set(id, rest);
+      } else if (_event === "span_ended" && merged.has(id)) {
+        Object.assign(merged.get(id)!, rest);
+      }
+    }
+    return [...merged.values()];
+  }
+
+  close() {
+    this.flush();
+  }
+}
+
+export function createTransport(mode: "ws" | "http" | "auto" = "auto"): Transport {
+  if (mode === "http") return new HTTPTransport();
+  if (mode === "ws") return new WSTransport();
+  // Auto: try WS
+  try {
+    return new WSTransport();
+  } catch {
+    return new HTTPTransport();
+  }
+}

package/src/utils.ts

@@ -0,0 +1,23 @@
+import { randomUUID } from "crypto";
+
+export function genId(): string {
+  return randomUUID();
+}
+
+export function nowIso(): string {
+  return new Date().toISOString();
+}
+
+export function utcNow(): Date {
+  return new Date();
+}
+
+export function truncateJson(obj: unknown, maxBytes = 10240): unknown {
+  try {
+    const s = JSON.stringify(obj);
+    if (Buffer.byteLength(s) <= maxBytes) return obj;
+    return JSON.parse(Buffer.from(s).subarray(0, maxBytes).toString());
+  } catch {
+    return String(obj).slice(0, maxBytes);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,2 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({ test: { globals: true, environment: "node", include: ["src/**/*.test.ts"] } });