feat(alarms): Support filtering alarms by source

src/core/utils.test.ts

@@ -1,5 +1,5 @@
 import { BackendSrv, TemplateSrv } from "@grafana/runtime";
-import { validateNumericInput, enumToOptions, filterXSSField, filterXSSLINQExpression, replaceVariables, queryInBatches, queryUsingSkip, queryUntilComplete, getVariableOptions, get, post, addOptionsToLookup, multipleValuesQuery, timeFieldsQuery } from "./utils";
+import { validateNumericInput, enumToOptions, filterXSSField, filterXSSLINQExpression, replaceVariables, queryInBatches, queryUsingSkip, queryUntilComplete, getVariableOptions, get, post, addOptionsToLookup, multipleValuesQuery, timeFieldsQuery, getFilterConcatOperator } from "./utils";
 import { BatchQueryConfig, QBField, QueryBuilderOption } from "./types";
 import { of, throwError } from 'rxjs';
 
@@ -733,3 +733,28 @@ describe('multipleValuesQuery', () => {
     expect(result).toBe('(field like "value1")');
   });
 });
+
+describe('getLogicalOperator', () => {
+  [
+    {
+      name: 'equals',
+      operator: '=',
+    },
+    {
+      name: 'is not blank',
+      operator: 'isnotblank',
+    },
+  ].forEach(testCase => {
+    it(`should return OR for ${testCase.name} operator`, () => {
+      const result = getFilterConcatOperator(testCase.operator);
+
+      expect(result).toBe('||');
+    });
+  });
+
+  it('should return AND as the default logical operator', () => {
+    const result = getFilterConcatOperator('>');
+
+    expect(result).toBe('&&');
+  });
+});

src/core/utils.ts

@@ -346,14 +346,26 @@ export function multipleValuesQuery(field: string): ExpressionTransformFunction
   return (value: string, operation: string, _options?: any) => {
     const isMultiSelect = isMultiValueExpression(value);
     const valuesArray = getMultipleValuesArray(value);
-    const logicalOperator = getLogicalOperator(operation);
+    const logicalOperator = getFilterConcatOperator(operation);
 
     return isMultiSelect
       ? `(${valuesArray.map(val => buildExpression(field, val, operation)).join(` ${logicalOperator} `)})`
       : buildExpression(field, value, operation);
   };
 }
 
+/**
+ * Gets the logical operator for a given query operation when building multi-value expressions
+ * or combining multiple conditions.
+ * @param operation The operation to be checked.
+ * @returns The logical operator as a string.
+ */
+export function getFilterConcatOperator(operation: string): string {
+  return operation === QueryBuilderOperations.EQUALS.name || operation === QueryBuilderOperations.IS_NOT_BLANK.name
+    ? '||'
+    : '&&';
+}
+
 /**
  * Builds a query expression for a specific field, value, and operation.
  * @param field - The name of the field to be queried.
@@ -390,16 +402,6 @@ function getMultipleValuesArray(value: string): string[] {
   return value.replace(/({|})/g, '').split(',');
 }
 
-/**
- * Gets the logical operator for a given query operation when building multi-value expressions
- * or combining multiple conditions.
- * @param operation The operation to be checked.
- * @returns The logical operator as a string.
- */
-function getLogicalOperator(operation: string): string {
-  return operation === QueryBuilderOperations.EQUALS.name ? '||' : '&&';
-}
-
 async function delay(timeout: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, timeout));
 }

src/datasources/alarms/AlarmsDataSourceCore.test.ts

@@ -218,6 +218,83 @@ describe('AlarmsDataSourceCore', () => {
         expect(datastore.templateSrv.replace).toHaveBeenCalledWith('channel != "${query0}"', {});
         expect(transformQuery).toBe('(channel != "channel1" && channel != "channel2")');
       });
