@skyhook-io/radar-app 1.16.0 → 1.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyhook-io/radar-app",
-  "version": "1.16.0",
+  "version": "1.16.1",
   "description": "Radar's full web UI as a reusable React component. Used by Radar's own binary and by external consumers like Radar Cloud.",
   "repository": {
     "type": "git",
@@ -42,7 +42,7 @@
     "yaml": "^2.9.0"
   },
   "peerDependencies": {
-    "@skyhook-io/k8s-ui": ">=1.16.0",
+    "@skyhook-io/k8s-ui": ">=1.16.1",
     "@tanstack/react-query": ">=5",
     "@xyflow/react": ">=12.0.0",
     "clsx": ">=2",

package/src/api/client.ts

@@ -1782,6 +1782,7 @@ export function useRadarFeature(feature: RadarFeature) {
   const support = radarFeatureSupport(feature, capabilities, currentVersion)
 
   return {
+    support,
     gatedKey: support === 'unsupported' ? ['radar-feature-unsupported'] : [],
     guard: <T,>(request: () => Promise<T>): Promise<T> =>
       guardRadarFeature(feature, support, { currentVersion, latestVersion }, request),
@@ -2946,14 +2947,28 @@ function workloadHistoryPath(kind: string, namespace: string, name: string, grou
 // The newest page of one workload's history: the workload, what it owns, K8s
 // Events about those, and the resources attached to it. Keyed under
 // "changes" so the live-update invalidation refreshes it.
+// A Radar that predates the scoped history endpoint settles as unsupported;
+// WorkloadView then falls back to the namespace's changes.
 export function useWorkloadHistory(kind: string, namespace: string, name: string, group?: string, enabled = true) {
-  return useQuery<WorkloadHistoryPage>({
-    queryKey: ["changes", "workload-history", kind, namespace, name, group ?? ""],
-    queryFn: ({ signal }) => fetchJSON(workloadHistoryPath(kind, namespace, name, group), signal),
+  const { guard, gatedKey, support } = useRadarFeature("workloadHistory");
+  const query = useQuery<WorkloadHistoryPage>({
+    queryKey: ["changes", "workload-history", kind, namespace, name, group ?? "", ...gatedKey],
+    queryFn: ({ signal }) =>
+      guard(() => fetchJSON<WorkloadHistoryPage>(workloadHistoryPath(kind, namespace, name, group), signal)),
     staleTime: 5000,
-    refetchInterval: CHANGES_REFRESH_INTERVAL_MS,
+    retry: shouldRetryRadarQuery,
+    refetchInterval: (query) =>
+      query.state.error instanceof RadarFeatureUnsupportedError ? false : CHANGES_REFRESH_INTERVAL_MS,
     enabled,
   });
+  // A probe answered by an older Radar settles as unsupported and stops
+  // polling; once /capabilities confirms the feature (the agent was upgraded),
+  // ask again rather than staying on the fallback.
+  const { error, refetch } = query;
+  useEffect(() => {
+    if (support === "supported" && error instanceof RadarFeatureUnsupportedError) void refetch();
+  }, [support, error, refetch]);
+  return query;
 }
 
 export function fetchWorkloadHistoryPage(kind: string, namespace: string, name: string, group: string | undefined, beforeSeq: number): Promise<WorkloadHistoryPage> {

package/src/api/radarFeatures.render.test.tsx

@@ -4,7 +4,7 @@ import { createRoot } from 'react-dom/client'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { afterEach, beforeEach, expect, it, vi } from 'vitest'
 import { getRadarUpgradeRequirement } from '@skyhook-io/k8s-ui'
-import { ApiError, isNotFoundError, useApplications, useCapacityPoolDetail, useDrainPlan, usePodEnvironment } from './client'
+import { ApiError, isNotFoundError, useApplications, useCapacityPoolDetail, useDrainPlan, usePodEnvironment, useWorkloadHistory } from './client'
 import { getApiBase } from './config'
 import { usePolicyResource } from './policy'
 import { isRadarFeatureUnsupported } from './radarFeatures'
@@ -188,3 +188,36 @@ it('never asks a Radar older than v1.8 for applications', async () => {
   expect(element.textContent).toBe('upgrade')
   expect(asked('/applications')).toBe(false)
 })
+
+function History() {
+  const { data, error } = useWorkloadHistory('deployments', 'shop', 'web', 'apps')
+  return <span>{data ? 'data' : isRadarFeatureUnsupported(error, 'workloadHistory') ? 'fallback' : 'pending'}</span>
+}
+
+it('never asks a Radar whose capabilities omit workload history', async () => {
+  client.setQueryData(['capabilities'], { features: { policyResource: true } })
+  await render(<History />)
+  expect(element.textContent).toBe('fallback')
+  expect(asked('/history')).toBe(false)
+})
+
+it("reads the router's 404 on workload history as unsupported before capabilities answer", async () => {
+  host.radarVersion = undefined
+  chiRoutes = ['/workloads/deployments/shop/web/history']
+  await render(<History />)
+  expect(element.textContent).toBe('fallback')
+  expect(requested.filter((url) => url.includes('/history'))).toHaveLength(1)
+})
+
+it('asks again once capabilities confirm workload history after a probe hit an older Radar', async () => {
+  host.radarVersion = undefined
+  chiRoutes = ['/workloads/deployments/shop/web/history']
+  await render(<History />)
+  expect(element.textContent).toBe('fallback')
+
+  chiRoutes = []
+  await act(async () => { client.setQueryData(['capabilities'], { features: { workloadHistory: true } }) })
+  await settle()
+  await settle()
+  expect(requested.filter((url) => url.includes('/history'))).toHaveLength(2)
+})

package/src/api/radarFeatures.test.ts

@@ -56,6 +56,15 @@ describe('radarFeatureSupport', () => {
   })
 })
 
+describe('workload history, whose flag shipped with its endpoint', () => {
+  it('trusts a loaded capabilities answer, and probes before it arrives', () => {
+    expect(radarFeatureSupport('workloadHistory', { features: { workloadHistory: true } }, undefined)).toBe('supported')
+    expect(radarFeatureSupport('workloadHistory', { features: { policyResource: true } }, 'v1.15.0')).toBe('unsupported')
+    expect(radarFeatureSupport('workloadHistory', { features: {} }, 'dev')).toBe('unsupported')
+    expect(radarFeatureSupport('workloadHistory', undefined, 'v1.15.0')).toBe('unknown')
+  })
+})
+
 describe('radarSpecSupport for a feature whose flag shipped with its endpoint', () => {
   const driftAlerts: RadarFeatureSpec = { label: 'Drift alerts', flag: 'resourceIssues', flagShippedWithEndpoint: true }
 

package/src/api/radarFeatures.ts

@@ -34,6 +34,7 @@ export const RADAR_FEATURES = {
   upgradeReadiness: { label: 'Upgrade impact reports', minimumVersion: 'v1.9.0' },
   drainPlan: { label: 'Drain plans', minimumVersion: 'v1.14.0' },
   applications: { label: 'Applications', minimumVersion: 'v1.7.7' },
+  workloadHistory: { label: 'Workload history', flag: 'workloadHistory', flagShippedWithEndpoint: true },
 } as const satisfies Record<string, RadarFeatureSpec>
 
 export type RadarFeature = keyof typeof RADAR_FEATURES

package/src/components/workload/WorkloadView.tsx

@@ -49,6 +49,7 @@ import {
 import {
   useWorkloadHistory,
   fetchWorkloadHistoryPage,
+  useChanges,
   useResourceWithRelationships,
   usePodLogs,
   useTopology,
@@ -803,18 +804,32 @@ export function WorkloadView({
   // colliding kind) under the wrong group and refetch once it settles.
   const historyGroupSettled = Boolean(rest.group) || resource !== undefined || resourceError != null
   const historyQuery = useWorkloadHistory(apiKind, namespace, name, effectiveGroup, expanded && historyGroupSettled)
+  // A Radar without the scoped history endpoint gets the namespace's newest
+  // changes instead, which the timeline filters to this workload.
+  const historyFallback = isRadarFeatureUnsupported(historyQuery.error, 'workloadHistory')
+  const namespaceChanges = useChanges({
+    namespaces: [namespace],
+    timeRange: 'all',
+    includeK8sEvents: true,
+    includeManaged: true,
+    limit: 10000,
+    enabled: expanded && historyFallback,
+  })
   const {
-    events: allEvents,
+    events: scopedEvents,
     truncated: historyTruncated,
     loadOlder: loadOlderHistory,
     loadingOlder: loadingOlderHistory,
     olderError: olderHistoryError,
   } = useHistoryPaging(
     `${effectiveGroup ?? ''}/${apiKind}/${namespace}/${name}`,
-    historyQuery.data,
+    historyFallback ? undefined : historyQuery.data,
     (beforeSeq) => fetchWorkloadHistoryPage(apiKind, namespace, name, effectiveGroup, beforeSeq),
   )
-  const eventsLoading = historyQuery.isLoading || (expanded && !historyGroupSettled)
+  const allEvents = historyFallback ? namespaceChanges.data : scopedEvents
+  const eventsLoading = historyFallback
+    ? namespaceChanges.isLoading
+    : historyQuery.isLoading || (expanded && !historyGroupSettled)
 
   // RBAC
   const canUpdateSecrets = useCanUpdateSecrets()
@@ -1211,14 +1226,14 @@ export function WorkloadView({
         refetch={refetchResourceAndRuns}
         // Timeline
         allEvents={allEvents}
-        historyTruncated={historyTruncated}
-        onLoadOlderHistory={loadOlderHistory}
-        loadingOlderHistory={loadingOlderHistory}
-        olderHistoryError={olderHistoryError}
-        historyScoped
-        historyIncomplete={Boolean(historyQuery.data?.incomplete)}
-        historyError={historyQuery.error as Error | null}
-        onRetryHistory={() => void historyQuery.refetch()}
+        historyTruncated={!historyFallback && historyTruncated}
+        onLoadOlderHistory={historyFallback ? undefined : loadOlderHistory}
+        loadingOlderHistory={!historyFallback && loadingOlderHistory}
+        olderHistoryError={historyFallback ? null : olderHistoryError}
+        historyScoped={!historyFallback}
+        historyIncomplete={!historyFallback && Boolean(historyQuery.data?.incomplete)}
+        historyError={(historyFallback ? namespaceChanges.error : historyQuery.error) as Error | null}
+        onRetryHistory={() => void (historyFallback ? namespaceChanges.refetch() : historyQuery.refetch())}
         relatedTimelineEvents={relatedTimelineEvents}
         eventsLoading={eventsLoading || (batchExecution && batchKind !== 'JobSet' && batchRunsQuery.isLoading)}
         topology={topology}