@finos/legend-application-query 13.8.52 → 13.8.54

package/src/__lib__/LegendQueryTelemetryHelper.ts

@@ -15,14 +15,17 @@
  */
 
 import type { TelemetryService } from '@finos/legend-application';
+import type { TelemetryErrorFields, TimingsRecord } from '@finos/legend-shared';
 import { LEGEND_QUERY_APP_EVENT } from './LegendQueryEvent.js';
+import type { QueryableSourceInfo } from '@finos/legend-storage';
+import type { QueryBuilderTelemetryContext } from '@finos/legend-query-builder';
 import {
   type GraphManagerOperationReport,
   GRAPH_MANAGER_EVENT,
   type GraphInitializationReport,
 } from '@finos/legend-graph';
 
-type Query_TelemetryData = {
+export type Query_TelemetryData = {
   query: {
     name: string;
     id: string;
@@ -46,6 +49,129 @@ type IntializeQueryState_TelemetryData = Query_TelemetryData &
     dependenciesCount: number;
   };
 
+/**
+ * Where the query creator was started from, returned by each creator store's
+ * `getInitializeTelemetrySource()`.
+ *
+ * The entry point the query creator was started from ({@link
+ * LegendQuerySourceInfo}) is spread FLAT into this payload, matching how
+ * `sourceInfo` is reported on every other query telemetry event.
+ *
+ * The index signature is what allows those flat keys — they vary by entry point
+ * and `LegendQuerySourceInfo` is a union, so they cannot be enumerated here.
+ * The union stays strictly typed where it is built, in each creator store's
+ * `getSourceInfo()` override.
+ */
+export type InitializeTelemetrySource = Record<PropertyKey, unknown> & {
+  /**
+   * Whether the most recently visited source was reopened, rather than the
+   * source being specified by the route
+   */
+  restoredFromRecent: boolean;
+};
+
+/**
+ * Base payload for the query creator failure event.
+ *
+ * There is no success counterpart: a successful load is reported by
+ * `query-builder.opened` from `legend-query-builder`, which fires for every
+ * route rather than creators only. This one survives because when a load fails
+ * there is no query builder to emit from, so it is the only record that an
+ * attempt happened.
+ */
+export type InitializeQueryCreator_TelemetryData = InitializeTelemetrySource & {
+  timings: TimingsRecord;
+};
+
+export type InitializeQueryCreatorFailure_TelemetryData =
+  InitializeQueryCreator_TelemetryData & TelemetryErrorFields;
+
+/**
+ * The query a lifecycle event acted on. `id` is always known for update, rename
+ * and delete — they act on a query that already exists. Identity beyond the id
+ * is partial: a delete resolves the entry from the loaded list, which may not
+ * contain it.
+ */
+export type PartialQuery_TelemetryData = {
+  query: {
+    id: string;
+    name?: string | undefined;
+    versionId?: string | undefined;
+    groupId?: string | undefined;
+    artifactId?: string | undefined;
+  };
+};
+
+/**
+ * Payload for a failed *create*.
+ *
+ * Deliberately has no `query` block: the server assigns the id, and a failed
+ * create never got that far, so no query exists to identify. The name the user
+ * chose is the only identity there is. Keeping this a separate type from
+ * {@link QueryLifecycleFailure_TelemetryData} means the three events that *do*
+ * always have an id cannot accidentally omit it.
+ */
+export type QueryCreateFailure_TelemetryData = {
+  queryName: string;
+} & TelemetryErrorFields;
+
+/**
+ * Payload for a failed update, rename or delete — actions on a query that
+ * already exists, so `query.id` is always present.
+ */
+export type QueryLifecycleFailure_TelemetryData = PartialQuery_TelemetryData &
+  TelemetryErrorFields;
+
+/**
+ * Payload for a failure during the existing-query load flow (graph build,
+ * query state init, viewer load).
+ *
+ * The query being loaded is identified by its route id — the full identity
+ * (`name`, `groupId`, ...) is only known once the query resolves, which by
+ * definition may not have happened when these failures fire. `queryId` is
+ * therefore the only guaranteed field; anything else that happens to be
+ * resolved is merged in via {@link PartialQuery_TelemetryData}.
+ */
+export type QueryLoadFailure_TelemetryData = {
+  queryId: string;
+} & Partial<PartialQuery_TelemetryData> &
+  TelemetryErrorFields;
+
+/**
+ * Payload for an in-session data-space or data-product switch made from the
+ * query-builder setup panel.
+ *
+ * `sourceInfo` (the query builder's source info at the moment the switch is
+ * made — i.e. what the user is switching *from*) is spread FLAT into the
+ * payload, matching how every other query telemetry event reports
+ * `sourceInfo`. It is typed as {@link QueryableSourceInfo} rather than
+ * `LegendQuerySourceInfo` because it comes off the query builder state
+ * (which types it generically) even though at runtime it is always a
+ * `LegendQuerySourceInfo` produced by an editor store's `getSourceInfo()`.
+ *
+ * `to` is the GAV + element path of the target selection: the group,
+ * artifact and version the data space / data product lives in, and its
+ * element path. A missing GAV (rare, but the `origin` field on
+ * `DepotEntityWithOrigin` is optional) is reported as `undefined` rather than
+ * omitted, so dashboards can distinguish "no origin" from "field absent".
+ */
+export type ChangeDataSpaceOrProduct_TelemetryData = {
+  sourceInfo?: QueryableSourceInfo | undefined;
+  to: {
+    groupId: string | undefined;
+    artifactId: string | undefined;
+    versionId: string | undefined;
+    path: string;
+  };
+};
+
+const flattenChangeDataSpaceOrProductSourceInfo = (
+  data: ChangeDataSpaceOrProduct_TelemetryData,
+): Record<string, unknown> => {
+  const { sourceInfo, ...rest } = data;
+  return { ...rest, ...(sourceInfo ?? {}) };
+};
+
 export class LegendQueryTelemetryHelper {
   static logEvent_ViewQuerySucceeded(
     service: TelemetryService,
@@ -64,6 +190,16 @@ export class LegendQueryTelemetryHelper {
     );
   }
 
+  static logEvent_InitializeQueryCreatorFailed(
+    service: TelemetryService,
+    data: InitializeQueryCreatorFailure_TelemetryData,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.INITIALIZE_QUERY_CREATOR__FAILURE,
+      data,
+    );
+  }
+
   static logEvent_CreateQuerySucceeded(
     service: TelemetryService,
     data: Query_TelemetryData,
@@ -95,6 +231,57 @@ export class LegendQueryTelemetryHelper {
     service.logEvent(LEGEND_QUERY_APP_EVENT.VIEW_SDLC_PROJECT__LAUNCH, {});
   }
 
+  // ── Query builder Help-menu items injected by Legend Query ───────────────
+  //
+  // Each takes the shared query builder telemetry envelope (source info flat +
+  // `state` nested), pulled from `queryBuilderState.safeGetTelemetryContext()`
+  // at the callsite.
+
+  static logEvent_AboutQueryInfoLaunched(
+    service: TelemetryService,
+    data: QueryBuilderTelemetryContext,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.ABOUT_QUERY_INFO__LAUNCH, data);
+  }
+
+  static logEvent_QueryVersionHistoryLaunched(
+    service: TelemetryService,
+    data: QueryBuilderTelemetryContext,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.QUERY_VERSION_HISTORY__LAUNCH,
+      data,
+    );
+  }
+
+  static logEvent_AboutLegendQueryLaunched(
+    service: TelemetryService,
+    data: QueryBuilderTelemetryContext,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.ABOUT_LEGEND_QUERY__LAUNCH, data);
+  }
+
+  static logEvent_AboutDataSpaceLaunched(
+    service: TelemetryService,
+    data: QueryBuilderTelemetryContext,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.ABOUT_DATA_SPACE__LAUNCH, data);
+  }
+
+  static logEvent_AboutDataProductLaunched(
+    service: TelemetryService,
+    data: QueryBuilderTelemetryContext,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.ABOUT_DATA_PRODUCT__LAUNCH, data);
+  }
+
+  static logEvent_AboutIngestLaunched(
+    service: TelemetryService,
+    data: QueryBuilderTelemetryContext,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.ABOUT_INGEST__LAUNCH, data);
+  }
+
   static logEvent_GraphInitializationSucceeded(
     service: TelemetryService,
     data: QueryGraphInitialization_TelemetryData | GraphInitializationReport,
@@ -109,6 +296,75 @@ export class LegendQueryTelemetryHelper {
     service.logEvent(LEGEND_QUERY_APP_EVENT.RENAME_QUERY__SUCCESS, data);
   }
 
+  static logEvent_DeleteQuerySucceeded(
+    service: TelemetryService,
+    data: PartialQuery_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.DELETE_QUERY__SUCCESS, data);
+  }
+
+  static logEvent_CreateQueryFailed(
+    service: TelemetryService,
+    data: QueryCreateFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.CREATE_QUERY__FAILURE, data);
+  }
+
+  static logEvent_UpdateQueryFailed(
+    service: TelemetryService,
+    data: QueryLifecycleFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.UPDATE_QUERY__FAILURE, data);
+  }
+
+  static logEvent_RenameQueryFailed(
+    service: TelemetryService,
+    data: QueryLifecycleFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.RENAME_QUERY__FAILURE, data);
+  }
+
+  static logEvent_DeleteQueryFailed(
+    service: TelemetryService,
+    data: QueryLifecycleFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.DELETE_QUERY__FAILURE, data);
+  }
+
+  static logEvent_ViewQueryFailed(
+    service: TelemetryService,
+    data: QueryLoadFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.VIEW_QUERY__FAILURE, data);
+  }
+
+  static logEvent_InitializeQueryStateFailed(
+    service: TelemetryService,
+    data: QueryLoadFailure_TelemetryData,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.INITIALIZE_QUERY_STATE__FAILURE,
+      data,
+    );
+  }
+
+  static logEvent_GraphInitializationFailed(
+    service: TelemetryService,
+    data: TelemetryErrorFields & Partial<PartialQuery_TelemetryData>,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.GRAPH_INITIALIZATION__FAILURE,
+      data,
+    );
+  }
+
+  static logEvent_ProductionizeQueryLaunched(
+    service: TelemetryService,
+    data: PartialQuery_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.PRODUCTIONIZE_QUERY__LAUNCH, data);
+  }
+
   static logEvent_QueryAISuggestLaunched(service: TelemetryService): void {
     service.logEvent(LEGEND_QUERY_APP_EVENT.LEGENDAI_QUERY_SUGGEST__LAUNCH, {});
   }
