frontend: apiDiscovery: Tighten fallback logging and spy cleanup

Bound the aggregated-discovery fallback log to a type plus the top-level
key list (capped at 10 entries) instead of dumping the whole payload.
A real discovery response can carry thousands of entries and burying
the devtools obscures the actual signal we wanted to surface in #4840.
Errors on the rejected branch still pass through raw so stacks survive.

Reword the legacy .catch log to say "fetch or parse" since the same
handler also catches res.json() rejections, not only transport errors.

Hoist the console.debug spy to a beforeEach/afterEach pair scoped to
the new describe block so the cleanup runs even when an assertion
throws, and restore only that single spy rather than vi.restoreAllMocks
which would clobber the file-level vi.mock for ./fetch.

Signed-off-by: Rudraksha Singh Sengar <rudraksharss@gmail.com>

Author: WasThatRudy

frontend/src/lib/k8s/api/v2/apiDiscovery.test.ts

@@ -14,7 +14,16 @@
  * limitations under the License.
  */
 
-import { afterEach, beforeEach, describe, expect, it, MockedFunction, vi } from 'vitest';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  MockedFunction,
+  MockInstance,
+  vi,
+} from 'vitest';
 import { apiDiscovery } from './apiDiscovery'; // Adjust path as needed
 // Adjust path as needed
 import { clusterFetch } from './fetch'; // Adjust path as needed
