@skyhook-io/k8s-ui 1.16.2 → 1.17.0

package/src/utils/node-lifecycle.ts

@@ -0,0 +1,77 @@
+import type { HealthLevel } from '../components/resources/resource-utils'
+
+const REMOVAL_ACTORS: Record<string, string> = {
+  ToBeDeletedByClusterAutoscaler: 'cluster autoscaler',
+  'karpenter.sh/disrupted': 'Karpenter',
+}
+
+const NETWORK_UNAVAILABLE_GRACE_MS = 2 * 60_000
+
+export const NODE_REMOVAL_WARNING_MS = 10 * 60_000
+export const NODE_REMOVAL_CRITICAL_MS = 30 * 60_000
+
+export interface NodeLifecycleState {
+  label: string
+  level: HealthLevel
+  removing: boolean
+  actor?: string
+  startedAt?: number
+  readinessFailed: boolean
+  delayed: boolean
+  problems: string[]
+}
+
+export type NodeLifecycleObservation = Omit<NodeLifecycleState, 'startedAt' | 'problems'> & {
+  startedAt?: string
+  problems?: string[]
+}
+
+export function getNodeLifecycle(node: any, now = Date.now()): NodeLifecycleState {
+  const ready = node?.status?.conditions?.find((condition: any) => condition.type === 'Ready')
+  const createdAt = Date.parse(node?.metadata?.creationTimestamp)
+  const validTime = (timestamp: number) => Number.isFinite(timestamp) && timestamp > 0 && timestamp <= now && (!Number.isFinite(createdAt) || timestamp >= createdAt) ? timestamp : undefined
+  let startedAt = validTime(Date.parse(node?.metadata?.deletionTimestamp))
+  let removing = Boolean(node?.metadata?.deletionTimestamp)
+  let actor: string | undefined
+  let candidate = false
+  for (const taint of node?.spec?.taints ?? []) {
+    if (taint.key === 'DeletionCandidateOfClusterAutoscaler' && taint.effect === 'PreferNoSchedule') candidate = true
+    if (taint.effect !== 'NoSchedule') continue
+    const source = REMOVAL_ACTORS[taint.key]
+    if (!source) continue
+    removing = true
+    actor = source
+    if (taint.key === 'ToBeDeletedByClusterAutoscaler' && /^\d+$/.test(taint.value ?? '')) {
+      const markerTime = validTime(Number(taint.value) * 1000)
+      if (markerTime !== undefined && (startedAt === undefined || markerTime < startedAt)) startedAt = markerTime
+    }
+  }
+  const readyTime = Date.parse(ready?.lastTransitionTime)
+  const readinessFailed = Boolean(ready && ready.status !== 'True' && !(removing && startedAt !== undefined && Number.isFinite(readyTime) && readyTime >= startedAt && readyTime <= now))
+  const delayed = removing && startedAt !== undefined && now - startedAt >= NODE_REMOVAL_WARNING_MS
+  let label = 'Unknown'
+  let level: HealthLevel = 'unknown'
+  if (removing) {
+    label = actor ? `Removing (${actor})` : 'Removing'
+    level = readinessFailed || (delayed && now - startedAt! >= NODE_REMOVAL_CRITICAL_MS) ? 'unhealthy' : delayed ? 'degraded' : 'neutral'
+  } else if (readinessFailed) {
+    label = 'NotReady'
+    level = 'unhealthy'
+  } else if (ready?.status === 'True') {
+    label = node?.spec?.unschedulable ? 'Cordoned' : candidate ? 'Scale-down candidate' : 'Ready'
+    level = node?.spec?.unschedulable ? 'degraded' : candidate ? 'neutral' : 'healthy'
+  }
+  const problems: string[] = []
+  if (removing && readinessFailed) label += ' · NotReady'
+  const problemLabels: Record<string, string> = { MemoryPressure: 'Memory pressure', DiskPressure: 'Disk pressure', PIDPressure: 'PID pressure', NetworkUnavailable: 'Network unavailable' }
+  for (const condition of node?.status?.conditions ?? []) {
+    if (condition.status !== 'True' || !problemLabels[condition.type]) continue
+    const conditionTime = Date.parse(condition.lastTransitionTime)
+    if (condition.type === 'NetworkUnavailable' && Number.isFinite(conditionTime) && conditionTime <= now && now - conditionTime < NETWORK_UNAVAILABLE_GRACE_MS) continue
+    problems.push(condition.type)
+    label += ` · ${problemLabels[condition.type]}`
+    if (condition.type !== 'NetworkUnavailable') level = 'unhealthy'
+    else if (level !== 'unhealthy') level = 'degraded'
+  }
+  return { label, level, removing, actor, startedAt, readinessFailed, delayed, problems }
+}

