feature: fix all remaining locations where tenancy is used within alerts

PeterYurkovich · PeterYurkovich · commit e9d77d5d1f20 · 2025-11-12T14:44:45.000-05:00
diff --git a/web/src/components/Incidents/IncidentsPage.tsx b/web/src/components/Incidents/IncidentsPage.tsx
@@ -65,7 +65,6 @@ import IncidentFilterToolbarItem, {
   useStateOptions,
 } from './ToolbarItemFilter';
 import { MonitoringProvider } from '../../contexts/MonitoringContext';
-import { ALL_NAMESPACES_KEY } from '../utils';
 import { isEmpty } from 'lodash-es';
 import { DataTestIDs } from '../data-test';
 import { DocumentTitle } from '@openshift-console/dynamic-plugin-sdk';
@@ -75,7 +74,7 @@ const IncidentsPage = () => {
   const dispatch = useDispatch();
   const location = useLocation();
   const urlParams = useMemo(() => parseUrlParams(location.search), [location.search]);
-  const { rules } = useAlerts({ overrideNamespace: ALL_NAMESPACES_KEY });
+  const { rules } = useAlerts({ dontUseTenancy: true });
   const { theme } = usePatternFlyTheme();
   // loading states
   const [incidentsAreLoading, setIncidentsAreLoading] = useState(true);
diff --git a/web/src/components/alerting/AlertsPage.tsx b/web/src/components/alerting/AlertsPage.tsx
@@ -32,8 +32,10 @@ import useSelectedFilters from './useSelectedFilters';
 import { MonitoringProvider } from '../../contexts/MonitoringContext';
 import { useAlerts } from '../../hooks/useAlerts';
 import { AccessDenied } from '../console/console-shared/src/components/empty-state/AccessDenied';
+import { useMonitoring } from '../../hooks/useMonitoring';
 
 const AlertsPage_: FC = () => {
+  const { useAlertsTenancy } = useMonitoring();
   const { t } = useTranslation(process.env.I18N_NAMESPACE);
   const [namespace] = useActiveNamespace();
   const { defaultAlertTenant, perspective } = usePerspective();
@@ -104,7 +106,7 @@ const AlertsPage_: FC = () => {
         fuzzyCaseInsensitive(clusterName, alert.labels?.cluster),
       type: 'alert-cluster',
     } as RowFilter);
-  } else if (namespace && namespace !== ALL_NAMESPACES_KEY) {
+  } else if (useAlertsTenancy && namespace && namespace !== ALL_NAMESPACES_KEY) {
     rowFilters = rowFilters.filter((filter) => filter.type !== 'alert-source');
   }
 
diff --git a/web/src/components/alerting/SilenceCreatePage.tsx b/web/src/components/alerting/SilenceCreatePage.tsx
@@ -5,8 +5,11 @@ import { SilenceForm } from './SilenceForm';
 import { MonitoringProvider } from '../../contexts/MonitoringContext';
 import { ALL_NAMESPACES_KEY } from '../utils';
 import { useQueryNamespace } from '../hooks/useQueryNamespace';
+import { useMonitoring } from '../../hooks/useMonitoring';
 
