@skyhook-io/radar-app 1.13.5 → 1.14.0

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

@@ -0,0 +1,172 @@
+import { type Issue, type IssueRecentChange } from "@skyhook-io/k8s-ui";
+import { type DiagnosisDNSContext } from "../../diagnoseEvidenceTypes";
+import {
+  ProjectionBuilder,
+  addChanges,
+  addIssueObservation,
+  addNarrowHint,
+  evidenceTierForRelevance,
+  invalidPayload,
+  scopeFromArgs,
+  sourceArgsRelevance,
+} from "../observations";
+import {
+  issue,
+  nonEmptyString,
+  parseJSON,
+  recentChange,
+  record,
+  stringArray,
+} from "../parse";
+import { type InvestigationEvidenceSource } from "../types";
+
+export function adaptIssues(
+  builder: ProjectionBuilder,
+  source: InvestigationEvidenceSource,
+  payload: unknown,
+): void {
+  const value = record(payload);
+  const raw = value?.issues;
+  if (
+    !value ||
+    !Array.isArray(raw) ||
+    typeof value.total !== "number" ||
+    typeof value.total_matched !== "number"
+  ) {
+    invalidPayload(builder, source);
+    return;
+  }
+  const issues = raw.map(issue).filter((item): item is Issue => Boolean(item));
+  if (issues.length !== raw.length) {
+    invalidPayload(builder, source);
+    return;
+  }
+  addNarrowHint(builder, source, value);
+  if (
+    value.total_matched > issues.length &&
+    !nonEmptyString(value.narrowHint)
+  ) {
+    builder.limit(
+      source,
+      "Issues",
+      `The query returned ${issues.length} of ${value.total_matched} matching issues.`,
+      "truncated",
+    );
+  }
+  if (typeof value.filter_errors === "number" && value.filter_errors > 0) {
+    builder.limit(
+      source,
+      "Issues filter",
+      nonEmptyString(value.filter_error_sample)
+        ? value.filter_error_sample
+        : `${value.filter_errors} issue rows could not be evaluated by the filter.`,
+      "error",
+    );
+  }
+  if (value.recent_changes_truncated === true) {
+    builder.limit(
+      source,
+      "Issue-related changes",
+      "The issue response omitted some recent changes.",
+      "truncated",
+    );
+  }
+  if (value.correlation_truncated === true) {
+    builder.limit(
+      source,
+      "Issue change correlation",
+      "Change correlation was not evaluated for every returned issue.",
+      "truncated",
+    );
+  }
+  const visibility = record(value.visibility);
+  if (
+    visibility &&
+    nonEmptyString(visibility.state) &&
+    visibility.state !== "ok"
+  ) {
+    builder.limit(
+      source,
+      "Issue visibility",
+      nonEmptyString(visibility.impact)
+        ? visibility.impact
+        : `Radar reported ${visibility.state} visibility for this issue query.`,
+      "unknown",
+    );
+  }
+  const issueChangesRaw = value.recent_changes;
+  if (Array.isArray(issueChangesRaw)) {
+    const changes = issueChangesRaw
+      .map(recentChange)
+      .filter((item): item is IssueRecentChange => Boolean(item));
+    if (changes.length === issueChangesRaw.length) {
+      addChanges(
+        builder,
+        source,
+        changes,
+        `changes:issues:${source.args ?? scopeFromArgs(source)}`,
+        undefined,
+        value.recent_changes_truncated !== true,
+      );
+    } else {
+      invalidPayload(builder, source, "Issue-related changes");
+    }
+  } else if (issueChangesRaw !== undefined) {
+    invalidPayload(builder, source, "Issue-related changes");
+  }
+  const clusterDNS = record(record(value.cluster_context)?.dns);
+  if (clusterDNS) {
+    const signals = stringArray(clusterDNS.signals) ?? [];
+    const findings = Array.isArray(clusterDNS.findings)
+      ? clusterDNS.findings
+      : [];
+    if (signals.length > 0 || findings.length > 0) {
+      builder.observe(`dns:issues:${scopeFromArgs(source)}`, "dns", source, {
+        tier: "context",
+        relevance: "broader",
+        tone: "warning",
+        title: "Cluster DNS signals",
+        summary:
+          signals[0] ||
+          `${findings.length} CoreDNS finding${findings.length === 1 ? "" : "s"}`,
+        data: {
+          type: "dns",
+          dns: {
+            signals,
+            coreDNSFindings: findings as DiagnosisDNSContext["coreDNSFindings"],
+          },
+        },
+      });
+    }
+  }
+  if (issues.length === 0) {
+    if (!source.confirmedSuccess || builder.limitedSources.has(source.id))
+      return;
+    const args = record(source.args ? parseJSON(source.args) : undefined);
+    if (!nonEmptyString(args?.namespace)) {
+      builder.limit(
+        source,
+        "Issues",
+        "Radar found no matching issues, but the search covered only namespaces the current user can access.",
+        "unknown",
+      );
+      return;
+    }
+    const scope = scopeFromArgs(source);
+    const relevance = sourceArgsRelevance(builder, source);
+    builder.observe(`issues:${source.args ?? scope}`, "receipt", source, {
+      tier: evidenceTierForRelevance("checked", relevance),
+      relevance,
+      tone: "neutral",
+      title: "No live issues matched this search",
+      summary: scope,
+      data: {
+        type: "receipt",
+        checked: "issues",
+        scope,
+      },
+    });
+  } else {
+    for (const item of issues) addIssueObservation(builder, source, item);
+  }
+}

