Filtering: NonApplicability improvements

packages/scenes/src/index.ts

@@ -41,6 +41,8 @@ export { SceneTimeZoneOverride } from './core/SceneTimeZoneOverride';
 
 export { SceneQueryRunner, type QueryRunnerState } from './querying/SceneQueryRunner';
 export { DataProviderProxy } from './querying/DataProviderProxy';
+export { buildApplicabilityMatcher } from './variables/applicabilityUtils';
+export { findClosestAdHocFilterInHierarchy } from './variables/adhoc/patchGetAdhocFilters';
 export {
   type ExtraQueryDescriptor,
   type ExtraQueryProvider,

packages/scenes/src/variables/DrilldownDependenciesManager.test.ts

@@ -0,0 +1,105 @@
+import { AdHocFiltersVariable, AdHocFilterWithLabels } from './adhoc/AdHocFiltersVariable';
+import { DrilldownDependenciesManager } from './DrilldownDependenciesManager';
+import { GroupByVariable } from './groupby/GroupByVariable';
+import { VariableDependencyConfig } from './VariableDependencyConfig';
+
+function createManager(opts: { adhocVar?: AdHocFiltersVariable; groupByVar?: GroupByVariable }) {
+  const mockDependencyConfig = { setVariableNames: jest.fn() } as unknown as VariableDependencyConfig<any>;
+  const manager = new DrilldownDependenciesManager(mockDependencyConfig);
+
+  if (opts.adhocVar) {
+    manager['_adhocFiltersVar'] = opts.adhocVar;
+  }
+  if (opts.groupByVar) {
+    manager['_groupByVar'] = opts.groupByVar;
+  }
+
+  return manager;
+}
+
+function createAdhocVar(
+  filters: AdHocFilterWithLabels[],
+  originFilters?: AdHocFilterWithLabels[],
+  applicabilityEnabled?: boolean
+) {
+  return new AdHocFiltersVariable({
+    datasource: { uid: 'my-ds-uid' },
+    name: 'filters',
+    filters,
+    originFilters,
+    applicabilityEnabled,
+  });
+}
+
+function createGroupByVar(value: string[], keysApplicability?: any[], applicabilityEnabled?: boolean) {
+  return new GroupByVariable({
+    datasource: { uid: 'my-ds-uid' },
+    name: 'groupby',
+    key: 'testGroupBy',
+    value,
+    text: value,
+    keysApplicability,
+    applicabilityEnabled,
+  });
+}
+
+describe('DrilldownDependenciesManager', () => {
+  describe('getFilters', () => {
+    it('should return undefined when no adhocFiltersVar', () => {
+      const manager = createManager({});
+      expect(manager.getFilters()).toBeUndefined();
+    });
+
+    it('should return all complete filters when no applicability results', () => {
+      const filters: AdHocFilterWithLabels[] = [
+        { key: 'env', value: 'prod', operator: '=' },
+        { key: 'cluster', value: 'us', operator: '=' },
+      ];
+
+      const manager = createManager({ adhocVar: createAdhocVar(filters) });
+
+      const result = manager.getFilters() ?? [];
+      expect(result).toHaveLength(2);
+      expect(result[0].key).toBe('env');
+      expect(result[1].key).toBe('cluster');
+    });
+
+    it('should exclude incomplete filters', () => {
+      const filters: AdHocFilterWithLabels[] = [
+        { key: 'env', value: 'prod', operator: '=' },
+        { key: '', value: '', operator: '' },
+      ];
+
+      const manager = createManager({ adhocVar: createAdhocVar(filters) });
+
+      const result = manager.getFilters() ?? [];
+      expect(result).toHaveLength(1);
+      expect(result[0].key).toBe('env');
+    });
+
+    it('should exclude variable-level nonApplicable filters', () => {
+      const filters: AdHocFilterWithLabels[] = [
+        { key: 'env', value: 'prod', operator: '=' },
+        { key: 'pod', value: 'abc', operator: '=', nonApplicable: true },
+      ];
+
+      const manager = createManager({ adhocVar: createAdhocVar(filters) });
+
+      const result = manager.getFilters() ?? [];
+      expect(result).toHaveLength(1);
+      expect(result[0].key).toBe('env');
+    });
+  });
+
+  describe('getGroupByKeys', () => {
+    it('should return undefined when no groupByVar', () => {
+      const manager = createManager({});
+      expect(manager.getGroupByKeys()).toBeUndefined();
+    });
+
+    it('should return all applicable keys', () => {
+      const manager = createManager({ groupByVar: createGroupByVar(['ns', 'pod']) });
+      expect(manager.getGroupByKeys()).toEqual(['ns', 'pod']);
+    });
+  });
+});

packages/scenes/src/variables/DrilldownDependenciesManager.ts

@@ -81,15 +81,21 @@ export class DrilldownDependenciesManager<TState extends SceneObjectState> {
   }
 
   public getFilters(): AdHocFilterWithLabels[] | undefined {
-    return this._adhocFiltersVar
-      ? [...(this._adhocFiltersVar.state.originFilters ?? []), ...this._adhocFiltersVar.state.filters].filter(
-          (f) => isFilterComplete(f) && isFilterApplicable(f)
-        )
-      : undefined;
+    if (!this._adhocFiltersVar) {
+      return undefined;
+    }
+
+    const stateFilters = this._adhocFiltersVar.state.filters;
+    const originFilters = this._adhocFiltersVar.state.originFilters ?? [];
+    const allFilters = [...originFilters, ...stateFilters];
+    return allFilters.filter((f) => isFilterComplete(f) && isFilterApplicable(f));
   }
 
   public getGroupByKeys(): string[] | undefined {
-    return this._groupByVar ? this._groupByVar.getApplicableKeys() : undefined;
+    if (!this._groupByVar) {
+      return undefined;
+    }
+    return this._groupByVar.getApplicableKeys();
   }
 
   public cleanup(): void {

packages/scenes/src/variables/adhoc/AdHocFiltersRecommendations.test.tsx

@@ -1,7 +1,15 @@
 import React from 'react';
 import { render, waitFor } from '@testing-library/react';
 import { DataSourceSrv, locationService, setDataSourceSrv, setRunRequest, setTemplateSrv } from '@grafana/runtime';
-import { DataQueryRequest, DataSourceApi, getDefaultTimeRange, LoadingState, PanelData } from '@grafana/data';
+import {
+  DataQueryRequest,
+  DataSourceApi,
+  getDefaultTimeRange,
+  LoadingState,
+  PanelData,
+  // @ts-expect-error (temporary till we update grafana/data)
+  DEFAULT_APPLICABILITY_KEY,
+} from '@grafana/data';
 import { Observable, of } from 'rxjs';
 import { EmbeddedScene } from '../../components/EmbeddedScene';
 import { SceneFlexLayout, SceneFlexItem } from '../../components/layout/SceneFlexLayout';
@@ -234,7 +242,7 @@ let runRequestSet = false;
 function setup(overrides?: Partial<AdHocFiltersVariableState>) {
   const getTagKeysSpy = jest.fn();
   const getTagValuesSpy = jest.fn();
-  const getDrilldownsApplicabilitySpy = jest.fn().mockResolvedValue([]);
+  const getDrilldownsApplicabilitySpy = jest.fn().mockResolvedValue(new Map([[DEFAULT_APPLICABILITY_KEY, []]]));
   const getRecommendedDrilldownsSpy = jest.fn().mockResolvedValue({ filters: [] });
 
   setDataSourceSrv({

packages/scenes/src/variables/adhoc/AdHocFiltersRecommendations.tsx

@@ -1,21 +1,18 @@
 import React from 'react';
-import {
-  // @ts-expect-error (temporary till we update grafana/data)
-  DrilldownsApplicability,
-  store,
-} from '@grafana/data';
+import { store } from '@grafana/data';
 import { sceneGraph } from '../../core/sceneGraph';
 import { getEnrichedDataRequest } from '../../querying/getEnrichedDataRequest';
 import { getQueriesForVariables } from '../utils';
-import { getDataSource } from '../../utils/getDataSource';
+
 import { DrilldownRecommendations, DrilldownPill } from '../components/DrilldownRecommendations';
 import { ScopesVariable } from '../variants/ScopesVariable';
 import { SCOPES_VARIABLE_NAME } from '../constants';
 import { AdHocFilterWithLabels, AdHocFiltersVariable } from './AdHocFiltersVariable';
 import { SceneObjectBase } from '../../core/SceneObjectBase';
 import { SceneComponentProps, SceneObjectState } from '../../core/types';
-import { wrapInSafeSerializableSceneObject } from '../../utils/wrapInSafeSerializableSceneObject';
+
 import { Unsubscribable } from 'rxjs';
+import { buildApplicabilityMatcher } from '../applicabilityUtils';
 
 export const MAX_RECENT_DRILLDOWNS = 3;
 export const MAX_STORED_RECENT_DRILLDOWNS = 10;
@@ -45,10 +42,6 @@ export class AdHocFiltersRecommendations extends SceneObjectBase<AdHocFiltersRec
     return this.parent;
   }
 
-  private get _scopedVars() {
-    return { __sceneObject: wrapInSafeSerializableSceneObject(this._adHocFilter) };
-  }
-
   private _activationHandler = () => {
     const json = store.get(this._getStorageKey());
     const storedFilters = json ? JSON.parse(json) : [];
@@ -110,7 +103,7 @@ export class AdHocFiltersRecommendations extends SceneObjectBase<AdHocFiltersRec
 
   private async _fetchRecommendedDrilldowns() {
     const adhoc = this._adHocFilter;
-    const ds = await getDataSource(adhoc.state.datasource, this._scopedVars);
+    const ds = await adhoc.getResolvedDataSource();
 
     // @ts-expect-error (temporary till we update grafana/data)
     if (!ds || !ds.getRecommendedDrilldowns) {
@@ -153,15 +146,12 @@ export class AdHocFiltersRecommendations extends SceneObjectBase<AdHocFiltersRec
       return;
     }
 
-    const applicabilityMap = new Map<string, boolean>();
-    response.forEach((item: DrilldownsApplicability) => {
-      applicabilityMap.set(item.key, item.applicable !== false);
-    });
+    const matcher = buildApplicabilityMatcher(response);
 
     const applicableFilters = storedFilters
       .filter((f) => {
-        const isApplicable = applicabilityMap.get(f.key);
-        return isApplicable === undefined || isApplicable === true;
+        const result = matcher(f.key, f.origin);
+        return !result || result.applicable;
       })
       .slice(-MAX_RECENT_DRILLDOWNS);
 

packages/scenes/src/variables/adhoc/AdHocFiltersVariable.test.tsx

@@ -26,6 +26,8 @@ import {
   PanelData,
   Scope,
   ScopeSpecFilter,
+  // @ts-expect-error (temporary till we update grafana/data)
+  DEFAULT_APPLICABILITY_KEY,
 } from '@grafana/data';
 import { Observable, of } from 'rxjs';
 import userEvent from '@testing-library/user-event';
@@ -2354,6 +2356,7 @@ describe.each(['11.1.2', '11.1.1'])('AdHocFiltersVariable', (v) => {
       //pod and static are non-applicable
       const { filtersVar, getDrilldownsApplicabilitySpy } = setup(
         {
+          applicabilityEnabled: true,
           filters: [
             {
               key: 'cluster',
@@ -2400,6 +2403,7 @@ describe.each(['11.1.2', '11.1.1'])('AdHocFiltersVariable', (v) => {
       //pod and static are non-applicable
       const { filtersVar, getDrilldownsApplicabilitySpy, getTagKeysSpy } = setup(
         {
+          applicabilityEnabled: true,
           filters: [
             {
               key: 'cluster',
@@ -2462,6 +2466,7 @@ describe.each(['11.1.2', '11.1.1'])('AdHocFiltersVariable', (v) => {
       //pod and static are non-applicable
       const { filtersVar, getDrilldownsApplicabilitySpy } = setup(
         {
+          applicabilityEnabled: true,
           filters: [
             {
               key: 'cluster',
@@ -2685,6 +2690,7 @@ describe.each(['11.1.2', '11.1.1'])('AdHocFiltersVariable', (v) => {
     it('should set non-applicable filters on activation', async () => {
       setup(
         {
+          applicabilityEnabled: true,
           filters: [
             { key: 'pod', operator: '=', value: 'val1' },
             { key: 'container', operator: '=', value: 'val3' },
@@ -3316,12 +3322,14 @@ function setup(
         ...(useGetDrilldownsApplicability && {
           getDrilldownsApplicability(options: any) {
             getDrilldownsApplicabilitySpy(options);
-            return [
-              { key: 'cluster', applicable: true },
-              { key: 'container', applicable: true },
-              { key: 'pod', applicable: false, reason: 'reason' },
-              { key: 'static', applicable: false, origin: 'dashboard' },
-            ];
+            const nonApplicableKeys = new Set(['pod', 'static']);
+            const results = (options.filters ?? []).map((f: any) => ({
+              key: f.key,
+              applicable: !nonApplicableKeys.has(f.key),
+              ...(nonApplicableKeys.has(f.key) && { reason: 'reason' }),
+              ...(f.origin && { origin: f.origin }),
+            }));
+            return new Map([[DEFAULT_APPLICABILITY_KEY, results]]);
           },
         }),
       };