@finos/legend-query-builder 4.19.12 → 4.19.13

package/src/__lib__/QueryBuilderTelemetryHelper.ts

@@ -15,29 +15,205 @@
  */
 
 import type { GraphManagerOperationReport } from '@finos/legend-graph';
+import type { TelemetryErrorFields, TimingsRecord } from '@finos/legend-shared';
 import type { TelemetryService } from '@finos/legend-application';
 import {
   QUERY_BUILDER_EVENT,
   QUERY_BUILDER_FILTER_EVENT,
   QUERY_BUILDER_POST_FILTER_EVENT,
+  type QUERY_BUILDER_OPENED_FROM,
 } from './QueryBuilderEvent.js';
-import type { QueryableClassMappingRuntimeInfo } from '../stores/QueryBuilderState.js';
+import type {
+  QueryBuilderQueryInfo,
+  QueryBuilderTelemetryContext,
+} from '../stores/QueryBuilderState.js';
 
-type QueryExecution_TelemetryData = GraphManagerOperationReport & {
-  dependenciesCount: number;
-  state?: QueryableClassMappingRuntimeInfo | undefined;
-};
-type QueryMappingModelCoverageAnalysis_TelemetryData =
+/**
+ * Every payload below extends {@link QueryBuilderTelemetryContext}, which
+ * carries two deliberately separate halves:
+ *
+ * - the entry point the query builder was *opened with* (`sourceInfo` — the
+ *   route: GAV, data space, data product, service, …), spread FLAT at the top
+ *   level;
+ * - the execution context it *resolved to* (class / mapping / runtime), nested
+ *   under `state`.
+ *
+ * Keeping them apart is what lets a dashboard distinguish "arrived on mapping
+ * X" from "currently querying mapping X" — for a mapping-sourced query both are
+ * populated and a divergence means the user switched, while for a data space or
+ * data product query only `state` carries a mapping, because the entry point
+ * resolves to one.
+ */
+type QueryExecution_TelemetryData = QueryBuilderTelemetryContext &
   GraphManagerOperationReport & {
     dependenciesCount: number;
-    state?: QueryableClassMappingRuntimeInfo | undefined;
+    queryInfo?: QueryBuilderQueryInfo | undefined;
+    executionDurationMs?: number | undefined;
   };
 
+/**
+ * Payload for query execution / plan / export failure events. Mirrors the shape
+ * of `LegendQueryTelemetryHelper` creator-failure payloads (`errorName`,
+ * `errorMessage`, `httpStatus`) so success/failure pairs can be joined on the
+ * same set of dimensions.
+ */
+export type QueryExecutionFailure_TelemetryData = QueryBuilderTelemetryContext &
+  TelemetryErrorFields & {
+    /**
+     * Backend trace ID for the failed execution, when the error carries one.
+     */
+    executionTraceId?: string | undefined;
+    /**
+     * Phase timings collected up to the point of failure. Which laps are
+     * *missing* is the useful signal: no
+     * `graph-manager.v1.engine-operation.server-call.success` means the query
+     * never reached the engine, so the failure is pre-flight rather than
+     * in-flight.
+     */
+    timings?: TimingsRecord | undefined;
+    queryInfo?: QueryBuilderQueryInfo | undefined;
+    executionDurationMs?: number | undefined;
+  } & Record<string, unknown>;
+
+/**
+ * Payload for {@link QUERY_BUILDER_EVENT.OPENED}.
+ *
+ * `openedFrom` is carried here and nowhere else. Which application emitted an
+ * event is already stamped on every payload by `TelemetryServicePlugin.setup()`
+ * (`appName`), and `appSessionId` is the join key back to this event — so
+ * repeating the surface on high-frequency events like `run-query.*` would
+ * duplicate data that is already reachable.
+ */
+export type QueryBuilderOpened_TelemetryData = QueryBuilderTelemetryContext & {
+  openedFrom: QUERY_BUILDER_OPENED_FROM;
+} & Record<string, unknown>;
+
+type QueryMappingModelCoverageAnalysis_TelemetryData =
+  QueryBuilderTelemetryContext &
+    GraphManagerOperationReport & {
+      dependenciesCount: number;
+    };
+
 type GraphFetchPanel_TelemtryData = {
   serializationType: string | undefined;
 };
 
