feat: Use extrapolation mode in alerts (#103731)

The backend returns extrapolation mode, a field used for transaction ->
span
migration. Use this value to call events-stats/ endpoint with the
correct extrapolation
mode and sampling mode.
Alerts with SERVER_WEIGHTED call events-stats/ with 'serverOnly'
extrapolation mode and SAMPLING_MODE.NORMAL
Alerts with NONE call events-stats/ with 'none' extrapolation mode and
SAMPLING_MODE.HIGH_ACCURACY

Extrapolation mode will be set in the backend and not a field we'd
expose to the user.
We're going to have an extrapolation mode called "serverOnly" which
extrapolates based on server sampling (which will match generic_metric
dataset numbers)
and disable extrapolation (ie extrapolation mode none) to match
transaction dataset numbers

This PR takes care of both legacy alerts and monitors

Author: shruthilayaj

static/app/actionCreators/events.tsx

@@ -41,6 +41,7 @@ type Options = {
   end?: DateString;
   environment?: readonly string[];
   excludeOther?: boolean;
+  extrapolationMode?: string;
   field?: string[];
   generatePathname?: (org: OrganizationSummary) => string;
   includePrevious?: boolean;
@@ -108,6 +109,7 @@ export const doEventsRequest = <IncludeAllArgsType extends boolean>(
     includeAllArgs,
     dataset,
     sampling,
+    extrapolationMode,
   }: EventsStatsOptions<IncludeAllArgsType>
 ): IncludeAllArgsType extends true
   ? Promise<ApiResult<EventsStats | MultiSeriesEventsStats>>
@@ -135,6 +137,7 @@ export const doEventsRequest = <IncludeAllArgsType extends boolean>(
       excludeOther: excludeOther ? '1' : undefined,
       dataset,
       sampling,
+      extrapolationMode,
     }).filter(([, value]) => typeof value !== 'undefined')
   );
 

static/app/components/charts/eventsRequest.tsx

