@finos/legend-application-query 13.8.52 → 13.8.54

package/lib/stores/QueryEditorStore.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { action, computed, flow, flowResult, makeObservable, observable, override, } from 'mobx';
-import { LogEvent, assertErrorThrown, uuid, assertType, guaranteeNonNullable, ActionState, StopWatch, guaranteeType, quantifyList, assertNonNullable, returnUndefOnError, UnsupportedOperationError, filterByType, } from '@finos/legend-shared';
+import { LogEvent, assertErrorThrown, uuid, assertType, guaranteeNonNullable, ActionState, StopWatch, guaranteeType, quantifyList, assertNonNullable, returnUndefOnError, UnsupportedOperationError, filterByType, buildTelemetryErrorFields, } from '@finos/legend-shared';
 import { PackageableRuntime, createPath, GraphManagerState, Query, PureExecution, PackageableElementExplicitReference, RuntimePointer, GRAPH_MANAGER_EVENT, extractElementNameFromPath, Mapping, createGraphBuilderReport, LegendSDLC, QuerySearchSpecification, toLightQuery, QueryParameterValue, reportGraphAnalytics, cloneQueryStereotype, cloneQueryTaggedValue, QueryProjectCoordinates, CORE_PURE_PATH, INTERNAL_ELEMENT_PATH, isValidFullPath, QUERY_PROFILE_PATH, QueryDataSpaceExecutionContextInfo, QueryExplicitExecutionContextInfo, QueryDataProductNativeExecutionContextInfo, QueryDataProductModelAccessExecutionContextInfo, QueryDataProductLakehouseExecutionContextInfo, QueryIngestExecutionContextInfo, ModelAccessPointGroup, IngestDefinition, LakehouseRuntime, V1_DATA_PRODUCT_ELEMENT_PROTOCOL_TYPE, V1_DataProductArtifact, V1_ModelAccessPointGroupInfo, DataProductAccessType, LakehouseAccessPoint, } from '@finos/legend-graph';
 import { generateExistingQueryEditorRoute, generateMappingQueryCreatorRoute, generateServiceQueryCreatorRoute, } from '../__lib__/LegendQueryNavigation.js';
 import { LEGEND_QUERY_APP_EVENT } from '../__lib__/LegendQueryEvent.js';
@@ -22,9 +22,11 @@ import { parseGACoordinates, StoredFileGeneration, } from '@finos/legend-storage
 import { resolveVersion, StoreProjectData, LATEST_VERSION_ALIAS, VersionedProjectData, retrieveProjectEntitiesWithClassifier, isSnapshotVersion, SNAPSHOT_VERSION_ALIAS, } from '@finos/legend-server-depot';
 import { ActionAlertActionType, ActionAlertType, DEFAULT_TAB_SIZE, DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH, } from '@finos/legend-application';
 import { LegendQueryEventHelper } from '../__lib__/LegendQueryEventHelper.js';
-import { ClassQueryBuilderState, MappingQueryBuilderState, ServiceQueryBuilderState, QueryLoaderState, QueryBuilderDataBrowserWorkflow, QueryBuilderActionConfig, QUERY_LOADER_DEFAULT_QUERY_SEARCH_LIMIT, ModelAccessPointDataProductExecutionState, LakehouseDataProductExecutionState, resolveDataProductAccessor, } from '@finos/legend-query-builder';
+import { ClassQueryBuilderState, MappingQueryBuilderState, ServiceQueryBuilderState, QueryLoaderState, QueryBuilderDataBrowserWorkflow, QueryBuilderActionConfig, QUERY_LOADER_DEFAULT_QUERY_SEARCH_LIMIT, ModelAccessPointDataProductExecutionState, LakehouseDataProductExecutionState, resolveDataProductAccessor, QUERY_BUILDER_OPENED_FROM, } from '@finos/legend-query-builder';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
-import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
+import { buildQueryCreateFailureData, buildQueryIdentity, buildQueryLifecycleFailureData, buildQueryLoaderLifecycleTelemetryHandlers, } from '../__lib__/LegendQueryLifecycleTelemetry.js';
+import { LegendQueryTelemetryHelper, } from '../__lib__/LegendQueryTelemetryHelper.js';
+import { LegendQuerySourceType, } from '../__lib__/LegendQuerySourceInfo.js';
 import {} from '@finos/legend-extension-dsl-data-space/application';
 import { DSL_DataSpace_getGraphManagerExtension, getOwnDataSpace, QUERY_PROFILE_TAG_DATA_SPACE, resolveExecutionContextMapping, retrieveAnalyticsResultCache, retrieveDataspaceArtifactsCache, } from '@finos/legend-extension-dsl-data-space/graph';
 import { generateDataSpaceQueryCreatorRoute } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