+/**
+ * Payloads for the authoring-side `*.change` events.
+ *
+ * Each nests what the user actually did under a `change` key, leaving the top
+ * level to the shared {@link QueryBuilderTelemetryContext} envelope. Beyond
+ * consistency this avoids a real collision: `change.sourceType` on a projection
+ * event ("explorer-property") means something entirely different from the
+ * top-level `sourceType` carried by `sourceInfo` ("data-product").
+ */
+type ExecutionContextChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    subtype: 'class' | 'mapping' | 'runtime';
+  };
+};
+
+type ProjectionChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    action: 'add' | 'remove' | 'move' | 'clear' | 'add-derivation';
+    sourceType?:
+      | 'explorer-property'
+      | 'explorer-relation'
+      | 'function'
+      | 'filter-condition'
+      | 'derivation';
+    /**
+     * The resulting column count — except for `clear`, where it is the number
+     * of columns that were removed.
+     */
+    columnCount: number;
+  };
+};
+
+type ResultModifierChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    limitSet: boolean;
+    distinctOn: boolean;
+    sortColumnCount: number;
+    sliceSet: boolean;
+  };
+};
+
+type AggregationChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    action: 'operator-change';
+    operatorName?: string | undefined;
+  };
+};
+
+type WindowChange_TelemetryData = QueryBuilderTelemetryContext & {
+  /**
+   * DnD reordering of window columns is intentionally not reported — it would
+   * emit on every hover-driven reorder, so there is no `move` action here.
+   */
+  change: {
+    action: 'add' | 'edit' | 'remove';
+    columnCount: number;
+  };
+};
+
+type GraphFetchChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    action: 'add' | 'remove' | 'check-toggle' | 'serialization-change';
+    nodeCount: number;
+    serializationType?: string | undefined;
+  };
+};
+
+type ParameterChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    action: 'add' | 'edit' | 'remove';
+    parameterCount: number;
+  };
+};
+
+type ConstantChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    action: 'add' | 'edit' | 'remove';
+    constantCount: number;
+  };
+};
+
+type WatermarkChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    enabled: boolean;
+  };
+};
+
+type MilestoningChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    subtype:
+      | 'business-date'
+      | 'processing-date'
+      | 'all-versions'
+      | 'all-versions-in-range';
+  };
+};
+
+/**
+ * Shared by the filter and post-filter trees. DnD reparenting/reordering of
+ * condition nodes is intentionally not reported, so there is no `move` action.
+ */
+type FilterChange_TelemetryData = QueryBuilderTelemetryContext & {
+  change: {
+    action: 'remove' | 'group-operation-change';
+    groupOperation?: 'and' | 'or' | undefined;
+  };
+};
+
 export class QueryBuilderTelemetryHelper {
+  static logEvent_QueryBuilderOpened(
+    service: TelemetryService,
+    data: QueryBuilderOpened_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.OPENED, data);
+  }
+
   static logEvent_QueryRunLaunched(
     service: TelemetryService,
     data?: Record<string, unknown> | undefined,
@@ -72,7 +248,7 @@ export class QueryBuilderTelemetryHelper {
 
   static logEvent_QueryRunFailed(
     service: TelemetryService,
-    data: { errorMessage: string } & Record<string, unknown>,
+    data: QueryExecutionFailure_TelemetryData,
   ): void {
     service.logEvent(QUERY_BUILDER_EVENT.RUN_QUERY__FAILURE, data);
   }
@@ -91,6 +267,13 @@ export class QueryBuilderTelemetryHelper {
     service.logEvent(QUERY_BUILDER_EVENT.EXPORT_QUERY_DATA__SUCCESS, data);
   }
 
+  static logEvent_ExportQueryDataFailed(
+    service: TelemetryService,
+    data: QueryExecutionFailure_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.EXPORT_QUERY_DATA__FAILURE, data);
+  }
+
   static logEvent_ExecutionPlanGenerationSucceeded(
     service: TelemetryService,
     data: QueryExecution_TelemetryData,
@@ -101,6 +284,16 @@ export class QueryBuilderTelemetryHelper {
     );
   }
 
+  static logEvent_ExecutionPlanGenerationFailed(
+    service: TelemetryService,
+    data: QueryExecutionFailure_TelemetryData,
+  ): void {
+    service.logEvent(
+      QUERY_BUILDER_EVENT.GENERATE_EXECUTION_PLAN__FAILURE,
+      data,
+    );
+  }
+
   static logEvent_ExecutionPlanDebugSucceeded(
     service: TelemetryService,
     data: QueryExecution_TelemetryData,
@@ -108,6 +301,13 @@ export class QueryBuilderTelemetryHelper {
     service.logEvent(QUERY_BUILDER_EVENT.DEBUG_EXECUTION_PLAN__SUCCESS, data);
   }
 
+  static logEvent_ExecutionPlanDebugFailed(
+    service: TelemetryService,
+    data: QueryExecutionFailure_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.DEBUG_EXECUTION_PLAN__FAILURE, data);
+  }
+
   static logEvent_EmbeddedDataCubeQueryRunSucceeded(
     service: TelemetryService,
     data: QueryExecution_TelemetryData,
@@ -289,4 +489,88 @@ export class QueryBuilderTelemetryHelper {
   ): void {
     service.logEvent(QUERY_BUILDER_EVENT.PANEL_GRAPH_FETCH_RENDER, data);
   }
+
+  static logEvent_ExecutionContextChanged(
+    service: TelemetryService,
+    data: ExecutionContextChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.EXECUTION_CONTEXT__CHANGE, data);
+  }
+
+  static logEvent_ProjectionChanged(
+    service: TelemetryService,
+    data: ProjectionChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.PROJECTION__CHANGE, data);
+  }
+
+  static logEvent_ResultModifierChanged(
+    service: TelemetryService,
+    data: ResultModifierChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.RESULT_MODIFIER__CHANGE, data);
+  }
+
+  static logEvent_AggregationChanged(
+    service: TelemetryService,
+    data: AggregationChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.AGGREGATION__CHANGE, data);
+  }
+
+  static logEvent_WindowChanged(
+    service: TelemetryService,
+    data: WindowChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.WINDOW__CHANGE, data);
+  }
+
+  static logEvent_GraphFetchChanged(
+    service: TelemetryService,
+    data: GraphFetchChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.GRAPH_FETCH__CHANGE, data);
+  }
+
+  static logEvent_ParameterChanged(
+    service: TelemetryService,
+    data: ParameterChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.PARAMETER__CHANGE, data);
+  }
+
+  static logEvent_ConstantChanged(
+    service: TelemetryService,
+    data: ConstantChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.CONSTANT__CHANGE, data);
+  }
+
+  static logEvent_WatermarkChanged(
+    service: TelemetryService,
+    data: WatermarkChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.WATERMARK__CHANGE, data);
+  }
+
+  static logEvent_MilestoningChanged(
+    service: TelemetryService,
+    data: MilestoningChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.MILESTONING__CHANGE, data);
+  }
+
+  static logEvent_FilterChanged(
+    service: TelemetryService,
+    data: FilterChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.FILTER__CHANGE, data);
+  }
+
+  static logEvent_PostFilterChanged(
+    service: TelemetryService,
+    data: FilterChange_TelemetryData,
+  ): void {
+    service.logEvent(QUERY_BUILDER_EVENT.POST_FILTER__CHANGE, data);
+  }
 }

