@skyhook-io/radar-app 1.14.2 → 1.14.4

package/src/components/diagnose/investigationEvidence/adapters/prometheus.ts

@@ -6,6 +6,7 @@ import {
   ProjectionBuilder,
   evidenceTierForRelevance,
   invalidPayload,
+  scopeFromArgs,
 } from "../observations";
 import {
   nonEmptyString,
@@ -767,3 +768,51 @@ export function adaptQueryPrometheus(
     },
   );
 }
+
+// A metric catalogue is bookkeeping for the query that follows; when the
+// agent cites it, the receipt says what was searched and how much came back.
+export function adaptDiscoverMetrics(
+  builder: ProjectionBuilder,
+  source: InvestigationEvidenceSource,
+  payload: unknown,
+): void {
+  const value = record(payload);
+  if (!value || typeof value.count !== "number") {
+    invalidPayload(builder, source);
+    return;
+  }
+  if (!source.confirmedSuccess) return;
+  const match = nonEmptyString(value.match) ? value.match : undefined;
+  const label = nonEmptyString(value.label) ? value.label : undefined;
+  const scope = match ?? scopeFromArgs(source);
+  builder.observe(
+    `metrics:discover:${scope}:${label ?? "names"}`,
+    "receipt",
+    source,
+    {
+      tier: evidenceTierForRelevance("checked", "broader"),
+      relevance: "broader",
+      tone: "neutral",
+      title: label
+        ? `Values of ${label}`
+        : match
+          ? `Metric names matching ${match}`
+          : "Metric names",
+      summary: `${value.count} ${label ? "values" : "metrics"} · last hour${value.truncated === true ? " · truncated" : ""}`,
+      data: {
+        type: "receipt",
+        checked: "metrics",
+        scope,
+        message: nonEmptyString(value.note) ? value.note : undefined,
+      },
+    },
+  );
+  if (value.truncated === true) {
+    builder.limit(
+      source,
+      "Metric discovery",
+      "The catalogue was truncated; a narrower selector would show the rest.",
+      "unknown",
+    );
+  }
+}

package/src/components/diagnose/investigationEvidence/adapters/rankings.ts