@@ -582,14 +591,21 @@ describe('apiDiscovery', () => {
   // logging, making "missing resources in the UI" extremely hard to debug.
   // These tests pin the discovery path to its debug logging contract.
   describe('logs the cause of every fallback or skipped fetch (#4840)', () => {
-    // Restore console.debug even if an assertion throws, so the spy never
-    // leaks into later tests (the Vitest config has restoreMocks disabled).
+    // One shared spy created in beforeEach and torn down in afterEach so the
+    // cleanup runs even when an assertion throws. Restoring the single spy
+    // (rather than `vi.restoreAllMocks()`) leaves the file-level `vi.mock`
+    // for `./fetch` intact and avoids cross-test interference.
+    let debugSpy: MockInstance;
+
+    beforeEach(() => {
+      debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+    });
+
     afterEach(() => {
-      vi.restoreAllMocks();
+      debugSpy.mockRestore();
     });
 
     it('logs the rejection reason when aggregated /api rejects', async () => {
-      const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
       const networkError = new Error('aggregated /api network down');
 
       mockClusterFetch
@@ -608,7 +624,6 @@ describe('apiDiscovery', () => {
     });
 
     it('logs the unusable payload when aggregated returns no items array', async () => {
-      const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
       const malformed = { unexpected: 'shape' };
 
       mockClusterFetch
@@ -623,10 +638,21 @@ describe('apiDiscovery', () => {
       expect(
         messages.some(m => m.includes('Aggregated /api discovery unusable for cluster cluster1'))
       ).toBe(true);
+      // The unusable payload itself is logged as a bounded summary (type +
+      // top-level keys), not the raw body. Verifying the keys list keeps the
+      // contract honest without coupling the test to summary internals.
+      const summariesWithUnexpectedKey = debugSpy.mock.calls
+        .flat()
+        .filter((arg): arg is { keys: string[] } => {
+          if (!arg || typeof arg !== 'object') return false;
+          const keys = (arg as { keys?: unknown }).keys;
+          return Array.isArray(keys) && keys.every(k => typeof k === 'string');
+        })
+        .filter(summary => summary.keys.includes('unexpected'));
+      expect(summariesWithUnexpectedKey.length).toBeGreaterThan(0);
     });
 
     it('logs the rejection reason when the legacy /api fetch rejects', async () => {
-      const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
       const legacyApiError = new Error('legacy /api dropped');
 
       mockClusterFetch
@@ -639,13 +665,14 @@ describe('apiDiscovery', () => {
 
       const messages = debugSpy.mock.calls.map(args => String(args[0]));
       expect(
-        messages.some(m => m.includes('Legacy /api discovery fetch failed for cluster cluster1'))
+        messages.some(m =>
+          m.includes('Legacy /api discovery fetch or parse failed for cluster cluster1')
+        )
       ).toBe(true);
       expect(debugSpy.mock.calls.some(args => args.includes(legacyApiError))).toBe(true);
     });
 
     it('logs the rejection reason when the legacy /apis fetch rejects', async () => {
-      const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
       const legacyApisError = new Error('legacy /apis dropped');
 
       mockClusterFetch
@@ -658,7 +685,9 @@ describe('apiDiscovery', () => {
 
       const messages = debugSpy.mock.calls.map(args => String(args[0]));
       expect(
-        messages.some(m => m.includes('Legacy /apis discovery fetch failed for cluster cluster1'))
+        messages.some(m =>
+          m.includes('Legacy /apis discovery fetch or parse failed for cluster cluster1')
+        )
       ).toBe(true);
       expect(debugSpy.mock.calls.some(args => args.includes(legacyApisError))).toBe(true);
     });

frontend/src/lib/k8s/api/v2/apiDiscovery.tsx

@@ -17,6 +17,22 @@
 import type { ApiResource } from './ApiResource';
 import { clusterFetch } from './fetch';
 
+/**
+ * Produces a bounded representation of an aggregated-discovery payload for
+ * fallback debug logs. A real discovery response can carry thousands of
+ * entries; dumping it to the console slows devtools and buries the actual
+ * "why was this unusable" signal. We log the value's type plus the first few
+ * top-level keys, which is enough to tell a missing `items` array apart from
+ * a wholly unexpected shape without flooding the log.
+ */
+function summariseAggregatedPayload(value: unknown): unknown {
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value as object);
+    return { type: 'object', keys: keys.slice(0, 10), keyCount: keys.length };
+  }
+  return { type: typeof value, value };
+}
+
 /**
  * Processes the items from an aggregated API discovery response.
  * @param items - The array of discovery items from the Kubernetes API discovery endpoint
@@ -183,15 +199,15 @@ export async function apiDiscovery(clusters: string[]): Promise<ApiResource[]> {
             `Aggregated /api discovery unusable for cluster ${cluster}; falling back to legacy:`,
             apiAggregatedResult.status === 'rejected'
               ? apiAggregatedResult.reason
-              : apiAggregatedResult.value
+              : summariseAggregatedPayload(apiAggregatedResult.value)
           );
         }
         if (!apisAggregatedOk) {
           console.debug(
             `Aggregated /apis discovery unusable for cluster ${cluster}; falling back to legacy:`,
             apisAggregatedResult.status === 'rejected'
               ? apisAggregatedResult.reason
-              : apisAggregatedResult.value
+              : summariseAggregatedPayload(apisAggregatedResult.value)
           );
         }
         useFallback = true;
@@ -206,16 +222,26 @@ export async function apiDiscovery(clusters: string[]): Promise<ApiResource[]> {
 
     if (useFallback) {
       try {
+        // The `.catch` here covers both the transport (`clusterFetch` rejects
+        // on a network/HTTP failure) and the JSON parse step (`res.json()`
+        // rejects on a malformed body), so we say "fetch or parse" rather
+        // than just "fetch" to keep the log honest about which step blew up.
         const coreApiVersionsPromise = clusterFetch('/api', { cluster })
           .then(res => res.json())
           .catch(err => {
-            console.debug(`Legacy /api discovery fetch failed for cluster ${cluster}:`, err);
+            console.debug(
+              `Legacy /api discovery fetch or parse failed for cluster ${cluster}:`,
+              err
+            );
             return null;
           });
         const apiGroupsPromise = clusterFetch('/apis', { cluster })
           .then(res => res.json())
           .catch(err => {
-            console.debug(`Legacy /apis discovery fetch failed for cluster ${cluster}:`, err);
+            console.debug(
+              `Legacy /apis discovery fetch or parse failed for cluster ${cluster}:`,
+              err
+            );
             return null;
           });