@rancher/shell 3.0.10 → 3.0.11

package/components/nav/TopLevelMenu.helper.ts

@@ -107,7 +107,6 @@ export interface TopLevelMenuHelper {
 
 export abstract class BaseTopLevelMenuHelper {
   protected $store: VuexStore;
-  protected hasProvCluster: boolean;
 
   /**
   * Filter mgmt clusters by
@@ -143,11 +142,9 @@ export abstract class BaseTopLevelMenuHelper {
     $store: VuexStore,
 }) {
     this.$store = $store;
-
-    this.hasProvCluster = this.$store.getters[`management/schemaFor`](CAPI.RANCHER_CLUSTER);
   }
 
-  protected convertToCluster(mgmtCluster: MgmtCluster, provCluster: ProvCluster): TopLevelMenuCluster {
+  protected convertToCluster(mgmtCluster: MgmtCluster, provCluster?: ProvCluster): TopLevelMenuCluster {
     return {
       id:              mgmtCluster.id,
       label:           mgmtCluster.nameDisplay,
@@ -173,7 +170,6 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
 
   private clustersPinnedWrapper: PaginationWrapper<any>;
   private clustersOthersWrapper: PaginationWrapper<any>;
-  private provClusterWrapper: PaginationWrapper<any>;
 
   private clusterCount = 0;
 
@@ -223,43 +219,10 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
       },
       formatResponse: { classify: true },
     });
-    // Fetch all prov clusters for the mgmt clusters we have
-    this.provClusterWrapper = new PaginationWrapper({
-      $store,
-      id:       'top-level-menu-prov-clusters',
-      onChange: async({ forceWatch, revision }) => {
-        if (!this.args) {
-          return;
-        }
-        try {
-          await this.update({
-            ...this.args,
-            forceWatch,
-            provClusterRevision: revision,
-          });
-        } catch {
-          // Failures should be logged lower down, not much we can do here except catch to prevent whole ui page warnings in dev mode
-        }
-      },
-      enabledFor: {
-        store:    STORE.MANAGEMENT,
-        resource: {
-          id:      CAPI.RANCHER_CLUSTER,
-          context: 'side-bar',
-        }
-      },
-      formatResponse: { classify: true }
-    });
   }
 
   // ---------- requests ----------
   async update(args: UpdateArgs) {
-    if (!this.hasProvCluster) {
-      // We're filtering out mgmt clusters without prov clusters, so if the user can't see any prov clusters at all
-      // exit early
-      return;
-    }
-
     this.args = args;
     const promises = {
       pinned:    this.updatePinned(args),
@@ -271,22 +234,11 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
       notPinned: MgmtCluster[]
     } = await allHash(promises) as any;
 
-    const provClusters = await this.updateProvCluster(res.notPinned, res.pinned, args);
-    const provClustersByMgmtId = provClusters.reduce((res: { [mgmtId: string]: ProvCluster}, provCluster: ProvCluster) => {
-      if (provCluster.mgmtClusterId) {
-        res[provCluster.mgmtClusterId] = provCluster;
-      }
-
-      return res;
-    }, {} as { [mgmtId: string]: ProvCluster});
-
     // Filter out mgmt clusters that don't have matching prov cluster and convert remaining to required format
     const _clustersNotPinned = res.notPinned
-      .filter((mgmtCluster) => !!provClustersByMgmtId[mgmtCluster.id])
-      .map((mgmtCluster) => this.convertToCluster(mgmtCluster, provClustersByMgmtId[mgmtCluster.id]));
+      .map((mgmtCluster) => this.convertToCluster(mgmtCluster));
     const _clustersPinned = res.pinned
-      .filter((mgmtCluster) => !!provClustersByMgmtId[mgmtCluster.id])
-      .map((mgmtCluster) => this.convertToCluster(mgmtCluster, provClustersByMgmtId[mgmtCluster.id]));
+      .map((mgmtCluster) => this.convertToCluster(mgmtCluster));
 
     this.clustersPinned.length = 0;
     this.clustersOthers.length = 0;
@@ -298,7 +250,6 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
   async destroy() {
     this.clustersPinnedWrapper.onDestroy();
     this.clustersOthersWrapper.onDestroy();
-    this.provClusterWrapper.onDestroy();
   }
 
   /**
@@ -445,41 +396,21 @@ export class TopLevelMenuHelperPagination extends BaseTopLevelMenuHelper impleme
       console.warn('Unable to set saved count for clusters', err); // eslint-disable-line no-console
     }
   }
-
-  /**
-   * Find all provisioning clusters associated with the displayed mgmt clusters
-   */
-  private async updateProvCluster(notPinned: MgmtCluster[], pinned: MgmtCluster[], args: UpdateArgs): Promise<ProvCluster[]> {
-    return this.provClusterWrapper.request({
-      forceWatch: args.forceWatch,
-      pagination: {
-        filters: [
-          PaginationParamFilter.createMultipleFields(
-            [...notPinned, ...pinned]
-              .map((mgmtCluster) => ({
-                field: 'status.clusterName', value: mgmtCluster.id, equals: true, exact: true
-              }))
-          )
-        ],
-        page:                 1,
-        sort:                 [],
-        projectsOrNamespaces: []
-      },
-      revision: args.provClusterRevision
-    })
-      .then((r) => r.data);
-  }
 }
 
 /**
  * Helper designed to supply non-paginated results for the top level menu cluster resources
  */
 export class TopLevelMenuHelperLegacy extends BaseTopLevelMenuHelper implements TopLevelMenuHelper {
+  protected hasProvCluster: boolean;
+
   constructor({ $store }: {
     $store: VuexStore,
   }) {
     super({ $store });
 
+    this.hasProvCluster = this.$store.getters[`management/schemaFor`](CAPI.RANCHER_CLUSTER);
+
     if (this.hasProvCluster) {
       $store.dispatch('management/findAll', { type: CAPI.RANCHER_CLUSTER });
     }
@@ -664,9 +595,6 @@ class TopLevelMenuHelperService {
     const canPagination = $store.getters[`management/paginationEnabled`]({
       id:      MANAGEMENT.CLUSTER,
       context: 'side-bar',
-    }) && $store.getters[`management/paginationEnabled`]({
-      id:      CAPI.RANCHER_CLUSTER,
-      context: 'side-bar',
     });
 
     this._helper = canPagination ? new TopLevelMenuHelperPagination({ $store }) : new TopLevelMenuHelperLegacy({ $store });

package/components/nav/__tests__/TopLevelMenu.helper.test.ts

@@ -102,7 +102,7 @@ describe('topLevelMenu.helper', () => {
     it('should initialize PaginationWrappers', () => {
       mockStore.getters['management/schemaFor'].mockReturnValue(true);
       new TopLevelMenuHelperPagination({ $store: mockStore });
-      expect(PaginationWrapper).toHaveBeenCalledTimes(3);
+      expect(PaginationWrapper).toHaveBeenCalledTimes(2);
     });
 
     it('should update clusters correctly', async() => {
@@ -113,19 +113,13 @@ describe('topLevelMenu.helper', () => {
       const mgmtOthers = [{
         id: 'c2', nameDisplay: 'Other', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
       }];
-      const provClusters = [
-        { mgmtClusterId: 'c1' },
-        { mgmtClusterId: 'c2' }
-      ];
 
       const mockRequestPinned = jest.fn().mockResolvedValue({ data: mgmtPinned });
       const mockRequestOthers = jest.fn().mockResolvedValue({ data: mgmtOthers });
-      const mockRequestProv = jest.fn().mockResolvedValue({ data: provClusters });
 
       (PaginationWrapper as unknown as jest.Mock)
         .mockImplementationOnce(() => ({ request: mockRequestPinned, onDestroy: jest.fn() }))
-        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }))
-        .mockImplementationOnce(() => ({ request: mockRequestProv, onDestroy: jest.fn() }));
+        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }));
 
       const helper = new TopLevelMenuHelperPagination({ $store: mockStore });
 
@@ -169,57 +163,12 @@ describe('topLevelMenu.helper', () => {
         },
         revision: undefined
       });
-      expect(mockRequestProv).toHaveBeenCalledWith({
-        forceWatch: undefined,
-        pagination: {
-          filters: [{
-            equals: true,
-            fields: [{
-              equals: true, exact: true, field: 'status.clusterName', value: mgmtOthers[0].id
-            }, {
-              equals: true, exact: true, field: 'status.clusterName', value: mgmtPinned[0].id
-            }],
-            param: 'filter'
-          }],
-          page:                 1,
-          projectsOrNamespaces: [],
-          sort:                 []
-        },
-        revision: undefined
-      });
 
       expect(helper.clustersPinned).toHaveLength(1);
       expect(helper.clustersPinned[0].id).toBe('c1');
       expect(helper.clustersOthers).toHaveLength(1);
       expect(helper.clustersOthers[0].id).toBe('c2');
     });
-
-    it('should filter out mgmt clusters without matching prov clusters', async() => {
-      mockStore.getters['management/schemaFor'].mockReturnValue(true);
-      const mgmtOthers = [{
-        id: 'c2', nameDisplay: 'Other', isReady: true, pinned: false, pin: jest.fn(), unpin: jest.fn()
-      }];
-      // No prov cluster for c2
-      const provClusters: any[] = [];
-
-      const mockRequestPinned = jest.fn().mockResolvedValue({ data: [] });
-      const mockRequestOthers = jest.fn().mockResolvedValue({ data: mgmtOthers });
-      const mockRequestProv = jest.fn().mockResolvedValue({ data: provClusters });
-
-      (PaginationWrapper as unknown as jest.Mock)
-        .mockImplementationOnce(() => ({ request: mockRequestPinned, onDestroy: jest.fn() }))
-        .mockImplementationOnce(() => ({ request: mockRequestOthers, onDestroy: jest.fn() }))
-        .mockImplementationOnce(() => ({ request: mockRequestProv, onDestroy: jest.fn() }));
-
-      const helper = new TopLevelMenuHelperPagination({ $store: mockStore });
-
-      await helper.update({
-        searchTerm: '',
-        pinnedIds:  [],
-      });
-
-      expect(helper.clustersOthers).toHaveLength(0);
-    });
   });
 
   describe('class: TopLevelMenuHelperService', () => {

package/config/private-label.js

@@ -1,5 +1,6 @@
 import { SETTING } from './settings';
 import { CURRENT_RANCHER_VERSION } from './version';
+import { requireAsset } from '@shell/utils/require-asset';
 
 export const ANY = 0;
 export const STANDARD = 1;
@@ -78,7 +79,7 @@ export function setTitle() {
   const v = getVendor();
 
   if (v === 'Harvester') {
-    const ico = require(`~shell/assets/images/pl/harvester.png`);
+    const ico = requireAsset(`~shell/assets/images/pl/harvester.png`);
 
     document.title = 'Harvester';
     const link = document.createElement('link');

package/config/product/apps.js

@@ -53,6 +53,7 @@ export function init(store) {
 
   configureType(CATALOG.APP, { isCreatable: false, isEditable: false });
   configureType(CATALOG.OPERATION, { isCreatable: false, isEditable: false });
+  configureType(CATALOG.CLUSTER_REPO, { listCreateButtonLabelKey: 'catalog.repo.add' });
 
   const repoType = {
     name:     'type',

package/core/__tests__/extension-manager-impl.test.js

@@ -38,8 +38,30 @@ jest.mock('@shell/core/plugin', () => {
   };
 });
 
-// Mock ExtensionPoint
-jest.mock('@shell/core/types', () => ({ ExtensionPoint: { EDIT_YAML: 'edit-yaml' } }));
+// Mock ExtensionPoint — only EDIT_YAML, simulating an older dashboard (e.g. 2.13)
+// that does not know about newer ExtensionPoints like 'Table'.
+// The ensureUIConfigCompat tests override this to include TABLE for plugin-helpers,
+// simulating an extension shipping a newer shell.
+jest.mock('@shell/core/types', () => ({
+  ExtensionPoint: { EDIT_YAML: 'edit-yaml' },
+  ActionLocation: { TABLE: 'table-action' },
+  CardLocation:   {},
+}));
+
+jest.mock('@shell/utils/platform', () => ({ isMac: false }));
+jest.mock('@shell/utils/string', () => ({
+  ucFirst:   jest.fn((s) => s),
+  randomStr: jest.fn(() => 'abc123'),
+}));
+jest.mock('@shell/config/query-params', () => ({
+  _EDIT:   'edit',
+  _CONFIG: 'config',
+  _DETAIL: 'detail',
+  _LIST:   'list',
+  _CREATE: 'create',
+}));
+jest.mock('@shell/utils/router', () => ({ getProductFromRoute: jest.fn() }));
+jest.mock('@shell/utils/object', () => ({ isEqual: jest.fn() }));
 
 // Mock PluginRoutes
 jest.mock('@shell/core/plugin-routes', () => {
@@ -299,6 +321,28 @@ describe('extension Manager', () => {
       delete window[pluginId];
     });
 
+    it('surfaces the plugin id and original error message when initialization fails', async() => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const pluginId = 'surface-error-plugin';
+      const originalError = new Error('something went wrong');
+      const mockPluginInit = jest.fn().mockImplementation(() => {
+        throw originalError;
+      });
+
+      window[pluginId] = { default: mockPluginInit };
+
+      const loadPromise = manager.loadAsync(pluginId, 'test.js');
+      const script = document.head.querySelector(`script[id="${ pluginId }"]`);
+
+      script.onload();
+
+      await expect(loadPromise).rejects.toThrow(`Could not initialize plugin ${ pluginId } - ${ originalError.message }`);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(`Could not initialize plugin ${ pluginId }`, originalError);
+
+      consoleErrorSpy.mockRestore();
+      delete window[pluginId];
+    });
+
     it('rejects if script load fails', async() => {
       const pluginId = 'fail-plugin';
       const loadPromise = manager.loadAsync(pluginId, 'bad-url.js');
@@ -433,5 +477,146 @@ describe('extension Manager', () => {
 
       expect(config).toStrictEqual([]);
     });
+
+    it('returns empty array for non-existent type', () => {
+      // Simulates an extension using a newer ExtensionPoint (e.g. 'Table')
+      // that the running dashboard does not have in its uiConfig
+      const config = manager.getUIConfig('unknown-type', 'some-area');
+
+      expect(config).toStrictEqual([]);
+    });
+  });
+
+  describe('ensureUIConfigCompat (via plugin-helpers)', () => {
+    // These tests verify that getApplicableExtensionEnhancements tracks missing
+    // ExtensionPoint keys and exits early when accessing them.
+    // This is the forwards-compatibility mechanism for extensions running on
+    // older dashboards that don't know about newer ExtensionPoints (e.g. 'Table').
+
+    const mockRoute = {
+      name:   'test',
+      params: {},
+      query:  {},
+      meta:   {},
+      hash:   '',
+      path:   '/test',
+    };
+
+    // Each test needs a fresh plugin-helpers module to reset the _uiConfigPatched tracking.
+    // The extension-manager is created with the "old" ExtensionPoint (only EDIT_YAML),
+    // then plugin-helpers is re-required with an "upgraded" ExtensionPoint that includes TABLE,
+    // simulating an extension built with a newer shell running on an older dashboard.
+    let freshGetApplicable;
+    let freshManager;
+
+    beforeEach(() => {
+      freshManager = createExtensionManager(context);
+
+      // Reset modules so plugin-helpers._uiConfigPatched starts as empty object
+      jest.resetModules();
+
+      // Override the types mock so plugin-helpers sees a newer ExtensionPoint with TABLE
+      jest.doMock('@shell/core/types', () => ({
+        ExtensionPoint: {
+          EDIT_YAML: 'edit-yaml',
+          TABLE:     'Table',
+        },
+        ActionLocation: { TABLE: 'table-action' },
+        CardLocation:   {},
+      }));
+
+      freshGetApplicable = require('@shell/core/plugin-helpers').getApplicableExtensionEnhancements;
+    });
+
+    it('returns empty array for missing ExtensionPoint and does not mutate uiConfig', () => {
+      // Verify 'Table' is NOT in uiConfig before the call
+      const uiConfig = freshManager.getAllUIConfig();
+
+      expect(uiConfig['Table']).toBeUndefined();
+
+      // Call getApplicableExtensionEnhancements which triggers ensureUIConfigCompat
+      const result = freshGetApplicable({ $extension: freshManager }, 'Table', 'some-area', mockRoute);
+
+      // Should return empty array for missing extension point
+      expect(result).toStrictEqual([]);
+
+      // uiConfig should NOT be mutated - 'Table' should remain undefined
+      expect(uiConfig['Table']).toBeUndefined();
+    });
+
+    it('does not affect existing ExtensionPoint keys', () => {
+      const mockAction = { label: 'Test', locationConfig: {} };
+      const plugin = {
+        types:           {},
+        uiConfig:        { 'edit-yaml': { header: [mockAction] } },
+        l10n:            {},
+        modelExtensions: {},
+        stores:          [],
+        locales:         [],
+        routes:          [],
+        validators:      {},
+        productNames:    [],
+      };
+
+      freshManager.applyPlugin(plugin);
+
+      const result = freshGetApplicable({ $extension: freshManager }, 'edit-yaml', 'header', mockRoute);
+
+      // Should return the actual action
+      expect(result).toHaveLength(1);
+      expect(result[0].label).toBe('Test');
+
+      // Existing config should be untouched
+      const uiConfig = freshManager.getAllUIConfig();
+
+      expect(uiConfig['edit-yaml'].header).toHaveLength(1);
+      expect(uiConfig['edit-yaml'].header[0]).toBe(mockAction);
+    });
+
+    it('logs a warning for missing ExtensionPoints', () => {
+      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+      freshGetApplicable({ $extension: freshManager }, 'Table', 'some-area', mockRoute);
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Table')
+      );
+
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('dashboard-side getUIConfig calls remain safe with optional chaining', () => {
+      // getUIConfig('Table', ...) should not crash even though 'Table' is missing
+      // Returns empty array due to optional chaining in extension-manager
+      expect(freshManager.getUIConfig('Table', 'some-area')).toStrictEqual([]);
+
+      // Trigger ensureUIConfigCompat via getApplicableExtensionEnhancements
+      const result = freshGetApplicable({ $extension: freshManager }, 'Table', 'some-area', mockRoute);
+
+      // getApplicableExtensionEnhancements exits early and returns empty array
+      expect(result).toStrictEqual([]);
+
+      // uiConfig is NOT mutated - 'Table' key still doesn't exist
+      const uiConfig = freshManager.getAllUIConfig();
+
+      expect(uiConfig['Table']).toBeUndefined();
+
+      // Direct getUIConfig calls still work safely (optional chaining)
+      expect(freshManager.getUIConfig('Table', 'some-area')).toStrictEqual([]);
+    });
+
+    it('only logs warning once for each missing ExtensionPoint', () => {
+      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+      // First call logs warning and tracks 'Table' as missing
+      freshGetApplicable({ $extension: freshManager }, 'Table', 'some-area', mockRoute);
+      // Second call should not log warning again (already tracked)
+      freshGetApplicable({ $extension: freshManager }, 'Table', 'some-area', mockRoute);
+
+      // Warning should only be logged once
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+
+      consoleWarnSpy.mockRestore();
+    });
   });
 });

package/core/extension-manager-impl.js

@@ -124,7 +124,9 @@ export const createExtensionManager = (context) => {
           } catch (e) {
             delete plugins[id];
 
-            return reject(new Error('Could not initialize plugin'));
+            console.error(`Could not initialize plugin ${ id }`, e); // eslint-disable-line no-console
+
+            return reject(new Error(`Could not initialize plugin ${ id } - ${ e?.message }`));
           }
 
           // Load all of the types etc from the plugin
@@ -426,7 +428,7 @@ export const createExtensionManager = (context) => {
    * Return the UI configuration for the given type and location
    */
     getUIConfig(type, uiArea) {
-      return uiConfig[type][uiArea] || [];
+      return uiConfig[type]?.[uiArea] || [];
     },
 
     /**

package/core/plugin-helpers.ts

@@ -137,6 +137,30 @@ function checkExtensionRouteBinding($route: any, locationConfig: any, context: a
   return res;
 }
 
+// Track which ExtensionPoint keys are missing from the extension manager's uiConfig.
+// This handles forwards-compatibility when extensions ship a newer shell that defines
+// ExtensionPoint values the running dashboard doesn't know about (e.g. 'Table' on 2.13).
+const _uiConfigPatched: { [point: string]: boolean } = {};
+
+function ensureUIConfigCompat(extensionManager: any) {
+  const uiConfig = extensionManager.getAllUIConfig?.();
+
+  if (uiConfig) {
+    const missingPoints: { [point: string]: boolean } = {};
+
+    Object.values(ExtensionPoint).forEach((ep) => {
+      if (!uiConfig[ep] && !_uiConfigPatched[ep]) {
+        missingPoints[ep] = true;
+        _uiConfigPatched[ep] = true;
+      }
+    });
+
+    if (Object.keys(missingPoints).length) {
+      console.warn(`[plugin-helpers] These ExtensionPoints aren't available for usage in this Rancher version: ${ Object.keys(missingPoints).join(', ') }`); // eslint-disable-line no-console
+    }
+  }
+}
+
 export function getApplicableExtensionEnhancements<T>(
   pluginCtx: ComponentOptionsMixin,
   actionType: ExtensionPoint,
@@ -148,6 +172,13 @@ export function getApplicableExtensionEnhancements<T>(
 
   // gate it so that we prevent errors on older versions of dashboard
   if (pluginCtx.$extension?.getUIConfig) {
+    ensureUIConfigCompat(pluginCtx.$extension);
+
+    // Exit early if actionType doesn't exist in the extension manager's uiConfig
+    if (_uiConfigPatched[actionType]) {
+      return [];
+    }
+
     const actions = pluginCtx.$extension.getUIConfig(actionType, uiArea);
 
     actions.forEach((action: any, i: number) => {

package/detail/__tests__/node.test.ts

@@ -0,0 +1,83 @@
+import { shallowMount } from '@vue/test-utils';
+import node from '@shell/detail/node.vue';
+import ConsumptionGauge from '@shell/components/ConsumptionGauge.vue';
+
+describe('view: node detail', () => {
+  const mockStore = {
+    getters: {
+      'cluster/schemaFor':         () => undefined,
+      'cluster/paginationEnabled': () => false,
+      'type-map/headersFor':       jest.fn(),
+      'i18n/t':                    (key: string) => key,
+      currentCluster:              { id: 'local' },
+    },
+    dispatch: jest.fn(),
+  };
+
+  const mocks = {
+    $store:      mockStore,
+    $fetchState: { pending: false },
+  };
+
+  const defaultNodeValue = {
+    metadata: { name: 'test-node' },
+    status:   {
+      nodeInfo: {}, images: [], conditions: []
+    },
+    spec:               { taints: [] },
+    pods:               [],
+    cpuCapacity:        4,
+    cpuUsage:           2,
+    ramReserved:        8000,
+    ramUsage:           4000,
+    podCapacity:        110,
+    podConsumed:        5,
+    isPidPressureOk:    true,
+    isDiskPressureOk:   true,
+    isMemoryPressureOk: true,
+    isKubeletOk:        true,
+    internalIp:         '10.0.0.1',
+  };
+
+  function createWrapper(nodeOverrides = {}) {
+    return shallowMount(node, {
+      props:  { value: { ...defaultNodeValue, ...nodeOverrides } },
+      global: { mocks },
+    });
+  }
+
+  function findGaugeByResource(wrapper: ReturnType<typeof createWrapper>, resourceKey: string) {
+    const gauges = wrapper.findAllComponents(ConsumptionGauge);
+
+    return gauges.find(
+      (g) => g.attributes('resourcename')?.includes(resourceKey)
+    );
+  }
+
+  it('should pass the "running" translation key as usedlabel to the pods ConsumptionGauge', () => {
+    const wrapper = createWrapper();
+
+    const podsGauge = findGaugeByResource(wrapper, 'consumptionGauge.pods');
+
+    expect(podsGauge).toBeDefined();
+    expect(podsGauge!.attributes('usedlabel')).toContain('consumptionGauge.running');
+  });
+
+  it('should NOT pass a usedlabel to the CPU ConsumptionGauge', () => {
+    const wrapper = createWrapper();
+
+    const cpuGauge = findGaugeByResource(wrapper, 'consumptionGauge.cpu');
+
+    expect(cpuGauge).toBeDefined();
+    expect(cpuGauge!.attributes('usedlabel')).toBeUndefined();
+  });
+
+  it('should NOT pass a usedlabel to the Memory ConsumptionGauge', () => {
+    const wrapper = createWrapper();
+
+    const memoryGauge = findGaugeByResource(wrapper, 'consumptionGauge.memory');
+
+    expect(memoryGauge).toBeDefined();
+    expect(memoryGauge!.attributes('usedlabel')).toBeUndefined();
+  });
+});

package/detail/management.cattle.io.oidcclient.vue

@@ -9,6 +9,7 @@ import DateComponent from '@shell/components/formatter/Date.vue';
 import { RcItemCard } from '@components/RcItemCard';
 import ActionMenu, { type ActionMenuSelection } from '@shell/components/ActionMenuShell.vue';
 import { Banner } from '@components/Banner';
+import keySvg from '~shell/assets/images/key.svg';
 
 type SecretActionType = 'create-secret' | 'regen-secret' | 'remove-secret'
 interface ClientSecretData { createdAt: string, lastUsedAt: string, lastFiveCharacters: string }
@@ -228,7 +229,7 @@ export default defineComponent({
           clientSecrets.push({
             id:                 oidcSecretDataKey,
             header:             { title: { text: oidcSecretDataKey } },
-            image:              { src: require('~shell/assets/images/key.svg') },
+            image:              { src: keySvg },
             createdAt,
             lastFiveCharacters: oidcSecretData.lastFiveCharacters,
             lastUsedAt,

package/detail/node.vue

@@ -234,6 +234,7 @@ export default {
         :resource-name="t('node.detail.glance.consumptionGauge.pods')"
         :capacity="value.podCapacity"
         :used="value.podConsumed"
+        :used-label="t('node.detail.glance.consumptionGauge.running')"
       />
     </div>
     <div class="spacer" />