package/src/utils/resource-hierarchy.test.ts

@@ -1528,3 +1528,35 @@ describe('structural app members survive the window filter', () => {
     expect(isChildVisibleInWindow(stray, 0, 1000, { pinned: false, userExpanded: false })).toBe(false)
   })
 })
+
+describe('uses edges in the timeline hierarchy', () => {
+  const node = (kind: string, apiVersion: string, name: string) => ({
+    id: `${kind.toLowerCase()}/team/${name}`, kind, name, status: 'healthy', data: { namespace: 'team', apiVersion },
+  })
+  const topology = {
+    nodes: [
+      node('HorizontalPodAutoscaler', 'autoscaling/v2', 'web'),
+      node('Deployment', 'apps/v1', 'web'),
+      node('Certificate', 'cert-manager.io/v1', 'tls'),
+      node('Issuer', 'cert-manager.io/v1', 'ca'),
+    ],
+    edges: [
+      { id: 'hpa', source: 'horizontalpodautoscaler/team/web', target: 'deployment/team/web', type: 'uses' },
+      { id: 'issuer', source: 'certificate/team/tls', target: 'issuer/team/ca', type: 'uses' },
+    ],
+  } as unknown as Topology
+  const events = [
+    changeEvent('HorizontalPodAutoscaler', 'team', 'web', { apiVersion: 'autoscaling/v2' }),
+    changeEvent('Deployment', 'team', 'web', { apiVersion: 'apps/v1' }),
+    changeEvent('Certificate', 'team', 'tls', { apiVersion: 'cert-manager.io/v1' }),
+    changeEvent('Issuer', 'team', 'ca', { apiVersion: 'cert-manager.io/v1' }),
+  ]
+
+  it('files an autoscaler under its workload but not a dependent under its dependency', () => {
+    const lanes = buildResourceHierarchy({ events, topology, grouping: 'owner' })
+    const top = lanes.map(lane => `${lane.kind}/${lane.name}`).sort()
+    expect(top).toEqual(['Certificate/tls', 'Deployment/web', 'Issuer/ca'])
+    const deployment = lanes.find(lane => lane.kind === 'Deployment')!
+    expect(deployment.children?.map(child => child.kind)).toEqual(['HorizontalPodAutoscaler'])
+  })
+})

package/src/utils/resource-hierarchy.ts