@@ -132,4 +388,24 @@ export class LegendQueryTelemetryHelper {
       errorMessage,
     });
   }
+
+  static logEvent_ChangeDataSpace(
+    service: TelemetryService,
+    data: ChangeDataSpaceOrProduct_TelemetryData,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.CHANGE_DATA_SPACE,
+      flattenChangeDataSpaceOrProductSourceInfo(data),
+    );
+  }
+
+  static logEvent_ChangeDataProduct(
+    service: TelemetryService,
+    data: ChangeDataSpaceOrProduct_TelemetryData,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.CHANGE_DATA_PRODUCT,
+      flattenChangeDataSpaceOrProductSourceInfo(data),
+    );
+  }
 }

package/src/application/LegendQueryApplicationConfig.ts

@@ -142,13 +142,15 @@ export interface LegendQueryApplicationConfigurationData
   depot: {
     url: string;
   };
-  engine: { url: string; queryUrl?: string };
-  studio: {
+  engine: {
     url: string;
-    instances: LegendStudioApplicationInstanceConfigurationData[];
+    queryUrl?: string;
+    useCookieAuthOnly?: boolean;
+    queryClientName?: string;
   };
-  taxonomy?: {
+  studio: {
     url: string;
+    instances: LegendStudioApplicationInstanceConfigurationData[];
   };
   dataCube?: {
     url: string;
@@ -171,9 +173,10 @@ export class LegendQueryApplicationConfig extends LegendApplicationConfig {
 
   readonly engineServerUrl: string;
   readonly engineQueryServerUrl?: string | undefined;
+  readonly engineUseCookieAuthOnly: boolean;
+  readonly engineQueryClientName?: string | undefined;
   readonly depotServerUrl: string;
   readonly studioApplicationUrl: string;
-  readonly taxonomyApplicationUrl?: string;
   readonly dataCubeApplicationUrl?: string;
   readonly marketplaceApplicationUrl?: string;
   readonly marketplaceProductionParallelUrl?: string;
@@ -204,6 +207,10 @@ export class LegendQueryApplicationConfig extends LegendApplicationConfig {
           input.configData.engine.queryUrl,
         )
       : undefined;
+    this.engineUseCookieAuthOnly = Boolean(
+      input.configData.engine.useCookieAuthOnly,
+    );
+    this.engineQueryClientName = input.configData.engine.queryClientName;
 
     // depot
     assertNonNullable(
@@ -233,13 +240,6 @@ export class LegendQueryApplicationConfig extends LegendApplicationConfig {
       `Can't configure application: 'studio.instances' field is missing`,
     );
 
-    // taxonomy
-    if (input.configData.taxonomy?.url) {
-      this.taxonomyApplicationUrl = LegendApplicationConfig.resolveAbsoluteUrl(
-        input.configData.taxonomy.url,
-      );
-    }
-
     // datacube
     if (input.configData.dataCube?.url) {
       this.dataCubeApplicationUrl = LegendApplicationConfig.resolveAbsoluteUrl(

package/src/components/Core_LegendQueryApplicationPlugin.tsx

@@ -141,6 +141,19 @@ import { LegendQueryDataProductQueryBuilderState } from '../stores/data-product/
 import { IngestLegendQueryBuilderState } from '../stores/ingest/IngestLegendQueryBuilderState.js';
 import { renderDataProductSampleQueryPanelContent } from './data-product/DataProductSampleQueryPanel.js';
 
+const isDataProductOrIngestQuery = (
+  queryBuilderState: QueryBuilderState,
+): boolean =>
+  queryBuilderState instanceof DataProductQueryBuilderState ||
+  queryBuilderState instanceof IngestLegendQueryBuilderState;
+
+const getUnsupportedExportActionMessage = (
+  queryBuilderState: QueryBuilderState,
+): string =>
+  isDataProductOrIngestQuery(queryBuilderState)
+    ? 'Not supported for Data Product or Ingest queries'
+    : 'Requires saved query';
+
 export const QUERY_DATACUBE_USAGE_TITLE = 'Legend DataCube';
 const QUERY_DATACUBE_SOURCE_TYPE = 'legendQuery';
 
@@ -387,6 +400,9 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
         title: 'Promote Curated Template query...',
         label: 'Curated Template Query',
         disableFunc: (queryBuilderState): boolean => {
+          if (isDataProductOrIngestQuery(queryBuilderState)) {
+            return true;
+          }
           if (
             queryBuilderState.workflowState.actionConfig instanceof
             QueryBuilderActionConfig_QueryApplication
@@ -463,13 +479,16 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
           }
         },
         icon: <ArrowCircleUpIcon />,
-        disableMessage: 'Requires saved query',
+        getDisableMessage: getUnsupportedExportActionMessage,
       },
       {
         key: 'legend-datacube-query',
         title: 'Launch Legend DataCube...',
         label: 'Legend DataCube',
         disableFunc: (queryBuilderState): boolean => {
+          if (isDataProductOrIngestQuery(queryBuilderState)) {
+            return true;
+          }
           if (
             queryBuilderState.workflowState.actionConfig instanceof
             QueryBuilderActionConfig_QueryApplication
@@ -515,7 +534,7 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
           }
         },
         icon: <CubeIcon />,
-        disableMessage: 'Requires saved query',
+        getDisableMessage: getUnsupportedExportActionMessage,
       },
     ];
   }
@@ -547,6 +566,10 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
             if (editorStore instanceof ExistingQueryEditorStore) {
+              LegendQueryTelemetryHelper.logEvent_AboutQueryInfoLaunched(
+                editorStore.applicationStore.telemetryService,
+                queryBuilderState.safeGetTelemetryContext(),
+              );
               editorStore.updateState.setShowQueryInfo(true);
             }
           }
@@ -577,6 +600,10 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
             if (editorStore instanceof ExistingQueryEditorStore) {
+              LegendQueryTelemetryHelper.logEvent_QueryVersionHistoryLaunched(
+                editorStore.applicationStore.telemetryService,
+                queryBuilderState.safeGetTelemetryContext(),
+              );
               editorStore.showQueryVersionHistory();
             }
           }
@@ -635,6 +662,10 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
           ) {
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
+            LegendQueryTelemetryHelper.logEvent_AboutLegendQueryLaunched(
+              editorStore.applicationStore.telemetryService,
+              queryBuilderState.safeGetTelemetryContext(),
+            );
             editorStore.setShowAppInfo(true);
           }
         },
