insights: add proactive mode pings back (#42554)

Author: leo

client/web/src/search/results/components/aggregation/SearchAggregationResult.tsx

@@ -53,6 +53,7 @@ export const SearchAggregationResult: FC<SearchAggregationResultProps> = props =
         caseSensitive,
         proactive: true,
         extendedTimeout,
+        telemetryService,
     })
 
     const handleCollapseClick = (): void => {

client/web/src/search/results/components/aggregation/hooks.ts

@@ -3,12 +3,14 @@ import { useCallback, useLayoutEffect, useMemo, useState } from 'react'
 import { gql, useQuery } from '@apollo/client'
 import { useHistory, useLocation } from 'react-router'
 
-import { SearchAggregationMode } from '@sourcegraph/shared/src/graphql-operations'
+import { NotAvailableReasonType, SearchAggregationMode } from '@sourcegraph/shared/src/graphql-operations'
 import { SearchPatternType } from '@sourcegraph/shared/src/schema'
+import { TelemetryService } from '@sourcegraph/shared/src/telemetry/telemetryService'
 
 import { GetSearchAggregationResult, GetSearchAggregationVariables } from '../../../../graphql-operations'
 
 import { AGGREGATION_MODE_URL_KEY, AGGREGATION_UI_MODE_URL_KEY } from './constants'
+import { GroupResultsPing } from './pings'
 import { AggregationUIMode } from './types'
 
 interface URLStateOptions<State, SerializedState> {
@@ -210,6 +212,7 @@ interface SearchAggregationDataInput {
     caseSensitive: boolean
     extendedTimeout: boolean
     proactive?: boolean
+    telemetryService: TelemetryService
 }
 
 interface AggregationState {
@@ -225,7 +228,15 @@ type SearchAggregationResults =
     | { data: GetSearchAggregationResult; loading: false; error: undefined }
 
 export const useSearchAggregationData = (input: SearchAggregationDataInput): SearchAggregationResults => {
-    const { query, patternType, aggregationMode, proactive, caseSensitive, extendedTimeout } = input
+    const {
+        query,
+        patternType,
+        aggregationMode,
+        proactive = false,
+        caseSensitive,
+        extendedTimeout,
+        telemetryService,
+    } = input
 
     const [, setAggregationMode] = useAggregationSearchMode()
     const [state, setState] = useState<AggregationState>(INITIAL_STATE)
@@ -276,6 +287,8 @@ export const useSearchAggregationData = (input: SearchAggregationDataInput): Sea
                 // skip: true resets data field in the useQuery hook, in order to use previously
                 // saved data we use useState to store data outside useQuery hook
                 setState({ data, calculatedMode: calculatedAggregationMode })
+
+                sendAggregationPing({ data, aggregationMode, extendedTimeout, proactive, telemetryService })
             },
         }
     )
@@ -318,3 +331,59 @@ export const isNonExhaustiveAggregationResults = (response?: GetSearchAggregatio
 
     return response.searchQueryAggregate?.aggregations?.__typename === 'NonExhaustiveSearchAggregationResult'
 }
+
+interface UseAggregationPingsArgs {
+    data: GetSearchAggregationResult | undefined
+    proactive: boolean
+    extendedTimeout: boolean
+    telemetryService: TelemetryService
+    aggregationMode: SearchAggregationMode | null
+}
+
+function sendAggregationPing({
+    data,
+    proactive,
+    extendedTimeout,
+    telemetryService,
+    aggregationMode,
+}: UseAggregationPingsArgs): void {
+    if (!data?.searchQueryAggregate.aggregations) {
+        return
+    }
+
+    const aggregation = data.searchQueryAggregate.aggregations
+    const aggregationType = aggregation.__typename
+    const aggregationAvailable =
+        aggregationType === 'ExhaustiveSearchAggregationResult' ||
+        aggregationType === 'NonExhaustiveSearchAggregationResult'
+    const aggregationUnavailable = aggregationType === 'SearchAggregationNotAvailable'
+
+    let pingType
+
+    if (aggregationUnavailable) {
+        const extensionAvailable = aggregation.reasonType === NotAvailableReasonType.TIMEOUT_EXTENSION_AVAILABLE
+        const noExtensionAvailable = aggregation.reasonType === NotAvailableReasonType.TIMEOUT_NO_EXTENSION_AVAILABLE
+
+        if (proactive && extensionAvailable) {
+            pingType = GroupResultsPing.ProactiveLimitHit
+        }
+
+        if (noExtensionAvailable) {
+            pingType = GroupResultsPing.ExplicitLimitHit
+        }
+    }
+
+    if (aggregationAvailable) {
+        if (proactive) {
+            pingType = GroupResultsPing.ProactiveLimitSuccess
+        }
+
+        if (extendedTimeout) {
+            pingType = GroupResultsPing.ExplicitLimitSuccess
+        }
+    }
+
+    if (pingType) {
+        telemetryService.log(pingType, { aggregationMode }, { aggregationMode })
+    }
+}

client/web/src/search/results/components/aggregation/pings.ts

@@ -13,4 +13,10 @@ export enum GroupResultsPing {
     ExpandFullViewPanel = 'GroupResultsExpandedViewOpen',
     CollapseFullViewPanel = 'GroupResultsExpandedViewCollapse',
     InfoIconHover = 'GroupResultsInfoIconHover',
+
+    // Proactive
+    ProactiveLimitHit = 'ProactiveLimitHit',
+    ProactiveLimitSuccess = 'ProactiveLimitSuccess',
+    ExplicitLimitHit = 'ExplicitLimitHit',
+    ExplicitLimitSuccess = 'ExplicitLimitSuccess',
 }

client/web/src/search/results/sidebar/SearchAggregations.tsx

@@ -58,6 +58,7 @@ export const SearchAggregations: FC<SearchAggregationsProps> = memo(props => {
         proactive,
         caseSensitive,
         extendedTimeout,
+        telemetryService,
     })
 
     // When query is updated reset extendedTimeout as per business rules
@@ -156,3 +157,5 @@ export const SearchAggregations: FC<SearchAggregationsProps> = memo(props => {
         </article>
     )
 })