@@ -699,6 +699,7 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
 
   // Source 2: Topology edges (for Service→Deployment, Ingress→Service, ConfigMap→Deployment).
   if (topology?.edges) {
+    const topologyNodeById = new Map(topology.nodes?.map(node => [node.id, node]) ?? [])
     for (const edge of topology.edges) {
       const sourceId = topologyLaneIdByNodeId.get(edge.source)
       const targetId = topologyLaneIdByNodeId.get(edge.target)
@@ -777,8 +778,15 @@ export function buildResourceHierarchy(options: HierarchyOptions): ResourceLane[
         }
       }
 
-      // configures/uses/protects: ConfigMap→Deployment, HPA→Deployment, PDB→Deployment (target is parent)
-      if (edge.type === 'configures' || edge.type === 'uses' || edge.type === 'protects') {
+      // configures/protects: ConfigMap→Deployment, PDB→Deployment (target is parent)
+      if (edge.type === 'configures' || edge.type === 'protects') {
+        link(sourceId, targetId, sourceExists)
+      }
+      // uses: only an autoscaler or a mounted claim belongs under the workload it
+      // serves. Other uses edges point from a dependent to what it depends on
+      // (Certificate→Issuer, Gateway→GatewayClass); nesting there would file
+      // every dependent under one shared dependency.
+      if (edge.type === 'uses' && attachesToTarget(topologyNodeById.get(edge.source))) {
         link(sourceId, targetId, sourceExists)
       }
     }
@@ -1468,3 +1476,21 @@ export function countEventsInHierarchy(lanes: ResourceLane[]): number {
   lanes.forEach(walk)
   return count
 }
+
+// The uses-edge sources that attach to their target workload: autoscalers and
+// PersistentVolumeClaims, matched on exact API group.
+const ATTACHED_USES_SOURCES = new Set([
+  'autoscaling/HorizontalPodAutoscaler',
+  'autoscaling.k8s.io/VerticalPodAutoscaler',
+  'keda.sh/ScaledObject',
+  'keda.sh/ScaledJob',
+  '/PersistentVolumeClaim',
+])
+
+function attachesToTarget(node: Topology['nodes'][number] | undefined): boolean {
+  if (!node) return false
+  const kind = topologyNodeResourceKind(node)
+  const apiVersion = typeof node.data?.apiVersion === 'string' ? node.data.apiVersion : ''
+  const group = canonicalResourceGroup(kind, apiVersionToGroup(apiVersion)) ?? ''
+  return ATTACHED_USES_SOURCES.has(`${group}/${kind}`)
+}

package/src/utils/resource-refs.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import type { ResourceRef } from '../types/core'
+import { dedupeResourceRefs, omitResourceRefs, resourceRefKey } from './resource-refs'
+
+describe('resource reference identity', () => {
+  const core: ResourceRef = { kind: 'Service', namespace: 'team', name: 'app' }
+  const knative: ResourceRef = { ...core, group: 'serving.knative.dev' }
+
+  it('deduplicates core aliases while preserving an identically named custom resource', () => {
+    const refs = [core, { ...core, group: '' }, knative]
+    expect(dedupeResourceRefs(refs)).toEqual([core, knative])
+    expect(refs).toHaveLength(3)
+    expect(resourceRefKey(core)).not.toBe(resourceRefKey(knative))
+  })
+
+  it('omits only the exact mirrored identity without mutating either list', () => {
+    const refs = [core, knative]
+    const excluded = [{ ...core, group: '' }]
+    expect(omitResourceRefs(refs, excluded)).toEqual([knative])
+    expect(refs).toEqual([core, knative])
+    expect(excluded).toHaveLength(1)
+  })
+})

package/src/utils/resource-refs.ts

@@ -0,0 +1,30 @@
+import type { ResourceRef } from '../types/core'
+
+/**
+ * resourceKey mirrors Go `audit.ResourceKey(group, kind, namespace, name)`:
+ * `group|Kind|namespace|name`. Group first because group and namespace can each
+ * independently be empty; `|` is delimiter-safe (K8s API groups follow
+ * DNS-subdomain rules and can't contain it).
+ */
+export function resourceKey(group: string, kind: string, namespace: string, name: string): string {
+  return `${group}|${kind}|${namespace}|${name}`;
+}
+
+export function resourceRefKey(ref: ResourceRef): string {
+  return resourceKey(ref.group ?? '', ref.kind, ref.namespace, ref.name);
+}
+
+export function dedupeResourceRefs(refs: ResourceRef[]): ResourceRef[] {
+  const seen = new Set<string>()
+  return refs.filter(ref => {
+    const key = resourceRefKey(ref)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+export function omitResourceRefs(refs: ResourceRef[], excluded: ResourceRef[]): ResourceRef[] {
+  const excludedKeys = new Set(excluded.map(resourceRefKey))
+  return refs.filter(ref => !excludedKeys.has(resourceRefKey(ref)))
+}