package/src/components/QueryBuilder.tsx

@@ -71,6 +71,7 @@ import {
 import { QueryBuilderParametersPanel } from './QueryBuilderParametersPanel.js';
 import { QueryBuilderFunctionsExplorerPanel } from './explorer/QueryBuilderFunctionsExplorerPanel.js';
 import { QueryBuilderTDSState } from '../stores/fetch-structure/tds/QueryBuilderTDSState.js';
+import { DataProductQueryBuilderState } from '../stores/workflows/dataProduct/DataProductQueryBuilderState.js';
 import { QueryBuilderDiffViewPanelDiaglog } from './QueryBuilderDiffPanel.js';
 import { guaranteeType, returnUndefOnError } from '@finos/legend-shared';
 import { QueryBuilderGraphFetchTreeState } from '../stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.js';
@@ -778,29 +779,36 @@ export const QueryBuilder = observer(
                         </MenuContentItemLabel>
                       </MenuContentItem>
                       <MenuContentDivider />
-                      <MenuContentItem
-                        onClick={openCheckEntitlmentsEditor}
-                        disabled={
-                          (queryBuilderState.isQuerySupported &&
-                            queryBuilderState.fetchStructureState
-                              .implementation instanceof QueryBuilderTDSState &&
-                            queryBuilderState.fetchStructureState.implementation
-                              .projectionColumns.length === 0) ||
-                          !queryBuilderState.canBuildQuery
-                        }
-                        title={
-                          !queryBuilderState.canBuildQuery
-                            ? 'Please fix query errors to check entitlements'
-                            : ''
-                        }
-                      >
-                        <MenuContentItemIcon>
-                          <DataAccessIcon />
-                        </MenuContentItemIcon>
-                        <MenuContentItemLabel>
-                          Check Entitlements
-                        </MenuContentItemLabel>
-                      </MenuContentItem>
+                      {!(
+                        queryBuilderState instanceof
+                        DataProductQueryBuilderState
+                      ) && (
+                        <MenuContentItem
+                          onClick={openCheckEntitlmentsEditor}
+                          disabled={
+                            (queryBuilderState.isQuerySupported &&
+                              queryBuilderState.fetchStructureState
+                                .implementation instanceof
+                                QueryBuilderTDSState &&
+                              queryBuilderState.fetchStructureState
+                                .implementation.projectionColumns.length ===
+                                0) ||
+                            !queryBuilderState.canBuildQuery
+                          }
+                          title={
+                            !queryBuilderState.canBuildQuery
+                              ? 'Please fix query errors to check entitlements'
+                              : ''
+                          }
+                        >
+                          <MenuContentItemIcon>
+                            <DataAccessIcon />
+                          </MenuContentItemIcon>
+                          <MenuContentItemLabel>
+                            Check Entitlements
+                          </MenuContentItemLabel>
+                        </MenuContentItem>
+                      )}
                       <MenuContentItem
                         onClick={editPure}
                         disabled={!queryBuilderState.canBuildQuery}

package/src/components/QueryBuilderConstantExpressionPanel.tsx

@@ -58,6 +58,7 @@ import {
 import { BasicValueSpecificationEditor } from './shared/BasicValueSpecificationEditor.js';
 import { QUERY_BUILDER_TEST_ID } from '../__lib__/QueryBuilderTesting.js';
 import { QUERY_BUILDER_DOCUMENTATION_KEY } from '../__lib__/QueryBuilderDocumentation.js';
+import { QueryBuilderTelemetryHelper } from '../__lib__/QueryBuilderTelemetryHelper.js';
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { variableExpression_setName } from '../stores/shared/ValueSpecificationModifierHelper.js';
 import { LambdaEditor } from './shared/LambdaEditor.js';
@@ -175,6 +176,16 @@ const QueryBuilderSimpleConstantExpressionEditor = observer(
       if (isCreating) {
         variableState.addConstant(constantState);
       }
+      QueryBuilderTelemetryHelper.logEvent_ConstantChanged(
+        applicationStore.telemetryService,
+        {
+          ...queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            action: isCreating ? 'add' : 'edit',
+            constantCount: variableState.constants.length,
+          },
+        },
+      );
       handleCancel();
     };
 
@@ -547,8 +558,19 @@ export const QueryBuilderConstantExpressionPanel = observer(
                   actions={{
                     editVariable: () =>
                       constantState.setSelectedConstant(constState),
-                    deleteVariable: () =>
-                      constantState.removeConstant(constState),
+                    deleteVariable: () => {
+                      constantState.removeConstant(constState);
+                      QueryBuilderTelemetryHelper.logEvent_ConstantChanged(
+                        queryBuilderState.applicationStore.telemetryService,
+                        {
+                          ...queryBuilderState.safeGetTelemetryContext(),
+                          change: {
+                            action: 'remove',
+                            constantCount: constantState.constants.length,
+                          },
+                        },
+                      );
+                    },
                   }}
                   extraContextMenuActions={getExtraContextMenu(constState)}
                   isReadOnly={isReadOnly}

package/src/components/QueryBuilderParametersPanel.tsx

@@ -50,6 +50,7 @@ import { LambdaParameterValuesEditor } from './shared/LambdaParameterValuesEdito
 import { VariableViewer } from './shared/QueryBuilderVariableSelector.js';
 import { QUERY_BUILDER_TEST_ID } from '../__lib__/QueryBuilderTesting.js';
 import { QUERY_BUILDER_DOCUMENTATION_KEY } from '../__lib__/QueryBuilderDocumentation.js';
+import { QueryBuilderTelemetryHelper } from '../__lib__/QueryBuilderTelemetryHelper.js';
 import { useCallback, useState } from 'react';
 import {
   buildElementOption,
@@ -166,6 +167,16 @@ const VariableExpressionEditor = observer(
           defaultMilestoningValue,
         );
       }
+      QueryBuilderTelemetryHelper.logEvent_ParameterChanged(
+        applicationStore.telemetryService,
+        {
+          ...queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            action: isCreating ? 'add' : 'edit',
+            parameterCount: queryParametersState.parameterStates.length,
+          },
+        },
+      );
 
       handleCancel();
     };
@@ -390,8 +401,20 @@ export const QueryBuilderParametersPanel = observer(
                     actions={{
                       editVariable: () =>
                         queryParameterState.setSelectedParameter(pState),
-                      deleteVariable: () =>
-                        queryParameterState.removeParameter(pState),
+                      deleteVariable: () => {
+                        queryParameterState.removeParameter(pState);
+                        QueryBuilderTelemetryHelper.logEvent_ParameterChanged(
+                          queryBuilderState.applicationStore.telemetryService,
+                          {
+                            ...queryBuilderState.safeGetTelemetryContext(),
+                            change: {
+                              action: 'remove',
+                              parameterCount:
+                                queryParameterState.parameterStates.length,
+                            },
+                          },
+                        );
+                      },
                     }}
                   />
                 ))}