-const CreateSilencePage = ({ isNamespaced }: { isNamespaced: boolean }) => {
+const CreateSilencePage = ({ allowNamespace }: { allowNamespace: boolean }) => {
+  const { namespace } = useQueryNamespace();
+  const { useAlertsTenancy } = useMonitoring();
   const { t } = useTranslation(process.env.I18N_NAMESPACE);
 
   const matchers = _.map(getAllQueryArguments(), (value, name) => ({
@@ -15,6 +18,8 @@ const CreateSilencePage = ({ isNamespaced }: { isNamespaced: boolean }) => {
     isRegex: false,
   }));
 
+  const isNamespaced = allowNamespace && useAlertsTenancy && namespace !== ALL_NAMESPACES_KEY;
+
   return _.isEmpty(matchers) ? (
     <SilenceForm defaults={{}} title={t('Create silence')} isNamespaced={isNamespaced} />
   ) : (
@@ -23,11 +28,9 @@ const CreateSilencePage = ({ isNamespaced }: { isNamespaced: boolean }) => {
 };
 
 export const MpCmoCreateSilencePage = () => {
-  const { namespace } = useQueryNamespace();
-
   return (
     <MonitoringProvider monitoringContext={{ plugin: 'monitoring-plugin', prometheus: 'cmo' }}>
-      <CreateSilencePage isNamespaced={namespace !== ALL_NAMESPACES_KEY} />
+      <CreateSilencePage allowNamespace={true} />
     </MonitoringProvider>
   );
 };
@@ -37,7 +40,7 @@ export const McpAcmCreateSilencePage = () => {
     <MonitoringProvider
       monitoringContext={{ plugin: 'monitoring-console-plugin', prometheus: 'acm' }}
     >
-      <CreateSilencePage isNamespaced={false} />
+      <CreateSilencePage allowNamespace={false} />
     </MonitoringProvider>
   );
 };
diff --git a/web/src/components/alerting/SilenceForm.tsx b/web/src/components/alerting/SilenceForm.tsx
@@ -134,7 +134,7 @@ const NegativeMatcherHelp = () => {
 const SilenceForm_: FC<SilenceFormProps> = ({ defaults, Info, title, isNamespaced }) => {
   const { t } = useTranslation(process.env.I18N_NAMESPACE);
   const { namespace } = useQueryNamespace();
-  const { prometheus } = useMonitoring();
+  const { prometheus, useAlertsTenancy } = useMonitoring();
   const navigate = useNavigate();
 
   const durations = useMemo(() => {
@@ -248,7 +248,11 @@ const SilenceForm_: FC<SilenceFormProps> = ({ defaults, Info, title, isNamespace
       return;
     }
 
-    const url = getAlertmanagerSilencesUrl({ prometheus, namespace });
+    const url = getAlertmanagerSilencesUrl({
+      prometheus,
+      namespace,
+      useTenancyPath: useAlertsTenancy,
+    });
     if (!url) {
       setError('Alertmanager URL not set');
       return;
@@ -279,7 +283,10 @@ const SilenceForm_: FC<SilenceFormProps> = ({ defaults, Info, title, isNamespace
     };
 
     consoleFetchJSON
-      .post(getAlertmanagerSilencesUrl({ prometheus, namespace }), body)
+      .post(
+        getAlertmanagerSilencesUrl({ prometheus, namespace, useTenancyPath: useAlertsTenancy }),
+        body,
+      )
       .then(({ silenceID }) => {
         setError(undefined);
         refetchSilencesAndAlerts();
diff --git a/web/src/components/dashboards/legacy/graph.tsx b/web/src/components/dashboards/legacy/graph.tsx
@@ -35,7 +35,7 @@ const Graph: FC<Props> = ({
   onDataChange,
 }) => {
   const dispatch = useDispatch();
-  const { plugin } = useMonitoring();
+  const { plugin, useMetricsTenancy } = useMonitoring();
   const endTime = useSelector(
     (state: MonitoringState) => getObserveState(plugin, state).dashboards.endTime,
   );
@@ -67,6 +67,7 @@ const Graph: FC<Props> = ({
       timespan={timespan}
       units={units as GraphUnits}
       onDataChange={onDataChange}
+      useTenancy={useMetricsTenancy}
       isPlain
     />
   );
diff --git a/web/src/components/hooks/useQueryNamespace.ts b/web/src/components/hooks/useQueryNamespace.ts
@@ -13,9 +13,6 @@ export const useQueryNamespace = () => {
     if (queryNamespace && activeNamespace !== queryNamespace) {
       setActiveNamespace(queryNamespace);
     }
-    if (!queryNamespace) {
-      setQueryNamespace(activeNamespace);
-    }
   }, [queryNamespace, activeNamespace, setActiveNamespace, setQueryNamespace]);
 
   return {
diff --git a/web/src/components/utils.ts b/web/src/components/utils.ts
@@ -246,13 +246,21 @@ export const buildPrometheusUrl = ({
   prometheusUrlProps: PrometheusURLProps;
   basePath: string;
 }): string | null => {
+  if (
+    basePath !== PROMETHEUS_TENANCY_BASE_PATH ||
+    prometheusUrlProps.namespace === ALL_NAMESPACES_KEY
+  ) {
+    prometheusUrlProps.namespace = undefined;
+  }
   if (prometheusUrlProps.endpoint !== PrometheusEndpoint.RULES && !prometheusUrlProps.query) {
     // Empty query provided, skipping API call
     return null;
   }
 
   const params = getSearchParams(prometheusUrlProps);
-  return `${basePath}/${prometheusUrlProps.endpoint}?${params.toString()}`;
+  return `${basePath}/${prometheusUrlProps.endpoint}${
+    params.size > 0 ? '?' + params.toString() : ''
+  }`;
 };
 
 type PrometheusURLProps = {
@@ -267,14 +275,16 @@ type PrometheusURLProps = {
 
 export const getAlertmanagerSilencesUrl = ({
   prometheus,
+  useTenancyPath,
   namespace,
 }: {
   prometheus: Prometheus;
+  useTenancyPath: boolean;
   namespace?: string;
 }) => {
   if (prometheus === 'acm') {
     return `${ALERTMANAGER_PROXY_PATH}/api/v2/silences`;
-  } else if (namespace && namespace !== ALL_NAMESPACES_KEY) {
+  } else if (useTenancyPath && namespace && namespace !== ALL_NAMESPACES_KEY) {
     return `${ALERTMANAGER_TENANCY_BASE_PATH}/api/v2/silences?namespace=${namespace}`;
   } else {
     return `${ALERTMANAGER_BASE_PATH}/api/v2/silences`;
diff --git a/web/src/hooks/useAlerts.ts b/web/src/hooks/useAlerts.ts
@@ -26,23 +26,24 @@ import {
   getAdditionalSources,
 } from '../components/alerting/AlertUtils';
 import { MonitoringState } from '../store/store';
-import { getObserveState, usePerspective } from '../components/hooks/usePerspective';
+import { getObserveState } from '../components/hooks/usePerspective';
 
 const POLLING_INTERVAL_MS = 15 * 1000; // 15 seconds
 
-export const useAlerts = (props?: { overrideNamespace?: string }) => {
+export const useAlerts = (props?: { dontUseTenancy?: boolean }) => {
   // Retrieve external information which dictates which alerts to load and use
   const { plugin } = useMonitoring();
   const [namespace] = useActiveNamespace();
-  const { prometheus, useAlertsTenancy } = useMonitoring();
-  const { perspective } = usePerspective();
-  const overriddenNamespace = props?.overrideNamespace ? props.overrideNamespace : namespace;
+  const { prometheus, useAlertsTenancy, accessCheckLoading } = useMonitoring();
+  const overriddenNamespace =
+    props?.dontUseTenancy || !useAlertsTenancy ? ALL_NAMESPACES_KEY : namespace;
 
   // Start polling for alerts, rules, and silences
   const { trigger } = useAlertsPoller({
     namespace: overriddenNamespace,
     prometheus,
     useAlertsTenancy,
+    accessCheckLoading,
   });
 
   // Retrieve alerts, rules and silences from the store, which is populated in the poller
@@ -97,16 +98,6 @@ export const useAlerts = (props?: { overrideNamespace?: string }) => {
     return clusterArray.sort();
   }, [silences]);
 
-  // When a user with cluster scoped alerts retrieves alerts from the tenancy API endpoint
-  // the API will still retrun ALL alerts, not just the ones which are available at that tenant
-  // As such we manually filter down the alerts on the frontend
-  const namespacedAlerts = useMemo(() => {
-    if (perspective === 'acm' || namespace === ALL_NAMESPACES_KEY) {
-      return alerts;
-    }
-    return alerts?.filter((alert) => alert.labels?.namespace === namespace);
-  }, [alerts, perspective, namespace]);
-
   return {
     trigger,
     additionalAlertSourceLabels,
@@ -116,18 +107,20 @@ export const useAlerts = (props?: { overrideNamespace?: string }) => {
     rulesAlertLoading,
     rules,
     silences,
-    alerts: namespacedAlerts,
+    alerts,
   };
 };
 
 const useAlertsPoller = ({
   namespace,
   prometheus,
   useAlertsTenancy,
+  accessCheckLoading,
 }: {
   namespace?: string;
   prometheus: Prometheus;
   useAlertsTenancy: boolean;
+  accessCheckLoading: boolean;
 }) => {
   const dispatch = useDispatch();
   const [customExtensions] =
@@ -148,14 +141,27 @@ const useAlertsPoller = ({
     prometheusUrlProps: { endpoint: PrometheusEndpoint.RULES, namespace },
     basePath: getPrometheusBasePath({ prometheus, useTenancyPath: useAlertsTenancy }),
   });
-  const silencesUrl = getAlertmanagerSilencesUrl({ prometheus, namespace });
+  const silencesUrl = getAlertmanagerSilencesUrl({
+    prometheus,
+    namespace,
+    useTenancyPath: useAlertsTenancy,
+  });
 
   const fetchDispatch = () =>
-    dispatch(fetchAlertingData(prometheus, namespace, rulesUrl, alertsSource, silencesUrl));
+    dispatch(
+      fetchAlertingData(
+        prometheus,
+        namespace,
+        rulesUrl,
+        alertsSource,
+        silencesUrl,
+        !accessCheckLoading, // Wait to poll until we know which endpoint to use
+      ),
+    );
 
   const dependencies = useMemo(
-    () => [namespace, rulesUrl, silencesUrl],
-    [namespace, rulesUrl, silencesUrl],
+    () => [namespace, rulesUrl, silencesUrl, useAlertsTenancy, accessCheckLoading],
+    [namespace, rulesUrl, silencesUrl, useAlertsTenancy, accessCheckLoading],
   );
 
   usePoll(fetchDispatch, POLLING_INTERVAL_MS, dependencies);
diff --git a/web/src/store/thunks.ts b/web/src/store/thunks.ts
@@ -22,9 +22,13 @@ export const fetchAlertingData =
     rulesUrl: string,
     alertsSource: any,
     silencesUrl: string,
+    active: boolean,
   ): ThunkAction<void, RootState, unknown, Action<string>> =>
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async (dispatch, getState) => {
+    if (!active) {
+      return;
+    }
     dispatch(alertingSetLoading(prometheus, namespace));
 
     const [rulesResponse, silencesResponse] = await Promise.allSettled([

Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,6 @@ export const useQueryNamespace = () => {`
`13`	`13`	`if (queryNamespace && activeNamespace !== queryNamespace) {`
`14`	`14`	`setActiveNamespace(queryNamespace);`
`15`	`15`	`}`
`16`		`- if (!queryNamespace) {`
`17`		`- setQueryNamespace(activeNamespace);`
`18`		`- }`
`19`	`16`	`}, [queryNamespace, activeNamespace, setActiveNamespace, setQueryNamespace]);`
`20`	`17`
`21`	`18`	`return {`