@skyhook-io/k8s-ui 1.8.14 → 1.9.0

package/src/components/resources/ResourcesView.tsx

@@ -133,13 +133,14 @@ import {
   podMatchesProblemCategory,
   SEVERITY_DOT_COLOR,
 } from './resource-utils'
-import { SEVERITY_BADGE, EVENT_TYPE_COLORS, SEVERITY_TEXT } from '../../utils/badge-colors'
+import { SEVERITY_BADGE, EVENT_TYPE_COLORS } from '../../utils/badge-colors'
 import { pluralize } from '../../utils/pluralize'
 import { getPodGpuCount, getNodeGpuCount } from '../../utils/extended-resources'
 import { type CustomColumnDef, type CustomColumnSource, customColumnKey, readCustomColumnValue, sanitizeCustomColumnDefs } from '../../utils/custom-columns'
 import { FreshnessControl, type FreshnessConnection } from '../ui/FreshnessControl'
 import { Tooltip } from '../ui/Tooltip'
 import { AuditBadgeTooltip, type AuditBadgeMessage } from '../audit/AuditBadgeTooltip'
+import { SEVERITY_TEXT_CLASS } from '../checks/severity'
 // CRD-specific cell components (extracted)
 import { GitRepositoryCell, OCIRepositoryCell, HelmRepositoryCell, KustomizationCell, FluxHelmReleaseCell, FluxAlertCell } from './renderers/flux-cells'
 import { ArgoApplicationCell, ArgoApplicationSetCell, ArgoAppProjectCell } from './renderers/argo-cells'
