@intelli-1113/stratos-sdk 1.3.4 → 1.3.6

package/src/otel-bridge-harness.js

@@ -0,0 +1,115 @@
+import spawn from "cross-spawn";
+import { setTimeout as sleep } from "node:timers/promises";
+
+export class OtelBridgeHarness {
+  constructor(opts = {}) {
+    this.token = opts.token || process.env.STRATOS_TOKEN;
+    this.url = opts.url || process.env.STRATOS_URL || "http://localhost:4000";
+    this.surface = opts.surface || process.env.STRATOS_SURFACE || "unknown";
+    this.port = opts.port || 4318;
+    this.child = null;
+    this.restartCount = 0;
+    this.maxRestarts = 5;
+    this.restartDelay = 1000;
+  }
+
+  start() {
+    if (this.child) {
+      console.warn("[otel-bridge-harness] Already running");
+      return;
+    }
+
+    const env = {
+      ...process.env,
+      STRATOS_TOKEN: this.token,
+      STRATOS_URL: this.url,
+      STRATOS_SURFACE: this.surface,
+      OTEL_EXPORTER_OTLP_PORT: String(this.port),
+    };
+
+    this.child = spawn("node", [require.resolve("./otel-bridge.js")], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      detached: false,
+    });
+
+    this.child.stdout.on("data", (data) => {
+      console.log(`[otel-bridge] ${data.toString().trim()}`);
+    });
+
+    this.child.stderr.on("data", (data) => {
+      console.error(`[otel-bridge] ${data.toString().trim()}`);
+    });
+
+    this.child.on("error", (err) => {
+      console.error(`[otel-bridge-harness] Error: ${err.message}`);
+      this.child = null;
+      this._scheduleRestart();
+    });
+
+    this.child.on("exit", (code) => {
+      console.warn(`[otel-bridge-harness] Bridge exited (code: ${code})`);
+      this.child = null;
+      if (code !== 0) {
+        this._scheduleRestart();
+      }
+    });
+
+    console.log(`[otel-bridge-harness] Started (PID: ${this.child.pid})`);
+  }
+
+  async _scheduleRestart() {
+    if (this.restartCount >= this.maxRestarts) {
+      console.error("[otel-bridge-harness] Max restarts exceeded. Giving up.");
+      return;
+    }
+
+    this.restartCount++;
+    const delay = this.restartDelay * Math.pow(2, this.restartCount - 1);
+    console.log(`[otel-bridge-harness] Restarting in ${delay}ms (attempt ${this.restartCount}/${this.maxRestarts})`);
+
+    await sleep(delay);
+    this.start();
+  }
+
+  stop() {
+    if (!this.child) return;
+
+    console.log("[otel-bridge-harness] Stopping...");
+    this.child.kill("SIGTERM");
+
+    setTimeout(() => {
+      if (this.child && !this.child.killed) {
+        console.warn("[otel-bridge-harness] Force killing after timeout");
+        this.child.kill("SIGKILL");
+      }
+    }, 2000);
+
+    this.child = null;
+  }
+
+  isRunning() {
+    return this.child != null && !this.child.killed;
+  }
+
+  getPid() {
+    return this.child?.pid || null;
+  }
+}
+
+export async function startOtelBridge(opts = {}) {
+  const harness = new OtelBridgeHarness(opts);
+  harness.start();
+
+  process.on("SIGINT", () => {
+    harness.stop();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", () => {
+    harness.stop();
+    process.exit(0);
+  });
+
+  return harness;
+}

