@obsunified/collector 2.0.1

package/dist/chunk-XKQTVIRE.js

@@ -0,0 +1,671 @@
+// src/lib/evidence-references.ts
+var analysisRoute = (analysisId) => `#/investigate/${encodeURIComponent(analysisId)}`;
+var analysisEvidenceReference = (evidence) => {
+  const route = analysisRoute(evidence.analysisId);
+  const status = evidence.result?.status ?? "unknown";
+  return {
+    evidenceId: `ask:analysis:${evidence.analysisId}`,
+    entityKind: "analysis",
+    entityId: evidence.analysisId,
+    route,
+    source: "ask.run_analysis",
+    confidence: evidence.result ? 1 : 0.55,
+    reason: evidence.result ? `Ask consulted analysis "${evidence.definition.title}" with latest status ${status}.` : `Ask consulted analysis "${evidence.definition.title}", but no latest result was available.`,
+    citations: [
+      {
+        label: evidence.definition.title,
+        entityKind: "analysis",
+        entityId: evidence.analysisId,
+        route
+      }
+    ],
+    suggestedNextPivots: [
+      {
+        label: "Open investigation",
+        entityKind: "analysis",
+        entityId: evidence.analysisId,
+        route,
+        reason: "Review the analysis payload, narrative, and connected telemetry rail."
+      }
+    ]
+  };
+};
+var askEvidenceReferences = (evidence) => [...evidence].map((item) => analysisEvidenceReference(item));
+var MAX_ANALYSIS_EVIDENCE_REFERENCES = 50;
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var asString = (value) => {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return null;
+};
+var normalizeHeader = (header) => header.trim().toLowerCase().replace(/[\s-]+/g, "_");
+var valueFor = (row, headerIndex, names) => {
+  for (const name of names) {
+    const index = headerIndex.get(name);
+    if (index === void 0) continue;
+    const value = asString(row[index]);
+    if (value) return value;
+  }
+  return null;
+};
+var traceRoute = (traceId) => `#/traces/${encodeURIComponent(traceId)}`;
+var spanRoute = (traceId, spanId) => `${traceRoute(traceId)}#span=${encodeURIComponent(spanId)}`;
+var evidenceRouteFor = (entityKind, entityId, traceId) => {
+  switch (entityKind) {
+    case "analysis":
+      return analysisRoute(entityId);
+    case "action":
+      return `#/actions/${encodeURIComponent(entityId)}`;
+    case "alert":
+      return `#/alerts?alert=${encodeURIComponent(entityId)}`;
+    case "agent_run":
+      return `#/agent-runs/${encodeURIComponent(entityId)}`;
+    case "ai_call":
+      return `#/ai/calls/${encodeURIComponent(entityId)}`;
+    case "eval":
+      return `#/evals/${encodeURIComponent(entityId)}`;
+    case "log":
+      return `#/logs?id=${encodeURIComponent(entityId)}`;
+    case "profile":
+      return traceId ? `#/profiles/${encodeURIComponent(entityId)}?trace_id=${encodeURIComponent(traceId)}` : `#/profiles/${encodeURIComponent(entityId)}`;
+    case "replay":
+      return `#/replay?session=${encodeURIComponent(entityId)}`;
+    case "service":
+      return `#/traces?service=${encodeURIComponent(entityId)}`;
+    case "span": {
+      const [tracePart, spanPart] = entityId.split(":");
+      return spanPart ? spanRoute(tracePart, spanPart) : `#/spans/${entityId}`;
+    }
+    case "tool_call":
+      return `#/tool-calls/${encodeURIComponent(entityId)}`;
+    case "trace":
+      return traceRoute(entityId);
+    case "docs":
+      return entityId.startsWith("#/") ? entityId : `#/docs/${entityId}`;
+  }
+  const exhaustive = entityKind;
+  return exhaustive;
+};
+var parseEvidenceTables = (payload) => {
+  const evidence = payload.evidence;
+  if (!isRecord(evidence)) return [];
+  const tables = [];
+  for (const [sectionName, section] of Object.entries(evidence)) {
+    if (!isRecord(section)) continue;
+    const headers = section.headers;
+    const rows = section.rows;
+    if (!Array.isArray(headers) || !headers.every(
+      (header) => typeof header === "string"
+    ) || !Array.isArray(rows)) {
+      continue;
+    }
+    const normalizedRows = rows.filter(
+      (row) => Array.isArray(row)
+    );
+    tables.push({
+      sectionName,
+      table: {
+        title: asString(section.title),
+        headers,
+        rows: normalizedRows
+      }
+    });
+  }
+  return tables;
+};
+var instrumentationGapEvidenceReferences = (result) => {
+  const gaps = result.payload.instrumentationGaps;
+  if (!isRecord(gaps)) return [];
+  const traceId = asString(gaps.traceId);
+  const blindspots = gaps.blindspots;
+  if (!traceId || !Array.isArray(blindspots)) return [];
+  return blindspots.filter(isRecord).map((gap, index) => {
+    const spanId = asString(gap.parentSpanId);
+    if (!spanId) return null;
+    const serviceName = asString(gap.parentServiceName);
+    const spanName = asString(gap.parentSpanName);
+    const durationMs = typeof gap.durationMs === "number" && Number.isFinite(gap.durationMs) ? gap.durationMs : null;
+    const ratio = typeof gap.ratioOfParent === "number" && Number.isFinite(gap.ratioOfParent) ? gap.ratioOfParent : null;
+    const recommendation = asString(gap.recommendation);
+    const thresholdVersion = asString(gap.thresholdVersion) ?? (isRecord(gaps.thresholds) ? asString(gaps.thresholds.version) : null);
+    const entityId = `${traceId}:${spanId}`;
+    const route = spanRoute(traceId, spanId);
+    const label = spanName ? `${spanName} (${spanId})` : `span ${spanId}`;
+    const durationText = durationMs === null ? "unknown duration" : `${durationMs}ms`;
+    const ratioText = ratio === null ? "" : `, ${(ratio * 100).toFixed(1)}% of parent`;
+    const thresholdText = thresholdVersion ? ` Thresholds: ${thresholdVersion}.` : "";
+    const docsRoute = "#/docs/howto/ebpf";
+    return {
+      evidenceId: `analysis:${result.analysisId}:instrumentation-gap:${index}:span:${entityId}`,
+      entityKind: "span",
+      entityId,
+      route,
+      source: "analysis.payload.instrumentationGaps",
+      confidence: 0.9,
+      reason: `Analysis "${result.analysisId}" found uninstrumented self-time on ${label}: ${durationText}${ratioText}.${thresholdText}${recommendation ? ` ${recommendation}` : ""}`,
+      citations: [
+        {
+          label: `trace ${traceId}`,
+          entityKind: "trace",
+          entityId: traceId,
+          route: traceRoute(traceId)
+        }
+      ],
+      suggestedNextPivots: [
+        {
+          label: "Open uninstrumented span",
+          entityKind: "span",
+          entityId,
+          route,
+          reason: "Inspect the parent span whose self-time suggests missing child instrumentation."
+        },
+        {
+          label: "Open trace gap data",
+          entityKind: "trace",
+          entityId: traceId,
+          route: `${traceRoute(traceId)}/gaps`,
+          reason: "Review all structured instrumentation blindspots for this trace."
+        },
+        {
+          label: "Open profiler setup docs",
+          entityKind: "docs",
+          entityId: "howto/ebpf",
+          route: docsRoute,
+          reason: serviceName != null ? `Use profiler or eBPF setup guidance to cover missing spans in ${serviceName}.` : "Use profiler or eBPF setup guidance to cover missing spans."
+        }
+      ]
+    };
+  }).filter((ref) => ref !== null).slice(0, MAX_ANALYSIS_EVIDENCE_REFERENCES);
+};
+var entityFromRow = (row, headers) => {
+  const headerIndex = new Map(headers.map((header, index) => [header, index]));
+  const traceId = valueFor(row, headerIndex, ["trace_id", "traceid", "trace"]);
+  const spanId = valueFor(row, headerIndex, ["span_id", "spanid"]);
+  const logId = valueFor(row, headerIndex, ["log_id", "logid"]);
+  const profileId = valueFor(row, headerIndex, ["profile_id", "profileid"]);
+  const actionId = valueFor(row, headerIndex, ["action_id", "actionid"]);
+  const agentRunId = valueFor(row, headerIndex, [
+    "agent_run_id",
+    "agentrunid",
+    "agent_run"
+  ]);
+  const toolCallId = valueFor(row, headerIndex, [
+    "tool_call_id",
+    "toolcallid",
+    "tool_call"
+  ]);
+  const evalId = valueFor(row, headerIndex, ["eval_id", "evalid"]);
+  const service = valueFor(row, headerIndex, ["service", "service_name"]);
+  const traceCitation = traceId ? [
+    {
+      label: `trace ${traceId}`,
+      entityKind: "trace",
+      entityId: traceId,
+      route: traceRoute(traceId)
+    }
+  ] : [];
+  if (traceId && spanId) {
+    const entityId = `${traceId}:${spanId}`;
+    return {
+      entityKind: "span",
+      entityId,
+      route: spanRoute(traceId, spanId),
+      label: `span ${spanId}`,
+      confidence: 0.95,
+      citations: traceCitation,
+      suggestedNextPivots: [
+        {
+          label: "Open span",
+          entityKind: "span",
+          entityId,
+          route: spanRoute(traceId, spanId),
+          reason: "Inspect the cited span in its trace context."
+        },
+        {
+          label: "Open trace",
+          entityKind: "trace",
+          entityId: traceId,
+          route: traceRoute(traceId),
+          reason: "Review the surrounding trace context."
+        }
+      ]
+    };
+  }
+  const candidates = [
+    {
+      entityKind: "trace",
+      entityId: traceId,
+      labelPrefix: "trace",
+      confidence: 0.95
+    },
+    {
+      entityKind: "action",
+      entityId: actionId,
+      labelPrefix: "action",
+      confidence: 0.9
+    },
+    {
+      entityKind: "tool_call",
+      entityId: toolCallId,
+      labelPrefix: "tool call",
+      confidence: 0.9
+    },
+    {
+      entityKind: "agent_run",
+      entityId: agentRunId,
+      labelPrefix: "agent run",
+      confidence: 0.9
+    },
+    {
+      entityKind: "profile",
+      entityId: profileId,
+      labelPrefix: "profile",
+      confidence: 0.9
+    },
+    {
+      entityKind: "log",
+      entityId: logId,
+      labelPrefix: "log",
+      confidence: 0.85
+    },
+    {
+      entityKind: "eval",
+      entityId: evalId,
+      labelPrefix: "eval",
+      confidence: 0.85
+    },
+    {
+      entityKind: "service",
+      entityId: service,
+      labelPrefix: "service",
+      confidence: 0.7
+    }
+  ];
+  const candidate = candidates.find((item) => item.entityId);
+  if (!candidate?.entityId) return null;
+  const route = evidenceRouteFor(
+    candidate.entityKind,
+    candidate.entityId,
+    traceId
+  );
+  return {
+    entityKind: candidate.entityKind,
+    entityId: candidate.entityId,
+    route,
+    label: `${candidate.labelPrefix} ${candidate.entityId}`,
+    confidence: candidate.confidence,
+    citations: traceCitation.filter(
+      (citation) => citation.entityKind !== candidate.entityKind || citation.entityId !== candidate.entityId
+    ),
+    suggestedNextPivots: [
+      {
+        label: `Open ${candidate.labelPrefix}`,
+        entityKind: candidate.entityKind,
+        entityId: candidate.entityId,
+        route,
+        reason: "Inspect the cited evidence row."
+      }
+    ]
+  };
+};
+var alertEvidenceReferences = (rule, evaluation) => {
+  const route = evidenceRouteFor("alert", rule.id);
+  const references = [
+    {
+      evidenceId: evaluation ? `alert:${rule.id}:evaluation:${evaluation.id}` : `alert:${rule.id}:rule`,
+      entityKind: "alert",
+      entityId: rule.id,
+      route,
+      source: evaluation ? "alert_evaluations" : "alerts.rule_evaluation_preview",
+      confidence: evaluation ? 1 : 0.8,
+      reason: evaluation ? `Alert "${rule.name}" evaluated to ${evaluation.value} and state ${evaluation.state}.` : `Alert "${rule.name}" was evaluated against its configured threshold.`,
+      citations: [
+        {
+          label: rule.name,
+          entityKind: "alert",
+          entityId: rule.id,
+          route
+        }
+      ],
+      suggestedNextPivots: [
+        {
+          label: "Open alert",
+          entityKind: "alert",
+          entityId: rule.id,
+          route,
+          reason: "Inspect the alert rule, threshold, and recent evaluations."
+        }
+      ]
+    }
+  ];
+  if (rule.analysisId) {
+    const analysisRouteValue = analysisRoute(rule.analysisId);
+    references.push({
+      evidenceId: evaluation ? `alert:${rule.id}:evaluation:${evaluation.id}:analysis:${rule.analysisId}` : `alert:${rule.id}:analysis:${rule.analysisId}`,
+      entityKind: "analysis",
+      entityId: rule.analysisId,
+      route: analysisRouteValue,
+      source: "alert_rules.analysis_id",
+      confidence: 0.9,
+      reason: `Alert "${rule.name}" is bound to analysis "${rule.analysisId}".`,
+      citations: [
+        {
+          label: rule.name,
+          entityKind: "alert",
+          entityId: rule.id,
+          route
+        }
+      ],
+      suggestedNextPivots: [
+        {
+          label: "Open investigation",
+          entityKind: "analysis",
+          entityId: rule.analysisId,
+          route: analysisRouteValue,
+          reason: "Review the analysis result that drives this alert."
+        }
+      ]
+    });
+  }
+  return references;
+};
+var aiEvaluationEvidenceReferences = (evaluation) => {
+  const spanEntityId = `${evaluation.traceId}:${evaluation.spanId}`;
+  const spanRouteValue = evidenceRouteFor(
+    "span",
+    spanEntityId,
+    evaluation.traceId
+  );
+  return [
+    {
+      evidenceId: `ai-evaluation:${evaluation.evaluationId}`,
+      entityKind: "eval",
+      entityId: evaluation.evaluationId,
+      route: evidenceRouteFor("eval", evaluation.evaluationId),
+      source: `ai_span_evaluations.${evaluation.source}`,
+      confidence: 0.95,
+      reason: `AI evaluation "${evaluation.name}" graded span "${evaluation.spanId}".`,
+      citations: [
+        {
+          label: `span ${evaluation.spanId}`,
+          entityKind: "span",
+          entityId: spanEntityId,
+          route: spanRouteValue
+        },
+        {
+          label: `trace ${evaluation.traceId}`,
+          entityKind: "trace",
+          entityId: evaluation.traceId,
+          route: evidenceRouteFor("trace", evaluation.traceId)
+        }
+      ],
+      suggestedNextPivots: [
+        {
+          label: "Open span",
+          entityKind: "span",
+          entityId: spanEntityId,
+          route: spanRouteValue,
+          reason: "Inspect the evaluated AI span and its surrounding trace."
+        }
+      ]
+    }
+  ];
+};
+var sourceLinkEvidenceReferences = (source, links) => {
+  const citations = [];
+  if (source.sourceRoute) {
+    citations.push({
+      label: source.sourceName ?? source.sourceId,
+      entityKind: "eval",
+      entityId: source.sourceId,
+      route: source.sourceRoute
+    });
+  }
+  const candidates = [
+    {
+      kind: "action",
+      id: links.sourceActionId,
+      label: "source action",
+      confidence: 0.92
+    },
+    {
+      kind: "tool_call",
+      id: links.sourceToolCallId,
+      label: "source tool call",
+      confidence: 0.9
+    },
+    {
+      kind: "agent_run",
+      id: links.sourceAgentRunId,
+      label: "source agent run",
+      confidence: 0.9
+    },
+    {
+      kind: "span",
+      id: links.sourceTraceId && links.sourceSpanId ? `${links.sourceTraceId}:${links.sourceSpanId}` : null,
+      label: "source span",
+      confidence: 0.9
+    },
+    {
+      kind: "trace",
+      id: links.sourceTraceId,
+      label: "source trace",
+      confidence: 0.88
+    }
+  ];
+  return candidates.filter(
+    (candidate) => Boolean(candidate.id)
+  ).map((candidate) => {
+    const route = evidenceRouteFor(
+      candidate.kind,
+      candidate.id,
+      links.sourceTraceId
+    );
+    return {
+      evidenceId: `${source.sourceKind}:${source.sourceId}:${candidate.kind}:${candidate.id}`,
+      entityKind: candidate.kind,
+      entityId: candidate.id,
+      route,
+      source: `${source.sourceKind}.source_links`,
+      confidence: candidate.confidence,
+      reason: `${source.sourceLabel} links to ${candidate.label} "${candidate.id}".`,
+      citations,
+      suggestedNextPivots: [
+        {
+          label: `Open ${candidate.label}`,
+          entityKind: candidate.kind,
+          entityId: candidate.id,
+          route,
+          reason: "Inspect the production evidence behind this evaluation item."
+        }
+      ]
+    };
+  });
+};
+var analysisResultEvidenceReferences = (result) => {
+  const references = [
+    ...instrumentationGapEvidenceReferences(result)
+  ];
+  for (const { sectionName, table } of parseEvidenceTables(result.payload)) {
+    const headers = table.headers.map(normalizeHeader);
+    for (const [rowIndex, row] of table.rows.entries()) {
+      if (references.length >= MAX_ANALYSIS_EVIDENCE_REFERENCES) {
+        return references;
+      }
+      const entity = entityFromRow(row, headers);
+      if (!entity) continue;
+      const title = table.title ?? sectionName;
+      references.push({
+        evidenceId: `analysis:${result.analysisId}:${sectionName}:${rowIndex}:${entity.entityKind}:${entity.entityId}`,
+        entityKind: entity.entityKind,
+        entityId: entity.entityId,
+        route: entity.route,
+        source: `analysis.payload.evidence.${sectionName}`,
+        confidence: entity.confidence,
+        reason: `Analysis "${result.analysisId}" cited ${entity.label} in "${title}" row ${rowIndex + 1}.`,
+        citations: entity.citations,
+        suggestedNextPivots: entity.suggestedNextPivots
+      });
+    }
+  }
+  return references;
+};
+
+// src/lib/llm.ts
+var DEFAULT_API_URL = "https://api.anthropic.com/v1/messages";
+var SYSTEM_PROMPT = `You write one-sentence operational narratives for a self-hosted observability dashboard.
+
+Hard rules \u2014 violations are unusable:
+1. Never start with "I", "Here's", "We", "It looks", or any first-person/chatbot framing. Write declarative statements about the system.
+2. If you reference a trace, span, log, or service, include the supplied identifier inline (e.g. "trace abc12345").
+3. Include a time anchor: "starting Nm ago", "for the last Nm", "since HH:MM" \u2014 pull from the inputs.
+4. \u2264 2 sentences total, \u2264 220 characters. Numbers belong in the sentence, not in a separate label.
+5. If the inputs are insufficient to write a useful sentence, output exactly the string NO_NARRATIVE (no quotes).
+
+Tone: like a senior on-call writing a Slack message. Specific, blunt, no hedging, no advice ("you should..."), no questions.`;
+var renderTemplate = (template, def, r) => {
+  const scope = def.scope ?? {};
+  const traceIds = Array.isArray(r.payload?.trace_ids) ? r.payload.trace_ids.filter((x) => typeof x === "string").slice(0, 5).join(", ") : "";
+  const subs = {
+    title: def.title,
+    status: r.status,
+    primary: r.primaryValue === null ? "n/a" : String(r.primaryValue),
+    baseline: r.baselineValue === null ? "n/a" : String(r.baselineValue),
+    delta_pct: r.deltaPct === null ? "n/a" : `${r.deltaPct.toFixed(1)}%`,
+    service: typeof scope.service === "string" ? scope.service : "",
+    trace_ids: traceIds
+  };
+  return template.replace(/\{\{(\w+)\}\}/g, (_, k) => subs[k] ?? "");
+};
+var buildUserPrompt = ({
+  definition,
+  current,
+  previous
+}) => {
+  const lines = [];
+  const tmplRendered = renderTemplate(
+    definition.narrate?.prompt ?? "",
+    definition,
+    current
+  ).trim();
+  if (tmplRendered) lines.push(tmplRendered);
+  lines.push("");
+  lines.push("Current state:");
+  lines.push(`- panel: ${definition.title}`);
+  lines.push(`- status: ${current.status}`);
+  if (current.primaryValue !== null)
+    lines.push(`- primary: ${current.primaryValue}`);
+  if (current.baselineValue !== null)
+    lines.push(`- baseline (1h): ${current.baselineValue}`);
+  if (current.deltaPct !== null)
+    lines.push(`- delta vs baseline: ${current.deltaPct.toFixed(1)}%`);
+  const since = previous ? Math.max(
+    1,
+    Math.round(
+      (new Date(current.generatedAt).getTime() - new Date(previous.generatedAt).getTime()) / 6e4
+    )
+  ) : null;
+  if (since !== null) {
+    lines.push(
+      `- previous run was ${since} minute${since === 1 ? "" : "s"} ago, status=${previous?.status ?? "n/a"}`
+    );
+  }
+  const payloadKeys = Object.keys(current.payload ?? {}).filter(
+    (k) => k !== "sparkline"
+  );
+  if (payloadKeys.length > 0) {
+    lines.push("");
+    lines.push("Payload details:");
+    for (const k of payloadKeys) {
+      const v = current.payload[k];
+      const rendered = typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? String(v) : JSON.stringify(v);
+      if (rendered.length <= 200) lines.push(`- ${k}: ${rendered}`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    "Output: a single sentence (max two), no preamble, no quotes, no Markdown."
+  );
+  return lines.join("\n");
+};
+var LlmCallError = class extends Error {
+  status;
+  constructor(message, status = null) {
+    super(message);
+    this.name = "LlmCallError";
+    this.status = status;
+  }
+};
+async function generateNarrative(req, config) {
+  if (config.provider === "openai") {
+    const { generateNarrativeOpenAI } = await import("./openai-FJYOQ7WO.js");
+    return generateNarrativeOpenAI(req, config);
+  }
+  return generateNarrativeAnthropic(req, config);
+}
+async function generateNarrativeAnthropic(req, config) {
+  const url = config.apiUrl ?? DEFAULT_API_URL;
+  const userPrompt = buildUserPrompt(req);
+  const tracer = config.tracer;
+  const callLLM = async (span) => {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-api-key": config.apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: config.model,
+        max_tokens: 200,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: userPrompt }]
+      }),
+      signal: config.signal
+    });
+    if (span) {
+      span.setAttribute("http.response.status_code", response.status);
+    }
+    if (!response.ok) {
+      const text2 = await response.text().catch(() => "");
+      throw new LlmCallError(
+        `anthropic ${response.status}: ${text2.slice(0, 200)}`,
+        response.status
+      );
+    }
+    const body = await response.json();
+    if (body.stop_reason === "max_tokens") {
+      throw new LlmCallError("anthropic response truncated by max_tokens");
+    }
+    if (span && body.usage) {
+      if (typeof body.usage.input_tokens === "number")
+        span.setAttribute("gen_ai.usage.input_tokens", body.usage.input_tokens);
+      if (typeof body.usage.output_tokens === "number")
+        span.setAttribute(
+          "gen_ai.usage.output_tokens",
+          body.usage.output_tokens
+        );
+    }
+    const text = (body.content ?? []).filter((block) => block?.type === "text").map((block) => block?.text ?? "").join("").trim();
+    if (!text || text === "NO_NARRATIVE") return null;
+    return text.replace(/^["']|["']$/g, "").trim();
+  };
+  if (!tracer) return callLLM(null);
+  return tracer("llm.anthropic.messages", async (span) => callLLM(span), {
+    "openinference.span.kind": "LLM",
+    "gen_ai.system": "anthropic",
+    "gen_ai.request.model": config.model,
+    "gen_ai.request.max_tokens": 200
+  });
+}
+
+export {
+  askEvidenceReferences,
+  alertEvidenceReferences,
+  aiEvaluationEvidenceReferences,
+  sourceLinkEvidenceReferences,
+  analysisResultEvidenceReferences,
+  LlmCallError,
+  generateNarrative
+};
+//# sourceMappingURL=chunk-XKQTVIRE.js.map