@@ -98,13 +100,7 @@ export class QueryCreatorState {
             this.editorStore.applicationStore.notificationService.notifySuccess(`Successfully created query!`);
             LegendQueryEventHelper.notify_QueryCreateSucceeded(this.editorStore.applicationStore.eventService, { queryId: newQuery.id });
             LegendQueryTelemetryHelper.logEvent_CreateQuerySucceeded(this.editorStore.applicationStore.telemetryService, {
-                query: {
-                    id: query.id,
-                    name: query.name,
-                    groupId: query.groupId,
-                    artifactId: query.artifactId,
-                    versionId: query.versionId,
-                },
+                ...buildQueryIdentity(query),
                 ...queryBuilderState.getExtraTelemetryMetadata(),
             });
             queryBuilderState.changeDetectionState.initialize(rawLambda);
@@ -117,6 +113,7 @@ export class QueryCreatorState {
             assertErrorThrown(error);
             this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE), error);
             this.editorStore.applicationStore.notificationService.notifyError(error);
+            LegendQueryTelemetryHelper.logEvent_CreateQueryFailed(this.editorStore.applicationStore.telemetryService, buildQueryCreateFailureData(this.queryName, error));
         }
         finally {
             this.createQueryState.reset();
@@ -205,18 +202,9 @@ export class QueryEditorStore {
             generateDefaultQueriesSummaryText: (queries) => queries.length
                 ? `Showing ${quantifyList(queries, 'recently viewed query', 'recently viewed queries')}`
                 : `No recently viewed queries`,
-            onQueryDeleted: (queryId) => LegendQueryUserDataHelper.removeRecentlyViewedQuery(this.applicationStore.userDataService, queryId),
-            onQueryRenamed: (query) => {
-                LegendQueryTelemetryHelper.logEvent_RenameQuerySucceeded(applicationStore.telemetryService, {
-                    query: {
-                        id: query.id,
-                        name: query.name,
-                        groupId: query.groupId,
-                        artifactId: query.artifactId,
-                        versionId: query.versionId,
-                    },
-                });
-            },
+            ...buildQueryLoaderLifecycleTelemetryHandlers(this.applicationStore, {
+                onQueryDeleted: (queryId) => LegendQueryUserDataHelper.removeRecentlyViewedQuery(this.applicationStore.userDataService, queryId),
+            }),
             handleFetchDefaultQueriesFailure: () => LegendQueryUserDataHelper.removeRecentlyViewedQueries(this.applicationStore.userDataService),
         });
         this.queryCreatorState = new QueryCreatorState(this, undefined);
@@ -315,9 +303,9 @@ export class QueryEditorStore {
             this.enableMinialGraphForDataSpaceLoadingPerformance) {
             return;
         }
+        const stopWatch = new StopWatch();
         try {
             this.initState.inProgress();
-            const stopWatch = new StopWatch();
             // TODO: when we genericize the way to initialize an application page
             this.applicationStore.assistantService.setIsHidden(true);
             // initialize the graph manager
@@ -327,21 +315,48 @@ export class QueryEditorStore {
                 clientConfig: {
                     baseUrl: this.applicationStore.config.engineServerUrl,
                     queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
+                    queryClientName: this.applicationStore.config.engineQueryClientName,
                     enableCompression: true,
+                    useCookieAuthOnly: this.applicationStore.config.engineUseCookieAuthOnly,
                 },
             }, {
                 tracerService: this.applicationStore.tracerService,
             });
             yield this.setUpEditorState();