package/src/otel-bridge.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import http from "node:http";
+import { randomBytes } from "node:crypto";
+
+const TOKEN = process.env.STRATOS_TOKEN || "";
+const STRATOS_URL = process.env.STRATOS_URL || "http://localhost:4000";
+const PORT = process.env.OTEL_EXPORTER_OTLP_PORT || 4318;
+const SURFACE = process.env.STRATOS_SURFACE || "unknown";
+
+if (!TOKEN) {
+  console.warn("[otel-bridge] Warning: STRATOS_TOKEN not set. Telemetry will not be forwarded.");
+}
+
+const hdr = { "Content-Type": "application/json", "x-stratos-token": TOKEN };
+
+function redactContent(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(redactContent);
+  const copy = { ...obj };
+  for (const key of Object.keys(copy)) {
+    if (key.includes("prompt") || key.includes("request") || key.includes("response") || key.includes("content")) {
+      copy[key] = null;
+    } else if (typeof copy[key] === "object") {
+      copy[key] = redactContent(copy[key]);
+    }
+  }
+  return copy;
+}
+
+function otlpToStratosSpan(otlpMetric) {
+  const traceId = (randomBytes(16)).toString("hex");
+  const spanId = (randomBytes(8)).toString("hex");
+  const now = BigInt(Date.now()) * 1000000n;
+
+  const attributes = otlpMetric.attributes || [];
+  const attrMap = {};
+  for (const attr of attributes) {
+    attrMap[attr.key] = attr.value?.stringValue || attr.value?.doubleValue || String(attr.value);
+  }
+
+  const redacted = redactContent(attrMap);
+
+  return {
+    traceId,
+    spanId,
+    name: `${SURFACE}.otel.usage`,
+    startTimeUnixNano: now.toString(),
+    endTimeUnixNano: now.toString(),
+    attributes: [
+      { key: "traceloop.span.kind", value: { stringValue: "llm" } },
+      { key: "stratos.surface", value: { stringValue: SURFACE } },
+      { key: "otel.bridge", value: { stringValue: "true" } },
+      ...Object.entries(redacted).map(([k, v]) => ({
+        key: `otel.${k}`,
+        value: { stringValue: String(v) },
+      })),
+    ],
+  };
+}
+
+function buildStratosPayload(otlpSpans) {
+  const attr = (k, v) => ({ key: k, value: { stringValue: String(v) } });
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: [attr("service.name", SURFACE)] },
+        scopeSpans: [
+          {
+            spans: otlpSpans.map((span) => ({
+              traceId: span.traceId,
+              spanId: span.spanId,
+              name: span.name,
+              startTimeUnixNano: span.startTimeUnixNano,
+              endTimeUnixNano: span.endTimeUnixNano,
+              attributes: span.attributes,
+            })),
+          },
+        ],
+      },
+    ],
+  };
+}
+
+const server = http.createServer(async (req, res) => {
+  const { method, url } = req;
+
+  if (url === "/v1/traces" && method === "POST") {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+
+    req.on("end", async () => {
+      try {
+        const otlpPayload = JSON.parse(body);
+        const otlpSpans = [];
+
+        for (const resourceSpan of otlpPayload.resourceSpans || []) {
+          for (const scopeSpan of resourceSpan.scopeSpans || []) {
+            for (const span of scopeSpan.spans || []) {
+              otlpSpans.push(otlpToStratosSpan(span));
+            }
+          }
+        }
+
+        if (otlpSpans.length > 0 && TOKEN) {
+          const stratosPayload = buildStratosPayload(otlpSpans);
+          try {
+            const fres = await fetch(`${STRATOS_URL}/api/ingest`, {
+              method: "POST",
+              headers: hdr,
+              body: JSON.stringify(stratosPayload),
+            });
+            if (!fres.ok) {
+              console.error(`[otel-bridge] Stratos returned ${fres.status}`);
+            }
+          } catch (err) {
+            console.error(`[otel-bridge] Failed to forward to Stratos: ${err.message}`);
+          }
+        }
+
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({}));
+      } catch (err) {
+        console.error(`[otel-bridge] Parse error: ${err.message}`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "parse error" }));
+      }
+    });
+    return;
+  }
+
+  if (url === "/v1/metrics" && method === "POST") {
+    req.on("data", () => {}); // Drain
+    req.on("end", () => {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({}));
+    });
+    return;
+  }
+
+  if (url === "/health" && method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", surface: SURFACE }));
+    return;
+  }
+
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "not found" }));
+});
+
+server.listen(PORT, "localhost", () => {
+  console.log(
+    `[otel-bridge] listening on http://localhost:${PORT}` +
+      (TOKEN ? ` (forwarding to ${STRATOS_URL})` : " (token not set; telemetry disabled)")
+  );
+  console.log(`[otel-bridge] surface: ${SURFACE}`);
+  console.log(`[otel-bridge] Set OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:${PORT} in your app`);
+});
+
+process.on("SIGINT", () => {
+  console.log("[otel-bridge] shutting down");
+  server.close(() => process.exit(0));
+});
+
+process.on("SIGTERM", () => {
+  console.log("[otel-bridge] shutting down");
+  server.close(() => process.exit(0));
+});

package/src/postinstall.js

@@ -6,6 +6,16 @@
 // (not node_modules/@intelli-1113/stratos-sdk).
 
 import { inspectLangChain, printInspectReport } from "./inspect-langchain.js";
+import { readFileSync } from "node:fs";
+
+function getSDKVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version;
+  } catch {
+    return "latest";
+  }
+}
 
 try {
   if (process.env.STRATOS_SKIP_POSTINSTALL === "1") process.exit(0);
@@ -13,17 +23,28 @@ try {
   // Prefer the consumer project root
   const cwd = process.env.INIT_CWD || process.cwd();
   const report = inspectLangChain({ cwd });
-  if (!report.hasLangChain) process.exit(0);
-  if (report.compatible) process.exit(0);
-
-  console.warn(
-    "\n[stratos] ⚠ LangChain version is not compatible with Stratos auto-metrics."
-  );
-  printInspectReport(report);
-  console.warn(
-    "[stratos] In your project, run:\n  npx stratos-inspect --fix\n"
-  );
+
+  // Show LangChain warnings if needed
+  if (report.hasLangChain && !report.compatible) {
+    console.warn(
+      "\n[stratos] ⚠ LangChain version is not compatible with Stratos auto-metrics."
+    );
+    printInspectReport(report);
+    console.warn(
+      "[stratos] In your project, run:\n  npx stratos-inspect --fix\n"
+    );
+  }
 } catch {
   // Never fail the host install
-  process.exit(0);
 }
+
+// Always show welcome message
+const version = getSDKVersion();
+console.log(`
+✨ Welcome to Stratos SDK v${version}!
+
+Get started:
+  → Run: stratos --help
+
+This will show all available commands and a 4-step integration guide.
+`);