@autter/runtime-node 1.4.0 → 1.5.0

package/dist/chunk-L6SRL65J.cjs

@@ -0,0 +1,202 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+var _chunkGI47WGRRcjs = require('./chunk-GI47WGRR.cjs');
+
+// src/doctor.ts
+var _fs = require('fs');
+var _path = require('path');
+var SDK_PACKAGES = ["@autter/runtime-node", "@autter/runtime-next", "@autter/runtime-browser"];
+var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
+function resolveEndpoint(flag, env = process.env) {
+  return (flag || env.AUTTER_ENDPOINT || env.AUTTER_RUNTIME_ENDPOINT || env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_ENDPOINT).replace(/\/$/, "");
+}
+function installedSdks(cwd) {
+  const found = /* @__PURE__ */ new Map();
+  for (let dir = cwd; ; dir = _path.dirname.call(void 0, dir)) {
+    for (const name of SDK_PACKAGES) {
+      if (found.has(name)) continue;
+      const file = _path.join.call(void 0, dir, "node_modules", ...name.split("/"), "package.json");
+      if (!_fs.existsSync.call(void 0, file)) continue;
+      try {
+        const version = JSON.parse(_fs.readFileSync.call(void 0, file, "utf8")).version;
+        if (typeof version === "string") found.set(name, version);
+      } catch (e) {
+      }
+    }
+    if (_path.dirname.call(void 0, dir) === dir) break;
+  }
+  if (!found.has(_chunkGI47WGRRcjs.SDK_IDENTITY.name)) found.set(_chunkGI47WGRRcjs.SDK_IDENTITY.name, _chunkGI47WGRRcjs.SDK_IDENTITY.version);
+  return [...found].map(([name, version]) => ({ name, version }));
+}
+function featuresInUse(sdks) {
+  return _chunkGI47WGRRcjs.COMPAT_MANIFEST.features.filter(
+    (feature) => sdks.some((sdk) => {
+      const min = feature.sdks[sdk.name];
+      return min !== void 0 && _chunkGI47WGRRcjs.versionAtLeast.call(void 0, sdk.version, min) === true;
+    })
+  ).map((feature) => feature.id);
+}
+async function checkKey(endpoint, key, timeoutMs) {
+  const res = await _chunkGI47WGRRcjs.compatRequest.call(void 0, "POST", `${endpoint}/v1/traces`, {
+    body: JSON.stringify({ resourceSpans: [] }),
+    headers: { authorization: `Bearer ${key}` },
+    unref: false,
+    timeoutMs
+  });
+  if (!res) return "unknown";
+  if (res.status >= 200 && res.status < 300) return "accepted";
+  if (res.status === 401) return "rejected";
+  if (res.status === 403) return "client_key";
+  if (res.status === 503) return "storage_unavailable";
+  return "unknown";
+}
+async function runDoctor(options = {}) {
+  const endpoint = resolveEndpoint(options.endpoint);
+  const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 5e3));
+  const sdks = installedSdks(_nullishCoalesce(options.cwd, () => ( process.cwd())));
+  const features = _optionalChain([options, 'access', _ => _.features, 'optionalAccess', _2 => _2.length]) ? options.features : featuresInUse(sdks);
+  const routes = [
+    ...new Set(
+      features.map((id) => _optionalChain([_chunkGI47WGRRcjs.COMPAT_MANIFEST, 'access', _3 => _3.features, 'access', _4 => _4.find, 'call', _5 => _5((f) => f.id === id), 'optionalAccess', _6 => _6.route])).filter((route) => Boolean(route))
+    )
+  ];
+  const { info, error } = await _chunkGI47WGRRcjs.fetchIngesterCompat.call(void 0, endpoint, { probeRoutes: routes, unref: false, timeoutMs });
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (issue) => {
+    const key2 = `${issue.feature}:${issue.kind}:${issue.component}`;
+    if (!seen.has(key2)) {
+      seen.add(key2);
+      issues.push(issue);
+    }
+  };
+  _chunkGI47WGRRcjs.evaluateCompat.call(void 0, { features, ingester: info }).forEach(add);
+  for (const sdk of sdks) {
+    if (_optionalChain([options, 'access', _7 => _7.features, 'optionalAccess', _8 => _8.length])) {
+      _chunkGI47WGRRcjs.evaluateCompat.call(void 0, { features: options.features, ingester: null, sdk }).forEach(add);
+    }
+  }
+  const key = options.key ? await checkKey(endpoint, options.key, timeoutMs) : void 0;
+  const featureRows = features.flatMap((id) => {
+    const feature = _chunkGI47WGRRcjs.COMPAT_MANIFEST.features.find((f) => f.id === id);
+    if (!feature) return [];
+    const bad = issues.some((issue) => issue.feature === id);
+    const known = _optionalChain([info, 'optionalAccess', _9 => _9.version]) != null || feature.route !== void 0 && _optionalChain([info, 'optionalAccess', _10 => _10.routes, 'optionalAccess', _11 => _11[feature.route]]) !== void 0;
+    return [{ id, title: feature.title, status: bad ? "incompatible" : known ? "ok" : "unknown" }];
+  });
+  const exitCode = !info ? 2 : issues.length || key === "rejected" || key === "client_key" || key === "storage_unavailable" ? 1 : 0;
+  return {
+    endpoint,
+    sdks,
+    ingester: info,
+    ...error && !info ? { ingesterError: error } : {},
+    ...key ? { key } : {},
+    features: featureRows,
+    issues,
+    exitCode
+  };
+}
+function formatDoctorReport(report) {
+  const lines = [];
+  lines.push(`Autter Runtime doctor`);
+  lines.push(`  endpoint   ${report.endpoint}`);
+  for (const sdk of report.sdks) lines.push(`  sdk        ${sdk.name}@${sdk.version}`);
+  if (!report.ingester) {
+    lines.push(`  ingester   unreachable or unidentified (${_nullishCoalesce(report.ingesterError, () => ( "unknown error"))})`);
+  } else if (report.ingester.version) {
+    lines.push(`  ingester   @autter/otlp-ingester@${report.ingester.version}`);
+    const schema = report.ingester.schema;
+    if (schema) {
+      lines.push(
+        `  schema     ${schema.status}${schema.applied.length ? ` (level ${schema.applied[schema.applied.length - 1]})` : ""}`
+      );
+    }
+  } else {
+    lines.push(`  ingester   1.4.0 or older (no /v1/compat endpoint; upgrade for a full report)`);
+  }
+  if (report.key) {
+    const text = {
+      accepted: "accepted",
+      rejected: "REJECTED (401): check AUTTER_RUNTIME_KEY",
+      client_key: "is a client/browser key; server SDKs need a server key",
+      storage_unavailable: "accepted, but the ingester's ClickHouse is unavailable (503)",
+      unknown: "could not be verified"
+    }[report.key];
+    lines.push(`  key        ${text}`);
+  }
+  if (report.features.length) {
+    lines.push("", "Features");
+    for (const feature of report.features) {
+      const mark = feature.status === "ok" ? "ok  " : feature.status === "incompatible" ? "FAIL" : "??  ";
+      lines.push(`  ${mark} ${feature.title} (${feature.id})`);
+    }
+  }
+  if (report.issues.length) {
+    lines.push("", "Problems");
+    for (const issue of report.issues) lines.push(`  - ${issue.message}`);
+  }
+  lines.push(
+    "",
+    report.exitCode === 0 ? "Compatible." : report.exitCode === 1 ? "Incompatible: see the problems above." : "Could not check the ingester. Pass --endpoint <url> (or set AUTTER_ENDPOINT)."
+  );
+  return lines.join("\n");
+}
+var DOCTOR_USAGE = `Usage: npx @autter/runtime-node doctor [options]
+
+Checks that your Autter SDKs, ingester and ClickHouse schema versions match.
+
+Options:
+  --endpoint <url>    Ingester base URL (default: $AUTTER_ENDPOINT, $OTEL_EXPORTER_OTLP_ENDPOINT, or ${DEFAULT_ENDPOINT})
+  --key <key>         Also verify an ingest key (default: $AUTTER_RUNTIME_KEY)
+  --features <a,b>    Only check these features (${_chunkGI47WGRRcjs.COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
+  --json              Machine-readable output
+  --timeout <ms>      Per-request timeout (default 5000)
+
+Exit codes: 0 compatible, 1 mismatch or rejected key, 2 ingester unreachable.`;
+function parseDoctorArgs(argv, env = process.env) {
+  const options = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const [flag, inline] = arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, void 0];
+    const value = () => _nullishCoalesce(inline, () => ( argv[++i]));
+    switch (flag) {
+      case "-h":
+      case "--help":
+        return { help: true };
+      case "--endpoint":
+        options.endpoint = value();
+        break;
+      case "--key":
+        options.key = value();
+        break;
+      case "--features":
+        options.features = (_nullishCoalesce(value(), () => ( ""))).split(",").map((f) => f.trim()).filter(Boolean);
+        break;
+      case "--json":
+        options.json = true;
+        break;
+      case "--timeout": {
+        const ms = Number(value());
+        if (!Number.isFinite(ms) || ms <= 0) return { error: "--timeout needs a positive number of ms" };
+        options.timeoutMs = ms;
+        break;
+      }
+      default:
+        return { error: `unknown option ${arg}` };
+    }
+  }
+  if (!options.key && env.AUTTER_RUNTIME_KEY) options.key = env.AUTTER_RUNTIME_KEY;
+  return options;
+}
+
+
+
+
+
+
+exports.runDoctor = runDoctor; exports.formatDoctorReport = formatDoctorReport; exports.DOCTOR_USAGE = DOCTOR_USAGE; exports.parseDoctorArgs = parseDoctorArgs;