feat(log-alerts): Add all supported aggregation types (#95364)

Adds support for all aggregation types that explore supports for logs.

Author: shruthilayaj

static/app/views/alerts/rules/metric/eapField.spec.tsx

@@ -242,4 +242,73 @@ describe('EAPField', () => {
     // this corresponds to the `spans` input
     expect(inputs[1]).toBeDisabled();
   });
+  it('renders count_unique with string arguments for logs', async () => {
+    function Component() {
+      const [aggregate, setAggregate] = useState('count(message)');
+      return (
+        <TraceItemAttributeProvider traceItemType={TraceItemDataset.LOGS} enabled>
+          <EAPField
+            aggregate={aggregate}
+            onChange={setAggregate}
+            eventTypes={[EventTypes.TRACE_ITEM_LOG]}
+          />
+        </TraceItemAttributeProvider>
+      );
+    }
+
+    render(<Component />);
+
+    expect(fieldsMock).toHaveBeenCalledWith(
+      `/organizations/${organization.slug}/trace-items/attributes/`,
+      expect.objectContaining({
+        query: expect.objectContaining({attributeType: 'number', itemType: 'logs'}),
+      })
+    );
+    expect(fieldsMock).toHaveBeenCalledWith(
+      `/organizations/${organization.slug}/trace-items/attributes/`,
+      expect.objectContaining({
+        query: expect.objectContaining({attributeType: 'string', itemType: 'logs'}),
+      })
+    );
+    await userEvent.click(screen.getByText('count'));
+    await userEvent.click(await screen.findByText('count_unique'));
+
+    expect(screen.getByText('count_unique')).toBeInTheDocument();
+    await userEvent.click(screen.getByText('message'));
+    expect(screen.getByText('severity')).toBeInTheDocument();
+  });
+  it('renders numeric aggregates with numeric arguments for logs', async () => {
+    function Component() {
+      const [aggregate, setAggregate] = useState('count(message)');
+      return (
+        <TraceItemAttributeProvider traceItemType={TraceItemDataset.LOGS} enabled>
+          <EAPField
+            aggregate={aggregate}
+            onChange={setAggregate}
+            eventTypes={[EventTypes.TRACE_ITEM_LOG]}
+          />
+        </TraceItemAttributeProvider>
+      );
+    }
+
+    render(<Component />);
+
+    expect(fieldsMock).toHaveBeenCalledWith(
+      `/organizations/${organization.slug}/trace-items/attributes/`,
+      expect.objectContaining({
+        query: expect.objectContaining({attributeType: 'number', itemType: 'logs'}),
+      })
+    );
+    expect(fieldsMock).toHaveBeenCalledWith(
+      `/organizations/${organization.slug}/trace-items/attributes/`,
+      expect.objectContaining({
+        query: expect.objectContaining({attributeType: 'string', itemType: 'logs'}),
+      })
+    );
+    await userEvent.click(screen.getByText('count'));
+    await userEvent.click(await screen.findByText('sum'));
+
+    expect(screen.getByText('sum')).toBeInTheDocument();
+    expect(screen.getByText('severity_number')).toBeInTheDocument();
+  });
 });

static/app/views/alerts/rules/metric/eapField.tsx

@@ -4,14 +4,12 @@ import styled from '@emotion/styled';
 import {Select} from 'sentry/components/core/select';
 import {t} from 'sentry/locale';
 import {space} from 'sentry/styles/space';
-import type {TagCollection} from 'sentry/types/group';
 import {defined} from 'sentry/utils';
 import {parseFunction} from 'sentry/utils/discover/fields';
 import {
   AggregationKey,
   ALLOWED_EXPLORE_VISUALIZE_AGGREGATES,
   NO_ARGUMENT_SPAN_AGGREGATES,
-  prettifyTagKey,
 } from 'sentry/utils/fields';
 import {Dataset, type EventTypes} from 'sentry/views/alerts/rules/metric/types';
 import {getTraceItemTypeForDatasetAndEventType} from 'sentry/views/alerts/wizard/utils';
@@ -20,7 +18,10 @@ import {
   updateVisualizeAggregate,
 } from 'sentry/views/explore/contexts/pageParamsContext/visualizes';
 import {useTraceItemAttributes} from 'sentry/views/explore/contexts/traceItemAttributeContext';
-import type {OurLogsAggregate} from 'sentry/views/explore/logs/types';
+import {
+  OurLogKnownFieldKey,
+  type OurLogsAggregate,
+} from 'sentry/views/explore/logs/types';
 import {TraceItemDataset} from 'sentry/views/explore/types';
 
 const DEFAULT_EAP_AGGREGATION = 'count';