+
+      describe('transformSourceFilter', () => {
+        [
+          {
+            name: 'source equals',
+            input: 'source = "test-source"',
+            expected: '(properties.system = "test-source" || properties.minionId = "test-source")',
+          },
+          {
+            name: 'source does not equal',
+            input: 'source != "test-source"',
+            expected: '(properties.system != "test-source" && properties.minionId != "test-source")',
+          },
+          {
+            name: 'source is blank',
+            input: 'string.IsNullOrEmpty(source)',
+            expected: '(string.IsNullOrEmpty(properties.system) && string.IsNullOrEmpty(properties.minionId))',
+          },
+          {
+            name: 'source is not blank',
+            input: '!string.IsNullOrEmpty(source)',
+            expected: '(!string.IsNullOrEmpty(properties.system) || !string.IsNullOrEmpty(properties.minionId))',
+          },
+        ].forEach(({ name, input, expected }) => {
+          it(`should transform ${name} filter`, () => {
+            const result = datastore.transformAlarmsQueryWrapper({}, input);
+
+            expect(result).toBe(expected);
+          });
+        });
+
+        [
+          {
+            name: 'source equals',
+            input: 'source = "${query0}"',
+            replacedInput: 'source = "{source1,source2}"',
+            expected:
+              '((properties.system = "source1" || properties.system = "source2") || (properties.minionId = "source1" || properties.minionId = "source2"))',
+          },
+          {
+            name: 'source does not equal',
+            input: 'source != "${query0}"',
+            replacedInput: 'source != "{source1,source2}"',
+            expected:
+              '((properties.system != "source1" && properties.system != "source2") && (properties.minionId != "source1" && properties.minionId != "source2"))',
+          },
+        ].forEach(({ name, input, replacedInput, expected }) => {
+          it(`should transform ${name} for mutiple value variable filter`, () => {
+            jest.spyOn(datastore.templateSrv, 'replace').mockReturnValue(replacedInput);
+
+            const transformQuery = datastore.transformAlarmsQueryWrapper({}, input);
+
+            expect(datastore.templateSrv.replace).toHaveBeenCalledWith(input, {});
+            expect(transformQuery).toBe(expected);
+          });
+        });
+
+        it('should replace single value variable in the source filter', () => {
+          const mockQueryBy = 'source != "${query0}"';
+          jest.spyOn(datastore.templateSrv, 'replace').mockReturnValue('source != "test-source"');
+
+          const transformQuery = datastore.transformAlarmsQueryWrapper({}, mockQueryBy);
+
+          expect(datastore.templateSrv.replace).toHaveBeenCalledWith('source != "${query0}"', {});
+          expect(transformQuery).toBe('(properties.system != "test-source" && properties.minionId != "test-source")');
+        });
+
+        it('should handle transformation for multiple source filters in a query', () => {
+          const mockFilter = 'source = "source1" || string.IsNullOrEmpty(source)';
+
+          const result = datastore.transformAlarmsQueryWrapper({}, mockFilter);
+
+          expect(result).toBe(
+            '(properties.system = "source1" || properties.minionId = "source1") || (string.IsNullOrEmpty(properties.system) && string.IsNullOrEmpty(properties.minionId))'
+          );
+        });
+      });
     });
   });
 

src/datasources/alarms/AlarmsDataSourceCore.ts

@@ -7,8 +7,9 @@ import { ExpressionTransformFunction, transformComputedFieldsQuery } from "core/
 import { ALARMS_TIME_FIELDS, AlarmsQueryBuilderFields } from "./constants/AlarmsQueryBuilder.constants";
 import { QueryBuilderOption, Workspace } from "core/types";
 import { WorkspaceUtils } from "shared/workspace.utils";
-import { getVariableOptions, multipleValuesQuery, timeFieldsQuery } from "core/utils";
+import { getFilterConcatOperator, getVariableOptions, multipleValuesQuery, timeFieldsQuery } from "core/utils";
 import { BackendSrv, getBackendSrv, getTemplateSrv, TemplateSrv } from "@grafana/runtime";
