@skyhook-io/radar-app 1.13.4 → 1.14.0

package/src/components/diagnose/target.test.ts

@@ -26,6 +26,25 @@ describe("investigation target identity", () => {
     ).toBe("Rollout.argoproj.io prod/checkout");
   });
 
+  it("formats saved plural targets as Kubernetes Kinds", () => {
+    expect(
+      formatInvestigationTarget({
+        kind: "deployments",
+        group: "apps",
+        namespace: "prod",
+        name: "api",
+      }),
+    ).toBe("Deployment.apps prod/api");
+    expect(
+      formatInvestigationTarget({
+        kind: "pods",
+        group: "metrics.k8s.io",
+        namespace: "prod",
+        name: "api",
+      }),
+    ).toBe("PodMetrics.metrics.k8s.io prod/api");
+  });
+
   it("keeps the core target label compact", () => {
     expect(
       formatInvestigationTarget({

package/src/components/diagnose/target.ts

@@ -1,6 +1,6 @@
 import { resourceKey } from "@skyhook-io/k8s-ui";
 
-import { kindToPluralWithGroup } from "../../utils/navigation";
+import { kindToPluralWithGroup, knownKindForPluralWithGroup } from "../../utils/navigation";
 
 export interface InvestigationTargetIdentity {
   kind: string;
@@ -31,6 +31,7 @@ export function runTargetKey(
 export function formatInvestigationTarget(
   target: InvestigationTargetIdentity,
 ): string {
-  const kind = target.group ? `${target.kind}.${target.group}` : target.kind;
+  const canonicalKind = knownKindForPluralWithGroup(target.kind, target.group) ?? target.kind;
+  const kind = target.group ? `${canonicalKind}.${target.group}` : canonicalKind;
   return `${kind} ${target.namespace ? `${target.namespace}/` : ""}${target.name}`;
 }

package/src/components/gitops/GitOpsView.tsx

@@ -72,6 +72,9 @@ import { useRegisterShortcut } from '../../hooks/useKeyboardShortcuts'
 import { CodeViewer } from '../ui/CodeViewer'
 import { ArgoResourceDiffLoader } from './ArgoResourceDiffLoader'
 import { RevisionMetaChip } from './RevisionMetaChip'
+import { RemoteDestinationCloudHint } from './RemoteDestinationCloudHint'
+
+const GITOPS_HEALTH_DOCS_URL = 'https://radarhq.io/docs/features/gitops#per-resource-health'
 import type { GitOpsHistoryItem } from '@skyhook-io/k8s-ui'
 
 const GITOPS_KINDS: APIResource[] = [
@@ -634,6 +637,9 @@ function GitOpsDetailView({ namespaces, onOpenResource, onOpenSettings }: GitOps
       detail={detail}
       insight={insightsQ.data ?? null}
       insightLoading={insightsQ.isLoading}
+      healthDocsUrl={GITOPS_HEALTH_DOCS_URL}
+      remoteDestinationHint={<RemoteDestinationCloudHint />}
+      onOpenSettings={onOpenSettings}
       renderRevisionMeta={
         isArgoApp && insightsQ.data?.capabilities?.revisionMetadataAvailable
           ? (revision) => (
@@ -808,6 +814,7 @@ function GitOpsDetailView({ namespaces, onOpenResource, onOpenSettings }: GitOps
                 onQueryChange={setGraphSearch}
                 filters={graphFilters}
                 showToolbar={false}
+                issues={insightsQ.data?.issues}
               />
             </div>
           </div>

package/src/components/gitops/RemoteDestinationCloudHint.tsx

@@ -0,0 +1,26 @@
+import { useNavCustomization } from '../../context/NavCustomization'
+import { useCapabilities } from '../../api/client'
+import { openCloudFunnel } from '../CloudFunnelButton'
+
+// The one sentence a standalone Radar adds after "this application deploys
+// to another cluster": the thing the user just ran into is what Radar Cloud
+// does. "Radar Cloud" opens the same dialog as the top-right button, so
+// there is one pitch and one connect flow. That dialog connects THIS
+// cluster; the destination is a second connect from Cloud, which is why the
+// copy says "both clusters" and promises the view in Cloud, not here. Rendered only when that button
+// is: the server decides whether there is anything to pitch (cloudConnect
+// capability), and embedded hosts (Radar Cloud itself) mount neither.
+export function RemoteDestinationCloudHint() {
+  const { embedded } = useNavCustomization()
+  const capabilities = useCapabilities()
+  if (embedded || !capabilities.data?.cloudConnect) return null
+  return (
+    <>
+      Connect both clusters to{' '}
+      <button type="button" onClick={openCloudFunnel} className="underline decoration-theme-border underline-offset-2 hover:text-theme-text-primary">
+        Radar Cloud
+      </button>{' '}
+      to see this app's resources together.
+    </>
+  )
+}

package/src/components/resource/PrometheusCharts.overlays.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { computeRequestLimitLines } from './PrometheusCharts'
+
+describe('Pod request and limit overlays', () => {
+  it('does not draw a Pod limit when one runtime container is unlimited', () => {
+    const resource = { spec: { containers: [
+      { resources: { requests: { cpu: '100m' }, limits: { cpu: '1' } } },
+      { resources: { requests: { cpu: '200m' } } },
+    ] } }
+    const lines = computeRequestLimitLines(resource, 'Pod', 'cpu')!
+    expect(lines).toHaveLength(1)
+    expect(lines[0].kind).toBe('request')
+    expect(lines[0].value).toBeCloseTo(0.3)
+  })
+  it('sums fully limited runtime containers at per-Pod scale', () => {
+    const resource = { spec: { replicas: 5, template: { spec: {
+      containers: [{ resources: { limits: { cpu: '1' } } }],
+      initContainers: [{ restartPolicy: 'Always', resources: { limits: { cpu: '200m' } } }],
+    } } } }
+    expect(computeRequestLimitLines(resource, 'Deployment', 'cpu')![0].value).toBeCloseTo(1.2)
+  })
+})

package/src/components/resource/PrometheusCharts.tsx

@@ -121,6 +121,7 @@ export function PrometheusCharts({ kind, namespace, name, showEmptyState = false
       statusError={status?.error}
       onConnect={() => connectMutation.mutate()}
       connecting={connectMutation.isPending}
+      discovering={status?.discovering === true}
       category={activeCategory}
       onCategoryChange={setActiveCategory}
       range={timeRange}
@@ -161,12 +162,12 @@ export function computeRequestLimitLines(
   if (runtimeContainers.length === 0) return undefined
 
   let reqSum = 0, reqAny = false
-  let limSum = 0, limAny = false
+  let limSum = 0, limAll = true
   for (const c of runtimeContainers) {
     const req = readQuantity(c.resources?.requests?.[category], category)
     const lim = readQuantity(c.resources?.limits?.[category], category)
     if (req != null) { reqSum += req; reqAny = true }
-    if (lim != null) { limSum += lim; limAny = true }
+    if (lim != null && lim > 0) { limSum += lim } else { limAll = false }
   }
 
   const lines: ReferenceLine[] = []
@@ -177,7 +178,7 @@ export function computeRequestLimitLines(
       kind: 'request',
     })
   }
-  if (limAny) {
+  if (limAll) {
     lines.push({
       value: limSum,
       label: `limit ${formatRequestLimitLabel(limSum, category)}`,

package/src/components/resource/PrometheusChartsGrid.render.test.tsx

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { renderToString } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { NavCustomizationProvider } from '../../context/NavCustomization'
+import type { WorkloadMetrics } from '../../api/workloadMetrics'
+
+let connected = false
+const ranges: string[] = []
+const charts: { seriesLabels?: string[]; referenceLines?: unknown[] }[] = []
+let workload: WorkloadMetrics
+
+vi.mock('../../api/client', async (importActual) => ({
+  ...(await importActual<typeof import('../../api/client')>()),
+  useAutoPromConnect: () => undefined,
+  usePrometheusStatus: () => ({ data: { connected, error: 'Backend query failed' } }),
+  usePrometheusConnect: () => ({ mutate: vi.fn(), isPending: false }),
+  usePrometheusResourceMetrics: (_kind: string, _ns: string, _name: string, _category: string, range: string) => {
+    ranges.push(range)
+    return { data: { unit: 'cores', result: { series: [{ labels: { pod: 'web-0' }, dataPoints: [{ timestamp: 100, value: 1 }, { timestamp: 160, value: 2 }] }] } } }
+  },
+}))
+vi.mock('../../api/workloadMetrics', () => ({ useWorkloadMetrics: () => ({ data: workload }) }))
+vi.mock('./RestartChart', () => ({ RestartEventLane: () => null }))
+vi.mock('./RightsizingStrip', () => ({ RightsizingStrip: () => null }))
+vi.mock('@skyhook-io/k8s-ui/components/charts', async (importActual) => ({
+  ...(await importActual<typeof import('@skyhook-io/k8s-ui/components/charts')>()),
+  AreaChart: (props: typeof charts[number]) => { charts.push(props); return <span>Chart</span> },
+}))
+
+const { PrometheusChartsGrid } = await import('./PrometheusChartsGrid')
+const resource = { spec: { template: { spec: { containers: [{ resources: { requests: { cpu: '100m' }, limits: { cpu: '200m' } } }] } } } }
+const render = (url = '/workloads/Deployment/demo/web?tab=metrics', embedded = false) => renderToString(
+  <MemoryRouter initialEntries={[url]}><NavCustomizationProvider value={embedded ? { embedded: true, rightExtras: null } : {}}>
+    <PrometheusChartsGrid kind="Deployment" namespace="demo" name="web" resource={resource} />
+  </NavCustomizationProvider></MemoryRouter>,
+)
+
+beforeEach(() => {
+  connected = false
+  ranges.length = 0
+  charts.length = 0
+  workload = { state: 'available', sources: [], pods: 1, podsTotal: 1, start: 100, end: 160, stepSeconds: 60, rateWindowSeconds: 300, history: {}, comparison: {}, panels: {} }
+})
+
+describe('Expanded metrics recovery and scope', () => {
+  it('offers standalone setup without losing the backend error or retry', () => {
+    const html = render()
+    expect(html).toContain('Backend query failed')
+    expect(html).toContain('Discover Prometheus')
+    expect(html).toContain('Configure metrics')
+    expect(html).toContain('workload-metrics.md#what-each-chart-needs')
+  })
+  it('uses operator guidance instead of standalone settings when embedded', () => {
+    const html = render(undefined, true)
+    expect(html).toContain('Ask your operator')
+    expect(html).not.toContain('Configure metrics')
+    expect(html).toContain('Discover Prometheus')
+  })
+  it.each([
+    ['/workloads/Deployment/demo/web?tab=metrics&metricsRange=3h', '3h'],
+    ['/applications?app=demo&workload=Deployment%2Fdemo%2Fweb&tab=metrics&metricsRange=6h', '6h'],
+    ['/applications?tab=metrics&metricsRange=invalid', '1h'],
+    ['/applications?tab=metrics', '1h'],
+  ])('reads and validates the URL range: %s', (url, expected) => {
+    connected = true
+    const html = render(url)
+    expect(html).toContain(`value="${expected}" selected=""`)
+    expect(ranges.length).toBeGreaterThan(0)
+    expect(ranges.every((range) => range === expected)).toBe(true)
+  })
+  it('leaves unverified charts accessible without template overlays or saturation', () => {
+    connected = true
+    const html = render()
+    expect(html).toContain('<details aria-label="Name-matched resource metrics">')
+    expect(html).toContain('Network and storage')
+    expect(html).not.toContain('% of limit')
+    expect(charts.length).toBeGreaterThan(0)
+    expect(charts.every((chart) => !chart.referenceLines?.length)).toBe(true)
+  })
+  it('labels unlabeled request totals without changing aggregate and quantile labels', () => {
+    connected = true
+    const series = [{ labels: {}, dataPoints: [{ timestamp: 160, value: 1 }] }]
+    workload.panels.requests = { state: 'available', unit: 'requests/s', series }
+    workload.panels.p50 = { state: 'available', unit: 'seconds', series }
+    workload.panels.p95 = { state: 'available', unit: 'seconds', series }
+    workload.panels.cpu = { state: 'available', unit: 'cores', series: [{ ...series[0], labels: { aggregation: 'Workload' } }, { ...series[0], labels: { aggregation: 'Maximum Pod' } }] }
+    render()
+    expect(charts.map((chart) => chart.seriesLabels)).toContainEqual(['Requests / sec'])
+    expect(charts.map((chart) => chart.seriesLabels)).toContainEqual(['p50', 'p95'])
+    expect(charts.map((chart) => chart.seriesLabels)).toContainEqual(['Workload', 'Maximum Pod'])
+  })
+  it('retains template references on verified current-Pod charts', () => {
+    connected = true
+    workload.history.cpu = { mode: 'current-pods' }
+    workload.panels.cpu = { state: 'available', unit: 'cores', series: [{ labels: { pod: 'web-0' }, dataPoints: [{ timestamp: 160, value: 0.1 }] }] }
+    render()
+    expect(charts.some((chart) => chart.referenceLines?.some((line) => (line as { label: string }).label === 'Template request 100m'))).toBe(true)
+  })
+})