+
+SearchAggregations.displayName = 'SearchAggregations'

doc/dev/background-information/insights/code_insights_pings.md

@@ -423,3 +423,15 @@ https://sourcegraph.com/search?q=context:global+repo:%5Egithub%5C.com/sourcegrap
   - [WeeklyGroupResultsChartBarClick](https://sourcegraph.com/search?q=context:%40sourcegraph/all+GroupResultsChartBarClick&patternType=regexp)
   - [WeeklyGroupResultsChartBarHover](https://sourcegraph.com/search?q=context:%40sourcegraph/all+GroupResultsChartBarHover&patternType=regexp)
 - **Version added:** 4.0 ([#40977](https://github.com/sourcegraph/sourcegraph/pull/40977))
+
+### Search mode (proactive/extended) success rate
+
+**Type:** FE event
+
+**Intended purpose:** To track the number of aggregation searches that succeed or hit limit in either a proactive or extended search. 
+
+**Functional implementation:** These pings fire a telemetry event when an aggregation search completes or times out.
+
+- Aggregation: weekly
+- Event Code: [WeeklyGroupResultsSearches](https://sourcegraph.com/search?q=context:%40sourcegraph/all+WeeklyGroupResultsSearches&patternType=lucky)
+- **Version added:** 4.1 ([#42554](https://github.com/sourcegraph/sourcegraph/pull/42554))

internal/types/types.go

@@ -1449,6 +1449,7 @@ type CodeInsightsUsageStatistics struct {
 	WeeklyGroupResultsChartBarClick                []GroupResultPing
 	WeeklyGroupResultsAggregationModeClicked       []GroupResultPing
 	WeeklyGroupResultsAggregationModeDisabledHover []GroupResultPing
+	WeeklyGroupResultsSearches                     []GroupResultSearchPing
 	WeeklySeriesBackfillTime                       []InsightsBackfillTimePing
 }
 
@@ -1464,6 +1465,12 @@ type GroupResultExpandedViewPing struct {
 	Count           *int32
 }
 
+type GroupResultSearchPing struct {
+	Name            PingName
+	AggregationMode *string
+	Count           *int32
+}
+
 type CodeInsightsCriticalTelemetry struct {
 	TotalInsights int32
 }

internal/usagestats/code_insights.go

@@ -227,6 +227,21 @@ func GetCodeInsightsUsageStatistics(ctx context.Context, db database.DB) (*types
 	}
 	stats.WeeklyGroupResultsExpandedViewCollapse = weeklyGroupResultsExpandedViewCollapse
 
+	weeklyGroupResultsSearches, err := GetGroupResultsSearchesPings(
+		ctx,
+		db,
+		[]types.PingName{
+			"ProactiveLimitHit",
+			"ProactiveLimitSuccess",
+			"ExplicitLimitHit",
+			"ExplicitLimitSuccess",
+		},
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "WeeklyGroupResultsSearches")
+	}
+	stats.WeeklyGroupResultsSearches = weeklyGroupResultsSearches
+
 	backfillTime, err := GetBackfillTimePing(ctx, db)
 	if err != nil {
 		return nil, errors.Wrap(err, "GetBackfillTimePing")
@@ -442,6 +457,40 @@ func GetGroupResultsExpandedViewPing(ctx context.Context, db database.DB, pingNa
 	return groupResultsExpandedViewPings, nil
 }
 
+func GetGroupResultsSearchesPings(ctx context.Context, db database.DB, pingNames []types.PingName) ([]types.GroupResultSearchPing, error) {
+	pings := []types.GroupResultSearchPing{}
+
+	for _, name := range pingNames {
+		rows, err := db.QueryContext(ctx, getGroupResultsSql, string(name), timeNow())
+		if err != nil {
+			return nil, err
+		}
+		err = func() error {
+			defer rows.Close()
+			var noop *string
+			for rows.Next() {
+				ping := types.GroupResultSearchPing{
+					Name: name,
+				}
+				if err := rows.Scan(
+					&ping.Count,
+					&ping.AggregationMode,
+					&noop,
+					&noop,
+				); err != nil {
+					return err
+				}
+				pings = append(pings, ping)
+			}
+			return nil
+		}()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return pings, nil
+}
+
 func GetBackfillTimePing(ctx context.Context, db database.DB) ([]types.InsightsBackfillTimePing, error) {
 	store := db.EventLogs()
 	name := InsightsBackfillTimePingName

internal/usagestats/code_insights_test.go

@@ -10,7 +10,6 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-
 	"github.com/sourcegraph/log/logtest"
 
 	"github.com/sourcegraph/sourcegraph/internal/database"
@@ -126,6 +125,7 @@ func TestCodeInsightsUsageStatistics(t *testing.T) {
 	want.WeeklyGroupResultsChartBarClick = []types.GroupResultPing{}
 	want.WeeklyGroupResultsAggregationModeClicked = []types.GroupResultPing{}
 	want.WeeklyGroupResultsAggregationModeDisabledHover = []types.GroupResultPing{}
+	want.WeeklyGroupResultsSearches = []types.GroupResultSearchPing{}
 	want.WeeklySeriesBackfillTime = []types.InsightsBackfillTimePing{}
 
 	if diff := cmp.Diff(want, have); diff != "" {