@@ -663,6 +694,10 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
             if (queryBuilderState instanceof DataSpaceQueryBuilderState) {
+              LegendQueryTelemetryHelper.logEvent_AboutDataSpaceLaunched(
+                editorStore.applicationStore.telemetryService,
+                queryBuilderState.safeGetTelemetryContext(),
+              );
               editorStore.setShowDataspaceInfo(true);
             }
           }
@@ -692,6 +727,10 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
             if (queryBuilderState instanceof DataProductQueryBuilderState) {
+              LegendQueryTelemetryHelper.logEvent_AboutDataProductLaunched(
+                editorStore.applicationStore.telemetryService,
+                queryBuilderState.safeGetTelemetryContext(),
+              );
               editorStore.setShowDataProductInfo(true);
             }
           }
@@ -710,9 +749,13 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
               QueryBuilderActionConfig_QueryApplication &&
             queryBuilderState instanceof IngestLegendQueryBuilderState
           ) {
-            queryBuilderState.workflowState.actionConfig.editorStore.setShowIngestInfo(
-              true,
+            const editorStore =
+              queryBuilderState.workflowState.actionConfig.editorStore;
+            LegendQueryTelemetryHelper.logEvent_AboutIngestLaunched(
+              editorStore.applicationStore.telemetryService,
+              queryBuilderState.safeGetTelemetryContext(),
             );
+            editorStore.setShowIngestInfo(true);
           }
         },
         icon: <InfoCircleIcon />,

