@finos/legend-application-studio 28.21.45 → 28.21.46

package/src/components/editor/side-bar/WorkflowManager.tsx

@@ -64,6 +64,7 @@ import {
 } from '@finos/legend-shared';
 import { CODE_EDITOR_LANGUAGE } from '@finos/legend-code-editor';
 import { CodeEditor } from '@finos/legend-lego/code-editor';
+import { LegendStudioTelemetryHelper } from '../../../__lib__/LegendStudioTelemetryHelper.js';
 
 const getWorkflowStatusIcon = (
   workflowStatus: WorkflowStatus,
@@ -501,6 +502,29 @@ export const WorkflowManager = observer(
       );
     }, [applicationStore, workflowManagerState]);
 
+    // Panel open / close telemetry — anchors a dwell time so we can measure
+    // engagement per surface. The mount emits `panel.open` and the cleanup
+    // emits `panel.close` with `dwellMs`.
+    useEffect(() => {
+      const openedAt = Date.now();
+      const editorStore = workflowManagerState.editorStore;
+      LegendStudioTelemetryHelper.logEvent_WorkflowManagerPanelOpened(
+        editorStore.applicationStore.telemetryService,
+        editorStore.editorMode.getSourceInfo(),
+        { scope: workflowManagerState.scope },
+      );
+      return () => {
+        LegendStudioTelemetryHelper.logEvent_WorkflowManagerPanelClosed(
+          editorStore.applicationStore.telemetryService,
+          editorStore.editorMode.getSourceInfo(),
+          {
+            scope: workflowManagerState.scope,
+            dwellMs: Date.now() - openedAt,
+          },
+        );
+      };
+    }, [workflowManagerState]);
+
     return (
       <div className="panel workflow-manager">
         <div className="panel__header side-bar__header">

package/src/index.ts

@@ -70,7 +70,10 @@ export * from './stores/extensions/DSL_Data_LegendStudioApplicationPlugin_Extens
 export { DataProductEditorState } from './stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.js';
 export { ComputeEditorState } from './stores/editor/editor-state/element-editor-state/compute/ComputeEditorState.js';
 export { LEGEND_STUDIO_DOCUMENTATION_KEY } from './__lib__/LegendStudioDocumentation.js';
-export { LegendStudioTelemetryHelper } from './__lib__/LegendStudioTelemetryHelper.js';
+export {
+  LegendStudioTelemetryHelper,
+  SERVICE_REGISTRATION_TRIGGER,
+} from './__lib__/LegendStudioTelemetryHelper.js';
 
 // components
 export { queryClass } from './components/editor/editor-group/uml-editor/ClassQueryBuilder.js';

package/src/stores/editor/EditorGraphState.ts

@@ -101,7 +101,10 @@ import { CONFIGURATION_EDITOR_TAB } from './editor-state/project-configuration-e
 import { PACKAGEABLE_ELEMENT_TYPE } from './utils/ModelClassifierUtils.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
 import { LEGEND_STUDIO_SETTING_KEY } from '../../__lib__/LegendStudioSetting.js';
-import { LegendStudioTelemetryHelper } from '../../__lib__/LegendStudioTelemetryHelper.js';
+import {
+  LegendStudioTelemetryHelper,
+  GRAPH_INITIALIZATION_ERROR_KIND,
+} from '../../__lib__/LegendStudioTelemetryHelper.js';
 
 export enum GraphBuilderStatus {
   SUCCEEDED = 'SUCCEEDED',
@@ -328,6 +331,10 @@ export class EditorGraphState {
   }
 
   *buildGraph(entities: Entity[]): GeneratorFn<GraphBuilderResult> {
+    LegendStudioTelemetryHelper.logEvent_GraphInitializationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+    );
     try {
       this.isInitializingGraph = true;
       const stopWatch = new StopWatch();
@@ -430,6 +437,28 @@ export class EditorGraphState {
         LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_FAILURE),
         error,
       );
+      const errorKind =
+        error instanceof DependencyGraphBuilderError
+          ? GRAPH_INITIALIZATION_ERROR_KIND.DEPENDENCY
+          : error instanceof GraphDataDeserializationError
+            ? GRAPH_INITIALIZATION_ERROR_KIND.DESERIALIZATION
+            : error instanceof NetworkClientError
+              ? GRAPH_INITIALIZATION_ERROR_KIND.NETWORK
+              : GRAPH_INITIALIZATION_ERROR_KIND.OTHER;
+      const fallbackToTextMode = !(
+        error instanceof DependencyGraphBuilderError ||
+        error instanceof GraphDataDeserializationError ||
+        error instanceof NetworkClientError
+      );
+      LegendStudioTelemetryHelper.logEvent_GraphInitializationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          errorKind,
+          errorMessage: error.message,
+          fallbackToTextMode,
+        },
+      );
       if (error instanceof DependencyGraphBuilderError) {
         this.editorStore.graphManagerState.graphBuildState.fail();
         // no recovery if dependency models cannot be built, this makes assumption that all dependencies models are compiled successfully

package/src/stores/editor/EditorStore.ts

@@ -769,6 +769,17 @@ export class EditorStore implements CommandRegistrar {
       // - view project
       // - back to the setup page
       const createWorkspaceAndRelaunch = async (): Promise<void> => {
+        const startTime = Date.now();
+        const identity = {
+          projectId,
+          workspaceId,
+          workspaceType: workspaceType.toString(),
+          hasPatchReleaseVersion: patchReleaseVersionId !== undefined,
+        };
+        LegendStudioTelemetryHelper.logEvent_SdlcWorkspaceCreateLaunched(
+          this.applicationStore.telemetryService,
+          identity,
+        );
         try {
           this.applicationStore.alertService.setBlockingAlert({
             message: 'Creating workspace...',
@@ -784,6 +795,10 @@ export class EditorStore implements CommandRegistrar {
           this.applicationStore.notificationService.notifySuccess(
             `Workspace '${workspace.workspaceId}' is succesfully created. Reloading application...`,
           );
+          LegendStudioTelemetryHelper.logEvent_SdlcWorkspaceCreateSucceeded(
+            this.applicationStore.telemetryService,
+            { ...identity, durationMs: Date.now() - startTime },
+          );
           this.applicationStore.navigationService.navigator.reload();
         } catch (error) {
           assertErrorThrown(error);
@@ -791,6 +806,10 @@ export class EditorStore implements CommandRegistrar {
             LogEvent.create(LEGEND_STUDIO_APP_EVENT.WORKSPACE_SETUP_FAILURE),
             error,
           );
+          LegendStudioTelemetryHelper.logEvent_SdlcWorkspaceCreateFailure(
+            this.applicationStore.telemetryService,
+            { ...identity, errorMessage: error.message },
+          );
           this.applicationStore.notificationService.notifyError(error);
         }
       };

package/src/stores/editor/EditorTabManagerState.ts

@@ -78,6 +78,12 @@ import { IngestDefinitionEditorState } from './editor-state/element-editor-state
 import { AvailabilityEditorState } from './editor-state/element-editor-state/availability/AvailabilityEditorState.js';
 import { ComputeEditorState } from './editor-state/element-editor-state/compute/ComputeEditorState.js';
 import type { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
+import {
+  EDITOR_TAB_CLOSE_TRIGGER,
+  EDITOR_TAB_OPEN_TRIGGER,
+  LegendStudioTelemetryHelper,
+} from '../../__lib__/LegendStudioTelemetryHelper.js';
+import { getEditorTabTelemetryData } from './EditorTabTelemetryHelper.js';
 
 export class EditorTabManagerState extends TabManagerState {
   readonly editorStore: EditorStore;
@@ -106,6 +112,115 @@ export class EditorTabManagerState extends TabManagerState {
     this.editorStore = editorStore;
   }
 
+  /**
+   * Per-tab dwell accounting for {@link EDITOR_TAB__CLOSE} telemetry.
+   * Keyed by `TabState.uuid`. `activeSince` is set when the tab becomes the
+   * current tab and cleared on switch away; `accumulatedMs` is the total time
+   * the tab held focus. On close we flush any live `activeSince` and emit
+   * the total. The map is pruned on close so it does not leak.
+   */
+  private tabDwell = new Map<
+    string,
+    { activeSince: number | undefined; accumulatedMs: number }
+  >();
+
+  private startDwell(tab: TabState): void {
+    const entry = this.tabDwell.get(tab.uuid);
+    const now = Date.now();
+    if (entry) {
+      entry.activeSince = now;
+    } else {
+      this.tabDwell.set(tab.uuid, { activeSince: now, accumulatedMs: 0 });
+    }
+  }
+
+  private flushDwell(tab: TabState): number {
+    const entry = this.tabDwell.get(tab.uuid);
+    if (!entry) {
+      return 0;
+    }
+    if (entry.activeSince !== undefined) {
+      entry.accumulatedMs += Date.now() - entry.activeSince;
+      entry.activeSince = undefined;
+    }
+    return entry.accumulatedMs;
+  }
+
+  private emitTabClose(tab: TabState, trigger: EDITOR_TAB_CLOSE_TRIGGER): void {
+    const dwellMs = this.flushDwell(tab);
+    this.tabDwell.delete(tab.uuid);
+    LegendStudioTelemetryHelper.logEvent_EditorTabClosed(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      {
+        ...getEditorTabTelemetryData(tab, this.editorStore),
+        dwellMs,
+        trigger,
+      },
+    );
+  }
+
+  override setCurrentTab(val: TabState | undefined): void {
+    const prev = this.currentTab;
+    if (prev && prev !== val) {
+      this.flushDwell(prev);
+    }
+    super.setCurrentTab(val);
+    if (val && val !== prev) {
+      this.startDwell(val);
+    }
+  }
+
+  override openTab(
+    tab: TabState,
+    trigger: EDITOR_TAB_OPEN_TRIGGER = EDITOR_TAB_OPEN_TRIGGER.PROGRAMMATIC,
+  ): void {
+    const isNew = !this.tabs.some((t) => t.match(tab));
+    super.openTab(tab);
+    if (isNew) {
+      LegendStudioTelemetryHelper.logEvent_EditorTabOpened(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...getEditorTabTelemetryData(tab, this.editorStore),
+          trigger,
+        },
+      );
+    }
+  }
+
+  override closeTab(
+    tab: TabState,
+    trigger: EDITOR_TAB_CLOSE_TRIGGER = EDITOR_TAB_CLOSE_TRIGGER.USER_CLOSE,
+  ): void {
+    if (tab.isPinned) {
+      return;
+    }
+    // Emit before super so the tab is still known and dwell can be flushed.
+    this.emitTabClose(tab, trigger);
+    super.closeTab(tab);
+  }
+
+  override closeAllTabs(
+    trigger: EDITOR_TAB_CLOSE_TRIGGER = EDITOR_TAB_CLOSE_TRIGGER.CLOSE_ALL,
+  ): void {
+    // Only non-pinned tabs are actually closed by the base implementation.
+    this.tabs
+      .filter((tab) => !tab.isPinned)
+      .forEach((tab) => this.emitTabClose(tab, trigger));
+    super.closeAllTabs();
+  }
+
+  override closeAllOtherTabs(
+    tab: TabState,
+    trigger: EDITOR_TAB_CLOSE_TRIGGER = EDITOR_TAB_CLOSE_TRIGGER.CLOSE_OTHERS,
+  ): void {
+    this.tabs
+      .filter((t) => !t.isPinned && t !== tab)
+      .forEach((t) => this.emitTabClose(t, trigger));
+    super.closeAllOtherTabs(tab);
+  }
+
   get dndType(): string {
     return 'editor.tab-manager.tab';
   }
@@ -141,7 +256,7 @@ export class EditorTabManagerState extends TabManagerState {
       currentTabState,
       currentTabElementPath,
     };
-    this.closeAllTabs();
+    this.closeAllTabs(EDITOR_TAB_CLOSE_TRIGGER.NAVIGATE_AWAY);
   }
 
   clearTabCache(): void {
@@ -273,6 +388,18 @@ export class EditorTabManagerState extends TabManagerState {
           return undefined;
         })
         .filter(isNonNullable);
+      // Emit OPEN telemetry for each restored tab so dwell tracking + dashboards
+      // treat cache-recovery as a first-class open (with trigger=restore).
+      this.tabs.forEach((tab) => {
+        LegendStudioTelemetryHelper.logEvent_EditorTabOpened(
+          this.editorStore.applicationStore.telemetryService,
+          this.editorStore.editorMode.getSourceInfo(),
+          {
+            ...getEditorTabTelemetryData(tab, this.editorStore),
+            trigger: EDITOR_TAB_OPEN_TRIGGER.RESTORE,
+          },
+        );
+      });
       this.setCurrentTab(
         this.findCurrentTab(
           this.cachedTabs.currentTabState,

package/src/stores/editor/EditorTabTelemetryHelper.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { TabState } from '@finos/legend-lego/application';
+import {
+  type EditorElementKind,
+  EDITOR_TAB_KIND,
+} from '../../__lib__/LegendStudioTelemetryHelper.js';
+import { ArtifactGenerationViewerState } from './editor-state/ArtifactGenerationViewerState.js';
+import { EditorDiffViewerState } from './editor-state/diff-viewer-state/EditorDiffViewerState.js';
+import { ElementEditorState } from './editor-state/element-editor-state/ElementEditorState.js';
+import { EndToEndWorkflowEditorState } from './editor-state/end-to-end-workflow-state/EndToEndWorkflowEditorState.js';
+import { ModelImporterState } from './editor-state/ModelImporterState.js';
+import { ProjectConfigurationEditorState } from './editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.js';
+import type { EditorStore } from './EditorStore.js';
+
+/**
+ * Classifies a Studio editor {@link TabState} for telemetry.
+ * Returns a `tabKind` bucket and, when the tab is an element editor, the
+ * `elementKind` (via `EditorGraphState.getPackageableElementType`, which is
+ * plugin-aware and so covers extension-provided element kinds) and
+ * `elementPath` of the underlying packageable element.
+ */
+export const getEditorTabTelemetryData = (
+  tab: TabState,
+  editorStore: EditorStore,
+): {
+  tabKind: EDITOR_TAB_KIND;
+  elementKind?: EditorElementKind | undefined;
+  elementPath?: string | undefined;
+} => {
+  if (tab instanceof ElementEditorState) {
+    return {
+      tabKind: EDITOR_TAB_KIND.ELEMENT,
+      elementKind: editorStore.graphState.getPackageableElementType(
+        tab.element,
+      ),
+      elementPath: tab.elementPath,
+    };
+  }
+  if (tab instanceof EditorDiffViewerState) {
+    return { tabKind: EDITOR_TAB_KIND.ENTITY_DIFF };
+  }
+  if (tab instanceof ArtifactGenerationViewerState) {
+    return { tabKind: EDITOR_TAB_KIND.ARTIFACT_GENERATION };
+  }
+  if (tab instanceof ModelImporterState) {
+    return { tabKind: EDITOR_TAB_KIND.MODEL_IMPORTER };
+  }
+  if (tab instanceof ProjectConfigurationEditorState) {
+    return { tabKind: EDITOR_TAB_KIND.PROJECT_CONFIGURATION };
+  }
+  if (tab instanceof EndToEndWorkflowEditorState) {
+    return { tabKind: EDITOR_TAB_KIND.END_TO_END_WORKFLOW };
+  }
+  return { tabKind: EDITOR_TAB_KIND.OTHER };
+};

package/src/stores/editor/GraphEditFormModeState.ts

@@ -52,7 +52,10 @@ import {
   graph_renameElement,
 } from '../graph-modifier/GraphModifierHelper.js';
 import { ElementEditorState } from './editor-state/element-editor-state/ElementEditorState.js';
-import { LegendStudioTelemetryHelper } from '../../__lib__/LegendStudioTelemetryHelper.js';
+import {
+  FORM_MODE_COMPILATION_ERROR_KIND,
+  LegendStudioTelemetryHelper,
+} from '../../__lib__/LegendStudioTelemetryHelper.js';
 import { GraphEditorMode } from './GraphEditorMode.js';
 import { GlobalBulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
 import type { EditorInitialConfiguration } from './editor-state/element-editor-state/ElementEditorInitialConfiguration.js';
@@ -548,6 +551,21 @@ export class GraphEditFormModeState extends GraphEditorMode {
           GraphCompilationOutcome.FAILED,
         );
       }
+      // NOTE: the `assertType(error, EngineError, ...)` above guarantees
+      // `error` is an `EngineError` here, so the classification only needs
+      // to distinguish `CompilationError` from other `EngineError`s.
+      LegendStudioTelemetryHelper.logEvent_GraphCompilationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          errorKind:
+            error instanceof CompilationError
+              ? FORM_MODE_COMPILATION_ERROR_KIND.COMPILATION
+              : FORM_MODE_COMPILATION_ERROR_KIND.ENGINE,
+          errorMessage: error.message,
+          fallbackToTextMode: fallbackToTextModeForDebugging,
+        },
+      );
     } finally {
       this.editorStore.graphState.isRunningGlobalCompile = false;
     }

package/src/stores/editor/editor-state/GraphGenerationState.ts

@@ -52,6 +52,10 @@ import { ExternalFormatState } from './ExternalFormatState.js';
 import { ExplorerTreeRootPackageLabel } from '../ExplorerTreeState.js';
 import type { DSL_Generation_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Generation_LegendStudioApplicationPlugin_Extension.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import {
+  GENERATION_MODE,
+  LegendStudioTelemetryHelper,
+} from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import {
   FileSystem_Directory,
   type FileSystemTreeNodeData,
@@ -194,6 +198,16 @@ export class DEPREACTED_GlobalFileGenerationState {
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          mode: GENERATION_MODE.GLOBAL,
+          enableArtifactGeneration:
+            this.graphGenerationState.enableArtifactGeneration,
+          errorMessage: error.message,
+        },
+      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
@@ -310,15 +324,36 @@ export class GraphGenerationState {
       return;
     }
     this.isRunningGlobalGenerate = true;
+    const startedAt = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const telemetryBase = {
+      mode: GENERATION_MODE.GLOBAL,
+      enableArtifactGeneration: this.enableArtifactGeneration,
+    };
+    LegendStudioTelemetryHelper.logEvent_GenerationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      telemetryBase,
+    );
     try {
       yield flowResult(this.generateModels());
       yield flowResult(this.generateArtifacts());
+      LegendStudioTelemetryHelper.logEvent_GenerationSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, durationMs: Date.now() - startedAt },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, errorMessage: error.message },
+      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
@@ -375,6 +410,15 @@ export class GraphGenerationState {
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          mode: GENERATION_MODE.GLOBAL,
+          enableArtifactGeneration: this.enableArtifactGeneration,
+          errorMessage: error.message,
+        },
+      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
@@ -412,6 +456,15 @@ export class GraphGenerationState {
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          mode: GENERATION_MODE.GLOBAL,
+          enableArtifactGeneration: this.enableArtifactGeneration,
+          errorMessage: error.message,
+        },
+      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );

package/src/stores/editor/editor-state/ModelImporterState.ts

@@ -33,6 +33,7 @@ import {
   assertTrue,
 } from '@finos/legend-shared';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import { PROJECT_CONFIG_UPDATE_ACTION } from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import type { EditorStore } from '../EditorStore.js';
 import { generateGAVCoordinates, type Entity } from '@finos/legend-storage';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
@@ -379,6 +380,7 @@ export class ExecuteInputDebugModelImporterEditorState extends ModelImporterEdit
       await flowResult(
         this.editorStore.projectConfigurationEditorState.updateProjectConfiguration(
           updateProjectConfigurationCommand,
+          PROJECT_CONFIG_UPDATE_ACTION.UPDATE_CONFIGS,
         ),
       );
       // open the debugger element

package/src/stores/editor/editor-state/element-editor-state/ElementExternalFormatGenerationState.ts

@@ -37,6 +37,10 @@ import {
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../EditorStore.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../__lib__/LegendStudioEvent.js';
+import {
+  GENERATION_MODE,
+  LegendStudioTelemetryHelper,
+} from '../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { GENERATION_FILE_ROOT_NAME } from '../../utils/FileSystemTreeUtils.js';
 import {
   configurationProperty_addConfigurationProperty,
@@ -99,6 +103,22 @@ export class XTGenerationState extends GeneratedFileStructureState {
 
   *generate(): GeneratorFn<void> {
     this.generatingAction.inProgress();
+    const startedAt = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const generationType = this.elementXTSchemaGenerationState.description.name;
+    const elementPath =
+      this.configSpecification.modelUnit.packageableElementIncludes[0]?.value
+        .path;
+    const telemetryBase = {
+      mode: GENERATION_MODE.ELEMENT_SCHEMA,
+      elementPath,
+      generationType,
+    };
+    LegendStudioTelemetryHelper.logEvent_GenerationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      telemetryBase,
+    );
     try {
       const modelUnit = this.configSpecification.modelUnit;
       const properties = [...this.configSpecification.configurationProperties];
@@ -122,6 +142,11 @@ export class XTGenerationState extends GeneratedFileStructureState {
         )
         .flat();
       this.processGenerationResult(output);
+      LegendStudioTelemetryHelper.logEvent_GenerationSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, durationMs: Date.now() - startedAt },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.fileSystemState.selectedNode = undefined;
@@ -130,6 +155,11 @@ export class XTGenerationState extends GeneratedFileStructureState {
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.generatingAction.complete();

package/src/stores/editor/editor-state/element-editor-state/availability/testable/AvailabilityTestableState.ts

@@ -50,6 +50,7 @@ import {
   TestableTestEditorState,
   TestableTestSuiteEditorState,
 } from '../../testable/TestableEditorState.js';
+import { TESTABLE_KIND } from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { RelationElementState } from '../../data/EmbeddedDataState.js';
 import { atomicTest_addAssertion } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import { externalFormatData_setData } from '../../../../../graph-modifier/DSL_Data_GraphModifierHelper.js';
@@ -345,6 +346,14 @@ export class AvailabilityTestState extends TestableTestEditorState {
   readonly suiteState: AvailabilityTestSuiteState;
   override test: AvailabilityBarrierTest;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.AVAILABILITY;
+  }
+
+  override get testablePath(): string {
+    return this.suiteState.testableState.availability.path;
+  }
+
   constructor(
     suiteState: AvailabilityTestSuiteState,
     test: AvailabilityBarrierTest,
@@ -436,6 +445,14 @@ export class AvailabilityTestSuiteState extends TestableTestSuiteEditorState {
   testToRename: AvailabilityBarrierTest | undefined;
   readonly testDataState: RelationElementState;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.AVAILABILITY;
+  }
+
+  override get testablePath(): string {
+    return this.testableState.availability.path;
+  }
+
   constructor(
     testableState: AvailabilityTestableState,
     suite: AvailabilityTestSuite,

package/src/stores/editor/editor-state/element-editor-state/dataProduct/testable/DataProductTestableState.ts

@@ -77,6 +77,7 @@ import {
   TestableTestEditorState,
   TestableTestSuiteEditorState,
 } from '../../testable/TestableEditorState.js';
+import { TESTABLE_KIND } from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { generateVariableExpressionMockValue } from '@finos/legend-query-builder';
 import {
   buildRelationElementsDataWithColumns,
@@ -208,6 +209,14 @@ export class DataProductTestState extends TestableTestEditorState {
   newParameterValueName = '';
   showNewParameterModal = false;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.DATA_PRODUCT;
+  }
+
+  override get testablePath(): string {
+    return this.suiteState.testableState.dataProduct.path;
+  }
+
   constructor(
     suiteState: DataProductTestSuiteState,
     test: DataProductAccessPointTest,
@@ -637,6 +646,14 @@ export class DataProductTestSuiteState extends TestableTestSuiteEditorState {
   declare selectTestState: DataProductTestState | undefined;
   testDataState: DataProductTestDataState;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.DATA_PRODUCT;
+  }
+
+  override get testablePath(): string {
+    return this.testableState.dataProduct.path;
+  }
+
   constructor(
     editorStore: EditorStore,
     testableState: DataProductTestableState,