feat(aci): Add support for logs metric detectors (#94676)

Author: scttcper

static/app/types/workflowEngine/detectors.tsx

@@ -1,12 +1,17 @@
 import type {DataConditionGroup} from 'sentry/types/workflowEngine/dataConditions';
-import type {AlertRuleSensitivity} from 'sentry/views/alerts/rules/metric/types';
+import type {
+  AlertRuleSensitivity,
+  Dataset,
+  EventTypes,
+} from 'sentry/views/alerts/rules/metric/types';
 
 /**
  * See SnubaQuerySerializer
  */
 interface SnubaQuery {
   aggregate: string;
-  dataset: string;
+  dataset: Dataset;
+  eventTypes: EventTypes[];
   id: string;
   query: string;
   /**

static/app/views/detectors/components/forms/metric/getDatasetConfig.tsx

@@ -1,4 +1,6 @@
+import {unreachable} from 'sentry/utils/unreachable';
 import {ErrorsConfig} from 'sentry/views/dashboards/datasetConfig/errors';
+import {LogsConfig} from 'sentry/views/dashboards/datasetConfig/logs';
 import {ReleasesConfig} from 'sentry/views/dashboards/datasetConfig/releases';
 import {SpansConfig} from 'sentry/views/dashboards/datasetConfig/spans';
 import {TransactionsConfig} from 'sentry/views/dashboards/datasetConfig/transactions';
@@ -17,7 +19,10 @@ export function getDatasetConfig(dataset: DetectorDataset) {
       return ReleasesConfig;
     case DetectorDataset.SPANS:
       return SpansConfig;
+    case DetectorDataset.LOGS:
+      return LogsConfig;
     default:
+      unreachable(dataset);
       return ErrorsConfig;
   }
 }

static/app/views/detectors/components/forms/metric/metric.tsx

@@ -1,6 +1,7 @@
 import {useContext, useMemo} from 'react';
 import styled from '@emotion/styled';
 
+import {FeatureBadge} from 'sentry/components/core/badge/featureBadge';
 import {Button} from 'sentry/components/core/button';
 import {Flex} from 'sentry/components/core/layout';
 import {Tooltip} from 'sentry/components/core/tooltip';
@@ -14,6 +15,7 @@ import Section from 'sentry/components/workflowEngine/ui/section';
 import {IconAdd} from 'sentry/icons';
 import {t} from 'sentry/locale';
 import {space} from 'sentry/styles/space';
+import type {SelectValue} from 'sentry/types/core';
 import {
   DataConditionType,
   DetectorPriorityLevel,
@@ -42,6 +44,7 @@ import {TraceItemDataset} from 'sentry/views/explore/types';
 
 function MetricDetectorFormContext({children}: {children: React.ReactNode}) {
   const projectId = useMetricDetectorFormField(METRIC_DETECTOR_FORM_FIELDS.projectId);
+  const dataset = useMetricDetectorFormField(METRIC_DETECTOR_FORM_FIELDS.dataset);
   const {projects} = useProjects();
 
   const traceItemProjects = useMemo(() => {
@@ -52,9 +55,14 @@ function MetricDetectorFormContext({children}: {children: React.ReactNode}) {
     return [project];
   }, [projectId, projects]);
 
+  let traceItemType = TraceItemDataset.SPANS;
+  if (dataset === DetectorDataset.LOGS) {
+    traceItemType = TraceItemDataset.LOGS;
+  }
+
   return (
     <TraceItemAttributeProvider
-      traceItemType={TraceItemDataset.SPANS}
+      traceItemType={traceItemType}
       projects={traceItemProjects}
       enabled
     >
@@ -198,13 +206,28 @@ function useDatasetChoices() {
   const organization = useOrganization();
 
   return useMemo(() => {
-    const datasetChoices: Array<[DetectorDataset, string]> = [
-      [DetectorDataset.ERRORS, t('Errors')],
-      [DetectorDataset.TRANSACTIONS, t('Transactions')],
+    const datasetChoices: Array<SelectValue<DetectorDataset>> = [
+      {
+        value: DetectorDataset.ERRORS,
+        label: t('Errors'),
+      },
+      {
+        value: DetectorDataset.TRANSACTIONS,
+        label: t('Transactions'),
+      },
       ...(organization.features.includes('visibility-explore-view')
-        ? ([[DetectorDataset.SPANS, t('Spans')]] as Array<[DetectorDataset, string]>)
+        ? [{value: DetectorDataset.SPANS, label: t('Spans')}]
+        : []),
+      ...(organization.features.includes('ourlogs-alerts')
+        ? [
+            {
+              value: DetectorDataset.LOGS,
+              label: t('Logs'),
+              trailingItems: <FeatureBadge type="beta" />,
+            },
+          ]
         : []),
-      [DetectorDataset.RELEASES, t('Releases')],
+      {value: DetectorDataset.RELEASES, label: t('Releases')},
     ];
 
     return datasetChoices;
@@ -239,7 +262,7 @@ function DetectSection() {
               </Tooltip>
             }
             name={METRIC_DETECTOR_FORM_FIELDS.dataset}
-            choices={datasetChoices}
+            options={datasetChoices}
             onChange={newDataset => {
               // Reset aggregate function to dataset default when dataset changes
               const datasetConfig = getDatasetConfig(newDataset);

static/app/views/detectors/components/forms/metric/metricFormData.tsx

@@ -10,10 +10,12 @@ import {
 } from 'sentry/types/workflowEngine/dataConditions';
 import type {Detector, DetectorConfig} from 'sentry/types/workflowEngine/detectors';
 import {defined} from 'sentry/utils';
+import {unreachable} from 'sentry/utils/unreachable';
 import {
   AlertRuleSensitivity,
   AlertRuleThresholdType,
   Dataset,
+  EventTypes,
 } from 'sentry/views/alerts/rules/metric/types';
 
 /**
@@ -24,6 +26,7 @@ export const enum DetectorDataset {
   TRANSACTIONS = 'transactions',
   SPANS = 'spans',
   RELEASES = 'releases',
+  LOGS = 'logs',
 }
 
 /**
@@ -223,18 +226,33 @@ function createConditions(data: MetricDetectorFormData): NewConditionGroup['cond
 /**
  * Convert backend dataset to our form dataset
  */
-const getDetectorDataset = (backendDataset: string): DetectorDataset => {
+const getDetectorDataset = (
+  backendDataset: Dataset,
+  eventTypes: EventTypes[]
+): DetectorDataset => {
   switch (backendDataset) {
+    case Dataset.REPLAYS:
+      throw new Error('Unsupported dataset');
     case Dataset.ERRORS:
+    case Dataset.ISSUE_PLATFORM:
       return DetectorDataset.ERRORS;
     case Dataset.TRANSACTIONS:
     case Dataset.GENERIC_METRICS:
       return DetectorDataset.TRANSACTIONS;
     case Dataset.EVENTS_ANALYTICS_PLATFORM:
-      return DetectorDataset.SPANS;
+      // Spans and logs use the same dataset
+      if (eventTypes.includes(EventTypes.TRACE_ITEM_SPAN)) {
+        return DetectorDataset.SPANS;
+      }
+      if (eventTypes.includes(EventTypes.TRACE_ITEM_LOG)) {
+        return DetectorDataset.LOGS;
+      }
+      throw new Error('Unsupported event types');
     case Dataset.METRICS:
+    case Dataset.SESSIONS:
       return DetectorDataset.RELEASES; // Maps metrics dataset to releases for crash rate
     default:
+      unreachable(backendDataset);
       return DetectorDataset.ERRORS;
   }
 };
@@ -252,7 +270,10 @@ const getBackendDataset = (dataset: DetectorDataset): string => {
       return Dataset.EVENTS_ANALYTICS_PLATFORM;
     case DetectorDataset.RELEASES:
       return Dataset.METRICS; // Maps to metrics dataset for crash rate queries
+    case DetectorDataset.LOGS:
+      return Dataset.EVENTS_ANALYTICS_PLATFORM;
     default:
+      unreachable(dataset);
       return Dataset.ERRORS;
   }
 };
@@ -271,7 +292,10 @@ function createDataSource(data: MetricDetectorFormData): NewDataSource {
         return ['trace_item_span'];
       case DetectorDataset.RELEASES:
         return []; // Crash rate queries don't have event types
+      case DetectorDataset.LOGS:
+        return ['trace_item_log'];
       default:
+        unreachable(dataset);
         return ['error'];
     }
   };
@@ -285,10 +309,12 @@ function createDataSource(data: MetricDetectorFormData): NewDataSource {
         return SnubaQueryType.ERROR;
       case DetectorDataset.TRANSACTIONS:
       case DetectorDataset.SPANS:
+      case DetectorDataset.LOGS:
         return SnubaQueryType.PERFORMANCE;
       case DetectorDataset.RELEASES:
         return SnubaQueryType.CRASH_RATE; // Maps to crash rate for metrics dataset
       default:
+        unreachable(dataset);
         return SnubaQueryType.ERROR;
     }
   };
