@skyhook-io/radar-app 1.14.4 → 1.14.6

package/src/components/rightsizing/model.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest'
 import type { RightsizingScanResponse, RightsizingRow } from '../../api/client'
-import { calculateImpact, classifyRows, flattenScanResults, scanClassCounts } from './model'
+import {
+  calculateImpact,
+  classifyRows,
+  flattenScanResults,
+  isActionableClass,
+  scanClassCounts,
+} from './model'
 
 function metric(overrides: Partial<RightsizingRow> = {}): RightsizingRow {
   return {
@@ -25,6 +31,7 @@ function response(
   scaledToZero = false,
 ): RightsizingScanResponse {
   return {
+    scanId: 'rs_test', scanStatus: 'finished', deadlineAt: '2026-09-19T10:03:00Z',
     state: 'complete',
     scannedAt: '2026-07-12T10:00:00Z',
     window: '7d',
@@ -34,7 +41,7 @@ function response(
       workloadsEvaluated: 1,
       workloadsWithData: 1,
       batches: 1,
-      completedBatches: 1,
+      attemptedBatches: 1, completedBatches: 1,
     },
     workloads: [
       {
@@ -152,6 +159,77 @@ describe('rightsizing scan model', () => {
     expect(classifyRows([metric({ queryError: 'query failed' })])).toBe('need_data')
   })
 
+  describe.each([
+    ['failed query', { queryError: 'usage query failed' }],
+    ['short history', { fit: 'insufficient_history' as const }],
+  ])('with %s on one resource', (_label, missing) => {
+    it.each([
+      [
+        'increase',
+        {
+          fit: 'under_requested' as const,
+          recommendedRequest: '1Gi',
+          recommendedRequestValue: 1024 ** 3,
+        },
+      ],
+      ['review', { currentPodOOM: true }],
+      ['review', { hpaManaged: true, recommendationReason: 'hpa_managed' }],
+      [
+        'reduction',
+        {
+          fit: 'oversized' as const,
+          currentRequestValue: 1024 ** 3,
+          recommendedRequest: '512Mi',
+          recommendedRequestValue: 512 * 1024 ** 2,
+        },
+      ],
+      ['need_data', {}],
+    ])('retains %s from the other resource', (classification, known) => {
+      const cpu = metric(missing)
+      const memory = metric({ resource: 'memory', ...known })
+      const rows = flattenScanResults(response([cpu, memory]))
+      expect(rows).toHaveLength(1)
+      expect(rows[0].classification).toBe(classification)
+      expect(rows[0].cpu).toBe(cpu)
+      expect(rows[0].memory).toBe(memory)
+      expect(scanClassCounts(rows)[rows[0].classification]).toBe(1)
+      const actions = rows.filter((row) => isActionableClass(row.classification))
+      expect(actions).toHaveLength(classification === 'need_data' ? 0 : 1)
+    })
+  })
+
+  it('retains a known CPU increase when memory has no evidence', () => {
+    const cpu = metric({
+      fit: 'under_requested',
+      recommendedRequest: '200m',
+      recommendedRequestValue: 0.2,
+      currentRequestValue: 0.1,
+    })
+    const memory = metric({ resource: 'memory', fit: 'insufficient_history' })
+    const [row] = flattenScanResults(response([cpu, memory], 3))
+    expect(row.classification).toBe('increase')
+    expect(row.impact.cpuChange).toBeCloseTo(0.3)
+    expect(row.impact.memoryChange).toBe(0)
+    expect(row.memory).toBe(memory)
+  })
+
+  it('keeps empty and entirely unevidenced containers in need_data', () => {
+    expect(classifyRows([])).toBe('need_data')
+    expect(
+      classifyRows([
+        metric({ queryError: 'usage query failed' }),
+        metric({ resource: 'memory', fit: 'insufficient_history' }),
+      ]),
+    ).toBe('need_data')
+    expect(
+      classifyRows(
+        [metric({ fit: 'insufficient_history' }), metric({ resource: 'memory' })],
+        0,
+        true,
+      ),
+    ).toBe('review')
+  })
+
   it('keeps workloads with no current replicas in review', () => {
     const oversized = flattenScanResults(
       response(
@@ -225,3 +303,43 @@ describe('rightsizing scan model', () => {
     expect(scanClassCounts(rows).increase).toBe(1)
   })
 })
+
+it('ranks known safety risks and increases above savings, while routine reviews stay lower', () => {
+  const make = (name: string, rows: RightsizingRow[], scaledToZero = false) => ({
+    ...response(rows, scaledToZero ? 0 : 1, 'shop', scaledToZero).workloads[0],
+    name,
+  })
+  const cut = metric({
+    fit: 'oversized',
+    currentRequestValue: 10,
+    recommendedRequestValue: 1,
+    recommendedRequest: '1',
+  })
+  const grow = metric({
+    fit: 'under_requested',
+    currentRequestValue: 0.1,
+    recommendedRequestValue: 0.2,
+    recommendedRequest: '200m',
+  })
+  const risk = metric({ resource: 'memory', currentPodOOM: true })
+  const workloads = [
+    make('cut', [cut]),
+    make('grow', [grow]),
+    make('hpa', [metric({ hpaManaged: true })]),
+    make('oom', [risk]),
+    make('limit', [metric({ limitConflict: true })]),
+    make('bursty', [{ ...cut, bursty: true }]),
+    make('throttled', [{ ...cut, throttleRatio: 0.2 }]),
+    make('idle', [risk], true),
+    make('failed-risk', [metric({ queryError: 'failed', currentPodOOM: true })]),
+    make('partial-grow', [grow, metric({ resource: 'memory', queryError: 'failed' })]),
+    make('steady', [metric()]),
+  ]
+  const rows = flattenScanResults({ ...response([]), workloads })
+  const names = rows.map((row) => row.name)
+  expect(new Set(names.slice(0, 3))).toEqual(new Set(['oom', 'limit', 'throttled']))
+  expect(names.slice(3, 5)).toEqual(['grow', 'partial-grow'])
+  expect(names[5]).toBe('cut')
+  expect(names.slice(6, 9)).toEqual(['bursty', 'hpa', 'idle'])
+  expect(names.slice(9)).toEqual(['failed-risk', 'steady'])
+})

package/src/components/rightsizing/model.ts

@@ -24,11 +24,11 @@ export interface RightsizingScanRow {
 }
 
 const CLASS_RANK: Record<ScanClass, number> = {
-  reduction: 0,
   increase: 1,
-  review: 2,
-  need_data: 3,
-  in_range: 4,
+  reduction: 2,
+  review: 3,
+  need_data: 4,
+  in_range: 5,
 }
 
 const MIN_CPU_REDUCTION = 0.05
@@ -39,32 +39,55 @@ export function classifyRows(
   replicas = 1,
   scaledToZero = false,
 ): ScanClass {
-  if (rows.some((row) => row.queryError || row.fit === 'insufficient_history')) return 'need_data'
+  const evidenced = rows.filter((row) => !row.queryError && row.fit !== 'insufficient_history')
+  if (evidenced.length === 0) return 'need_data'
   if (scaledToZero) return 'review'
   if (
-    rows.some(
+    evidenced.some(
       (row) =>
         (row.fit === 'under_requested' || row.fit === 'missing_request') && row.recommendedRequest,
     )
   )
     return 'increase'
-  if (rows.some(needsManualReview)) return 'review'
-  const impact = calculateImpact(rows, replicas)
+  if (evidenced.some(needsManualReview)) return 'review'
+  const impact = calculateImpact(evidenced, replicas)
   if (-impact.cpuChange >= MIN_CPU_REDUCTION || -impact.memoryChange >= MIN_MEMORY_REDUCTION)
     return 'reduction'
-  return 'in_range'
+  return evidenced.length === rows.length ? 'in_range' : 'need_data'
 }
 
 function needsManualReview(row: RightsizingRow): boolean {
   return (
     row.hpaManaged ||
+    needsSafetyReview(row) ||
+    (isReduction(row) && row.bursty === true) ||
+    row.recommendationReason === 'hpa_evidence_unavailable' ||
+    row.recommendationReason === 'oom_evidence_unavailable'
+  )
+}
+
+function needsSafetyReview(row: RightsizingRow): boolean {
+  return (
     row.currentPodOOM === true ||
     row.windowOomEvidence === true ||
     row.limitConflict === true ||
-    row.recommendationReason === 'hpa_evidence_unavailable' ||
-    row.recommendationReason === 'oom_evidence_unavailable' ||
-    (isReduction(row) && (row.bursty || (row.throttleRatio ?? 0) >= 0.1))
+    (isReduction(row) && (row.throttleRatio ?? 0) >= 0.1)
+  )
+}
+
+function scanPriority(row: RightsizingScanRow): number {
+  if (
+    !row.scaledToZero &&
+    [row.cpu, row.memory].some(
+      (resource) =>
+        resource &&
+        !resource.queryError &&
+        resource.fit !== 'insufficient_history' &&
+        needsSafetyReview(resource),
+    )
   )
+    return 0
+  return CLASS_RANK[row.classification]
 }
 
 function isReduction(row: RightsizingRow): boolean {
@@ -117,7 +140,7 @@ export function flattenScanResults(scan: RightsizingScanResponse): RightsizingSc
   }
   return result.sort(
     (a, b) =>
-      CLASS_RANK[a.classification] - CLASS_RANK[b.classification] ||
+      scanPriority(a) - scanPriority(b) ||
       impactScore(b) - impactScore(a) ||
       a.namespace.localeCompare(b.namespace) ||
       a.name.localeCompare(b.name) ||

package/src/components/rightsizing/notices.test.tsx

@@ -0,0 +1,176 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import type { RightsizingRow, RightsizingScanResponse } from '../../api/client'
+import { FitWhy, ScanNotices, ScanSummary } from './RightsizingScanView'
+
+const scan: RightsizingScanResponse = {
+  scanId: 'rs_test', scanStatus: 'finished', deadlineAt: '2026-09-19T10:03:00Z',
+    state: 'complete',
+  scannedAt: '2026-09-19T06:52:54Z',
+  window: '7d',
+  source: 'radar',
+  coverage: {
+    workloadsDiscovered: 120,
+    workloadsEvaluated: 120,
+    workloadsWithData: 47,
+    batches: 3,
+    attemptedBatches: 3, completedBatches: 3,
+  },
+  workloads: [],
+}
+
+function render(result: RightsizingScanResponse) {
+  return renderToStaticMarkup(<ScanNotices result={result} />)
+}
+
+describe('rightsizing scan notices', () => {
+  it('keeps timeout coverage visible with query failures behind one collapsed disclosure', () => {
+    const html = render({
+      ...scan,
+      state: 'partial',
+      coverage: {
+        ...scan.coverage,
+        workloadsEvaluated: 100,
+        attemptedBatches: 1, completedBatches: 0,
+        daemonSetsWithoutNodes: 27,
+      },
+      warnings: ['cpu_query_failed', 'memory_query_failed', 'scan_deadline_exceeded'].map(
+        (code) => ({ code, message: 'backend-specific details' }),
+      ),
+    })
+    expect(html.match(/<section/g)).toHaveLength(1)
+    expect(html.match(/<button/g)).toHaveLength(1)
+    expect(html).toContain('Partial results')
+    expect(html).not.toContain('workloads evaluated')
+    expect(html).toContain('select namespaces in the top bar')
+    expect(html).toContain('Available recommendations are shown')
+    expect(html).toContain('aria-expanded="false"')
+    expect(html).toContain('inert=""')
+    expect(html).toContain('Some CPU data could not be queried')
+    expect(html).toContain('Some memory data could not be queried')
+    expect(html).toContain('27 DaemonSets')
+    expect(html).not.toContain('completed batches')
+    expect(html).not.toContain('backend-specific details')
+  })
+
+  it('does not label a complete scan with excluded DaemonSets as a query failure', () => {
+    const html = render({
+      ...scan,
+      coverage: { ...scan.coverage, daemonSetsWithoutNodes: 1 },
+    })
+    expect(html).toContain('Scan notes')
+    expect(html).toContain('1 DaemonSet runs on no node right now and is not listed')
+    expect(html).not.toContain('<button')
+    expect(html).not.toContain('Partial results')
+    expect(html).not.toContain('time limit')
+  })
+
+  it('preserves access and cache limitations without claiming a timeout', () => {
+    const html = render({
+      ...scan,
+      state: 'partial',
+      coverage: {
+        ...scan.coverage,
+        restrictedKinds: ['Deployment'],
+        partiallyCachedKinds: ['StatefulSet'],
+        unavailableKinds: ['DaemonSet'],
+      },
+    })
+    expect(html).toContain('Kubernetes access')
+    expect(html).toContain('available ownership data')
+    expect(html).toContain('caching only some namespaces')
+    expect(html).not.toContain('time limit')
+  })
+
+  it('does not infer a timeout or short history from a query failure', () => {
+    const html = render({
+      ...scan,
+      state: 'partial',
+      warnings: [{ code: 'cpu_query_failed', message: 'unknown error' }],
+    })
+    expect(html).toContain('Some CPU data could not be queried')
+    expect(html).not.toContain('time limit')
+    expect(html).not.toContain('not enough recent history')
+  })
+
+  it('shows no notice for a clean scan and no empty Details button for deadline-only partial results', () => {
+    expect(render(scan)).toBe('')
+    const html = render({
+      ...scan,
+      state: 'partial',
+      warnings: [{ code: 'scan_deadline_exceeded', message: 'deadline' }],
+    })
+    expect(html).toContain('time limit')
+    expect(html).not.toContain('<button')
+  })
+})
+
+describe('rightsizing evidence explanation', () => {
+  const row: RightsizingRow = {
+    container: 'app',
+    resource: 'cpu',
+    fit: 'insufficient_history',
+    confidence: 'low',
+    coverage: 0,
+    sampleCount: 0,
+    expectedSamples: 2017,
+    hpaManaged: false,
+    hpaEvidenceAvailable: true,
+    oomEvidenceAvailable: false,
+  }
+
+  it('distinguishes failed queries from successfully measured short history', () => {
+    const failed = renderToStaticMarkup(
+      <FitWhy label="CPU" row={{ ...row, queryError: 'usage query failed' }} />,
+    )
+    expect(failed).toContain('Metrics could not be queried')
+    expect(failed).not.toContain('0.0 days')
+    expect(failed).not.toContain('Wait for more runtime history')
+    const short = renderToStaticMarkup(<FitWhy label="CPU" row={row} />)
+    expect(short).toContain('0.0 days')
+    expect(short).toContain('Wait for more runtime history')
+  })
+})
+
+describe('rightsizing scope and coverage summary', () => {
+  const counts = {
+    increase: 1,
+    reduction: 4,
+    review: 0,
+    in_range: 2,
+    need_data: 3,
+  }
+  it('separates attempted workloads from usage evidence and container counts', () => {
+    const html = renderToStaticMarkup(
+      <ScanSummary
+        namespaces={['dev', 'staging']}
+        result={{
+          ...scan,
+          coverage: { ...scan.coverage, workloadsEvaluated: 100 },
+        }}
+        counts={counts}
+        selected="actions"
+        onSelect={() => {}}
+      />,
+    )
+    expect(html).toContain('dev, staging')
+    expect(html).toContain('Change scan scope in the top bar')
+    expect(html).toContain('100 of 120 workloads attempted')
+    expect(html).toContain('47 with usage data')
+    expect(html).toContain('7d window')
+    expect(html).toContain('1 container<')
+    expect(html).not.toContain('workloads evaluated')
+  })
+  it('qualifies the all-namespace scope by visibility', () => {
+    const html = renderToStaticMarkup(
+      <ScanSummary
+        namespaces={[]}
+        result={scan}
+        counts={counts}
+        selected="actions"
+        onSelect={() => {}}
+      />,
+    )
+    expect(html).toContain('All visible namespaces')
+  })
+})

package/src/components/settings/OperatorManagedNotice.tsx

@@ -0,0 +1,17 @@
+import { Lock } from 'lucide-react'
+
+export function OperatorManagedNotice({ helmValue }: { helmValue?: string }) {
+  return (
+    <div className="flex items-start gap-2 rounded-lg border border-theme-border bg-theme-elevated/50 p-3 text-sm">
+      <Lock className="mt-0.5 h-4 w-4 shrink-0 text-theme-text-tertiary" />
+      <div className="min-w-0">
+        <p className="font-medium text-theme-text-primary">Managed by your operator</p>
+        <p className="mt-1 text-xs text-theme-text-secondary">
+          To change these settings, ask your operator to update {helmValue ? <><code className="font-mono">{helmValue}</code> in </> : null}
+          Radar’s Helm values or startup configuration.
+          {' '}<a className="text-accent hover:underline" href="https://github.com/skyhook-io/radar/blob/main/docs/in-cluster.md#installation-settings" target="_blank" rel="noreferrer">Configuration guide</a>
+        </p>
+      </div>
+    </div>
+  )
+}