package/src/components/diagnose/investigationEvidence/adapters/logs.test.ts

@@ -0,0 +1,283 @@
+import { describe, expect, it } from "vitest";
+import {
+  investigationEvidenceSubjectRef,
+  projectInvestigationEvidence,
+  resolveInvestigationRootCauseEvidence,
+} from "../index";
+import {
+  evidenceRef,
+  groupsOf,
+  project,
+  tool,
+  workloadLogsArgs,
+  workloadLogsPayload,
+} from "../evidenceFixtures";
+
+// The get_workload_logs response shape, with the stream rows fetchPodLogs
+// emits per pod and container.
+
+describe("workload logs adapter", () => {
+  it("keeps one multi-container result as one source with several observations", () => {
+    const ref = evidenceRef("a", "b");
+    const projection = project([
+      tool("wl-logs", "get_workload_logs", workloadLogsPayload, {
+        summary: workloadLogsArgs,
+        evidenceRef: ref,
+      }),
+    ]);
+    const logs = groupsOf(projection.groups, "logs");
+    expect(logs.map((group) => group.identity)).toEqual([
+      "logs:current:api-68c7b766dc-fmphn:api",
+      "logs:current:api-68c7b766dc-fmphn:istio-proxy",
+      "logs:current:api-68c7b766dc-q2zxr:api",
+    ]);
+    expect(projection.sources).toHaveLength(1);
+    expect(projection.coverage).toMatchObject({
+      attempted: 1,
+      projected: 1,
+      limited: 1,
+    });
+    expect(new Set(logs.map((group) => group.latest.source.id)).size).toBe(1);
+    // Diagnose relates a target workload to its pods the same way.
+    expect(logs.map((group) => group.latest.relevance)).toEqual([
+      "producer-related",
+      "producer-related",
+      "producer-related",
+    ]);
+    expect(logs[0].latest.tier).toBe("supporting");
+    expect(logs[0].latest.tone).toBe("warning");
+    expect(logs[0].latest.data).toMatchObject({
+      type: "logs",
+      namespace: "shop",
+      previous: false,
+      warnings: workloadLogsPayload.warnings,
+    });
+    expect(
+      (logs[0].latest.data as { logs?: { lines: string[] } }).logs?.lines[0],
+    ).not.toContain("[");
+    expect(logs[1].latest.tier).toBe("context");
+    expect(investigationEvidenceSubjectRef(logs[2].latest.data)).toEqual({
+      kind: "Pod",
+      namespace: "shop",
+      name: "api-68c7b766dc-q2zxr",
+    });
+
+    const resolution = resolveInvestigationRootCauseEvidence(
+      projection,
+      { status: "linked", refs: [ref] },
+      0,
+    );
+    expect(resolution.status).toBe("linked");
+    expect(resolution.links[0].source.stepId).toBe("wl-logs");
+    expect(resolution.links[0].originalGroupId).toBe(logs[0].id);
+    expect(projection.sources[0].primaryGroupId).toBe(logs[0].id);
+    expect(
+      projection.limitations.map((limitation) => limitation.source),
+    ).toEqual(["Workload logs"]);
+    expect(projection.limitations[0].kind).toBe("truncated");
+  });
+
+  it("accepts every workload kind the producer resolves, including Rollouts", () => {
+    const rollout = projectInvestigationEvidence(
+      [
+        {
+          timeline: [
+            tool(
+              "wl-rollout",
+              "get_workload_logs",
+              { ...workloadLogsPayload, workload: "rollouts/shop/api" },
+              {
+                summary: JSON.stringify({
+                  namespace: "shop",
+                  name: "api",
+                  kind: "rollout",
+                }),
+              },
+            ),
+          ],
+        },
+      ],
+      { kind: "Rollout", group: "argoproj.io", namespace: "shop", name: "api" },
+    );
+    expect(
+      groupsOf(rollout.groups, "logs").map((group) => group.latest.relevance),
+    ).toEqual(["producer-related", "producer-related", "producer-related"]);
+    expect(rollout.limitations.map((limitation) => limitation.kind)).toEqual([
+      "truncated",
+    ]);
+  });
+
+  it("scopes a sibling workload's logs as broader and a Pod target's own row as target", () => {
+    const sibling = project([
+      tool(
+        "wl-sibling",
+        "get_workload_logs",
+        { ...workloadLogsPayload, workload: "deployments/shop/api-worker" },
+        {
+          summary: JSON.stringify({
+            namespace: "shop",
+            name: "api-worker",
+            kind: "deployment",
+          }),
+        },
+      ),
+    ]);
+    expect(
+      groupsOf(sibling.groups, "logs").map((group) => group.latest.relevance),
+    ).toEqual(["broader", "broader", "broader"]);
+    expect(
+      groupsOf(sibling.groups, "logs").map((group) => group.latest.tier),
+    ).toEqual(["context", "context", "context"]);
+
+    const podTarget = projectInvestigationEvidence(
+      [
+        {
+          timeline: [
+            tool("wl-pod", "get_workload_logs", workloadLogsPayload, {
+              summary: workloadLogsArgs,
+            }),
+          ],
+        },
+      ],
+      {
+        kind: "Pod",
+        group: "",
+        namespace: "shop",
+        name: "api-68c7b766dc-q2zxr",
+      },
+    );
+    expect(
+      groupsOf(podTarget.groups, "logs").map((group) => group.latest.relevance),
+    ).toEqual(["broader", "broader", "target"]);
+  });
+
+  it("reports a failed read as a limitation and no pods as a scoped receipt", () => {
+    const failed = project([
+      tool(
+        "wl-error",
+        "get_workload_logs",
+        {
+          workload: "deployments/shop/api",
+          pods: 2,
+          logsError: "no kube client in request context",
+        },
+        { summary: workloadLogsArgs },
+      ),
+    ]);
+    expect(failed.groups).toHaveLength(0);
+    expect(failed.limitations).toEqual([
+      expect.objectContaining({
+        source: "Workload logs",
+        message: "no kube client in request context",
+        kind: "error",
+      }),
+    ]);
+
+    const empty = project([
+      tool(
+        "wl-empty",
+        "get_workload_logs",
+        {
+          workload: "jobs/shop/api",
+          pods: 0,
+          logs: "No pods found for this Job yet. Check scheduling, admission, or controller events.",
+          emptyReason: "no-pods",
+          emptyMessage:
+            "No pods found for this Job yet. Check scheduling, admission, or controller events.",
+          command: "kubectl logs job/api -n shop",
+        },
+        {
+          summary: JSON.stringify({
+            namespace: "shop",
+            name: "api",
+            kind: "job",
+          }),
+        },
+      ),
+    ]);
+    const receipt = groupsOf(empty.groups, "receipt")[0].latest;
+    expect(receipt.tier).toBe("context");
+    expect(receipt.relevance).toBe("broader");
+    expect(receipt.data).toMatchObject({
+      type: "receipt",
+      checked: "logs",
+      scope: "Job shop/api",
+      message:
+        "No pods found for this Job yet. Check scheduling, admission, or controller events.",
+    });
+    expect(empty.limitations).toHaveLength(0);
+
+    const unconfirmed = project([
+      tool(
+        "wl-unconfirmed",
+        "get_workload_logs",
+        { workload: "deployments/shop/api", pods: 0, logs: "no pods" },
+        { summary: workloadLogsArgs, isError: undefined },
+      ),
+    ]);
+    expect(groupsOf(unconfirmed.groups, "receipt")).toHaveLength(0);
+  });
+
+  it("rejects malformed payloads and per-stream errors honestly", () => {
+    const malformed = project([
+      tool(
+        "wl-bad",
+        "get_workload_logs",
+        { workload: "pods/shop/api", pods: 1, logs: [] },
+        { summary: workloadLogsArgs },
+      ),
+      tool(
+        "wl-stream-error",
+        "get_workload_logs",
+        {
+          workload: "deployments/shop/api",
+          pods: 1,
+          logs: [
+            {
+              pod: "api-68c7b766dc-fmphn",
+              container: "api",
+              error: "failed to get logs: container is waiting to start",
+            },
+          ],
+        },
+        { summary: workloadLogsArgs },
+      ),
+      tool(
+        "wl-null",
+        "get_workload_logs",
+        { workload: "deployments/shop/api", pods: 3, logs: null },
+        { summary: workloadLogsArgs },
+      ),
+      tool(
+        "wl-zero-with-streams",
+        "get_workload_logs",
+        {
+          workload: "deployments/shop/api",
+          pods: 0,
+          logs: workloadLogsPayload.logs,
+        },
+        { summary: workloadLogsArgs },
+      ),
+    ]);
+    expect(malformed.groups).toHaveLength(0);
+    expect(
+      malformed.limitations.map((limitation) => [
+        limitation.source,
+        limitation.kind,
+      ]),
+    ).toEqual([
+      ["Workload logs", "unknown"],
+      ["api-68c7b766dc-fmphn / api", "error"],
+      ["Workload logs", "unknown"],
+    ]);
+    expect(malformed.limitations[0].sources.map((item) => item.stepId)).toEqual(
+      ["wl-bad", "wl-zero-with-streams"],
+    );
+    expect(malformed.limitations[0].message).toContain(
+      "couldn't summarize this investigation step",
+    );
+    expect(malformed.limitations[2].message).toContain(
+      "Radar found 3 pods but got no logs from them",
+    );
+  });
+});

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