-            yield flowResult(this.buildGraph());
-            this.queryBuilderState = (yield this.initializeQueryBuilderState(stopWatch));
+            try {
+                yield flowResult(this.buildGraph());
+            }
+            catch (error) {
+                assertErrorThrown(error);
+                this.logBuildGraphFailure(error);
+                throw error;
+            }
+            try {
+                this.queryBuilderState = (yield this.initializeQueryBuilderState(stopWatch));
+            }
+            catch (error) {
+                assertErrorThrown(error);
+                this.logInitializeQueryBuilderStateFailure(error);
+                throw error;
+            }
             this.queryLoaderState.initialize(this.queryBuilderState);
             this.initState.pass();
+            // the canonical "a query builder is loaded" signal, emitted for every
+            // route — creator and saved alike. Reported here rather than from each
+            // route's own load event so that counting opens does not require a union
+            // of differently shaped, half-covering events.
+            this.queryBuilderState.logOpened(this.getOpenedFrom(), {
+                ...this.getInitializeTelemetrySource(),
+                timings: this.applicationStore.timeService.finalizeTimingsRecord(stopWatch),
+            });
         }
         catch (error) {
             assertErrorThrown(error);
             this.applicationStore.logService.error(LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE), error);
             this.applicationStore.notificationService.notifyError(error);
+            // NOTE: log before handling the failure, which may reset the editor
+            // state that the telemetry source is derived from
+            this.logInitializeFailureMetrics(stopWatch, error);
             this.onInitializeFailure();
             this.initState.fail();
         }
