fixup: use schema cancelled event

Author: Anemy

packages/compass-schema/src/components/compass-schema.tsx

@@ -446,7 +446,7 @@ export default connect(
   }),
   {
     onStartAnalysis: startAnalysis,
-    onStopAnalysis: stopAnalysis,
+    onStopAnalysis: () => stopAnalysis(true),
     onExportSchemaClicked: openExportSchema,
   }
 )(Schema);

packages/compass-schema/src/modules/schema-analysis.ts

@@ -222,9 +222,7 @@ export async function calculateSchemaMetadata(schema: Schema): Promise<{
   return {
     field_types: fieldTypes,
     geo_data: hasGeoData,
-    // TODO: calculate these
     optional_field_count: optionalFieldCount,
-
     schema_depth: schemaDepth,
     variable_type_count: variableTypeCount,
   };

packages/compass-schema/src/stores/schema-analysis-reducer.ts

@@ -2,6 +2,7 @@ import type { Schema } from 'mongodb-schema';
 import { isInternalFieldPath } from 'hadron-document';
 import type { Action, Reducer } from 'redux';
 import type { AggregateOptions } from 'mongodb';
+import type { QueryBarService } from '@mongodb-js/compass-query-bar';
 import { type AnalysisState } from '../constants/analysis-states';
 import {
   ANALYSIS_STATE_ANALYZING,
@@ -169,10 +170,58 @@ export const geoLayersDeleted = (
   };
 };
 
-export const stopAnalysis = (): SchemaThunkAction<void> => {
+// We track when the user cancels the analysis. We use the userCancelled
+// flag to indicate if we should track, as we also automatically stop
+// analysis when deactivating the plugin.
+const userCancelledAnalysisAbortReason = 'Cancelled analysis';
+
+export const stopAnalysis = (
+  userCancelled = false
+): SchemaThunkAction<void> => {
   return (dispatch, getState, { abortControllerRef }) => {
     if (!abortControllerRef.current) return;
-    abortControllerRef.current?.abort();
+    abortControllerRef.current?.abort(
+      userCancelled ? userCancelledAnalysisAbortReason : undefined
+    );
+  };
+};
+
+const getSchemaAnalyzedEventPayload = ({
+  schema,
+  query,
+  analysisTime,
+}: {
+  schema: Schema | null;
+  query: ReturnType<QueryBarService['getLastAppliedQuery']>;
+  analysisTime: number;
+}) => {
+  return async () => {
+    const {
+      field_types,
+      geo_data,
+      optional_field_count,
+      schema_depth,
+      variable_type_count,
+    } = schema
+      ? await calculateSchemaMetadata(schema)
+      : {
+          field_types: {},
+          geo_data: false,
+          optional_field_count: 0,
+          schema_depth: 0,
+          variable_type_count: 0,
+        };
+
+    return {
+      with_filter: Object.entries(query.filter ?? {}).length > 0,
+      schema_width: schema?.fields?.length ?? 0,
+      field_types,
+      variable_type_count,
+      optional_field_count,
+      schema_depth,
+      geo_data,
+      analysis_time_ms: analysisTime,
+    };
   };
 };
 
@@ -223,12 +272,12 @@ export const startAnalysis = (): SchemaThunkAction<
     abortControllerRef.current = new AbortController();
     const abortSignal = abortControllerRef.current.signal;
 
+    const analysisStartTime = Date.now();
     try {
       debug('analysis started');
 
       dispatch({ type: SchemaAnalysisActions.analysisStarted });
 
-      const analysisStartTime = Date.now();
       const schemaAccessor = await analyzeSchema(
         dataService,
         abortSignal,
@@ -237,6 +286,11 @@ export const startAnalysis = (): SchemaThunkAction<
         driverOptions,
         logger
       );
+
+      if (abortSignal?.aborted) {
+        throw new Error(abortSignal?.reason || new Error('Operation aborted'));
+      }
+
       let schema: Schema | null = null;
       if (schemaAccessor) {
         schema = await schemaAccessor.getInternalSchema();
@@ -256,38 +310,33 @@ export const startAnalysis = (): SchemaThunkAction<
         schemaAccessor,
       });
 
-      const trackEvent = async () => {
-        const {
-          field_types,
-          geo_data,
-          optional_field_count,
-          schema_depth,
-          variable_type_count,
-        } = schema
-          ? await calculateSchemaMetadata(schema)
-          : {
-              field_types: {},
-              geo_data: false,
-              optional_field_count: 0,
-              schema_depth: 0,
-              variable_type_count: 0,
-            };
-
-        return {
-          with_filter: Object.entries(query.filter ?? {}).length > 0,
-          schema_width: schema?.fields?.length ?? 0,
-          field_types,
-          variable_type_count,
-          optional_field_count,
-          schema_depth,
-          geo_data,
-          analysis_time_ms: analysisTime,
-        };
-      };
-      track('Schema Analyzed', trackEvent, connectionInfoRef.current);
+      track(
+        'Schema Analyzed',
+        getSchemaAnalyzedEventPayload({
+          schema,
+          query,
+          analysisTime,
+        }),
+        connectionInfoRef.current
+      );
 
       geoLayersRef.current = {};
     } catch (err: any) {
+      if (
+        abortSignal.aborted &&
+        abortSignal.reason === userCancelledAnalysisAbortReason
+      ) {
+        const analysisTime = Date.now() - analysisStartTime;
+        track(
+          'Schema Analysis Cancelled',
+          {
+            analysis_time_ms: analysisTime,
+            with_filter: Object.entries(query.filter ?? {}).length > 0,
+          },
+          connectionInfoRef.current
+        );
+      }
+
       log.error(
         mongoLogId(1_001_000_188),
         'Schema analysis',

packages/compass-schema/src/stores/schema-export-reducer.ts

@@ -195,7 +195,7 @@ const _trackSchemaExported = ({
   };
 };
 
-export const onSchemaExportCopied = (): SchemaThunkAction<void> => {
+export const trackSchemaExported = (): SchemaThunkAction<void> => {
   return (dispatch, getState) => {
     const {
       schemaAnalysis: { schema },