@skyhook-io/k8s-ui 1.8.11 → 1.8.13

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/applications.test.ts

@@ -412,6 +412,40 @@ describe('buildAppMembershipIndex', () => {
     expect(idx.byResource.has('Route/team-a/HTTPRoute/web-http')).toBe(false)
   })
 
+  it('indexes explicit relationship refs across namespaces', () => {
+    const idx = buildAppMembershipIndex([
+      row({
+        key: 'team-a/app/billing', name: 'billing', namespaces: ['team-a', 'shared'],
+        relationships: {
+          serviceRefs: [{ kind: 'Service', namespace: 'team-a', name: 'billing-api' }],
+          configRefs: [{ kind: 'ConfigMap', namespace: 'shared', name: 'billing-config' }],
+          storageRefs: [{ kind: 'PersistentVolumeClaim', namespace: 'team-a', name: 'billing-data' }],
+        },
+      }),
+    ])
+
+    expect(idx.byResource.get('Service/team-a/billing-api')?.appName).toBe('billing')
+    expect(idx.byResource.get('ConfigMap/shared/billing-config')?.appName).toBe('billing')
+    expect(idx.byResource.get('PersistentVolumeClaim/team-a/billing-data')?.appName).toBe('billing')
+  })
+
+  it('indexes the exact deployment source object', () => {
+    const idx = buildAppMembershipIndex([
+      row({
+        key: 'team-a/app/billing', name: 'billing',
+        sourceRef: {
+          type: 'gitops',
+          tool: 'argocd',
+          kind: 'Application',
+          namespace: 'argocd',
+          name: 'billing',
+        },
+      }),
+    ])
+
+    expect(idx.byResource.get('Application/argocd/billing')?.appName).toBe('billing')
+  })
+
   it('skips satellites for a multi-namespace app (can not place them unambiguously)', () => {
     const idx = buildAppMembershipIndex([
       row({

package/src/utils/applications.ts

@@ -641,6 +641,31 @@ export function buildAppMembershipIndex(rows: AppRow[]): AppMembershipIndex {
         setFirst(byResource, `${routeKind}/${ns}/${routeName}`, membership);
       }
     }
+    if (row.relationships) {
+      const explicitRefs = [
+        row.relationships.serviceRefs,
+        row.relationships.ingressRefs,
+        row.relationships.routeRefs,
+        row.relationships.configRefs,
+        row.relationships.scalerRefs,
+        row.relationships.storageRefs,
+        row.relationships.pdbRefs,
+        row.relationships.networkPolicyRefs,
+      ];
+      for (const refs of explicitRefs) {
+        for (const ref of refs ?? []) {
+          if (ref.kind && ref.name)
+            setFirst(byResource, `${ref.kind}/${ref.namespace}/${ref.name}`, membership);
+        }
+      }
+    }
+    if (row.sourceRef?.kind && row.sourceRef.name) {
+      setFirst(
+        byResource,
+        `${row.sourceRef.kind}/${row.sourceRef.namespace}/${row.sourceRef.name}`,
+        membership,
+      );
+    }
     for (const mk of row.matchKeys || []) {
       if (mk.startsWith("name-stem:")) continue;
       setFirst(byEvidence, mk, membership);

package/src/utils/index.ts

@@ -23,5 +23,6 @@ export * from './git-provider-urls'
 export * from './applications'
 export * from './topology-neighborhood'
 export * from './application-topology'
+export * from './application-history'
 export * from './bulk-workload-actions'
 export * from './workflow-execution'

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

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest'
 
 import type { TimelineEvent, Topology } from '../types/core'
 
-import { buildResourceHierarchy, extractPinnedLanes, removePinnedLanes, isPinnedLaneRef, laneTrackEvents, laneHasEventInWindow, isChildVisibleInWindow, subtreeEvents, getAllEventsFromHierarchy, collidingLaneKeys, laneCollisionKey, type ResourceLane } from './resource-hierarchy'
+import { buildResourceHierarchy, eventsForApplication, extractPinnedLanes, removePinnedLanes, isPinnedLaneRef, laneTrackEvents, laneHasEventInWindow, isChildVisibleInWindow, subtreeEvents, getAllEventsFromHierarchy, collidingLaneKeys, laneCollisionKey, type ResourceLane } from './resource-hierarchy'
 import type { AppMembershipIndex, AppMembership } from './applications'
 
 function svcEvent(namespace: string, name: string): TimelineEvent {
@@ -274,6 +274,40 @@ describe('buildResourceHierarchy app-membership cascade (grouping=app)', () => {
   })
 })
 
+describe('eventsForApplication', () => {
+  const billing: AppMembership = { appKey: 'team-a/app/billing', appName: 'billing' }
+
+  it('returns a selected singleton app subtree without the global two-member threshold', () => {
+    const deployment = changeEvent('Deployment', 'team-a', 'billing-api', { id: 'deployment' })
+    const pod = changeEvent('Pod', 'team-a', 'billing-api-abc12', {
+      id: 'pod',
+      owner: { kind: 'Deployment', name: 'billing-api' },
+    })
+    const unrelated = changeEvent('Deployment', 'team-a', 'other', { id: 'other' })
+    const appIndex = index({ 'Deployment/team-a/billing-api': billing })
+
+    const events = eventsForApplication([deployment, pod, unrelated], undefined, appIndex)
+
+    expect(events.map((event) => event.id).sort()).toEqual(['deployment', 'pod'])
+  })
+
+  it('includes a relationship root and its owned descendants', () => {
+    const service = changeEvent('Service', 'team-a', 'billing-api', { id: 'service' })
+    const deployment = changeEvent('Deployment', 'team-a', 'billing-api', { id: 'deployment' })
+    const topology = {
+      nodes: [
+        { id: 'service/team-a/billing-api', data: {} },
+        { id: 'deployment/team-a/billing-api', data: {} },
+      ],
+      edges: [{ id: 'edge', source: 'service/team-a/billing-api', target: 'deployment/team-a/billing-api', type: 'exposes' }],
+    } as unknown as Topology
+    const appIndex = index({ 'Service/team-a/billing-api': billing })
+
+    expect(eventsForApplication([service, deployment], topology, appIndex).map((event) => event.id).sort())
+      .toEqual(['deployment', 'service'])
+  })
+})
+
 // --- kind-contract nesting (parent-driven naming) ---------------------------
 //
 // A resource whose only in-window events are ownerless (deletion-time cache miss)

package/src/utils/resource-hierarchy.ts

@@ -1049,6 +1049,26 @@ export function subtreeEvents(lane: ResourceLane): TimelineEvent[] {
   return sortEventsForRendering(unique)
 }
 
+/** Return every event attributable to one selected application. The caller
+ * supplies an index containing only that app, so singleton apps are retained
+ * even though the global Timeline intentionally avoids one-member app groups. */
+export function eventsForApplication(
+  events: TimelineEvent[],
+  topology: Topology | undefined,
+  appIndex: AppMembershipIndex,
+): TimelineEvent[] {
+  const roots = buildResourceHierarchy({ events, topology, grouping: 'owner' })
+  const matched = roots.filter((lane) => cascadeRootMembership(lane, appIndex) !== null)
+  const unique = new Map<string, TimelineEvent>()
+  for (const lane of matched) {
+    for (const event of subtreeEvents(lane)) unique.set(event.id, event)
+  }
+  return [...unique.values()].sort((a, b) => {
+    const byTime = new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    return byTime || (b.seq ?? 0) - (a.seq ?? 0) || a.id.localeCompare(b.id)
+  })
+}
+
 /** The events a lane paints on its OWN track row, given whether it's expanded.
  *  - collapsed parent → whole-subtree aggregate (the roll-up)
  *  - expanded parent, or a leaf → only the lane's own events