@@ -42,11 +43,21 @@ const SPAN_OPERATIONS = [
 ];
 
 const LOG_OPERATIONS = [
-  {
-    label: AggregationKey.COUNT,
-    value: AggregationKey.COUNT,
-  },
-] satisfies Array<{label: string; value: OurLogsAggregate}>;
+  AggregationKey.COUNT,
+  AggregationKey.COUNT_UNIQUE,
+  AggregationKey.SUM,
+  AggregationKey.AVG,
+  AggregationKey.P50,
+  AggregationKey.P75,
+  AggregationKey.P90,
+  AggregationKey.P95,
+  AggregationKey.P99,
+  AggregationKey.MIN,
+  AggregationKey.MAX,
+].map(aggregate => ({
+  label: aggregate,
+  value: aggregate as OurLogsAggregate,
+})) satisfies Array<{label: string; value: OurLogsAggregate}>;
 
 function EAPFieldWrapper({aggregate, onChange, eventTypes}: Props) {
   return <EAPField aggregate={aggregate} onChange={onChange} eventTypes={eventTypes} />;
@@ -69,15 +80,8 @@ function EAPField({aggregate, onChange, eventTypes}: Props) {
 
   const storedTags =
     aggregation === AggregationKey.COUNT_UNIQUE ? storedStringTags : storedNumberTags;
-  const numberTags: TagCollection = useMemo(() => {
-    const availableTags: TagCollection = storedTags;
-    if (field && !defined(storedTags[field])) {
-      availableTags[field] = {key: field, name: prettifyTagKey(field)};
-    }
-    return availableTags;
-  }, [field, storedTags]);
 
-  const fieldsArray = Object.values(numberTags);
+  const fieldsArray = Object.values(storedTags);
 
   // When using the async variant of SelectControl, we need to pass in an option object instead of just the value
   const [lockOptions, selectedOption] = useMemo(() => {
@@ -105,7 +109,7 @@ function EAPField({aggregate, onChange, eventTypes}: Props) {
       return;
     }
 
-    const selectedMeta = field ? numberTags[field] : undefined;
+    const selectedMeta = field ? storedTags[field] : undefined;
     if (!field || !selectedMeta) {
       const newSelection = fieldsArray[0];
       if (newSelection) {
@@ -114,29 +118,44 @@ function EAPField({aggregate, onChange, eventTypes}: Props) {
         onChange(DEFAULT_EAP_METRICS_ALERT_FIELD, {});
       }
     }
-  }, [lockOptions, onChange, aggregate, aggregation, field, numberTags, fieldsArray]);
+  }, [lockOptions, onChange, aggregate, aggregation, field, storedTags, fieldsArray]);
 
   const handleFieldChange = useCallback(
     (option: any) => {
-      const selectedMeta = numberTags[option.value];
+      const selectedMeta = storedTags[option.value];
       if (!selectedMeta) {
         return;
       }
       onChange(`${aggregation}(${selectedMeta.key})`, {});
     },
-    [numberTags, onChange, aggregation]
+    [storedTags, onChange, aggregation]
   );
 
   const handleOperationChange = useCallback(
     (option: any) => {
-      const newAggregate = updateVisualizeAggregate({
-        newAggregate: option.value,
-        oldAggregate: aggregation || DEFAULT_EAP_AGGREGATION,
-        oldArgument: field || DEFAULT_EAP_FIELD,
-      });
+      let newAggregate: string;
+      if (traceItemType === TraceItemDataset.LOGS) {
+        if ([AggregationKey.COUNT, AggregationKey.COUNT_UNIQUE].includes(option.value)) {
+          newAggregate = `${option.value}(${OurLogKnownFieldKey.MESSAGE})`;
+        } else if (NO_ARGUMENT_SPAN_AGGREGATES.includes(option.value as AggregationKey)) {
+          newAggregate = `${option.value}()`;
+        } else {
+          const argument =
+            field && defined(storedNumberTags[field])
+              ? field
+              : (Object.values(storedNumberTags)?.[0]?.key ?? '');
+          newAggregate = `${option.value}(${argument})`;
+        }
+      } else {
+        newAggregate = updateVisualizeAggregate({
+          newAggregate: option.value,
+          oldAggregate: aggregation || DEFAULT_EAP_AGGREGATION,
+          oldArgument: field || DEFAULT_EAP_FIELD,
+        });
+      }
       onChange(newAggregate, {});
     },
-    [aggregation, field, onChange]
+    [aggregation, field, onChange, storedNumberTags, traceItemType]
   );
 
   // As SelectControl does not support an options size limit out of the box