package/src/components/QueryBuilderSideBar.tsx

@@ -47,6 +47,7 @@ import {
   type PackageableElementOption,
 } from '@finos/legend-lego/graph-editor';
 import type { QueryBuilder_LegendApplicationPlugin_Extension } from '../stores/QueryBuilder_LegendApplicationPlugin_Extension.js';
+import { QueryBuilderTelemetryHelper } from '../__lib__/QueryBuilderTelemetryHelper.js';
 
 export const getParameterValue = (
   parameter: ValueSpecification | undefined,
@@ -130,6 +131,15 @@ export const QueryBuilderClassSelector = observer(
         return;
       }
       queryBuilderState.changeSourceElement(val.value);
+      QueryBuilderTelemetryHelper.logEvent_ExecutionContextChanged(
+        applicationStore.telemetryService,
+        {
+          ...queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            subtype: 'class',
+          },
+        },
+      );
       onClassChange?.(val.value);
     };
 
@@ -256,6 +266,15 @@ const BasicQueryBuilderSetup = observer(
         return;
       }
       queryBuilderState.changeMapping(val.value);
+      QueryBuilderTelemetryHelper.logEvent_ExecutionContextChanged(
+        applicationStore.telemetryService,
+        {
+          ...queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            subtype: 'mapping',
+          },
+        },
+      );
     };
     const mappingFilterOption = createFilter({
       ignoreCase: true,
@@ -287,6 +306,15 @@ const BasicQueryBuilderSetup = observer(
         return;
       }
       queryBuilderState.changeRuntime(val.value);
+      QueryBuilderTelemetryHelper.logEvent_ExecutionContextChanged(
+        applicationStore.telemetryService,
+        {
+          ...queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            subtype: 'runtime',
+          },
+        },
+      );
     };
     const runtimeFilterOption = createFilter({
       ignoreCase: true,

package/src/components/fetch-structure/QueryBuilderGraphFetchTreePanel.tsx

@@ -409,6 +409,17 @@ export const QueryBuilderGraphFetchExternalConfig = observer(
       } else {
         removeNodeRecursively(serializationTreeData, node);
         serializationState.setGraphFetchTree({ ...serializationTreeData });
+        QueryBuilderTelemetryHelper.logEvent_GraphFetchChanged(
+          graphFetchState.queryBuilderState.applicationStore.telemetryService,
+          {
+            ...graphFetchState.queryBuilderState.safeGetTelemetryContext(),
+            change: {
+              action: 'remove',
+              nodeCount: serializationTreeData.nodes.size,
+              serializationType: serializationState.getLabel(),
+            },
+          },
+        );
       }
     };
 
@@ -533,10 +544,31 @@ export const QueryBuilderGraphFetchTreeExplorer = observer(
         updateTreeData({ ...serializationState.treeData });
       }
       updateTreeData({ ...treeData });
+      QueryBuilderTelemetryHelper.logEvent_GraphFetchChanged(
+        graphFetchState.queryBuilderState.applicationStore.telemetryService,
+        {
+          ...graphFetchState.queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            action: 'remove',
+            nodeCount: treeData.nodes.size,
+          },
+        },
+      );
     };
 
