@skyhook-io/k8s-ui 1.8.10 → 1.8.12

package/src/utils/application-history.ts

@@ -0,0 +1,257 @@
+import type { ResourceRef, TimelineEvent } from '../types/core'
+import { getKindLabel } from './api-resources'
+import type { AppHistory, AppHistoryAnchor, AppSourceRef } from './applications'
+import { isProblematicEvent } from './resource-hierarchy'
+
+export type ApplicationHistoryCategory = 'deployment' | 'change' | 'problem'
+export type ApplicationHistoryRange = '24h' | '7d' | '30d' | 'all'
+
+export interface ApplicationHistoryItem {
+  id: string
+  category: ApplicationHistoryCategory
+  title: string
+  timestamp: string
+  detail?: string
+  status?: string
+  revision?: string
+  initiatedBy?: string
+  count?: number
+  resource?: ResourceRef
+  sourceRef?: AppSourceRef
+}
+
+const ROOT_RUNTIME_KINDS = new Set([
+  'Deployment',
+  'DaemonSet',
+  'StatefulSet',
+  'Rollout',
+  'Job',
+  'CronJob',
+  'Workflow',
+  'CronWorkflow',
+])
+
+const RELATED_RUNTIME_KINDS = new Set([
+  'Service',
+  'Ingress',
+  'Gateway',
+  'HTTPRoute',
+  'GRPCRoute',
+  'TCPRoute',
+  'TLSRoute',
+  'ConfigMap',
+  'Secret',
+  'SealedSecret',
+  'HorizontalPodAutoscaler',
+  'ScaledObject',
+  'ScaledJob',
+  'PersistentVolumeClaim',
+  'PodDisruptionBudget',
+  'NetworkPolicy',
+  'ServiceAccount',
+  'ServiceMonitor',
+  'PodMonitor',
+])
+
+const NORMAL_BATCH_LIFECYCLE_REASONS = new Set([
+  'started',
+  'created',
+  'completed',
+  'complete',
+  'successcriteriamet',
+])
+
+const CONFIG_DATA_KINDS = new Set(['ConfigMap', 'Secret', 'SealedSecret'])
+const CONFIG_DATA_PATH = /^(?:spec\.)?(?:data|stringData|binaryData|encryptedData)(\W|$)/
+const EPHEMERAL_RUN_KINDS = new Set(['Job', 'Workflow'])
+const SOURCE_BURST_WINDOW_MS = 2 * 60 * 1000
+
+const PROBLEM_TITLES: Record<string, string> = {
+  failedscheduling: "Can't be scheduled",
+  failedmount: "Volume can't be mounted",
+  failedattachvolume: "Volume can't be attached",
+  failedpull: 'Image pull failed',
+  errimagepull: 'Image pull failed',
+  imagepullbackoff: 'Image pull back-off',
+  unhealthy: 'Health check failed',
+}
+
+function validTimestamp(value: string | undefined): value is string {
+  return Boolean(value && !value.startsWith('0001-01-01T00:00:00') && Number.isFinite(new Date(value).getTime()))
+}
+
+function sourceMatchesEvent(source: AppSourceRef | undefined, event: TimelineEvent): boolean {
+  if (!source) return false
+  return source.kind.toLowerCase() === event.kind.toLowerCase()
+    && source.namespace === event.namespace
+    && source.name === event.name
+}
+
+function anchorItem(anchor: AppHistoryAnchor, sourceRef: AppSourceRef | undefined, index: number): ApplicationHistoryItem | null {
+  if (!validTimestamp(anchor.timestamp)) return null
+  return {
+    id: `source:${anchor.type}:${anchor.timestamp}:${anchor.revision ?? index}`,
+    category: 'deployment',
+    title: anchor.title,
+    timestamp: anchor.timestamp,
+    detail: anchor.source || anchor.message,
+    status: anchor.status,
+    revision: anchor.revision,
+    initiatedBy: anchor.initiatedBy,
+    sourceRef,
+  }
+}
+
+function eventTitle(event: TimelineEvent, problem: boolean): string {
+  const kind = getKindLabel(event.kind)
+  if (problem) {
+    const reason = event.reason?.toLowerCase()
+    if (reason === 'podscheduled' && event.message?.includes('nodes are available')) return "Can't be scheduled"
+    if (reason === 'failedcreate') {
+      if (event.kind === 'CronJob' || event.kind === 'CronWorkflow') return 'Scheduled run could not be created'
+      if (ROOT_RUNTIME_KINDS.has(event.kind)) return 'Pod could not be created'
+      return `${kind} could not create a resource`
+    }
+    if (EPHEMERAL_RUN_KINDS.has(event.kind)) {
+      if (reason === 'backofflimitexceeded') return `${kind} failed after repeated retries`
+      if (reason === 'deadlineexceeded') return `${kind} exceeded its deadline`
+      if (reason === 'failed') return `${kind} failed`
+    }
+    return PROBLEM_TITLES[reason ?? ''] ?? event.reason ?? `${kind} needs attention`
+  }
+  if (event.eventType === 'add') return `${kind} created`
+  if (event.eventType === 'delete') return `${kind} deleted`
+  if (event.reason && event.reason !== 'Update' && event.reason !== 'Updated') return event.reason
+  return `${kind} updated`
+}
+
+function eventDetail(event: TimelineEvent): string | undefined {
+  const message = event.message?.trim()
+  const summary = event.diff?.summary?.trim()
+  if (message && summary && message !== summary) return `${message} · ${summary}`
+  return message || summary || undefined
+}
+
+function hasDesiredStateChange(event: TimelineEvent): boolean {
+  return Boolean(event.diff?.fields.some(({ path }) => {
+    if (path === 'spec' || path.startsWith('spec.')) return true
+    if (!CONFIG_DATA_KINDS.has(event.kind)) return false
+    return path === 'immutable' || (event.kind === 'Secret' && path === 'type') || CONFIG_DATA_PATH.test(path)
+  }))
+}
+
+function hasConfigurationDataChange(event: TimelineEvent): boolean {
+  return CONFIG_DATA_KINDS.has(event.kind) && Boolean(event.diff?.fields.some(({ path }) =>
+    path === 'immutable' || CONFIG_DATA_PATH.test(path),
+  ))
+}
+
+function isEphemeralRun(event: TimelineEvent): boolean {
+  return EPHEMERAL_RUN_KINDS.has(event.kind) && Boolean(event.owner)
+}
+
+function historyEventItem(event: TimelineEvent): ApplicationHistoryItem | null {
+  if (!validTimestamp(event.timestamp)) return null
+  const unhealthy = event.healthState === 'degraded' || event.healthState === 'unhealthy'
+  const leafRuntimeResource = event.kind === 'Pod' || event.kind === 'ReplicaSet'
+  const reason = event.reason?.toLowerCase()
+  const normalBatchLifecycle = EPHEMERAL_RUN_KINDS.has(event.kind)
+    && event.eventType !== 'Warning'
+    && Boolean(reason && NORMAL_BATCH_LIFECYCLE_REASONS.has(reason))
+  const problem = !normalBatchLifecycle
+    && (isProblematicEvent(event) || (unhealthy && (!leafRuntimeResource || Boolean(event.message?.trim()))))
+  if (!problem && event.source === 'k8s_event') return null
+  if (event.kind === 'Pod' || event.kind === 'ReplicaSet') {
+    if (!problem) return null
+  } else if (!problem && !ROOT_RUNTIME_KINDS.has(event.kind) && !RELATED_RUNTIME_KINDS.has(event.kind)) {
+    return null
+  }
+  if (!problem && event.eventType === 'update' && !hasDesiredStateChange(event)) return null
+  if (!problem && (event.eventType === 'add' || event.eventType === 'delete') && isEphemeralRun(event)) return null
+  const resource = problem && event.owner
+    ? {
+        kind: event.owner.kind,
+        namespace: event.namespace,
+        name: event.owner.name,
+      }
+    : {
+        kind: event.kind,
+        namespace: event.namespace,
+        name: event.name,
+        group: event.apiVersion?.includes('/') ? event.apiVersion.split('/')[0] : undefined,
+      }
+  return {
+    id: `event:${event.id}`,
+    category: problem ? 'problem' : 'change',
+    title: eventTitle(event, problem),
+    timestamp: event.timestamp,
+    detail: eventDetail(event),
+    count: event.count,
+    resource,
+  }
+}
+
+function warningKey(item: ApplicationHistoryItem): string {
+  const resource = item.resource
+  return `${item.title}\u0000${resource?.kind ?? ''}\u0000${resource?.namespace ?? ''}\u0000${resource?.name ?? ''}\u0000${item.detail ?? ''}`
+}
+
+export function buildApplicationHistoryItems(
+  history: AppHistory | undefined,
+  events: TimelineEvent[],
+): ApplicationHistoryItem[] {
+  const anchorsByChange = new Map<string, AppHistoryAnchor>()
+  for (const anchor of history?.anchors ?? []) {
+    if (!validTimestamp(anchor.timestamp)) continue
+    const key = `${anchor.type}\u0000${anchor.title}\u0000${anchor.timestamp}\u0000${anchor.revision ?? ''}`
+    const existing = anchorsByChange.get(key)
+    if (!existing) {
+      anchorsByChange.set(key, anchor)
+      continue
+    }
+    anchorsByChange.set(key, {
+      ...existing,
+      status: anchor.status ?? existing.status,
+      source: existing.source ?? anchor.source,
+      message: anchor.message ?? existing.message,
+      initiatedBy: anchor.initiatedBy ?? existing.initiatedBy,
+    })
+  }
+  const anchors = [...anchorsByChange.values()]
+    .map((anchor, index) => anchorItem(anchor, history?.sourceRef, index))
+    .filter((item): item is ApplicationHistoryItem => item !== null)
+  const hasAnchors = anchors.length > 0
+  const anchorTimes = anchors.map(({ timestamp }) => new Date(timestamp).getTime())
+  const warningItems = new Map<string, ApplicationHistoryItem>()
+  const runtimeItems: ApplicationHistoryItem[] = []
+
+  for (const event of events) {
+    const item = historyEventItem(event)
+    if (!item) continue
+    if (item.category !== 'problem' && sourceMatchesEvent(history?.sourceRef, event)) continue
+    if (item.category !== 'problem') {
+      const eventTime = new Date(item.timestamp).getTime()
+      if (!hasConfigurationDataChange(event)
+        && hasAnchors
+        && anchorTimes.some((anchorTime) => Math.abs(eventTime - anchorTime) <= SOURCE_BURST_WINDOW_MS)) continue
+      runtimeItems.push(item)
+      continue
+    }
+    const key = warningKey(item)
+    const existing = warningItems.get(key)
+    if (!existing) {
+      warningItems.set(key, item)
+      continue
+    }
+    existing.count = Math.max(existing.count ?? 1, item.count ?? 1)
+    if (new Date(item.timestamp).getTime() > new Date(existing.timestamp).getTime()) {
+      existing.timestamp = item.timestamp
+      existing.id = item.id
+    }
+  }
+
+  return [...anchors, ...runtimeItems, ...warningItems.values()].sort((a, b) => {
+    const byTime = new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    return byTime || a.id.localeCompare(b.id)
+  })
+}

