@finos/legend-application-query 13.8.52 → 13.8.54

package/src/stores/QueryEditorStore.ts

@@ -39,6 +39,7 @@ import {
   returnUndefOnError,
   UnsupportedOperationError,
   filterByType,
+  buildTelemetryErrorFields,
 } from '@finos/legend-shared';
 import {
   type LightQuery,
@@ -138,9 +139,29 @@ import {
   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,
+  type InitializeTelemetrySource,
+} from '../__lib__/LegendQueryTelemetryHelper.js';
+import {
+  type LegendQueryDataProductSampleSourceInfo,
+  type LegendQueryDataProductSourceInfo,
+  type LegendQueryDataSpaceSourceInfo,
+  type LegendQueryIngestSourceInfo,
+  type LegendQueryMappingSourceInfo,
+  type LegendQueryServiceSourceInfo,
+  type LegendQuerySourceInfo,
+  LegendQuerySourceType,
+} from '../__lib__/LegendQuerySourceInfo.js';
 import { type ResolvedDataSpaceEntityWithOrigin } from '@finos/legend-extension-dsl-data-space/application';
 import {
   type DataSpace,
@@ -276,13 +297,7 @@ export class QueryCreatorState {
       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(),
         },
       );
@@ -300,6 +315,10 @@ export class QueryCreatorState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
+      LegendQueryTelemetryHelper.logEvent_CreateQueryFailed(
+        this.editorStore.applicationStore.telemetryService,
+        buildQueryCreateFailureData(this.queryName, error),
+      );
     } finally {
       this.createQueryState.reset();
     }
@@ -430,25 +449,13 @@ export abstract class QueryEditorStore {
                 'recently viewed queries',
               )}`
             : `No recently viewed queries`,
-        onQueryDeleted: (queryId): void =>
-          LegendQueryUserDataHelper.removeRecentlyViewedQuery(
-            this.applicationStore.userDataService,
-            queryId,
-          ),
-        onQueryRenamed: (query): void => {
-          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): void =>
+            LegendQueryUserDataHelper.removeRecentlyViewedQuery(
+              this.applicationStore.userDataService,
+              queryId,
+            ),
+        }),
         handleFetchDefaultQueriesFailure: (): void =>
           LegendQueryUserDataHelper.removeRecentlyViewedQueries(
             this.applicationStore.userDataService,
@@ -608,9 +615,9 @@ export abstract class QueryEditorStore {
       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);
@@ -623,7 +630,10 @@ export abstract 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,
           },
         },
         {
@@ -632,12 +642,33 @@ export abstract class QueryEditorStore {
       );
 
       yield this.setUpEditorState();
-      yield flowResult(this.buildGraph());
-      this.queryBuilderState = (yield this.initializeQueryBuilderState(
-        stopWatch,
-      )) as QueryBuilderState;
+      try {
+        yield flowResult(this.buildGraph());
+      } catch (error) {
+        assertErrorThrown(error);
+        this.logBuildGraphFailure(error);
+        throw error;
+      }
+      try {
+        this.queryBuilderState = (yield this.initializeQueryBuilderState(
+          stopWatch,
+        )) as QueryBuilderState;
+      } 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(
@@ -645,6 +676,9 @@ export abstract class QueryEditorStore {
         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();
     }
@@ -654,6 +688,53 @@ export abstract class QueryEditorStore {
     // 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(): LegendQuerySourceInfo | undefined {
+    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(): QUERY_BUILDER_OPENED_FROM {
+    return QUERY_BUILDER_OPENED_FROM.QUERY_CREATOR;
+  }
+
+  /**
+   * Where the query was started from, reported when the query creator is
+   * initialized
+   */
+  getInitializeTelemetrySource(): InitializeTelemetrySource {
+    return {
+      // spread flat, matching how `sourceInfo` is reported on every other query
+      // telemetry event — see `QueryBuilderTelemetryContext`
+      ...this.getSourceInfo(),
+      restoredFromRecent: false,
+    };
+  }
+
+  logInitializeFailureMetrics(stopWatch: StopWatch, error: Error): void {
+    LegendQueryTelemetryHelper.logEvent_InitializeQueryCreatorFailed(
+      this.applicationStore.telemetryService,
+      {
+        ...this.getInitializeTelemetrySource(),
+        ...buildTelemetryErrorFields(error),
+        timings:
+          this.applicationStore.timeService.finalizeTimingsRecord(stopWatch),
+      },
+    );
+  }
+
   *searchExistingQueryName(searchText: string): GeneratorFn<void> {
     const isValidSearchString =
       searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
@@ -687,6 +768,33 @@ export abstract class QueryEditorStore {
     );
   }
 
+  /**
+   * 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: Error): void {
+    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: Error): void {
+    // no-op by default; overrides on saved-query stores emit failure telemetry
+  }
+
   *buildFullGraph(): GeneratorFn<void> {
     const stopWatch = new StopWatch();
 
@@ -1282,6 +1390,10 @@ export abstract class QueryEditorStore {
       | ((val: ResolvedDataSpaceEntityWithOrigin) => void)
       | undefined,
     productSelectorState?: DataProductSelectorState | undefined,
+    sourceInfo?:
+      | LegendQueryDataProductSourceInfo
+      | LegendQueryDataProductSampleSourceInfo
+      | undefined,
   ): Promise<LegendQueryDataProductQueryBuilderState> {
     // 3. Build minimal graph and get analysis result
     const dataProductAnalysisResult =
@@ -1325,12 +1437,6 @@ export abstract class QueryEditorStore {
     }
     // 6. Create query builder state
     const projectInfo = { groupId, artifactId, versionId };
-    const sourceInfo = {
-      groupId,
-      artifactId,
-      versionId,
-      dataProduct: dataProductPath,
-    };
     const queryBuilderState = new LegendQueryDataProductQueryBuilderState(
       this.applicationStore,
       this.graphManagerState,
@@ -1348,11 +1454,20 @@ export abstract class QueryEditorStore {
         new DataProductSelectorState(
           this.depotServerClient,
           this.applicationStore,
+          this.lakehouseState?.contractServerClient,
         ),
       onLegacyDataSpaceChange,
       undefined,
       this.applicationStore.config.options.queryBuilderConfig,
-      sourceInfo,
+      sourceInfo ?? {
+        sourceType: LegendQuerySourceType.DATA_PRODUCT,
+        groupId,
+        artifactId,
+        versionId,
+        dataProduct: dataProductPath,
+        accessType: dataProductAccessType,
+        accessId,
+      },
     );
 
     if (
@@ -1449,13 +1564,19 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
     };
   }
 
-  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
-    const projectInfo = this.getProjectInfo();
-    const sourceInfo = {
-      groupId: projectInfo.groupId,
-      artifactId: projectInfo.artifactId,
-      versionId: projectInfo.versionId,
+  override getSourceInfo(): LegendQueryMappingSourceInfo {
+    return {
+      sourceType: LegendQuerySourceType.MAPPING,
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+      mapping: this.mappingPath,
+      runtime: this.runtimePath,
     };
+  }
+
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
+    const sourceInfo = this.getSourceInfo();
     const queryBuilderState = new MappingQueryBuilderState(
       this.applicationStore,
       this.graphManagerState,
@@ -1574,6 +1695,16 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
     };
   }
 
+  override getSourceInfo(): LegendQueryServiceSourceInfo {
+    return {
+      sourceType: LegendQuerySourceType.SERVICE,
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+      service: this.servicePath,
+    };
+  }
+
   async initializeQueryBuilderState(): Promise<QueryBuilderState> {
     const service = this.graphManagerState.graph.getService(this.servicePath);
     assertType(
@@ -1582,13 +1713,7 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
       `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,
