@finos/legend-application-studio 28.21.45 → 28.21.47

package/src/components/editor/editor-group/service-editor/ServiceEditor.tsx

@@ -71,6 +71,7 @@ import {
   validate_ServicePattern,
   validate_ServiceMcpServer,
   DeploymentOwnership,
+  Service,
   UserListOwnership,
 } from '@finos/legend-graph';
 import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../../../__lib__/LegendStudioApplicationNavigationContext.js';
@@ -78,7 +79,11 @@ import { ServiceTestableEditor } from './testable/ServiceTestableEditor.js';
 import { flowResult } from 'mobx';
 import { ServicePostValidationsEditor } from './ServicePostValidationEditor.js';
 import type { DSL_Service_LegendStudioApplicationPlugin_Extension } from '../../../../stores/extensions/DSL_Service_LegendStudioApplicationPlugin_Extension.js';
-import { LegendStudioTelemetryHelper } from '../../../../__lib__/LegendStudioTelemetryHelper.js';
+import {
+  LEGENDAI_SUGGEST_STAGE,
+  LEGENDAI_SUGGEST_SURFACE,
+} from '../../../../__lib__/LegendStudioTelemetryHelper.js';
+import { useLegendAISuggestTelemetry } from '../LegendAISuggestTelemetryHooks.js';
 import { LEGEND_STUDIO_DOCUMENTATION_KEY } from '../../../../__lib__/LegendStudioDocumentation.js';
 import { DocumentationLink } from '@finos/legend-lego/application';
 