@@ -0,0 +1,147 @@
+import { nonEmptyString, parseJSON, record } from "../parse";
+import {
+  invalidPayload,
+  evidenceTierForRelevance,
+  sameKind,
+  scopeFromArgs,
+  type ProjectionBuilder,
+} from "../observations";
+import type {
+  InvestigationEvidenceSource,
+  InvestigationRankingRow,
+} from "../types";
+
+function quantity(milli: unknown, unit: "m" | "Mi"): string {
+  return typeof milli === "number" ? `${milli}${unit}` : "";
+}
+
+// A ranking is one card: the rows as the tool ordered them, with the
+// investigated resource's own row (or its pods) marked so the reader sees
+// where it stands without hunting.
+export function adaptTopResources(
+  builder: ProjectionBuilder,
+  source: InvestigationEvidenceSource,
+  payload: unknown,
+): void {
+  const value = record(payload);
+  if (!value || !nonEmptyString(value.kind)) {
+    invalidPayload(builder, source);
+    return;
+  }
+  if (value.metricsAvailable === false) {
+    builder.limit(
+      source,
+      "Live metrics",
+      nonEmptyString(value.reason)
+        ? value.reason
+        : "Live metrics were not available for this ranking.",
+      "unknown",
+    );
+    return;
+  }
+  const raw = Array.isArray(value.items)
+    ? value.items
+    : Array.isArray(value.workloads)
+      ? value.workloads
+      : [];
+  const rows: InvestigationRankingRow[] = raw.flatMap((entry) => {
+    const item = record(entry);
+    if (!item || !nonEmptyString(item.kind) || !nonEmptyString(item.name))
+      return [];
+    const namespace = nonEmptyString(item.namespace)
+      ? item.namespace
+      : undefined;
+    // Rows carry kind, namespace and name and no API group; the kinds a
+    // ranking holds (pods, the built-in workloads, nodes) are not ambiguous.
+    const target =
+      (item.kind === "Pod" && builder.establishedTargetPods.has(item.name)) ||
+      (sameKind(item.kind, builder.target.kind) &&
+        (namespace ?? "") === (builder.target.namespace ?? "") &&
+        item.name === builder.target.name);
+    const ownerRaw = record(item.owner);
+    const owner =
+      ownerRaw && nonEmptyString(ownerRaw.kind) && nonEmptyString(ownerRaw.name)
+        ? {
+            kind: ownerRaw.kind,
+            ...(nonEmptyString(ownerRaw.group)
+              ? { group: ownerRaw.group }
+              : {}),
+            ...(namespace ? { namespace } : {}),
+            name: ownerRaw.name,
+          }
+        : undefined;
+    return [
+      {
+        kind: item.kind,
+        namespace,
+        name: item.name,
+        ...(owner ? { owner } : {}),
+        cpu: quantity(item.cpuMilli, "m"),
+        memory: quantity(item.memoryMi, "Mi"),
+        ...(typeof item.cpuLimitMilli === "number" && item.cpuLimitMilli > 0
+          ? { cpuLimit: quantity(item.cpuLimitMilli, "m") }
+          : {}),
+        ...(typeof item.memoryLimitMi === "number" && item.memoryLimitMi > 0
+          ? { memoryLimit: quantity(item.memoryLimitMi, "Mi") }
+          : {}),
+        ...(typeof item.restarts === "number"
+          ? { restarts: item.restarts }
+          : {}),
+        ...(nonEmptyString(item.ready) ? { ready: item.ready } : {}),
+        ...(nonEmptyString(item.status) ? { status: item.status } : {}),
+        target,
+      },
+    ];
+  });
+  const args = record(parseJSON(source.args ?? ""));
+  const scope = scopeFromArgs(source);
+  const sort = nonEmptyString(value.sort)
+    ? value.sort
+    : nonEmptyString(args?.sort)
+      ? args.sort
+      : "cpu";
+  const relevance = rows.some((row) => row.target)
+    ? "producer-related"
+    : "broader";
+  const targetRows = rows.filter((row) => row.target).length;
+  // A pod ranking of the workload's own namespace that holds none of its
+  // established pods says so on the card, so the reader does not scan for a
+  // row that is not there. "Not in these results" is all that is known: a
+  // capped ranking omits low consumers, and the tool's skipped count does
+  // not say which pods it skipped.
+  const rankedNamespace = nonEmptyString(args?.namespace)
+    ? args.namespace
+    : undefined;
+  const targetPodsAbsent =
+    value.kind === "pods" &&
+    targetRows === 0 &&
+    builder.establishedTargetPods.size > 0 &&
+    (rankedNamespace === undefined ||
+      rankedNamespace === builder.target.namespace);
+  const skipped =
+    typeof value.skippedNoMetrics === "number" && value.skippedNoMetrics > 0
+      ? value.skippedNoMetrics
+      : 0;
+  builder.observe(`ranking:${value.kind}:${sort}:${scope}`, "ranking", source, {
+    tier: evidenceTierForRelevance("context", relevance),
+    relevance,
+    tone: "neutral",
+    title: `Top ${value.kind} by ${sort}`,
+    summary: [
+      `${rows.length} ranked`,
+      targetRows > 0
+        ? `${targetRows === 1 ? "this workload's row" : `${targetRows} of its pods`} marked`
+        : undefined,
+      rankedNamespace ? `in ${rankedNamespace}` : "cluster-wide",
+      targetPodsAbsent
+        ? "this workload's pods aren't in these results"
+        : undefined,
+      skipped > 0
+        ? `${skipped} ${value.kind === "nodes" ? (skipped === 1 ? "node" : "nodes") : skipped === 1 ? "pod" : "pods"} omitted: no metrics`
+        : undefined,
+    ]
+      .filter(Boolean)
+      .join(" · "),
+    data: { type: "ranking", kind: value.kind, sort, rows, scope },
+  });
+}

package/src/components/diagnose/investigationEvidence/adapters/resource.ts