@@ -1799,13 +1924,7 @@ export class ExistingQueryUpdateState {
       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(),
         },
       );
@@ -1819,6 +1938,10 @@ export class ExistingQueryUpdateState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
+      LegendQueryTelemetryHelper.logEvent_UpdateQueryFailed(
+        this.editorStore.applicationStore.telemetryService,
+        buildQueryLifecycleFailureData(this.editorStore.id, error),
+      );
     } finally {
       this.updateQueryState.complete();
     }
@@ -1848,13 +1971,7 @@ export class ExistingQueryUpdateState {
       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,
         },
       );
@@ -1865,6 +1982,10 @@ export class ExistingQueryUpdateState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
+      LegendQueryTelemetryHelper.logEvent_UpdateQueryFailed(
+        this.editorStore.applicationStore.telemetryService,
+        buildQueryLifecycleFailureData(queryId, error),
+      );
     } finally {
       this.updateQueryState.complete();
     }
@@ -2002,17 +2123,45 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       this.applicationStore.telemetryService,
       {
         graph: graphBuilderReportData,
-        query: {
-          id: currentQuery.id,
-          name: currentQuery.name,
-          groupId: currentQuery.groupId,
-          artifactId: currentQuery.artifactId,
-          versionId: currentQuery.versionId,
-        },
+        ...buildQueryIdentity(currentQuery),
+      },
+    );
+  }
+
+  override logBuildGraphFailure(error: Error): void {
+    // 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) : {}),
       },
     );
   }
 
+  override logInitializeQueryBuilderStateFailure(error: Error): void {
+    const currentQuery = this._lightQuery;
+    LegendQueryTelemetryHelper.logEvent_ViewQueryFailed(
+      this.applicationStore.telemetryService,
+      {
+        queryId: this.queryId,
+        ...(currentQuery ? buildQueryIdentity(currentQuery) : {}),
+        ...buildTelemetryErrorFields(error),
+      },
+    );
+  }
+
+  override getOpenedFrom(): QUERY_BUILDER_OPENED_FROM {
+    return QUERY_BUILDER_OPENED_FROM.QUERY_SAVED;
+  }
+
+  override logInitializeFailureMetrics(): void {
+    // Do nothing: an existing query is not a query creator
+  }
+
   setLightQuery(val: LightQuery): void {
     this._lightQuery = val;
   }