@@ -267,32 +272,42 @@ const ServiceGeneralEditor = observer(() => {
   const [aiDocSuggestion, setAIDocSuggestion] = useState<string | undefined>(
     undefined,
   );
+  const aiSuggestTelemetry = useLegendAISuggestTelemetry(
+    editorStore,
+    { surface: LEGENDAI_SUGGEST_SURFACE.SERVICE, elementPath: service.path },
+    { legendAIUrl, available: Boolean(aiDocSuggester), isReadOnly },
+  );
   const suggestDocumentationWithAI = async (): Promise<void> => {
     if (!aiDocSuggester || !legendAIUrl) {
       return;
     }
-    LegendStudioTelemetryHelper.logEvent_ServiceLegendAISuggestLaunched(
-      applicationStore.telemetryService,
-      service.path,
-      editorStore.editorMode.getSourceInfo(),
-    );
+    const request = aiSuggestTelemetry.launch({
+      existingText: service.documentation,
+    });
     setIsSuggestingWithAI(true);
     setAIDocSuggestion(undefined);
+    let stage = LEGENDAI_SUGGEST_STAGE.SERIALIZE;
     try {
       const serviceGrammar =
         await editorStore.graphManagerState.graphManager.elementsToPureCode([
           service,
         ]);
+      stage = LEGENDAI_SUGGEST_STAGE.REQUEST;
       const suggestion = await aiDocSuggester(serviceGrammar, legendAIUrl);
-      setAIDocSuggestion(suggestion);
+      const shouldShow = aiSuggestTelemetry.succeed(request, {
+        suggestionText: suggestion,
+        definitionsLength: serviceGrammar.length,
+        currentText: service.documentation,
+      });
+      if (!shouldShow) {
+        applicationStore.notificationService.notifyWarning(
+          'LegendAI did not return a documentation suggestion for this service',
+        );
+      }
+      setAIDocSuggestion(shouldShow ? suggestion : undefined);
     } catch (error) {
       assertErrorThrown(error);
-      LegendStudioTelemetryHelper.logEvent_ServiceLegendAISuggestFailure(
-        applicationStore.telemetryService,
-        service.path,
-        error.message,
-        editorStore.editorMode.getSourceInfo(),
-      );
+      aiSuggestTelemetry.fail(request, error, stage);
       if (
         error instanceof NetworkClientError &&
         (error.response.status === HttpStatus.UNAUTHORIZED ||
@@ -314,20 +329,23 @@ const ServiceGeneralEditor = observer(() => {
     if (!aiDocSuggestion) {
       return;
     }
-    LegendStudioTelemetryHelper.logEvent_ServiceLegendAISuggestApplied(
-      applicationStore.telemetryService,
-      service.path,
-      editorStore.editorMode.getSourceInfo(),
-    );
+    const servicePath = service.path;
+    aiSuggestTelemetry.apply({
+      existingText: service.documentation,
+      appliedText: aiDocSuggestion,
+      readCurrentText: (store) => {
+        const element =
+          store.graphManagerState.graph.getNullableElement(servicePath);
+        return element instanceof Service
+          ? { found: true, text: element.documentation }
+          : { found: false };
+      },
+    });
     service_setDocumentation(service, aiDocSuggestion);
     setAIDocSuggestion(undefined);
   };
   const discardAIDocSuggestion = (): void => {
-    LegendStudioTelemetryHelper.logEvent_ServiceLegendAISuggestDiscarded(
-      applicationStore.telemetryService,
-      service.path,
-      editorStore.editorMode.getSourceInfo(),
-    );
+    aiSuggestTelemetry.discard();
     setAIDocSuggestion(undefined);
   };
 

package/src/components/editor/editor-group/service-editor/testable/ServiceTestDataEditor.tsx

@@ -113,10 +113,8 @@ export const RowIdentifierEditor = observer(
             tableRowIdentifierState.connectionTestDataState.editorStore
               .changeDetectionState.observerContext,
           );
-        if (valueSpec) {
-          rowIdentifierState.updateRowIdentifierValue(valueSpec);
-          rowIdentifierState.updateRowIdentifierColumn(val.value);
-        }
+        rowIdentifierState.updateRowIdentifierValue(valueSpec);
+        rowIdentifierState.updateRowIdentifierColumn(val.value);
       }
     };
 
@@ -129,9 +127,7 @@ export const RowIdentifierEditor = observer(
           tableRowIdentifierState.connectionTestDataState.editorStore
             .changeDetectionState.observerContext,
         );
-      if (valueSpec) {
-        rowIdentifierState.updateRowIdentifierValue(valueSpec);
-      }
+      rowIdentifierState.updateRowIdentifierValue(valueSpec);
     };
 
     return (
@@ -166,10 +162,8 @@ export const RowIdentifierEditor = observer(
                 .changeDetectionState.observerContext
             }
             typeCheckOption={{
-              expectedType: guaranteeNonNullable(
-                getPrimitiveTypeFromRelationalType(
-                  guaranteeNonNullable(rowIdentifierState.column.type),
-                ),
+              expectedType: getPrimitiveTypeFromRelationalType(
+                guaranteeNonNullable(rowIdentifierState.column.type),
               ),
             }}
             resetValue={resetNode}

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,11 +70,27 @@ 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,
+  LEGENDAI_SUGGEST_SURFACE,
+  LEGENDAI_SUGGEST_STAGE,
+  LEGENDAI_SUGGEST_ERROR_KIND,
+  LEGENDAI_SUGGEST_ABANDON_PHASE,
+  LEGENDAI_SUGGEST_RETENTION,
+  LEGENDAI_SUGGEST_MATCH_STRATEGY,
+  type LegendAISuggestTarget,
+} from './__lib__/LegendStudioTelemetryHelper.js';
+export {
+  LegendAISuggestTelemetryTracker,
+  type LegendAISuggestRequest,
+  type LegendAIAppliedTextReader,
+} from './stores/editor/LegendAISuggestTelemetry.js';
 
 // components
 export { queryClass } from './components/editor/editor-group/uml-editor/ClassQueryBuilder.js';
 export * from './components/editor/EditorStoreProvider.js';
+export { useLegendAISuggestTelemetry } from './components/editor/editor-group/LegendAISuggestTelemetryHooks.js';
 export { ActivityBarMenu } from './components/editor/ActivityBar.js';
 export * from './components/workspace-setup/ProjectSelectorUtils.js';
 export * from './components/workspace-setup/WorkspaceSelectorUtils.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

@@ -23,6 +23,7 @@ import {
   observable,
 } from 'mobx';
 import { ExplorerTreeState } from './ExplorerTreeState.js';
+import { LegendAIAppliedSuggestionRegistry } from './LegendAISuggestTelemetry.js';
 import {
   ACTIVITY_MODE,
   PANEL_MODE,
@@ -222,6 +223,8 @@ export class EditorStore implements CommandRegistrar {
   readonly showcasePanelDisplayState: PanelDisplayState;
   readonly showcaseDefaultSize = 500;
   readonly tabManagerState = new EditorTabManagerState(this);
+  readonly legendAIAppliedSuggestionRegistry =
+    new LegendAIAppliedSuggestionRegistry();
   supportedElementTypesWithCategory: Map<string, string[]>;
 
   lazyTextEditorStore = new LazyTextEditorStore(this);
@@ -769,6 +772,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 +798,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 +809,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';
@@ -481,6 +484,19 @@ export class GraphEditFormModeState extends GraphEditorMode {
       );
     } catch (error) {
       assertErrorThrown(error);
+      if (!(error instanceof EngineError)) {
+        // Non-engine errors (e.g. network) are re-thrown below by `assertType`;
+        // still close out the `launch` emitted above so it has a terminal event.
+        LegendStudioTelemetryHelper.logEvent_GraphCompilationFailure(
+          this.editorStore.applicationStore.telemetryService,
+          this.editorStore.editorMode.getSourceInfo(),
+          {
+            errorKind: FORM_MODE_COMPILATION_ERROR_KIND.OTHER,
+            errorMessage: error.message,
+            fallbackToTextMode: false,
+          },
+        );
+      }
       // TODO: we probably should make this pattern of error the handling for all other exceptions in the codebase
       // i.e. there should be a catch-all handler (we can use if-else construct to check error types)
       assertType(error, EngineError, `Unhandled exception:\n${error}`);
@@ -523,6 +539,24 @@ export class GraphEditFormModeState extends GraphEditorMode {
         }
       }
 
+      // NOTE: the `assertType(error, EngineError, ...)` above guarantees
+      // `error` is an `EngineError` here, so the classification only needs
+      // to distinguish `CompilationError` from other `EngineError`s.
+      // Emitted before the (potentially slow, potentially throwing) switch to
+      // text mode so the failure is always recorded with an accurate timestamp.
+      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,
+        },
+      );
+
       // decide if we need to fall back to text mode for debugging
       if (fallbackToTextModeForDebugging) {
         // TODO: when we support showing multiple notifications, we can split this into 2