@@ -1829,8 +1830,8 @@ interface ResourcesViewData {
   onNavigate?: (path: string, options?: { replace?: boolean }) => void
   certExpiry?: Record<string, { expired?: boolean; daysLeft: number }>
   certExpiryError?: boolean
-  // Cluster Audit findings for the listed kind, keyed by "namespace/name" (the
-  // list shows one kind at a time, so ns/name is unambiguous). Host-injected.
+  /** Cluster Audit findings keyed by "namespace/name". Raw compatibility
+   *  counts render danger as High and warning as Medium. */
   auditBadges?: Record<string, { danger: number; warning: number; messages?: AuditBadgeMessage[] }>
   onOpenLogs?: (params: { namespace: string; podName: string; containers: string[]; containerName?: string }) => void
   onOpenWorkloadLogs?: (params: { namespace: string; workloadKind: string; workloadName: string }) => void
@@ -1889,7 +1890,8 @@ interface ResourcesViewProps {
   topNodeMetrics?: TopNodeMetrics[]
   certExpiry?: Record<string, { expired?: boolean; daysLeft: number }>
   certExpiryError?: boolean
-  // Cluster Audit findings for the selected kind, keyed by "namespace/name".
+  /** Cluster Audit findings keyed by "namespace/name". Raw compatibility
+   *  counts render danger as High and warning as Medium. */
   auditBadges?: Record<string, { danger: number; warning: number; messages?: AuditBadgeMessage[] }>
   // Pinned kinds
   pinned?: Array<{ name: string; kind: string; group: string }>
@@ -5381,8 +5383,8 @@ function CellContent({ resource, kind, column, group, majorityNodeMinorVersion,
         {auditTotal > 0 && audit && (
           <Tooltip content={audit.messages && audit.messages.length > 0
             ? <AuditBadgeTooltip messages={audit.messages} />
-            : `${auditTotal} audit ${auditTotal === 1 ? 'finding' : 'findings'}${audit.danger > 0 ? ` · ${audit.danger} danger` : ''}`}>
-            <span className={clsx('shrink-0 inline-flex items-center gap-0.5 text-[10px] font-medium cursor-help', audit.danger > 0 ? SEVERITY_TEXT.error : SEVERITY_TEXT.warning)}>
+            : `${auditTotal} audit ${auditTotal === 1 ? 'finding' : 'findings'}${audit.danger > 0 ? ` · ${audit.danger} high` : ''}${audit.warning > 0 ? ` · ${audit.warning} medium` : ''}`}>
+            <span className={clsx('shrink-0 inline-flex items-center gap-0.5 text-[10px] font-medium cursor-help', audit.danger > 0 ? SEVERITY_TEXT_CLASS.high : SEVERITY_TEXT_CLASS.medium)}>
               <AlertTriangle className="w-3 h-3" />
               {auditTotal}
             </span>
@@ -6265,7 +6267,7 @@ function ServiceCell({ resource, column }: { resource: any; column: string }) {
       const flagged = auditBadges?.[`${meta.namespace || ''}/${meta.name}`]
       if (flagged && flagged.danger + flagged.warning > 0) {
         return (
-          <span className={clsx('badge', flagged.danger > 0 ? 'status-unhealthy' : 'status-degraded')}>
+          <span className={clsx('badge', flagged.danger > 0 ? 'status-alert' : 'status-degraded')}>
             No endpoints
           </span>
         )

package/src/components/resources/get-pod-phase-display.test.ts

@@ -26,6 +26,210 @@ describe('getPodStatus', () => {
     }
     expect(getPodStatus(crashing).level).toBe('unhealthy')
   })
+
+  it('deranks a serving container with unsettled crash history', () => {
+    const recovered = {
+      status: {
+        phase: 'Running',
+        containerStatuses: [{
+          name: 'app',
+          ready: true,
+          restartCount: 2,
+          state: { running: {} },
+          lastState: { terminated: { reason: 'Error', exitCode: 1 } },
+        }],
+      },
+    }
+    expect(getPodStatus(recovered)).toMatchObject({ text: 'Restarted (2)', level: 'degraded' })
+    expect(getPodPhaseDisplay(recovered)).toMatchObject({
+      text: 'Running — Recently restarted (2 restarts)',
+      level: 'degraded',
+    })
+  })
+
+  it('keeps a non-serving container with crash history unhealthy', () => {
+    const down = {
+      status: {
+        phase: 'Running',
+        containerStatuses: [{
+          name: 'app',
+          ready: false,
+          restartCount: 2,
+          state: { running: {} },
+          lastState: { terminated: { reason: 'Error', exitCode: 1 } },
+        }],
+      },
+    }
+    expect(getPodStatus(down).level).toBe('unhealthy')
+    expect(getPodPhaseDisplay(down).level).toBe('unhealthy')
+  })
+
+  it('keeps a readiness-probed flapper visible until the settle window', () => {
+    const flapper = {
+      spec: { containers: [{ name: 'app', readinessProbe: { tcpSocket: { port: 8080 } } }] },
+      status: {
+        phase: 'Running',
+        containerStatuses: [{
+          name: 'app',
+          ready: true,
+          restartCount: 2,
+          state: { running: { startedAt: new Date(Date.now() - 60 * 1000).toISOString() } },
+          lastState: {
+            terminated: {
+              reason: 'Error',
+              exitCode: 1,
+              finishedAt: new Date(Date.now() - 60 * 1000).toISOString(),
+            },
+          },
+        }],
+      },
+    }
+    expect(getPodStatus(flapper).level).toBe('degraded')
+
+    const settled = structuredClone(flapper)
+    settled.status.containerStatuses[0].state.running.startedAt = new Date(Date.now() - 6 * 60 * 1000).toISOString()
+    expect(getPodStatus(settled).level).toBe('healthy')
+  })
+
+  it('lets an active sibling failure outrank recovered crash history', () => {
+    const pod = {
+      status: {
+        phase: 'Running',
+        containerStatuses: [
+          {
+            name: 'app',
+            ready: true,
+            restartCount: 2,
+            state: { running: {} },
+            lastState: { terminated: { reason: 'Error', exitCode: 1 } },
+          },
+          {
+            name: 'image',
+            ready: false,
+            state: { waiting: { reason: 'ImagePullBackOff' } },
+          },
+        ],
+      },
+    }
+    expect(getPodStatus(pod)).toMatchObject({ text: 'ImagePullBackOff', level: 'unhealthy' })
+    expect(getPodPhaseDisplay(pod)).toMatchObject({
+      text: 'Running — ImagePullBackOff',
+      level: 'unhealthy',
+    })
+  })
+
+  it('keeps a not-ready sibling visible ahead of recovered crash history', () => {
+    const pod = {
+      status: {
+        phase: 'Running',
+        containerStatuses: [
+          {
+            name: 'app',
+            ready: true,
+            restartCount: 1,
+            state: { running: {} },
+            lastState: { terminated: { reason: 'Error', exitCode: 1 } },
+          },
+          {
+            name: 'sidecar',
+            ready: false,
+            restartCount: 0,
+            state: { running: {} },
+          },
+        ],
+      },
+    }
+    expect(getPodStatus(pod)).toMatchObject({ text: 'Running (1/2)', level: 'degraded' })
+    expect(getPodPhaseDisplay(pod)).toMatchObject({
+      text: 'Running — Not Ready (1/2)',
+      level: 'degraded',
+    })
+  })
+
+  it('counts only crash history still inside the settle window', () => {
+    const pod = {
+      status: {
+        phase: 'Running',
+        containerStatuses: [
+          {
+            name: 'app',
+            ready: true,
+            restartCount: 1,
+            state: { running: {} },
+            lastState: { terminated: { reason: 'Error', exitCode: 1 } },
+          },
+          {
+            name: 'settled-sidecar',
+            ready: true,
+            restartCount: 40,
+            state: { running: { startedAt: new Date(Date.now() - 60 * 60 * 1000).toISOString() } },
+            lastState: {
+              terminated: {
+                reason: 'Error',
+                exitCode: 1,
+                finishedAt: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+              },
+            },
+          },
+        ],
+      },
+    }
+    expect(getPodStatus(pod)).toMatchObject({ text: 'Restarted (1)', level: 'degraded' })
+    expect(getPodPhaseDisplay(pod)).toMatchObject({
+      text: 'Running — Recently restarted (1 restart)',
+      level: 'degraded',
+    })
+  })
+
+  it('does not revive old crash history after a long node outage', () => {
+    const pod = {
+      status: {
+        phase: 'Running',
+        containerStatuses: [{
+          name: 'app',
+          ready: true,
+          restartCount: 5,
+          state: { running: { startedAt: new Date(Date.now() - 30 * 1000).toISOString() } },
+          lastState: {
+            terminated: {
+              reason: 'Error',
+              exitCode: 1,
+              finishedAt: new Date(Date.now() - 3 * 60 * 60 * 1000).toISOString(),
+            },
+          },
+        }],
+      },
+    }
+    expect(getPodStatus(pod)).toMatchObject({ text: 'Running', level: 'healthy' })
+
+    const maxBackoffContinuation = structuredClone(pod)
+    maxBackoffContinuation.status.containerStatuses[0].state.running.startedAt =
+      new Date(Date.now() - 60 * 1000).toISOString()
+    maxBackoffContinuation.status.containerStatuses[0].lastState.terminated.finishedAt =
+      new Date(Date.now() - 6 * 60 * 1000).toISOString()
+    expect(getPodStatus(maxBackoffContinuation).level).toBe('degraded')
+  })
+
+  it('shows Terminating instead of a recovered-crash warning during graceful deletion', () => {
+    const terminating = {
+      metadata: { deletionTimestamp: new Date().toISOString() },
+      status: {
+        phase: 'Running',
+        containerStatuses: [{
+          name: 'app',
+          ready: true,
+          restartCount: 2,
+          state: { running: {} },
+          lastState: { terminated: { reason: 'Error', exitCode: 1 } },
+        }],
+      },
+    }
+    expect(getPodStatus(terminating)).toMatchObject({ text: 'Terminating', level: 'neutral' })
+    expect(getPodPhaseDisplay(terminating)).toMatchObject({
+      text: 'Running — Terminating',
+      level: 'neutral',
+    })
+  })
 })
 
 const podRunningHealthy = {

package/src/components/resources/resource-utils.ts

@@ -171,6 +171,63 @@ function firstFatalContainer(pod: any): { name: string; reason: string } | null
   return null
 }
 
+const CRASH_SETTLE_MS = 5 * 60 * 1000
+const STALE_CRASH_STATE_GAP_MS = 2 * CRASH_SETTLE_MS
+
+function stableCrashHistory(cs: any): boolean {
+  if (!cs?.restartCount) return false
+
+  const startedAt = cs?.state?.running?.startedAt
+  const finishedAt = cs?.lastState?.terminated?.finishedAt
+  if (startedAt) {
+    const startedAtMs = new Date(startedAt).getTime()
+    if (Number.isFinite(startedAtMs) && Date.now() - startedAtMs >= CRASH_SETTLE_MS) return false
+    if (finishedAt) {
+      const finishedAtMs = new Date(finishedAt).getTime()
+      if (
+        Number.isFinite(startedAtMs)
+        && Number.isFinite(finishedAtMs)
+        && startedAtMs - finishedAtMs > STALE_CRASH_STATE_GAP_MS
+      ) return false
+    }
+  } else if (cs?.state?.running && finishedAt) {
+    const finishedAtMs = new Date(finishedAt).getTime()
+    if (Number.isFinite(finishedAtMs) && Date.now() - finishedAtMs >= CRASH_SETTLE_MS) return false
+  }
+  if (cs?.state?.terminated?.exitCode === 0) return false
+
+  const term = cs?.lastState?.terminated
+  if (!term || term.reason === 'OOMKilled') return false
+  return term.reason === 'CrashLoopBackOff' || term.reason === 'Error' || Number(term.exitCode ?? 0) !== 0
+}
+
+function podCrashHistoryLevel(pod: any): 'degraded' | 'unhealthy' | null {
+  let degraded = false
+  for (const cs of pod?.status?.containerStatuses || []) {
+    if (!stableCrashHistory(cs)) continue
+    if (!(cs?.state?.running && cs?.ready)) return 'unhealthy'
+    degraded = true
+  }
+
+  const initContainers = pod?.spec?.initContainers || []
+  for (const cs of pod?.status?.initContainerStatuses || []) {
+    const spec = initContainers.find((c: any) => c?.name === cs?.name)
+    const restartable = spec?.restartPolicy === 'Always'
+    if (!stableCrashHistory(cs)) continue
+    if (!(restartable && cs?.state?.running && cs?.ready)) return 'unhealthy'
+    degraded = true
+  }
+  return degraded ? 'degraded' : null
+}
+
+function podCrashRestartTotal(pod: any): number {
+  const main = pod?.status?.containerStatuses || []
+  const init = pod?.status?.initContainerStatuses || []
+  return [...main, ...init]
+    .filter(stableCrashHistory)
+    .reduce((sum, cs) => sum + (cs?.restartCount || 0), 0)
+}
+
 export function getPodStatus(pod: any): StatusBadge {
   const phase = pod.status?.phase || 'Unknown'
   const containerStatuses = pod.status?.containerStatuses || []
@@ -194,6 +251,17 @@ export function getPodStatus(pod: any): StatusBadge {
     return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
   }
 
+  const crashHistoryLevel = phase !== 'Succeeded' && phase !== 'Unknown'
+    ? podCrashHistoryLevel(pod)
+    : null
+  if (crashHistoryLevel === 'unhealthy') {
+    return {
+      text: 'CrashLoopBackOff',
+      color: healthColors.unhealthy,
+      level: 'unhealthy',
+    }
+  }
+
   // Terminating: neutral while gracefully shutting down, degraded once stuck
   // (a wedged finalizer / preStop hook holding the pod open).
   if (pod.metadata?.deletionTimestamp) {
@@ -203,6 +271,16 @@ export function getPodStatus(pod: any): StatusBadge {
     return { text: 'Terminating', color: healthColors.neutral, level: 'neutral' }
   }
 
+  const hasUnsettledMainContainer = containerStatuses.some((c: any) => !containerSettledOk(c))
+  if (crashHistoryLevel === 'degraded' && !hasUnsettledMainContainer) {
+    const restarts = podCrashRestartTotal(pod)
+    return {
+      text: `Restarted (${restarts})`,
+      color: healthColors.degraded,
+      level: 'degraded',
+    }
+  }
+
   switch (phase) {
     case 'Running': {
       // Degrade only on containers that are neither ready nor successfully done —
@@ -288,6 +366,18 @@ export function getPodPhaseDisplay(pod: any): PodPhaseDisplay {
     return { phase, text: 'Failed', level: 'unhealthy' }
   }
 
+  const crashHistoryLevel = phase !== 'Succeeded' && phase !== 'Unknown'
+    ? podCrashHistoryLevel(pod)
+    : null
+  if (crashHistoryLevel === 'unhealthy') {
+    return {
+      phase,
+      text: `${phase} — CrashLoopBackOff`,
+      level: 'unhealthy',
+      hint: 'At least one container has crash history and is not serving now.',
+    }
+  }
+
   // Terminating: neutral while gracefully shutting down, degraded once stuck.
   if (pod?.metadata?.deletionTimestamp) {
     const stuck = minutesSince(pod.metadata.deletionTimestamp) >= TERMINATING_STUCK_MINUTES
@@ -301,6 +391,17 @@ export function getPodPhaseDisplay(pod: any): PodPhaseDisplay {
     }
   }
 
+  const hasUnsettledMainContainer = containerStatuses.some((c) => !containerSettledOk(c))
+  if (crashHistoryLevel === 'degraded' && !hasUnsettledMainContainer) {
+    const crashRestarts = podCrashRestartTotal(pod)
+    return {
+      phase,
+      text: `${phase} — Recently restarted (${crashRestarts} restart${crashRestarts === 1 ? '' : 's'})`,
+      level: 'degraded',
+      hint: 'Containers are ready now but remain in the crash settle window.',
+    }
+  }
+
   switch (phase) {
     case 'Running': {
       // A successfully-completed container (exit 0) is settled, not "not ready" —