@@ -2162,12 +2311,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         runtime,
       );
       if (matchingExecutionContext) {
-        const sourceInfo = {
+        const sourceInfo: LegendQueryDataSpaceSourceInfo = {
+          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(
@@ -2264,6 +2415,7 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             new DataProductSelectorState(
               this.depotServerClient,
               this.applicationStore,
+              this.lakehouseState?.contractServerClient,
             ),
             () => {
               this.applicationStore.notificationService.notifyWarning(
@@ -2318,11 +2470,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       }
     } else if (exec instanceof QueryExplicitExecutionContextInfo) {
       const projectInfo = this.getProjectInfo();
-      const sourceInfo = {
+      const sourceInfo: LegendQueryMappingSourceInfo = {
+        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,
@@ -2387,6 +2542,18 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             '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;
     } else if (exec instanceof QueryIngestExecutionContextInfo) {
@@ -2445,11 +2612,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         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,
+        } satisfies LegendQueryIngestSourceInfo,
       );
       await ingestQueryBuilderState.changeAccessorOwner(ingestDefinition);
       await ingestQueryBuilderState.changeAccessor({
@@ -2516,11 +2686,27 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       }
     }
 
-    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,
@@ -2537,26 +2723,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       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;

package/src/stores/QueryProductionizerSetupStore.ts

@@ -25,8 +25,9 @@ import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
 import { EXTERNAL_APPLICATION_NAVIGATION__generateStudioProductionizeQueryUrl } from '../__lib__/LegendQueryNavigation.js';
 import { BaseQuerySetupStore } from './QuerySetupStore.js';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
-import { quantifyList } from '@finos/legend-shared';
+import { buildQueryLoaderLifecycleTelemetryHandlers } from '../__lib__/LegendQueryLifecycleTelemetry.js';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
+import { quantifyList } from '@finos/legend-shared';
 
 export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
   readonly queryLoaderState: QueryLoaderState;
@@ -61,25 +62,13 @@ export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
                 'recently viewed queries',
               )}`
             : `No recently viewed queries`,
-        onQueryDeleted: (queryId): void =>
-          LegendQueryUserDataHelper.removeRecentlyViewedQuery(
-            this.applicationStore.userDataService,
-            queryId,
-          ),
-        onQueryRenamed: (query): void => {
-          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): void =>
+            LegendQueryUserDataHelper.removeRecentlyViewedQuery(
+              this.applicationStore.userDataService,
+              queryId,
+            ),
+        }),
         handleFetchDefaultQueriesFailure: (): void =>
           LegendQueryUserDataHelper.removeRecentlyViewedQueries(
             this.applicationStore.userDataService,
@@ -108,6 +97,21 @@ export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
         prompt: 'Please do not close the application',
         showLoading: true,
       });
+      // emitted at the actual handoff to studio — the setup landing action
+      // that lands us on this route is upstream and may be abandoned before
+      // the user picks a query, so emitting here counts real launches only
+      LegendQueryTelemetryHelper.logEvent_ProductionizeQueryLaunched(
+        this.applicationStore.telemetryService,
+        {
+          query: {
+            id: selectedQuery.id,
+            name: selectedQuery.name,
+            groupId: selectedQuery.groupId,
+            artifactId: selectedQuery.artifactId,
+            versionId: selectedQuery.versionId,
+          },
+        },
+      );
       this.applicationStore.navigationService.navigator.goToAddress(
         EXTERNAL_APPLICATION_NAVIGATION__generateStudioProductionizeQueryUrl(
           matchingSDLCEntry.url,

package/src/stores/QuerySetupStore.ts

@@ -80,7 +80,10 @@ export abstract class BaseQuerySetupStore {
           clientConfig: {
             baseUrl: this.applicationStore.config.engineServerUrl,
             queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
+            queryClientName: this.applicationStore.config.engineQueryClientName,
             enableCompression: true,
+            useCookieAuthOnly:
+              this.applicationStore.config.engineUseCookieAuthOnly,
           },
         },
         {

package/src/stores/__test-utils__/LegendQueryApplicationTestUtils.ts

@@ -30,9 +30,6 @@ const TEST_DATA__appConfig = {
     url: 'https://testStudioUrl',
     instances: [],
   },
-  taxonomy: {
-    url: 'https://testTaxonomyUrl',
-  },
 };
 
 export const TEST__getTestLegendQueryApplicationConfig = (

package/src/stores/data-cube/ExistingQueryDataCubeViewer.ts

@@ -71,6 +71,7 @@ export class ExistingQueryDataCubeEditorStore {
           clientConfig: {
             baseUrl: this.applicationStore.config.engineServerUrl,
             queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
+            queryClientName: this.applicationStore.config.engineQueryClientName,
             enableCompression: true,
           },
         },