@@ -422,7 +448,7 @@ export function getMetricDetectorFormData(detector: Detector): MetricDetectorFor
   const conditionData = processDetectorConditions(detector);
 
   const dataset = snubaQuery?.dataset
-    ? getDetectorDataset(snubaQuery.dataset)
+    ? getDetectorDataset(snubaQuery.dataset, snubaQuery.eventTypes)
     : DetectorDataset.SPANS;
 
   return {

static/app/views/detectors/components/forms/metric/customMeasurements.tsx renamed to static/app/views/detectors/components/forms/metric/useCustomMeasurements.tsx

@@ -4,16 +4,14 @@ import type {Query} from 'history';
 import {getFieldTypeFromUnit} from 'sentry/components/events/eventCustomPerformanceMetrics';
 import {normalizeDateTimeParams} from 'sentry/components/organizations/pageFilters/parse';
 import type {PageFilters} from 'sentry/types/core';
-import type {Organization} from 'sentry/types/organization';
 import type {CustomMeasurementCollection} from 'sentry/utils/customMeasurements/customMeasurements';
 import {useApiQuery} from 'sentry/utils/queryClient';
+import useOrganization from 'sentry/utils/useOrganization';
 
 type MeasurementsMetaResponse = Record<string, {functions: string[]; unit: string}>;
 
-export function useCustomMeasurements(
-  organization: Organization,
-  selection?: PageFilters
-) {
+export function useCustomMeasurements(selection?: PageFilters) {
+  const organization = useOrganization();
   const query: Query = selection?.datetime
     ? normalizeDateTimeParams(selection.datetime)
     : {};

static/app/views/detectors/components/forms/metric/visualize.tsx

@@ -17,14 +17,14 @@ import {ALLOWED_EXPLORE_VISUALIZE_AGGREGATES, prettifyTagKey} from 'sentry/utils
 import {unreachable} from 'sentry/utils/unreachable';
 import useOrganization from 'sentry/utils/useOrganization';
 import useTags from 'sentry/utils/useTags';
-import {useCustomMeasurements} from 'sentry/views/detectors/components/forms/metric/customMeasurements';
 import {getDatasetConfig} from 'sentry/views/detectors/components/forms/metric/getDatasetConfig';
 import {
   DetectorDataset,
   METRIC_DETECTOR_FORM_FIELDS,
   useMetricDetectorFormField,
 } from 'sentry/views/detectors/components/forms/metric/metricFormData';
 import {DetectorQueryFilterBuilder} from 'sentry/views/detectors/components/forms/metric/queryFilterBuilder';
+import {useCustomMeasurements} from 'sentry/views/detectors/components/forms/metric/useCustomMeasurements';
 import {SectionLabel} from 'sentry/views/detectors/components/forms/sectionLabel';
 import type {FieldValue} from 'sentry/views/discover/table/types';
 import {FieldValueKind} from 'sentry/views/discover/table/types';
@@ -84,7 +84,7 @@ function getAggregateOptions(
   tableFieldOptions: Record<string, SelectValue<FieldValue>>
 ): Array<[string, string]> {
   // For spans dataset, use the predefined aggregates
-  if (dataset === DetectorDataset.SPANS) {
+  if (dataset === DetectorDataset.SPANS || dataset === DetectorDataset.LOGS) {
     return ALLOWED_EXPLORE_VISUALIZE_AGGREGATES.map(aggregate => [aggregate, aggregate]);
   }
 
@@ -169,12 +169,14 @@ function buildAggregateFunction(aggregate: string, parameters: string[]): string
 
 export function Visualize() {
   const organization = useOrganization();
-  const {customMeasurements} = useCustomMeasurements(organization);
+  const {customMeasurements} = useCustomMeasurements();
   const dataset = useMetricDetectorFormField(METRIC_DETECTOR_FORM_FIELDS.dataset);
   const aggregateFunction = useMetricDetectorFormField(
     METRIC_DETECTOR_FORM_FIELDS.aggregateFunction
   );
   const tags = useTags();
+
+  // See TraceItemAttributeProvider for how these contexts are populated
   const {tags: numericSpanTags} = useTraceItemTags('number');
   const {tags: stringSpanTags} = useTraceItemTags('string');
   const formContext = useContext(FormContext);
@@ -193,7 +195,7 @@ export function Visualize() {
 
   const fieldOptions = useMemo(() => {
     // For Spans dataset, use span-specific options from the provider
-    if (dataset === DetectorDataset.SPANS) {
+    if (dataset === DetectorDataset.SPANS || dataset === DetectorDataset.LOGS) {
       const spanColumnOptions: Array<[string, string]> = [
         ...Object.values(stringSpanTags).map((tag): [string, string] => [
           tag.key,
@@ -278,7 +280,9 @@ export function Visualize() {
   };
 
   const hasVisibleParameters =
-    Boolean(aggregateMetadata?.parameters?.length) && dataset !== DetectorDataset.SPANS;
+    Boolean(aggregateMetadata?.parameters?.length) &&
+    dataset !== DetectorDataset.SPANS &&
+    dataset !== DetectorDataset.LOGS;
 
   return (
     <CustomMeasurementsContext value={{customMeasurements}}>

static/app/views/detectors/list.spec.tsx

@@ -18,6 +18,7 @@ import {
   DataConditionType,
   DetectorPriorityLevel,
 } from 'sentry/types/workflowEngine/dataConditions';
+import {Dataset, EventTypes} from 'sentry/views/alerts/rules/metric/types';
 import DetectorsList from 'sentry/views/detectors/list';
 
 describe('DetectorsList', function () {
@@ -71,10 +72,11 @@ describe('DetectorsList', function () {
                 snubaQuery: {
                   environment: 'production',
                   aggregate: 'count()',
-                  dataset: 'events',
+                  dataset: Dataset.ERRORS,
                   id: '1',
                   query: 'event.type:error',
                   timeWindow: 3600,
+                  eventTypes: [EventTypes.ERROR],
                 },
                 id: '1',
                 status: 200,

tests/js/fixtures/detectors.ts

@@ -2,6 +2,7 @@ import {DataConditionGroupFixture} from 'sentry-fixture/dataConditions';
 import {UserFixture} from 'sentry-fixture/user';
 
 import type {Detector, SnubaQueryDataSource} from 'sentry/types/workflowEngine/detectors';
+import {Dataset, EventTypes} from 'sentry/views/alerts/rules/metric/types';
 
 export function DetectorFixture(params: Partial<Detector> = {}): Detector {
   return {
@@ -40,10 +41,11 @@ export function SnubaQueryDataSourceFixture(
       subscription: '1',
       snubaQuery: {
         aggregate: '',
-        dataset: '',
+        dataset: Dataset.ERRORS,
         id: '',
         query: '',
         timeWindow: 60,
+        eventTypes: [EventTypes.ERROR],
       },
     },
     ...params,