feat: add explore equation to dashboards

static/app/views/dashboards/datasetConfig/spans.tsx

@@ -1,4 +1,5 @@
 import pickBy from 'lodash/pickBy';
+import trimStart from 'lodash/trimStart';
 
 import {doEventsRequest} from 'sentry/actionCreators/events';
 import type {Client} from 'sentry/api';
@@ -17,7 +18,13 @@ import type {EventsTableData, TableData} from 'sentry/utils/discover/discoverQue
 import type {EventData} from 'sentry/utils/discover/eventView';
 import type {RenderFunctionBaggage} from 'sentry/utils/discover/fieldRenderers';
 import {emptyStringValue, getFieldRenderer} from 'sentry/utils/discover/fieldRenderers';
-import type {Aggregation, QueryFieldValue} from 'sentry/utils/discover/fields';
+import {
+  getEquationAliasIndex,
+  isEquation,
+  isEquationAlias,
+  type Aggregation,
+  type QueryFieldValue,
+} from 'sentry/utils/discover/fields';
 import {
   doDiscoverQuery,
   type DiscoverQueryExtras,
@@ -129,7 +136,7 @@ export const SpansConfig: DatasetConfig<
 > = {
   defaultField: DEFAULT_FIELD,
   defaultWidgetQuery: DEFAULT_WIDGET_QUERY,
-  enableEquations: false,
+  enableEquations: true,
   SearchBar: SpansSearchBar,
   filterYAxisAggregateParams: () => filterAggregateParams,
   filterYAxisOptions,
@@ -288,6 +295,15 @@ function getEventsRequest(
   };
 
   if (query.orderby) {
+    if (isEquationAlias(trimStart(query.orderby, '-'))) {
+      const equations = query.fields?.filter(isEquation) ?? [];
+      const equationIndex = getEquationAliasIndex(trimStart(query.orderby, '-'));
+
+      const orderby = equations[equationIndex];
+      if (orderby) {
+        query.orderby = query.orderby.startsWith('-') ? `-${orderby}` : orderby;
+      }
+    }
     params.sort = toArray(query.orderby);
   }
 
@@ -359,7 +375,10 @@ function getSeriesRequest(
 // Filters the primary options in the sort by selector
 function filterSeriesSortOptions(columns: Set<string>) {
   return (option: FieldValueOption) => {
-    if (option.value.kind === FieldValueKind.FUNCTION) {
+    if (
+      option.value.kind === FieldValueKind.FUNCTION ||
+      option.value.kind === FieldValueKind.EQUATION
+    ) {
       return true;
     }
 

static/app/views/dashboards/datasetConfig/utils/getSeriesRequestData.tsx

@@ -5,11 +5,11 @@ import type {PageFilters} from 'sentry/types/core';
 import type {Organization} from 'sentry/types/organization';
 import {
   getAggregateAlias,
+  getEquationAliasIndex,
   isEquation,
   isEquationAlias,
 } from 'sentry/utils/discover/fields';
-import type {DiscoverDatasets} from 'sentry/utils/discover/types';
-import {TOP_N} from 'sentry/utils/discover/types';
+import {DiscoverDatasets, TOP_N} from 'sentry/utils/discover/types';
 import {DisplayType, type Widget} from 'sentry/views/dashboards/types';
 import {getNumEquations, getWidgetInterval} from 'sentry/views/dashboards/utils';
 
@@ -93,18 +93,43 @@ export function getSeriesRequestData(
       requestData.excludeOther =
         widgetQuery.aggregates.length !== 1 || widget.queries.length !== 1;
 
-      if (isEquation(trimStart(widgetQuery.orderby, '-'))) {
-        const nextEquationIndex = getNumEquations(widgetQuery.aggregates);
-        const isDescending = widgetQuery.orderby.startsWith('-');
-        const prefix = isDescending ? '-' : '';
+      if ([DiscoverDatasets.OURLOGS, DiscoverDatasets.SPANS].includes(dataset)) {
+        if (
+          isEquation(trimStart(widgetQuery.orderby, '-')) &&
+          !requestData.field?.includes(trimStart(widgetQuery.orderby, '-'))
+        ) {
+          requestData.field = [
+            ...widgetQuery.columns,
+            ...widgetQuery.aggregates,
+            trimStart(widgetQuery.orderby, '-'),
+          ];
+        } else if (isEquationAlias(trimStart(widgetQuery.orderby, '-'))) {
+          const equations = widgetQuery.fields?.filter(isEquation) ?? [];
+          const equationIndex = getEquationAliasIndex(
+            trimStart(widgetQuery.orderby, '-')
+          );
 
-        // Construct the alias form of the equation and inject it into the request
-        requestData.orderby = `${prefix}equation[${nextEquationIndex}]`;
-        requestData.field = [
-          ...widgetQuery.columns,
-          ...widgetQuery.aggregates,
-          trimStart(widgetQuery.orderby, '-'),
-        ];
+          const equationOrderBy = equations[equationIndex];
+          if (equationOrderBy) {
+            requestData.orderby = widgetQuery.orderby.startsWith('-')
+              ? `-${equationOrderBy}`
+              : equationOrderBy;
+          }
+        }
+      } else {
+        if (isEquation(trimStart(widgetQuery.orderby, '-'))) {
+          const nextEquationIndex = getNumEquations(widgetQuery.aggregates);
+          const isDescending = widgetQuery.orderby.startsWith('-');
+          const prefix = isDescending ? '-' : '';
+
+          // Construct the alias form of the equation and inject it into the request
+          requestData.orderby = `${prefix}equation[${nextEquationIndex}]`;
+          requestData.field = [
+            ...widgetQuery.columns,
+            ...widgetQuery.aggregates,
+            trimStart(widgetQuery.orderby, '-'),
+          ];
+        }
       }
     }
   }

static/app/views/dashboards/utils/getWidgetExploreUrl.spec.tsx

@@ -41,6 +41,41 @@ describe('getWidgetExploreUrl', () => {
     });
   });
 
+  it('returns the correct aggregate mode url for table widgets with equations sort', () => {
+    const widget = WidgetFixture({
+      displayType: DisplayType.TABLE,
+      queries: [
+        {
+          fields: ['span.description', 'equation|avg(span.duration) + 100'],
+          aggregates: ['equation|avg(span.duration) + 100'],
+          columns: ['span.description'],
+          conditions: '',
+          orderby: '-equation[0]',
+          name: '',
+        },
+      ],
+    });
+
+    const url = getWidgetExploreUrl(widget, undefined, selection, organization);
+
+    // Note: for table widgets the mode is set to samples and the fields are propagated
+    expectUrl(url).toMatch({
+      path: '/organizations/org-slug/explore/traces/',
+      params: [
+        ['field', 'span.description'],
+        ['groupBy', 'span.description'],
+        ['interval', '30m'],
+        ['mode', 'aggregate'],
+        ['statsPeriod', '14d'],
+        ['sort', '-equation|avg(span.duration) + 100'],
+        [
+          'visualize',
+          JSON.stringify({chartType: 1, yAxes: ['equation|avg(span.duration) + 100']}),
+        ],
+      ],
+    });
+  });
+
   it('returns the correct samples mode url for table widgets without aggregation', () => {
     const widget = WidgetFixture({
       displayType: DisplayType.TABLE,

static/app/views/dashboards/utils/getWidgetExploreUrl.tsx

@@ -6,8 +6,11 @@ import type {Organization} from 'sentry/types/organization';
 import {defined} from 'sentry/utils';
 import {
   getAggregateAlias,
+  getEquationAliasIndex,
   isAggregateField,
   isAggregateFieldOrEquation,
+  isEquation,
+  isEquationAlias,
   parseFunction,
 } from 'sentry/utils/discover/fields';
 import {FieldKind, getFieldDefinition} from 'sentry/utils/fields';
@@ -336,6 +339,14 @@ function _getWidgetExploreUrl(
     } else if (exploreMode === Mode.AGGREGATE) {
       sort = widget.queries[0]?.orderby;
     }
+  } else if (isEquationAlias(sortColumn) && exploreMode === Mode.AGGREGATE) {
+    const equations = query.fields?.filter(isEquation) ?? [];
+    const equationIndex = getEquationAliasIndex(sortColumn);
+
+    const orderby = equations[equationIndex];
+    if (orderby) {
+      sort = `${sortDirection}${orderby}`;
+    }
   } else if (!isAggregateFieldOrEquation(sortColumn)) {
     sort = widget.queries[0]?.orderby;
   }

static/app/views/dashboards/widgetBuilder/components/exploreArithmeticBuilder.tsx

@@ -0,0 +1,74 @@
+import {useCallback, useMemo} from 'react';
+
+import {ArithmeticBuilder} from 'sentry/components/arithmeticBuilder';
+import type {Expression} from 'sentry/components/arithmeticBuilder/expression';
+import type {FunctionArgument} from 'sentry/components/arithmeticBuilder/types';
+import {stripEquationPrefix} from 'sentry/utils/discover/fields';
+import {
+  ALLOWED_EXPLORE_EQUATION_AGGREGATES,
+  FieldKind,
+  getFieldDefinition,
+} from 'sentry/utils/fields';
+import {useTraceItemTags} from 'sentry/views/explore/contexts/spanTagsContext';
+import {useExploreSuggestedAttribute} from 'sentry/views/explore/hooks/useExploreSuggestedAttribute';
+
+type Props = {
+  equation: string;
+  onUpdate: (value: string) => void;
+};
+
+export function ExploreArithmeticBuilder({equation, onUpdate}: Props) {
+  const expression = stripEquationPrefix(equation);
+  const {tags: numberTags} = useTraceItemTags('number');
+  const {tags: stringTags} = useTraceItemTags('string');
+
+  const functionArguments: FunctionArgument[] = useMemo(() => {
+    return [
+      ...Object.entries(numberTags).map(([key, tag]) => {
+        return {
+          kind: FieldKind.MEASUREMENT,
+          name: key,
+          label: tag.name,
+        };
+      }),
+      ...Object.entries(stringTags).map(([key, tag]) => {
+        return {
+          kind: FieldKind.TAG,
+          name: key,
+          label: tag.name,
+        };
+      }),
+    ];
+  }, [numberTags, stringTags]);
+
+  const getSpanFieldDefinition = useCallback(
+    (key: string) => {
+      const tag = numberTags[key] ?? stringTags[key];
+      return getFieldDefinition(key, 'span', tag?.kind);
+    },
+    [numberTags, stringTags]
+  );
+
+  const handleExpressionChange = useCallback(
+    (newExpression: Expression) => {
+      onUpdate(stripEquationPrefix(newExpression.text));
+    },
+    [onUpdate]
+  );
+
+  const getSuggestedAttribute = useExploreSuggestedAttribute({
+    numberAttributes: numberTags,
+    stringAttributes: stringTags,
+  });
+
+  return (
+    <ArithmeticBuilder
+      aggregations={ALLOWED_EXPLORE_EQUATION_AGGREGATES}
+      functionArguments={functionArguments}
+      getFieldDefinition={getSpanFieldDefinition}
+      expression={expression}
+      setExpression={handleExpressionChange}
+      getSuggestedKey={getSuggestedAttribute}
+    />
+  );
+}