+import { MINION_ID_CUSTOM_PROPERTY, SYSTEM_CUSTOM_PROPERTY } from "./constants/SourceProperties.constants";
 
 export abstract class AlarmsDataSourceCore extends DataSourceBase<AlarmsQuery> {
   private readonly queryAlarmsUrl = `${this.instanceSettings.url}${QUERY_ALARMS_RELATIVE_PATH}`;
@@ -65,19 +66,30 @@ export abstract class AlarmsDataSourceCore extends DataSourceBase<AlarmsQuery> {
     Object.values(AlarmsQueryBuilderFields).map(field => {
       const dataField = field.dataField as string;
 
-      return [
-        dataField,
-        this.isTimeField(dataField)
-          ? timeFieldsQuery(dataField)
-          : multipleValuesQuery(dataField),
-      ];
+      if (dataField === AlarmsQueryBuilderFields.SOURCE.dataField) {
+        return [dataField, this.getSourceTransformation()];
+      } else if (this.isTimeField(dataField)) {
+        return [dataField, timeFieldsQuery(dataField)];
+      } else {
+        return [dataField, multipleValuesQuery(dataField)];
+      }
     })
   );
 
   private isTimeField(field: string): boolean {
     return ALARMS_TIME_FIELDS.includes(field);
   }
 
+  private getSourceTransformation(): ExpressionTransformFunction {
+    return (value: string, operation: string) => {
+      const systemExpression = multipleValuesQuery(`properties.${SYSTEM_CUSTOM_PROPERTY}`)(value, operation);
+      const minionExpression = multipleValuesQuery(`properties.${MINION_ID_CUSTOM_PROPERTY}`)(value, operation);
+      const logicalOperator = getFilterConcatOperator(operation);
+
+      return `(${systemExpression} ${logicalOperator} ${minionExpression})`;
+    };
+  }
+
   private getStatusCodeErrorMessage(errorDetails: { statusCode: string; message: string }): string {
     let errorMessage: string;
     switch (errorDetails.statusCode) {

src/datasources/alarms/components/query-builder/AlarmsQueryBuilder.test.tsx

@@ -86,6 +86,16 @@ describe('AlarmsQueryBuilder', () => {
     expect(conditionsContainer.item(0)?.textContent).toContain('Workspace Name');
   });
 
+  it('should select source in query builder', () => {
+    const { conditionsContainer } = renderElement('source = "test-source"', [], [workspace]);
+
+    expect(conditionsContainer?.length).toBe(1);
+    const conditionText = conditionsContainer.item(0)?.textContent;
+    expect(conditionText).toContain('Source');
+    expect(conditionText).toContain('equals');
+    expect(conditionText).toContain('test-source');
+  });
+
   it('should select value for alarm ID in query builder', () => {
     const { conditionsContainer } = renderElement('alarmId = "test-alarm-123"');
 

src/datasources/alarms/constants/AlarmsQueryBuilder.constants.ts

@@ -145,6 +145,19 @@ export const AlarmsQueryBuilderFields: Record<string, QBField> = {
     dataField: 'resourceType',
     filterOperations: BASIC_STRING_FILTER_OPERATIONS,
   },
+  SOURCE: {
+    label: 'Source',
+    dataField: 'source',
+    filterOperations: [
+      QueryBuilderOperations.EQUALS.name, 
+      QueryBuilderOperations.DOES_NOT_EQUAL.name,
+      QueryBuilderOperations.IS_BLANK.name,
+      QueryBuilderOperations.IS_NOT_BLANK.name,
+      /* #AB#3422087 - Switch to BASIC_STRING_FILTER_OPERATIONS 
+      once transformation support for "contains" and "does not contain" 
+      is implemented */
+    ],
+  },
   WORKSPACE: {
     label: 'Workspace',
     dataField: 'workspace',
@@ -171,4 +184,5 @@ export const AlarmsQueryBuilderStaticFields: QBField[] = [
   AlarmsQueryBuilderFields.KEYWORD,
   AlarmsQueryBuilderFields.PROPERTIES,
   AlarmsQueryBuilderFields.RESOURCE_TYPE,
+  AlarmsQueryBuilderFields.SOURCE,
 ];

src/datasources/alarms/constants/SourceProperties.constants.ts

@@ -0,0 +1,2 @@
+export const SYSTEM_CUSTOM_PROPERTY = 'system';
+export const MINION_ID_CUSTOM_PROPERTY = 'minionId';