@@ -349,6 +364,45 @@ export class QueryEditorStore {
     onInitializeFailure() {
         // Do Nothing
     }
+    /**
+     * Where the query was started from, used as the source info of the query
+     * builder state. Since this is derived from the editor state (e.g. the
+     * route) rather than the query builder state, it is also available when
+     * the editor fails to initialize.
+     */
+    getSourceInfo() {
+        return undefined;
+    }
+    /**
+     * Which surface opened the query builder, reported as `openedFrom` on
+     * `query-builder.opened`. Creator routes inherit this; only
+     * `ExistingQueryEditorStore` overrides it.
+     *
+     * Note this names the surface only — what is being queried is already carried
+     * by `getSourceInfo()` on the same payload.
+     */
+    getOpenedFrom() {
+        return QUERY_BUILDER_OPENED_FROM.QUERY_CREATOR;
+    }
+    /**
+     * Where the query was started from, reported when the query creator is
+     * initialized
+     */
+    getInitializeTelemetrySource() {
+        return {
+            // spread flat, matching how `sourceInfo` is reported on every other query
+            // telemetry event — see `QueryBuilderTelemetryContext`
+            ...this.getSourceInfo(),
+            restoredFromRecent: false,
+        };
+    }
+    logInitializeFailureMetrics(stopWatch, error) {
+        LegendQueryTelemetryHelper.logEvent_InitializeQueryCreatorFailed(this.applicationStore.telemetryService, {
+            ...this.getInitializeTelemetrySource(),
+            ...buildTelemetryErrorFields(error),
+            timings: this.applicationStore.timeService.finalizeTimingsRecord(stopWatch),
+        });
+    }
     *searchExistingQueryName(searchText) {
         const isValidSearchString = searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
         try {
@@ -371,6 +425,28 @@ export class QueryEditorStore {
     logBuildGraphMetrics(graphBuilderReportData) {
         LegendQueryTelemetryHelper.logEvent_GraphInitializationSucceeded(this.applicationStore.telemetryService, graphBuilderReportData);
     }
+    /**
+     * Failure counterpart of {@link logBuildGraphMetrics}. Fires when the graph
+     * build stage of `initialize()` throws. Base emits with only the error
+     * dimensions — {@link ExistingQueryEditorStore} overrides to attach the
+     * loaded query's identity, mirroring how its success override attaches
+     * identity too.
+     */
+    logBuildGraphFailure(error) {
+        LegendQueryTelemetryHelper.logEvent_GraphInitializationFailed(this.applicationStore.telemetryService, buildTelemetryErrorFields(error));
+    }
+    /**
+     * Failure hook for the query builder state initialization stage of
+     * `initialize()`. Default is a no-op: creator routes already report a
+     * failure here through `INITIALIZE_QUERY_CREATOR__FAILURE`, so emitting a
+     * second event would double-count. {@link ExistingQueryEditorStore}
+     * overrides this to emit `VIEW_QUERY__FAILURE`, the counterpart of the
+     * `VIEW_QUERY__SUCCESS` its `initializeQueryBuilderState` fires on the
+     * happy path.
+     */
+    logInitializeQueryBuilderStateFailure(_error) {
+        // no-op by default; overrides on saved-query stores emit failure telemetry
+    }
     *buildFullGraph() {
         const stopWatch = new StopWatch();
         const projectInfo = this.getProjectInfo();
@@ -675,7 +751,7 @@ export class QueryEditorStore {
      * creates `LegendQueryDataProductQueryBuilderState`, and wires in
      * mapping coverage results.
      */
-    async buildDataProductQueryBuilderState(groupId, artifactId, versionId, dataProductPath, artifact, accessId, dataProductAccessType, onDataProductChange, onLegacyDataSpaceChange, productSelectorState) {
+    async buildDataProductQueryBuilderState(groupId, artifactId, versionId, dataProductPath, artifact, accessId, dataProductAccessType, onDataProductChange, onLegacyDataSpaceChange, productSelectorState, sourceInfo) {
         // 3. Build minimal graph and get analysis result
         const dataProductAnalysisResult = await this.buildGraphAndDataproductAnalyticsResult(groupId, artifactId, versionId, dataProductPath, dataProductAccessType, accessId, artifact);
         // 4. Get the data product from the built graph
@@ -696,16 +772,18 @@ export class QueryEditorStore {
         }
         // 6. Create query builder state
         const projectInfo = { groupId, artifactId, versionId };
-        const sourceInfo = {
+        const queryBuilderState = new LegendQueryDataProductQueryBuilderState(this.applicationStore, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, 
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        new QueryBuilderActionConfig_QueryApplication(this), dataProduct, artifact, resolvedState, this.depotServerClient, projectInfo, onDataProductChange, (path, gav) => this.createLakehousePackageableRuntime(path, gav), productSelectorState ??
+            new DataProductSelectorState(this.depotServerClient, this.applicationStore, this.lakehouseState?.contractServerClient), onLegacyDataSpaceChange, undefined, this.applicationStore.config.options.queryBuilderConfig, sourceInfo ?? {
+            sourceType: LegendQuerySourceType.DATA_PRODUCT,
             groupId,
             artifactId,
             versionId,
             dataProduct: dataProductPath,
-        };
-        const queryBuilderState = new LegendQueryDataProductQueryBuilderState(this.applicationStore, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, 
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        new QueryBuilderActionConfig_QueryApplication(this), dataProduct, artifact, resolvedState, this.depotServerClient, projectInfo, onDataProductChange, (path, gav) => this.createLakehousePackageableRuntime(path, gav), productSelectorState ??
-            new DataProductSelectorState(this.depotServerClient, this.applicationStore), onLegacyDataSpaceChange, undefined, this.applicationStore.config.options.queryBuilderConfig, sourceInfo);
+            accessType: dataProductAccessType,
+            accessId,
+        });
         if (dataProductAnalysisResult.dataProductAnalysis
             .mappingToMappingCoverageResult) {
             queryBuilderState.mappingToMappingCoverageResult =
@@ -764,13 +842,18 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
             versionId: this.versionId,
         };
     }
-    async initializeQueryBuilderState() {
-        const projectInfo = this.getProjectInfo();
-        const sourceInfo = {
-            groupId: projectInfo.groupId,
-            artifactId: projectInfo.artifactId,
-            versionId: projectInfo.versionId,
+    getSourceInfo() {
+        return {
+            sourceType: LegendQuerySourceType.MAPPING,
+            groupId: this.groupId,
+            artifactId: this.artifactId,
+            versionId: this.versionId,
+            mapping: this.mappingPath,
+            runtime: this.runtimePath,
         };
+    }
+    async initializeQueryBuilderState() {
+        const sourceInfo = this.getSourceInfo();
         const queryBuilderState = new MappingQueryBuilderState(this.applicationStore, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, new QueryBuilderActionConfig_QueryApplication(this), (val) => {
             this.applicationStore.navigationService.navigator.updateCurrentLocation(generateMappingQueryCreatorRoute(this.groupId, this.artifactId, this.versionId, val.path, guaranteeType(queryBuilderState.executionContextState.runtimeValue, RuntimePointer).packageableRuntime.value.path));
         }, (val) => {
@@ -832,16 +915,19 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
             versionId: this.versionId,
         };
     }
+    getSourceInfo() {
+        return {
+            sourceType: LegendQuerySourceType.SERVICE,
+            groupId: this.groupId,
+            artifactId: this.artifactId,
+            versionId: this.versionId,
+            service: this.servicePath,
+        };
+    }
     async initializeQueryBuilderState() {
         const service = this.graphManagerState.graph.getService(this.servicePath);
         assertType(service.execution, PureExecution, `Can't process service execution: only Pure execution is supported`);
-        const projectInfo = this.getProjectInfo();
-        const sourceInfo = {
-            groupId: projectInfo.groupId,
-            artifactId: projectInfo.artifactId,
-            versionId: projectInfo.versionId,
-            service: service.path,
-        };
+        const sourceInfo = this.getSourceInfo();
         const queryBuilderState = new ServiceQueryBuilderState(this.applicationStore, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, new QueryBuilderActionConfig_QueryApplication(this), service, this.graphManagerState.usableServices, this.executionKey, (val) => {
             this.applicationStore.navigationService.navigator.goToLocation(generateServiceQueryCreatorRoute(this.groupId, this.artifactId, this.versionId, val.path));
         }, (val) => {
@@ -971,13 +1057,7 @@ export class ExistingQueryUpdateState {
             const updatedQuery = (yield this.editorStore.graphManagerState.graphManager.updateQuery(query, this.editorStore.graphManagerState.graph));
             this.editorStore.applicationStore.notificationService.notifySuccess(`Successfully updated query!`);
             LegendQueryTelemetryHelper.logEvent_UpdateQuerySucceeded(this.editorStore.applicationStore.telemetryService, {
-                query: {
-                    id: query.id,
-                    name: query.name,
-                    groupId: query.groupId,
-                    artifactId: query.artifactId,
-                    versionId: query.versionId,
-                },
+                ...buildQueryIdentity(query),
                 ...queryBuilderState.getExtraTelemetryMetadata(),
             });
             config.onQueryUpdate?.(updatedQuery);
@@ -988,6 +1068,7 @@ export class ExistingQueryUpdateState {
             assertErrorThrown(error);
             this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE), error);
             this.editorStore.applicationStore.notificationService.notifyError(error);
+            LegendQueryTelemetryHelper.logEvent_UpdateQueryFailed(this.editorStore.applicationStore.telemetryService, buildQueryLifecycleFailureData(this.editorStore.id, error));
         }
         finally {
             this.updateQueryState.complete();
@@ -1004,13 +1085,7 @@ export class ExistingQueryUpdateState {
             this.editorStore.applicationStore.notificationService.notifySuccess(`Successfully updated query!`);
             const extraTelemetryMetadata = this.editorStore.queryBuilderState?.getExtraTelemetryMetadata() ?? {};
             LegendQueryTelemetryHelper.logEvent_UpdateQuerySucceeded(this.editorStore.applicationStore.telemetryService, {
-                query: {
-                    id: updatedQuery.id,
-                    name: updatedQuery.name,
-                    groupId: updatedQuery.groupId,
-                    artifactId: updatedQuery.artifactId,
-                    versionId: updatedQuery.versionId,
-                },
+                ...buildQueryIdentity(updatedQuery),
                 ...extraTelemetryMetadata,
             });
         }
@@ -1018,6 +1093,7 @@ export class ExistingQueryUpdateState {
             assertErrorThrown(error);
             this.editorStore.applicationStore.logService.error(LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE), error);
             this.editorStore.applicationStore.notificationService.notifyError(error);
+            LegendQueryTelemetryHelper.logEvent_UpdateQueryFailed(this.editorStore.applicationStore.telemetryService, buildQueryLifecycleFailureData(queryId, error));
         }
         finally {
             this.updateQueryState.complete();
@@ -1114,15 +1190,33 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         const currentQuery = guaranteeNonNullable(this._lightQuery);
         LegendQueryTelemetryHelper.logEvent_GraphInitializationSucceeded(this.applicationStore.telemetryService, {
             graph: graphBuilderReportData,
-            query: {
-                id: currentQuery.id,
-                name: currentQuery.name,
-                groupId: currentQuery.groupId,
-                artifactId: currentQuery.artifactId,
-                versionId: currentQuery.versionId,
-            },
+            ...buildQueryIdentity(currentQuery),
+        });
+    }
+    logBuildGraphFailure(error) {
+        // attach whatever identity is already known — `_lightQuery` is only
+        // populated once the query resolves, which may not have happened yet, so
+        // the route id is the only guaranteed field
+        const currentQuery = this._lightQuery;
+        LegendQueryTelemetryHelper.logEvent_GraphInitializationFailed(this.applicationStore.telemetryService, {
+            ...buildTelemetryErrorFields(error),
+            ...(currentQuery ? buildQueryIdentity(currentQuery) : {}),
+        });
+    }
+    logInitializeQueryBuilderStateFailure(error) {
+        const currentQuery = this._lightQuery;
+        LegendQueryTelemetryHelper.logEvent_ViewQueryFailed(this.applicationStore.telemetryService, {
+            queryId: this.queryId,
+            ...(currentQuery ? buildQueryIdentity(currentQuery) : {}),
+            ...buildTelemetryErrorFields(error),
         });
     }
+    getOpenedFrom() {
+        return QUERY_BUILDER_OPENED_FROM.QUERY_SAVED;
+    }
+    logInitializeFailureMetrics() {
+        // Do nothing: an existing query is not a query creator
+    }
     setLightQuery(val) {
         this._lightQuery = val;
     }
@@ -1207,11 +1301,13 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             const matchingExecutionContext = resolveExecutionContext(dataSpace, exec.executionKey, mapping, runtime);
             if (matchingExecutionContext) {
                 const sourceInfo = {
+                    sourceType: LegendQuerySourceType.DATA_SPACE,
                     groupId: queryInfo.groupId,
                     artifactId: queryInfo.artifactId,
                     versionId: queryInfo.versionId,
                     queryId: queryInfo.id,
                     dataSpace: dataSpace.path,
+                    executionContext: exec.executionKey,
                 };
                 const visitedDataSpaces = LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(this.applicationStore.userDataService);
                 const dataSpaceQueryBuilderState = new LegendQueryDataSpaceQueryBuilderState(this.applicationStore, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, new QueryBuilderActionConfig_QueryApplication(this), dataSpace, matchingExecutionContext, isLightGraphEnabled, this.depotServerClient, {
@@ -1264,7 +1360,7 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
                     else {
                         this.applicationStore.notificationService.notifyWarning(`Can't switch data product: default execution context not specified`);
                     }
-                }, new DataProductSelectorState(this.depotServerClient, this.applicationStore), () => {
+                }, new DataProductSelectorState(this.depotServerClient, this.applicationStore, this.lakehouseState?.contractServerClient), () => {
                     this.applicationStore.notificationService.notifyWarning('Switching data products is not supported from the existing query editor. Please open a new query instead.');
                 }, dataSpaceAnalysisResult, undefined, undefined, undefined, this.applicationStore.config.options.queryBuilderConfig, sourceInfo);
                 const matchingExecutionContextMapping = resolveExecutionContextMapping(matchingExecutionContext);
@@ -1295,10 +1391,13 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         else if (exec instanceof QueryExplicitExecutionContextInfo) {
             const projectInfo = this.getProjectInfo();
             const sourceInfo = {
+                sourceType: LegendQuerySourceType.MAPPING,
                 groupId: projectInfo.groupId,
                 artifactId: projectInfo.artifactId,
                 versionId: projectInfo.versionId,
                 queryId: queryInfo.id,
+                mapping: exec.mapping,
+                runtime: exec.runtime,
             };
             const classQueryBuilderState = new ClassQueryBuilderState(this.applicationStore, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, this.applicationStore.config.options.queryBuilderConfig, sourceInfo);
             classQueryBuilderState.workflowState.updateActionConfig(new QueryBuilderActionConfig_QueryApplication(this));
@@ -1330,6 +1429,15 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             const artifact = await this.fetchDataProductArtifact(queryInfo.groupId, queryInfo.artifactId, queryInfo.versionId, exec.dataProductPath);
             const queryBuilderState = await this.buildDataProductQueryBuilderState(queryInfo.groupId, queryInfo.artifactId, queryInfo.versionId, exec.dataProductPath, artifact, executionContextId, accessType, async () => {
                 this.applicationStore.notificationService.notifyWarning('Switching data products is not supported from the existing query editor. Please open a new query instead.');
+            }, undefined, undefined, {
+                sourceType: LegendQuerySourceType.DATA_PRODUCT,
+                groupId: queryInfo.groupId,
+                artifactId: queryInfo.artifactId,
+                versionId: queryInfo.versionId,
+                queryId: queryInfo.id,
+                dataProduct: exec.dataProductPath,
+                accessType,
+                accessId: executionContextId,
             });
             return queryBuilderState;
         }
@@ -1363,10 +1471,13 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
                 return next;
             };
             const ingestQueryBuilderState = new IngestLegendQueryBuilderState(this.applicationStore, undefined, this.graphManagerState, QueryBuilderDataBrowserWorkflow.INSTANCE, new QueryBuilderActionConfig_QueryApplication(this), ingestDefinition, Array.from(this._ingestEntitiesByPath.keys()), swapIngest, adhocRuntime, projectInfo, this.applicationStore.config.options.queryBuilderConfig, {
+                sourceType: LegendQuerySourceType.INGEST,
                 groupId: projectInfo.groupId,
                 artifactId: projectInfo.artifactId,
                 versionId: projectInfo.versionId,
                 queryId: queryInfo.id,
+                ingestDefinitionPath: exec.ingestDefinitionPath,
+                dataSet: exec.dataSet,
             });
             await ingestQueryBuilderState.changeAccessorOwner(ingestDefinition);
             await ingestQueryBuilderState.changeAccessor({
@@ -1403,7 +1514,21 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
                 this.applicationStore.logService.error(LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE), `Error resolving preset query param values: ${error.message}`);
             }
         }
-        queryBuilderState.initializeWithQuery(existingQueryLambda, defaultParameters, query.gridConfig);
+        try {
+            queryBuilderState.initializeWithQuery(existingQueryLambda, defaultParameters, query.gridConfig);
+        }
+        catch (error) {
+            assertErrorThrown(error);
+            // pair with `INITIALIZE_QUERY_STATE__SUCCESS` below — this is the tight
+            // boundary that success wraps, so failure is reported here rather than
+            // in the outer catch (which owns `VIEW_QUERY__FAILURE`)
+            LegendQueryTelemetryHelper.logEvent_InitializeQueryStateFailed(this.applicationStore.telemetryService, {
+                queryId: this.queryId,
+                ...buildQueryIdentity(query),
+                ...buildTelemetryErrorFields(error),
+            });
+            throw error;
+        }
         initailizeQueryStateReport.timings =
             this.applicationStore.timeService.finalizeTimingsRecord(initailizeQueryStateStopWatch, initailizeQueryStateReport.timings);
         const report = reportGraphAnalytics(this.graphManagerState.graph);
@@ -1411,23 +1536,11 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         // send analytics
         LegendQueryTelemetryHelper.logEvent_InitializeQueryStateSucceeded(this.applicationStore.telemetryService, {
             ...initailizeQueryStateReport,
-            query: {
-                id: query.id,
-                name: query.name,
-                groupId: query.groupId,
-                artifactId: query.artifactId,
-                versionId: query.versionId,
-            },
+            ...buildQueryIdentity(query),
         });
         LegendQueryTelemetryHelper.logEvent_ViewQuerySucceeded(this.applicationStore.telemetryService, {
             ...report,
-            query: {
-                id: query.id,
-                name: query.name,
-                groupId: query.groupId,
-                artifactId: query.artifactId,
-                versionId: query.versionId,
-            },
+            ...buildQueryIdentity(query),
         });
         return queryBuilderState;
     }