-    const toggleChecked = (): void =>
+    const toggleChecked = (): void => {
       graphFetchState.setChecked(!graphFetchState.isChecked);
+      QueryBuilderTelemetryHelper.logEvent_GraphFetchChanged(
+        graphFetchState.queryBuilderState.applicationStore.telemetryService,
+        {
+          ...graphFetchState.queryBuilderState.safeGetTelemetryContext(),
+          change: {
+            action: 'check-toggle',
+            nodeCount: treeData.nodes.size,
+          },
+        },
+      );
+    };
 
     const openConfigModal = (): void => {
       if (serializationState instanceof GraphFetchPureSerializationState) {
@@ -594,6 +626,18 @@ export const QueryBuilderGraphFetchTreeExplorer = observer(
                             );
                             break;
                         }
+                        QueryBuilderTelemetryHelper.logEvent_GraphFetchChanged(
+                          graphFetchState.queryBuilderState.applicationStore
+                            .telemetryService,
+                          {
+                            ...graphFetchState.queryBuilderState.safeGetTelemetryContext(),
+                            change: {
+                              action: 'serialization-change',
+                              nodeCount: treeData.nodes.size,
+                              serializationType: implementationType,
+                            },
+                          },
+                        );
                       },
                     ),
                 },
@@ -769,6 +813,17 @@ const QueryBuilderGraphFetchTreePanel = observer(
             refreshTreeData: true,
           });
         }
+        QueryBuilderTelemetryHelper.logEvent_GraphFetchChanged(
+          graphFetchTreeState.queryBuilderState.applicationStore
+            .telemetryService,
+          {
+            ...graphFetchTreeState.queryBuilderState.safeGetTelemetryContext(),
+            change: {
+              action: 'add',
+              nodeCount: graphFetchTreeState.treeData?.nodes.size ?? 0,
+            },
+          },
+        );
       },
       [graphFetchTreeState, serializationState],
     );