package/src/utils/application-topology.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, it } from 'vitest'
+import type { GitOpsResourceTree, Topology } from '../types'
+import { collapseStableReplicaSets, deploymentInventoryFromGitOps, deploymentInventoryFromHelm, layerDeploymentInventory, topologyGroup } from './application-topology'
+
+const topology: Topology = {
+  nodes: [
+    { id: 'deployment/default/api', kind: 'Deployment', name: 'api', status: 'healthy', data: { namespace: 'default', apiVersion: 'apps/v1' } },
+    { id: 'service/default/external', kind: 'Service', name: 'external', status: 'healthy', data: { namespace: 'default', apiVersion: 'v1' } },
+  ],
+  edges: [],
+}
+
+it('resolves the stored API group for source-only CRD nodes', () => {
+  expect(topologyGroup({
+    id: 'source/prometheusrule',
+    kind: 'PrometheusRule',
+    name: 'alerts',
+    status: 'healthy',
+    data: { namespace: 'monitoring', sourceGroup: 'monitoring.coreos.com' },
+  })).toBe('monitoring.coreos.com')
+})
+
+function inventory(warnings?: string[]): GitOpsResourceTree {
+  const root = { id: 'root', ref: { group: 'argoproj.io', kind: 'Application', namespace: 'argocd', name: 'api' }, role: 'root' as const, tool: 'argocd' as const }
+  return {
+    root,
+    warnings,
+    edges: [],
+    nodes: [
+      root,
+      { id: 'deployment', ref: { group: 'apps', kind: 'Deployment', namespace: 'default', name: 'api' }, role: 'declared', tool: 'argocd' },
+      { id: 'config', ref: { kind: 'ConfigMap', namespace: 'default', name: 'api-config' }, role: 'declared', tool: 'argocd' },
+    ],
+  }
+}
+
+describe('layerDeploymentInventory', () => {
+  it('separates overlapping, runtime-only, and managed-only resources', () => {
+    const result = layerDeploymentInventory(topology, deploymentInventoryFromGitOps(inventory())!, 'Argo CD')
+
+    expect(result.managedRuntimeCount).toBe(1)
+    expect(result.runtimeOnlyCount).toBe(1)
+    expect(result.managedOnly.map((node) => node.name)).toEqual(['api-config'])
+    expect(result.topology.nodes[0].data?.deploymentMembership).toBeUndefined()
+    expect(result.topology.nodes[1].data?.deploymentMembership).toBe('runtime-only')
+    expect(result.topology.nodes[2]).toMatchObject({ kind: 'ConfigMap', name: 'api-config', data: { deploymentMembership: 'source-only' } })
+  })
+
+  it('does not claim runtime-only membership for a partial inventory', () => {
+    const result = layerDeploymentInventory(topology, deploymentInventoryFromGitOps(inventory(['Some resources are hidden']))!, 'Argo CD')
+
+    expect(result.inventoryComplete).toBe(false)
+    expect(result.runtimeOnlyCount).toBe(0)
+    expect(result.topology.nodes[1].data?.deploymentMembership).toBeUndefined()
+  })
+
+  it('does not claim runtime-only membership for Helm without a completeness signal', () => {
+    const helmInventory = deploymentInventoryFromHelm([{
+      apiVersion: 'apps/v1',
+      kind: 'Deployment',
+      namespace: 'default',
+      name: 'api',
+      status: 'ready',
+    }])!
+    const result = layerDeploymentInventory(topology, helmInventory, 'Helm')
+
+    expect(result.inventoryComplete).toBe(false)
+    expect(result.runtimeOnlyCount).toBe(0)
+    expect(result.topology.nodes[1].data?.deploymentMembership).toBeUndefined()
+  })
+
+  it('adds no membership markers when source and runtime agree', () => {
+    const matchingTopology: Topology = {
+      nodes: [topology.nodes[0]],
+      edges: [],
+    }
+    const matchingInventory = inventory()
+    matchingInventory.nodes = matchingInventory.nodes.filter((node) => node.id !== 'config')
+
+    const result = layerDeploymentInventory(matchingTopology, deploymentInventoryFromGitOps(matchingInventory)!, 'Argo CD')
+
+    expect(result.runtimeOnlyCount).toBe(0)
+    expect(result.managedOnly).toEqual([])
+    expect(result.topology.nodes[0].data?.deploymentMembership).toBeUndefined()
+  })
+
+  it('does not merge same-named resources from different CRD groups', () => {
+    const collisionTopology: Topology = {
+      nodes: [{ id: 'service/default/api', kind: 'Service', name: 'api', status: 'healthy', data: { namespace: 'default', apiVersion: 'serving.knative.dev/v1' } }],
+      edges: [],
+    }
+    const result = layerDeploymentInventory(collisionTopology, deploymentInventoryFromGitOps({
+      root: inventory().root,
+      edges: [],
+      nodes: [
+        inventory().root,
+        { id: 'core-service', ref: { kind: 'Service', namespace: 'default', name: 'api' }, role: 'declared', tool: 'argocd' },
+      ],
+    })!, 'Argo CD')
+
+    expect(result.managedRuntimeCount).toBe(0)
+    expect(result.runtimeOnlyCount).toBe(1)
+    expect(result.managedOnly.map((node) => node.id)).toEqual(['core-service'])
+  })
+
+  it('does not classify synthetic graph nodes as runtime-only resources', () => {
+    const syntheticTopology: Topology = {
+      nodes: [
+        { id: 'podgroup/default/api', kind: 'PodGroup', name: 'api', status: 'healthy', data: { namespace: 'default' } },
+        { id: 'internet', kind: 'Internet', name: 'Internet', status: 'healthy', data: {} },
+      ],
+      edges: [],
+    }
+    const result = layerDeploymentInventory(syntheticTopology, deploymentInventoryFromGitOps(inventory())!, 'Argo CD')
+
+    expect(result.runtimeOnlyCount).toBe(0)
+    expect(result.topology.nodes.slice(0, 2).every((node) => node.data?.deploymentMembership === undefined)).toBe(true)
+  })
+
+  it('groups repeated source-only resources so large bundles remain readable', () => {
+    const largeInventory = inventory()
+    largeInventory.nodes = [
+      largeInventory.root,
+      ...Array.from({ length: 5 }, (_, index) => ({
+        id: `rule-${index}`,
+        ref: { group: 'monitoring.coreos.com', kind: 'PrometheusRule', namespace: 'monitoring', name: `rule-${index}` },
+        role: 'declared' as const,
+        tool: 'argocd' as const,
+      })),
+    ]
+
+    const result = layerDeploymentInventory({ nodes: [], edges: [] }, deploymentInventoryFromGitOps(largeInventory)!, 'Argo CD')
+
+    expect(result.managedOnly).toHaveLength(5)
+    expect(result.topology.nodes).toHaveLength(1)
+    expect(result.topology.nodes[0]).toMatchObject({ kind: 'PrometheusRule', data: { sourceInventoryGroup: true, sourceInventoryCount: 5 } })
+  })
+
+  it('summarizes a large source-only inventory outside the graph', () => {
+    const largeInventory = inventory()
+    largeInventory.nodes = [
+      largeInventory.root,
+      ...Array.from({ length: 10 }, (_, index) => ({
+        id: `rule-${index}`,
+        ref: { group: 'monitoring.coreos.com', kind: 'PrometheusRule', namespace: 'monitoring', name: `rule-${index}` },
+        role: 'declared' as const,
+        tool: 'argocd' as const,
+      })),
+      ...Array.from({ length: 5 }, (_, index) => ({
+        id: `config-${index}`,
+        ref: { kind: 'ConfigMap', namespace: 'monitoring', name: `config-${index}` },
+        role: 'declared' as const,
+        tool: 'argocd' as const,
+      })),
+    ]
+
+    const result = layerDeploymentInventory({ nodes: [], edges: [] }, deploymentInventoryFromGitOps(largeInventory)!, 'Argo CD')
+
+    expect(result.managedOnly).toHaveLength(15)
+    expect(result.topology.nodes).toHaveLength(0)
+    expect(result.managedOnlySummary).toBe('10 PrometheusRules · 5 ConfigMaps')
+  })
+})
+
+describe('collapseStableReplicaSets', () => {
+  const replicaSetTopology: Topology = {
+    nodes: [
+      { id: 'deployment/default/api', kind: 'Deployment', name: 'api', status: 'healthy', data: { namespace: 'default' } },
+      { id: 'replicaset/default/api-abc', kind: 'ReplicaSet', name: 'api-abc', status: 'healthy', data: { namespace: 'default', readyReplicas: 2, totalReplicas: 2 } },
+      { id: 'pod/default/api-1', kind: 'Pod', name: 'api-1', status: 'healthy', data: { namespace: 'default' } },
+    ],
+    edges: [
+      { id: 'deployment-rs', source: 'deployment/default/api', target: 'replicaset/default/api-abc', type: 'manages' },
+      { id: 'rs-pod', source: 'replicaset/default/api-abc', target: 'pod/default/api-1', type: 'manages' },
+    ],
+  }
+
+  it('collapses a stable single ReplicaSet and rewires its pods', () => {
+    const result = collapseStableReplicaSets(replicaSetTopology, new Set())
+    expect(result.nodes.map((node) => node.kind)).toEqual(['Deployment', 'Pod'])
+    expect(result.edges).toContainEqual(expect.objectContaining({ source: 'deployment/default/api', target: 'pod/default/api-1' }))
+    expect(result.nodes[0].data).toMatchObject({ replicaSetCount: 1, replicaSetsCollapsed: true })
+  })
+
+  it('shows the ReplicaSet when the developer expands it', () => {
+    const result = collapseStableReplicaSets(replicaSetTopology, new Set(['deployment/default/api']))
+    expect(result.nodes.map((node) => node.kind)).toEqual(['Deployment', 'ReplicaSet', 'Pod'])
+    expect(result.nodes[0].data).toMatchObject({ replicaSetCount: 1, replicaSetsCollapsed: false })
+  })
+
+  it('keeps an unhealthy ReplicaSet visible automatically', () => {
+    const unhealthy = {
+      ...replicaSetTopology,
+      nodes: replicaSetTopology.nodes.map((node) => node.kind === 'ReplicaSet' ? { ...node, status: 'degraded' as const } : node),
+    }
+    expect(collapseStableReplicaSets(unhealthy, new Set()).nodes.map((node) => node.kind)).toContain('ReplicaSet')
+  })
+})