@@ -0,0 +1,183 @@
+import { displayKind } from "@skyhook-io/k8s-ui";
+import {
+  ProjectionBuilder,
+  addLogs,
+  addNarrowHint,
+  evidenceTierForRelevance,
+  invalidPayload,
+  previousFromArgs,
+  relevanceForResource,
+  resourceMatchesTarget,
+  sourceArgsRelevance,
+} from "../observations";
+import {
+  filteredLogs,
+  nonEmptyString,
+  nonNegativeInteger,
+  parseJSON,
+  parseLogEntry,
+  record,
+  stringArray,
+} from "../parse";
+import {
+  type InvestigationEvidenceRelevance,
+  type InvestigationEvidenceSource,
+} from "../types";
+
+export function adaptPodLogs(
+  builder: ProjectionBuilder,
+  source: InvestigationEvidenceSource,
+  payload: unknown,
+): void {
+  const value = record(payload);
+  const logs = filteredLogs(payload) ?? filteredLogs(value);
+  if (!logs) {
+    invalidPayload(builder, source);
+    return;
+  }
+  if (value) addNarrowHint(builder, source, value);
+  const warnings = stringArray(value?.warnings) ?? [];
+  const args = record(source.args ? parseJSON(source.args) : undefined);
+  const pod = nonEmptyString(args?.name) ? args.name : "Pod";
+  const container = nonEmptyString(args?.container)
+    ? args.container
+    : "default container";
+  addLogs(
+    builder,
+    source,
+    { pod, container, logs },
+    previousFromArgs(source),
+    warnings,
+    sourceArgsRelevance(builder, source, "Pod"),
+    nonEmptyString(args?.namespace) ? args.namespace : undefined,
+  );
+}
+const WORKLOAD_LOG_KINDS: Readonly<Record<string, string>> = {
+  deployments: "Deployment",
+  statefulsets: "StatefulSet",
+  daemonsets: "DaemonSet",
+  rollouts: "Rollout",
+  jobs: "Job",
+  workflows: "Workflow",
+};
+/** `get_workload_logs` states what it read as `<plural>/<namespace>/<name>`. */
+function workloadLogsSubject(
+  value: string,
+): { kind: string; namespace: string; name: string } | undefined {
+  const parts = value.split("/");
+  if (parts.length !== 3) return undefined;
+  const kind = WORKLOAD_LOG_KINDS[parts[0]];
+  if (!kind || !parts[1] || !parts[2]) return undefined;
+  return { kind, namespace: parts[1], name: parts[2] };
+}
+export function adaptWorkloadLogs(
+  builder: ProjectionBuilder,
+  source: InvestigationEvidenceSource,
+  payload: unknown,
+): void {
+  const value = record(payload);
+  const workload = nonEmptyString(value?.workload)
+    ? workloadLogsSubject(value.workload)
+    : undefined;
+  if (!value || !workload || !nonNegativeInteger(value.pods)) {
+    invalidPayload(builder, source);
+    return;
+  }
+  // The producer names the workload without an API group; as with other
+  // group-less producers, the investigation target supplies that dimension.
+  const workloadRelevance = relevanceForResource(builder, {
+    ...workload,
+    group: builder.target.group,
+  });
+  const scope = `${displayKind(workload.kind)} ${workload.namespace}/${workload.name}`;
+  const previous = previousFromArgs(source);
+  addNarrowHint(builder, source, value);
+  if (nonEmptyString(value.logsError)) {
+    builder.limit(source, "Workload logs", value.logsError, "error");
+    return;
+  }
+  if (value.pods === 0) {
+    // The producer replaces the stream list with a message when it resolved
+    // no pods; any other shape is not this response.
+    if (
+      typeof value.logs !== "string" ||
+      (value.emptyMessage !== undefined &&
+        typeof value.emptyMessage !== "string") ||
+      value.narrowHint !== undefined
+    ) {
+      invalidPayload(builder, source);
+      return;
+    }
+    if (!source.confirmedSuccess) return;
+    // The producer's own sentence when it gave one; otherwise nothing, because
+    // "no pods to read logs from" is already the whole answer.
+    const message = nonEmptyString(value.emptyMessage)
+      ? value.emptyMessage
+      : nonEmptyString(value.logs)
+        ? value.logs
+        : undefined;
+    builder.observe(
+      `workload-logs:${previous ? "previous" : "current"}:${scope}`,
+      "receipt",
+      source,
+      {
+        tier: evidenceTierForRelevance("checked", workloadRelevance),
+        relevance: workloadRelevance,
+        tone: "neutral",
+        title: "No pods to read logs from",
+        summary: scope,
+        data: { type: "receipt", checked: "logs", scope, message },
+      },
+    );
+    return;
+  }
+  const logsRaw = value.logs;
+  const noStreams = `Radar found ${value.pods} pod${value.pods === 1 ? "" : "s"} but got no logs from ${value.pods === 1 ? "it" : "them"}, so the logs were not checked.`;
+  if (!Array.isArray(logsRaw)) {
+    if (logsRaw === undefined || logsRaw === null) {
+      builder.limit(source, "Workload logs", noStreams, "unknown");
+    } else {
+      invalidPayload(builder, source);
+    }
+    return;
+  }
+  const warnings = stringArray(value.warnings) ?? [];
+  for (const raw of logsRaw) {
+    const entry = parseLogEntry(raw);
+    if (!entry) {
+      invalidPayload(
+        builder,
+        source,
+        previous ? "Previous logs" : "Current logs",
+      );
+      continue;
+    }
+    // A Pod target is named exactly by its own row; a workload target relates
+    // to its rows the way diagnose relates to the pods it resolved.
+    const rowRelevance: InvestigationEvidenceRelevance = resourceMatchesTarget(
+      builder.target,
+      {
+        kind: "Pod",
+        group: "",
+        namespace: workload.namespace,
+        name: entry.pod,
+      },
+    )
+      ? "target"
+      : workloadRelevance === "target"
+        ? "producer-related"
+        : "broader";
+    addLogs(
+      builder,
+      source,
+      entry,
+      previous,
+      warnings,
+      rowRelevance,
+      workload.namespace,
+    );
+  }
+  if (logsRaw.length === 0) {
+    builder.limit(source, "Workload logs", noStreams, "unknown");
+  }
+}