@@ -150,6 +150,10 @@ type EventsRequestPartialProps = {
    * Is query out of retention
    */
   expired?: boolean;
+  /**
+   * The extrapolation mode to apply to the EAP
+   */
+  extrapolationMode?: string;
   /**
    * List of fields to group with when doing a topEvents request.
    */

static/app/types/workflowEngine/detectors.tsx

@@ -9,6 +9,7 @@ import type {
   AlertRuleThresholdType,
   Dataset,
   EventTypes,
+  ExtrapolationMode,
 } from 'sentry/views/alerts/rules/metric/types';
 import type {UptimeMonitorMode} from 'sentry/views/alerts/rules/uptime/types';
 import type {Monitor, MonitorConfig} from 'sentry/views/insights/crons/types';
@@ -27,6 +28,7 @@ export interface SnubaQuery {
    */
   timeWindow: number;
   environment?: string;
+  extrapolationMode?: ExtrapolationMode;
 }
 
 /**
@@ -179,6 +181,7 @@ interface UpdateSnubaDataSourcePayload {
   query: string;
   queryType: number;
   timeWindow: number;
+  extrapolationMode?: string;
 }
 
 interface UpdateUptimeDataSourcePayload {

static/app/views/alerts/rules/metric/details/index.spec.tsx

@@ -10,7 +10,12 @@ import {act, render, screen, userEvent} from 'sentry-test/reactTestingLibrary';
 import ProjectsStore from 'sentry/stores/projectsStore';
 import {trackAnalytics} from 'sentry/utils/analytics';
 import MetricAlertDetails from 'sentry/views/alerts/rules/metric/details';
-import {Dataset, EventTypes} from 'sentry/views/alerts/rules/metric/types';
+import {
+  Dataset,
+  EventTypes,
+  ExtrapolationMode,
+} from 'sentry/views/alerts/rules/metric/types';
+import {SAMPLING_MODE} from 'sentry/views/explore/hooks/useProgressiveQuery';
 
 jest.mock('sentry/utils/analytics');
 
@@ -290,4 +295,106 @@ describe('MetricAlertDetails', () => {
       'true'
     );
   });
+
+  it('uses SERVER_WEIGHTED extrapolation mode when alert has it configured', async () => {
+    const {organization, routerProps} = initializeOrg();
+    const ruleWithExtrapolation = MetricRuleFixture({
+      projects: [project.slug],
+      dataset: Dataset.EVENTS_ANALYTICS_PLATFORM,
+      aggregate: 'count()',
+      query: '',
+      eventTypes: [EventTypes.TRACE_ITEM_SPAN],
+      extrapolationMode: ExtrapolationMode.SERVER_WEIGHTED,
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/org-slug/alert-rules/${ruleWithExtrapolation.id}/`,
+      body: ruleWithExtrapolation,
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/org-slug/incidents/`,
+      body: [],
+    });
+
+    const eventsStatsRequest = MockApiClient.addMockResponse({
+      url: '/organizations/org-slug/events-stats/',
+      body: EventsStatsFixture(),
+    });
+
+    render(
+      <MetricAlertDetails
+        organization={organization}
+        {...routerProps}
+        params={{ruleId: ruleWithExtrapolation.id}}
+      />,
+      {
+        organization,
+      }
+    );
+
+    expect(await screen.findByText(ruleWithExtrapolation.name)).toBeInTheDocument();
+
+    // Verify events-stats is called with 'serverOnly' extrapolation mode
+    expect(eventsStatsRequest).toHaveBeenCalledWith(
+      '/organizations/org-slug/events-stats/',
+      expect.objectContaining({
+        query: expect.objectContaining({
+          extrapolationMode: 'serverOnly',
+          sampling: SAMPLING_MODE.NORMAL,
+        }),
+      })
+    );
+  });
+
+  it('uses NONE extrapolation mode when alert has it configured', async () => {
+    const {organization, routerProps} = initializeOrg();
+    const ruleWithNoExtrapolation = MetricRuleFixture({
+      projects: [project.slug],
+      dataset: Dataset.EVENTS_ANALYTICS_PLATFORM,
+      aggregate: 'count()',
+      query: '',
+      eventTypes: [EventTypes.TRACE_ITEM_SPAN],
+      extrapolationMode: ExtrapolationMode.NONE,
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/org-slug/alert-rules/${ruleWithNoExtrapolation.id}/`,
+      body: ruleWithNoExtrapolation,
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/org-slug/incidents/`,
+      body: [],
+    });
+
+    const eventsStatsRequest = MockApiClient.addMockResponse({
+      url: '/organizations/org-slug/events-stats/',
+      body: EventsStatsFixture(),
+    });
+
+    render(
+      <MetricAlertDetails
+        organization={organization}
+        {...routerProps}
+        params={{ruleId: ruleWithNoExtrapolation.id}}
+      />,
+      {
+        organization,
+      }
+    );
+
+    expect(await screen.findByText(ruleWithNoExtrapolation.name)).toBeInTheDocument();
+
+    // Verify events-stats is called with 'none' extrapolation mode
+    expect(eventsStatsRequest).toHaveBeenCalledWith(
+      '/organizations/org-slug/events-stats/',
+      expect.objectContaining({
+        query: expect.objectContaining({
+          extrapolationMode: 'none',
+          sampling: SAMPLING_MODE.HIGH_ACCURACY,
+        }),
+      })
+    );
+  });
 });

static/app/views/alerts/rules/metric/details/metricChart.tsx

@@ -52,7 +52,11 @@ import useOrganization from 'sentry/utils/useOrganization';
 import {COMPARISON_DELTA_OPTIONS} from 'sentry/views/alerts/rules/metric/constants';
 import {makeDefaultCta} from 'sentry/views/alerts/rules/metric/metricRulePresets';
 import type {MetricRule} from 'sentry/views/alerts/rules/metric/types';
-import {AlertRuleTriggerType, Dataset} from 'sentry/views/alerts/rules/metric/types';
+import {
+  AlertRuleTriggerType,
+  Dataset,
+  ExtrapolationMode,
+} from 'sentry/views/alerts/rules/metric/types';
 import {isCrashFreeAlert} from 'sentry/views/alerts/rules/metric/utils/isCrashFreeAlert';
 import {
   isEapAlertType,
@@ -475,7 +479,9 @@ export default function MetricChart({
       referrer: 'api.alerts.alert-rule-chart',
       samplingMode:
         rule.dataset === Dataset.EVENTS_ANALYTICS_PLATFORM
-          ? SAMPLING_MODE.NORMAL
+          ? rule.extrapolationMode === ExtrapolationMode.NONE
+            ? SAMPLING_MODE.HIGH_ACCURACY
+            : SAMPLING_MODE.NORMAL
           : undefined,
     },
     {enabled: !shouldUseSessionsStats}

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

@@ -9,7 +9,7 @@ import GlobalModal from 'sentry/components/globalModal';
 
 import MetricRuleDuplicate from './duplicate';
 import type {Action} from './types';
-import {AlertRuleTriggerType} from './types';
+import {AlertRuleTriggerType, Dataset, EventTypes, ExtrapolationMode} from './types';
 
 describe('MetricRuleDuplicate', () => {
   beforeEach(() => {
@@ -55,6 +55,14 @@ describe('MetricRuleDuplicate', () => {
       url: '/organizations/org-slug/members/',
       body: [MemberFixture()],
     });
+    MockApiClient.addMockResponse({
+      url: '/organizations/org-slug/recent-searches/',
+      body: [],
+    });
+    MockApiClient.addMockResponse({
+      url: '/organizations/org-slug/trace-items/attributes/',
+      body: [],
+    });
   });
 
   it('renders new alert form with values copied over', async () => {
@@ -153,4 +161,68 @@ describe('MetricRuleDuplicate', () => {
     // Duplicated alert has been called
     expect(req).toHaveBeenCalled();
   });
+
+  it('duplicates rule with SERVER_WEIGHTED extrapolation mode but creates new rule without it', async () => {
+    const ruleWithExtrapolation = MetricRuleFixture({
+      id: '7',
+      name: 'Alert Rule with Extrapolation',
+      dataset: Dataset.EVENTS_ANALYTICS_PLATFORM,
+      aggregate: 'count()',
+      query: '',
+      eventTypes: [EventTypes.TRACE_ITEM_SPAN],
+      extrapolationMode: ExtrapolationMode.SERVER_WEIGHTED,
+    });
+
+    const {organization, project, routerProps} = initializeOrg({
+      organization: {
+        access: ['alerts:write'],
+      },
+      router: {
+        params: {},
+        location: {
+          query: {
+            createFromDuplicate: 'true',
+            duplicateRuleId: `${ruleWithExtrapolation.id}`,
+          },
+        },
+      },
+    });
+
+    const req = MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/alert-rules/${ruleWithExtrapolation.id}/`,
+      body: ruleWithExtrapolation,
+    });
+
+    const eventsStatsRequest = MockApiClient.addMockResponse({
+      url: '/organizations/org-slug/events-stats/',
+      body: null,
+    });
+
+    render(
+      <Fragment>
+        <GlobalModal />
+        <MetricRuleDuplicate project={project} userTeamIds={[]} {...routerProps} />
+      </Fragment>
+    );
+
+    // Wait for the form to load with duplicated values
+    expect(await screen.findByTestId('critical-threshold')).toHaveValue('70');
+    expect(screen.getByTestId('alert-name')).toHaveValue(
+      `${ruleWithExtrapolation.name} copy`
+    );
+
+    // Verify the original rule was fetched
+    expect(req).toHaveBeenCalled();
+
+    // Verify events-stats chart requests do NOT include extrapolation mode
+    // (duplicated rules are treated as new rules)
+    expect(eventsStatsRequest).toHaveBeenCalledWith(
+      '/organizations/org-slug/events-stats/',
+      expect.objectContaining({
+        query: expect.not.objectContaining({
+          extrapolationMode: expect.anything(),
+        }),
+      })
+    );
+  });
 });