@@ -230,6 +230,7 @@ export function adaptListResources(
   builder: ProjectionBuilder,
   source: InvestigationEvidenceSource,
   payload: unknown,
+  options: { title?: string } = {},
 ): void {
   if (!Array.isArray(payload)) {
     invalidPayload(builder, source);
@@ -254,7 +255,7 @@ export function adaptListResources(
   const namespace = nonEmptyString(args?.namespace)
     ? args.namespace
     : undefined;
-  const title = namespace ? `${noun} in ${namespace}` : noun;
+  const title = options.title ?? (namespace ? `${noun} in ${namespace}` : noun);
   if (resources.length === 0) {
     // list_resources intentionally returns [] for some RBAC-filtered reads;
     // even a successful transport outcome therefore cannot prove absence.
@@ -271,15 +272,24 @@ export function adaptListResources(
     return (
       health === "unhealthy" ||
       health === "degraded" ||
-      (resource.summaryContext?.issueCount ?? 0) > 0
+      (resource.summaryContext?.issueCount ?? 0) > 0 ||
+      nonEmptyString(resource.issue)
     );
   });
-  builder.observe(`inventory:${source.args ?? scope}`, "inventory", source, {
-    tier: "context",
-    relevance: "broader",
-    tone: hasAdverseResource ? "warning" : "neutral",
-    title,
-    summary: `${resources.length} returned${nonEmptyString(args?.group) ? ` · ${args.group}` : ""}`,
-    data: { type: "inventory", resources, scope },
-  });
+  // Listings of different things share an argument shape (a cluster-wide
+  // package list and a cluster-wide Helm list are both "{}"), so the tool is
+  // part of what makes one listing the same card as an earlier read.
+  builder.observe(
+    `inventory:${source.tool}:${source.args ?? scope}`,
+    "inventory",
+    source,
+    {
+      tier: "context",
+      relevance: "broader",
+      tone: hasAdverseResource ? "warning" : "neutral",
+      title,
+      summary: `${resources.length} returned${nonEmptyString(args?.group) ? ` · ${args.group}` : ""}`,
+      data: { type: "inventory", resources, scope },
+    },
+  );
 }

package/src/components/diagnose/investigationEvidence/bodies/index.tsx

@@ -0,0 +1,127 @@
+import type { MetricsChangeCoverage } from "../../investigationMetrics";
+import type {
+  InvestigationEvidenceData,
+  InvestigationResourceSummary,
+} from "..";
+import { investigationResourceEvidenceHasDetails } from "../../investigationResourceEvidenceModel";
+import {
+  CrashBody,
+  IssueBody,
+  ResourceBody,
+  StartupBody,
+  diagnosedScalers,
+} from "./workload";
+import { ChangesBody, EventsBody, LogsBody } from "./streams";
+import {
+  DNSBody,
+  NetworkBody,
+  RelationshipsBody,
+  TopologyBody,
+} from "./network";
+import { InventoryBody } from "./inventory";
+import { AlertsBody, MetricsBody } from "./metrics";
+import { HelmBody, PermissionsBody } from "./platform";
+import { RankingBody } from "./ranking";
+import { PostureBody } from "./posture";
+
+export function EvidenceBody({
+  data,
+  cardSummary,
+  changeCoverage,
+  condensed = false,
+  citedRows,
+}: {
+  data: InvestigationEvidenceData;
+  cardSummary?: string;
+  /** Change markers for a metrics chart; derived by the pane, never by data. */
+  changeCoverage?: MetricsChangeCoverage;
+  /** The card's title already names the stream: skip the repeated badges. */
+  condensed?: boolean;
+  /** Listing rows the card's citations name; they lead the inventory. */
+  citedRows?: readonly InvestigationResourceSummary[];
+}) {
+  switch (data.type) {
+    case "issue":
+      return <IssueBody data={data} cardSummary={cardSummary} />;
+    case "startup":
+      return <StartupBody data={data} />;
+    case "crash":
+      return <CrashBody data={data} />;
+    case "resource":
+      return <ResourceBody data={data} />;
+    case "logs":
+      return <LogsBody data={data} condensed={condensed} />;
+    case "events":
+      return <EventsBody data={data} />;
+    case "changes":
+      return <ChangesBody data={data} />;
+    case "dns":
+      return <DNSBody data={data} />;
+    case "network":
+      return <NetworkBody data={data} />;
+    case "relationships":
+      return <RelationshipsBody data={data} />;
+    case "topology":
+      return <TopologyBody data={data} />;
+    case "inventory":
+      return <InventoryBody data={data} cited={citedRows} />;
+    case "receipt":
+      // The title and the scope above it are the answer. A body appears only
+      // when it adds the reason or the limit, so an absent one renders nothing
+      // rather than an empty line.
+      return data.message ? (
+        <p className="text-xs text-theme-text-secondary">{data.message}</p>
+      ) : null;
+    case "alerts":
+      return <AlertsBody data={data} />;
+    case "helm":
+      return <HelmBody data={data} />;
+    case "permissions":
+      return <PermissionsBody data={data} />;
+    case "metrics":
+      return <MetricsBody data={data} changeCoverage={changeCoverage} />;
+    case "ranking":
+      return <RankingBody data={data} />;
+    case "posture":
+      return <PostureBody data={data} />;
+  }
+}
+
+export function evidenceHasDetails(
+  data: InvestigationEvidenceData,
+  cardSummary?: string,
+): boolean {
+  switch (data.type) {
+    case "issue": {
+      const summary = cardSummary?.trim();
+      const cause = data.issue.cause?.trim();
+      const message = data.issue.message?.trim();
+      return Boolean(
+        (cause && cause !== summary) ||
+        (message && message !== summary && message !== cause) ||
+        data.pods?.length,
+      );
+    }
+    case "startup":
+      return (data.pods?.length ?? 0) > 1;
+    case "receipt":
+      return false;
+    case "resource": {
+      const replicas = data.resourceContext?.workloadSummary?.replicas;
+      return Boolean(
+        investigationResourceEvidenceHasDetails(data.resource) ||
+        replicas?.desired !== undefined ||
+        data.resourceContext?.statusSummary?.conditions?.length ||
+        diagnosedScalers(data.resourceContext).length ||
+        data.gitOpsDiagnosis ||
+        data.warnings.length,
+      );
+    }
+    case "logs":
+      return (data.logs?.lines?.length ?? 0) > 0 || Boolean(data.error);
+    case "changes":
+      return data.changes.length > 0 || Boolean(data.changeContext?.evidence);
+    default:
+      return true;
+  }
+}

package/src/components/diagnose/investigationEvidence/bodies/inventory.tsx

@@ -0,0 +1,158 @@
+import { clsx } from "clsx";
+import { Badge, StatusDot, mapHealthToTone } from "@skyhook-io/k8s-ui";
+import type { DiagnosisEvidenceSubject } from "../../../../api/diagnose";
+import {
+  investigationSourceArgs,
+  type InvestigationResourceSummary,
+  type InvestigationEvidenceSource,
+} from "..";
+import { listingRowNamesSubject, sameKind } from "../../investigationCase";
+import type { EvidenceDataOf } from "../cardParts";
+
+// The rows the citations on a card name, in citation order: one row when the
+// name picks exactly one entry, otherwise a line saying the entry is absent
+// or which entries the name could mean.
+export function listingScopeNamespace(
+  source: InvestigationEvidenceSource,
+): string | undefined {
+  const namespace = investigationSourceArgs(source)?.namespace;
+  return typeof namespace === "string" && namespace ? namespace : undefined;
+}
+
+export function namedInventoryRows(
+  resources: InvestigationResourceSummary[],
+  items: readonly { subject?: DiagnosisEvidenceSubject }[],
+  /** The namespace the listing call was scoped to; rows omit it then. */
+  scopeNamespace?: string,
+): {
+  key: string;
+  label: string;
+  matches: number;
+  row?: InvestigationResourceSummary;
+}[] {
+  const seen = new Set<string>();
+  const out: {
+    key: string;
+    label: string;
+    matches: number;
+    row?: InvestigationResourceSummary;
+  }[] = [];
+  for (const item of items) {
+    const subject = item.subject;
+    if (!subject?.name) continue;
+    // Agents write namespace "" for a cluster-scoped kind; that states none.
+    const namespace = subject.namespace || undefined;
+    // Kind is part of what a subject names once a package can be named by
+    // its declaring object: "Package staging/podinfo" and "HelmRelease
+    // staging/podinfo" ask different questions of the same listing.
+    const key = `${subject.kind}/${namespace ?? ""}/${subject.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    // A row without a namespace lives in the listing's scope, or in none
+    // (a cluster-scoped kind); neither satisfies a namespace the citation
+    // states unless it is the scope itself. A package row's namespace is
+    // where the package runs, while the object the agent names as declaring
+    // it (a Flux HelmRelease in flux-system) lives elsewhere, so that
+    // namespace is not held against a package; a subject that names the
+    // package as a Package means the namespace it says.
+    const declaringObject = (resource: InvestigationResourceSummary) =>
+      resource.kind === "Package" && !sameKind(subject.kind, "Package");
+    const matches = resources.filter(
+      (resource) =>
+        listingRowNamesSubject(resource, subject) &&
+        (namespace === undefined ||
+          declaringObject(resource) ||
+          (resource.namespace ?? scopeNamespace) === namespace),
+    );
+    out.push({
+      key,
+      label: namespace ? `${namespace}/${subject.name}` : subject.name,
+      matches: matches.length,
+      row: matches.length === 1 ? matches[0] : undefined,
+    });
+  }
+  return out;
+}
+
+export function InventoryRow({
+  resource,
+  divider = false,
+  cited = false,
+}: {
+  resource: InvestigationResourceSummary;
+  divider?: boolean;
+  cited?: boolean;
+}) {
+  return (
+    <div
+      data-inventory-row={cited ? "cited" : undefined}
+      className={clsx(
+        "flex min-w-0 items-center gap-2 px-2.5 py-1.5",
+        divider && "border-t border-theme-border/60",
+        cited && "bg-theme-hover/40",
+      )}
+    >
+      <StatusDot
+        tone={mapHealthToTone(resource.summaryContext?.health ?? "")}
+        className="shrink-0"
+      />
+      <Badge tone="structural" size="sm">
+        {resource.kind}
+      </Badge>
+      <span className="min-w-0 flex-1">
+        <span className="block truncate font-mono text-xs text-theme-text-secondary">
+          {resource.namespace ? `${resource.namespace}/` : ""}
+          {resource.name}
+        </span>
+        {resource.issue ? (
+          <span className="block truncate text-xs text-warning-text">
+            {resource.issue}
+          </span>
+        ) : null}
+        {resource.match ? (
+          <span className="block truncate font-mono text-[11px] text-theme-text-tertiary">
+            {resource.match}
+          </span>
+        ) : null}
+      </span>
+      {resource.ready || resource.status ? (
+        <span className="ml-auto shrink-0 font-mono text-xs text-theme-text-tertiary">
+          {resource.ready || resource.status}
+        </span>
+      ) : null}
+      {(resource.summaryContext?.issueCount ?? 0) > 0 ? (
+        <Badge severity="warning" size="sm">
+          {resource.summaryContext?.issueCount} issues
+        </Badge>
+      ) : null}
+    </div>
+  );
+}
+
+// The rows the card's citations name lead the listing, so the entry a claim
+// is about is in view without scrolling a long inventory for it.
+export function InventoryBody({
+  data,
+  cited = [],
+}: {
+  data: EvidenceDataOf<"inventory">;
+  cited?: readonly InvestigationResourceSummary[];
+}) {
+  const lead = [...new Set(cited)];
+  const rows = [
+    ...lead,
+    ...data.resources.filter((resource) => !lead.includes(resource)),
+  ];
+  return (
+    <div className="max-h-72 overflow-y-auto rounded-md border border-theme-border">
+      {rows.map((resource, index) => (
+        <InventoryRow
+          key={`${resource.kind}-${resource.namespace ?? ""}-${resource.name}`}
+          resource={resource}
+          divider={index > 0}
+          cited={lead.includes(resource)}
+        />
+      ))}
+    </div>
+  );
+}