package/src/components/QueryEditor.tsx

@@ -99,6 +99,7 @@ import {
   HttpStatus,
   isValidUrl,
   NetworkClientError,
+  StopWatch,
 } from '@finos/legend-shared';
 import { DSL_DATA_SPACE_LEGEND_QUERY_DOCUMENTATION_KEY } from '../__lib__/DSL_DataSpace_LegendQueryDocumentation.js';
 import { LegendQueryInfo } from './LegendQueryAppInfo.js';
@@ -188,22 +189,33 @@ const CreateQueryDialog = observer(() => {
     if (!aiSuggester || !editorStore.queryBuilderState || !legendAIUrl) {
       return;
     }
+    const sourceInfo = editorStore.getSourceInfo();
     LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestLaunched(
       applicationStore.telemetryService,
+      { sourceInfo },
     );
     setIsSuggestingWithAI(true);
     setAISuggestion(undefined);
+    const stopWatch = new StopWatch();
     try {
       const request = await buildAISuggestionRequest(
         editorStore.queryBuilderState,
       );
       const suggestion = await aiSuggester(request, legendAIUrl);
       setAISuggestion(suggestion);
+      LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestSucceeded(
+        applicationStore.telemetryService,
+        { sourceInfo, durationMs: stopWatch.elapsed },
+      );
     } catch (error) {
       assertErrorThrown(error);
       LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestFailure(
         applicationStore.telemetryService,
-        error.message,
+        {
+          sourceInfo,
+          durationMs: stopWatch.elapsed,
+          errorMessage: error.message,
+        },
       );
       if (
         error instanceof NetworkClientError &&
@@ -228,6 +240,7 @@ const CreateQueryDialog = observer(() => {
     }
     LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestApplied(
       applicationStore.telemetryService,
+      { sourceInfo: editorStore.getSourceInfo() },
     );
     createQueryState.setQueryName(aiSuggestion.title);
     createQueryState.setQueryDescription(aiSuggestion.description);
@@ -236,6 +249,7 @@ const CreateQueryDialog = observer(() => {
   const discardAISuggestion = (): void => {
     LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestDiscarded(
       applicationStore.telemetryService,
+      { sourceInfo: editorStore.getSourceInfo() },
     );
     setAISuggestion(undefined);
   };
@@ -510,8 +524,14 @@ const RenameQueryDialog = observer(
       ) {
         return;
       }
+      const sourceInfo = existingEditorStore.getSourceInfo();
+      LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestLaunched(
+        applicationStore.telemetryService,
+        { sourceInfo },
+      );
       setIsSuggestingWithAI(true);
       setAISuggestion(undefined);
+      const stopWatch = new StopWatch();
       try {
         const request = await buildAISuggestionRequest(
           existingEditorStore.queryBuilderState,
@@ -519,11 +539,19 @@ const RenameQueryDialog = observer(
         );
         const suggestion = await aiSuggester(request, legendAIUrl);
         setAISuggestion(suggestion);
+        LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestSucceeded(
+          applicationStore.telemetryService,
+          { sourceInfo, durationMs: stopWatch.elapsed },
+        );
       } catch (error) {
         assertErrorThrown(error);
         LegendQueryAgentChatTelemetryHelper.logEvent_QueryAISuggestFailure(
           applicationStore.telemetryService,
-          error.message,
+          {
+            sourceInfo,
+            durationMs: stopWatch.elapsed,
+            errorMessage: error.message,
+          },
         );
         if (
           error instanceof NetworkClientError &&

package/src/components/data-space/DataSpaceInfo.tsx

@@ -34,8 +34,8 @@ import {
   DataSpaceSupportEmail,
 } from '@finos/legend-extension-dsl-data-space/graph';
 import {
+  EXTERNAL_APPLICATION_NAVIGATION__generateMarketplaceDataspaceViewUrl,
   EXTERNAL_APPLICATION_NAVIGATION__generateStudioSDLCProjectViewUrl,
-  EXTERNAL_APPLICATION_NAVIGATION__generateTaxonomyDataspaceViewUrl,
 } from '../../__lib__/LegendQueryNavigation.js';
 import { flowResult } from 'mobx';
 import { assertErrorThrown, guaranteeType } from '@finos/legend-shared';
@@ -134,14 +134,14 @@ export const QueryEditorDataspaceInfoModal = observer(
     const storePath =
       connection?.store?.value.path ?? dataSpaceMedata?.storePath;
 
-    const openInTaxonomy = (): void => {
+    const openInMarketplace = (): void => {
       if (
         projectInfo &&
-        editorStore.applicationStore.config.taxonomyApplicationUrl
+        editorStore.applicationStore.config.marketplaceApplicationUrl
       ) {
         editorStore.applicationStore.navigationService.navigator.visitAddress(
-          EXTERNAL_APPLICATION_NAVIGATION__generateTaxonomyDataspaceViewUrl(
-            editorStore.applicationStore.config.taxonomyApplicationUrl,
+          EXTERNAL_APPLICATION_NAVIGATION__generateMarketplaceDataspaceViewUrl(
+            editorStore.applicationStore.config.marketplaceApplicationUrl,
             projectInfo.groupId,
             projectInfo.artifactId,
             projectInfo.versionId,
@@ -176,11 +176,11 @@ export const QueryEditorDataspaceInfoModal = observer(
               title="Close"
               disabled={
                 !(
-                  editorStore.applicationStore.config.taxonomyApplicationUrl &&
-                  projectInfo
+                  editorStore.applicationStore.config
+                    .marketplaceApplicationUrl && projectInfo
                 )
               }
-              onClick={openInTaxonomy}
+              onClick={openInMarketplace}
             >
               Open Data Space
             </button>

package/src/components/data-space/DataSpaceQuerySetup.tsx

@@ -38,6 +38,7 @@ import type {
 } from '../../stores/data-space/DataProductSelectorState.js';
 import { flowResult } from 'mobx';
 import { DepotEntityWithOrigin } from '@finos/legend-storage';
+import { LegendQueryTelemetryHelper } from '../../__lib__/LegendQueryTelemetryHelper.js';
 
 // Custom format function to handle both DataSpace and DataProduct options
 const formatDataSpaceOrProductOptionLabel = (
@@ -90,8 +91,32 @@ const DataProductQuerySetupSetupPanelContent = observer(
       queryBuilderState.queryAgentChatState?.abort();
       const value = option?.value;
       if (value instanceof ResolvedDataSpaceEntityWithOrigin) {
+        LegendQueryTelemetryHelper.logEvent_ChangeDataSpace(
+          applicationStore.telemetryService,
+          {
+            sourceInfo: queryBuilderState.sourceInfo,
+            to: {
+              groupId: value.origin?.groupId,
+              artifactId: value.origin?.artifactId,
+              versionId: value.origin?.versionId,
+              path: value.path,
+            },
+          },
+        );
         queryBuilderState.changeHandlers.onDataSpaceChange(value);
       } else if (value instanceof DepotEntityWithOrigin) {
+        LegendQueryTelemetryHelper.logEvent_ChangeDataProduct(
+          applicationStore.telemetryService,
+          {
+            sourceInfo: queryBuilderState.sourceInfo,
+            to: {
+              groupId: value.origin?.groupId,
+              artifactId: value.origin?.artifactId,
+              versionId: value.origin?.versionId,
+              path: value.path,
+            },
+          },
+        );
         queryBuilderState.changeHandlers.onDataProductChange(value);
       }
     };