@finos/legend-application-studio 22.4.3 → 22.4.5

package/src/stores/EditorGraphState.ts

@@ -89,11 +89,12 @@ import {
   GraphManagerTelemetry,
   DataElement,
   type PackageableElement,
-  type GraphBuilderReport,
   type CompilationWarning,
   type TextCompilationResult,
   type CompilationResult,
   type PureModel,
+  createGraphBuilderReport,
+  reportGraphAnalytics,
 } from '@finos/legend-graph';
 import {
   ActionAlertActionType,
@@ -106,6 +107,7 @@ import { PACKAGEABLE_ELEMENT_TYPE } from './shared/ModelClassifierUtils.js';
 import { GlobalTestRunnerState } from './sidebar-state/testable/GlobalTestRunnerState.js';
 import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioAppEvent.js';
 import { ExplorerTreeState } from './ExplorerTreeState.js';
+import { LegendStudioTelemetry } from './LegendStudioTelemetry.js';
 
 export enum GraphBuilderStatus {
   SUCCEEDED = 'SUCCEEDED',
@@ -347,59 +349,70 @@ export class EditorGraphState {
       const dependencyEntitiesIndex = (yield flowResult(
         this.getIndexedDependencyEntities(),
       )) as Map<string, Entity[]>;
-      stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_DEPENDENCIES_FETCHED);
-
-      const dependency_buildReport =
-        (yield this.editorStore.graphManagerState.graphManager.buildDependencies(
-          this.editorStore.graphManagerState.coreModel,
-          this.editorStore.graphManagerState.systemModel,
-          dependencyManager,
-          dependencyEntitiesIndex,
-          this.editorStore.graphManagerState.dependenciesBuildState,
-        )) as GraphBuilderReport;
+      stopWatch.record(GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS);
+
+      const dependency_buildReport = createGraphBuilderReport();
+      yield this.editorStore.graphManagerState.graphManager.buildDependencies(
+        this.editorStore.graphManagerState.coreModel,
+        this.editorStore.graphManagerState.systemModel,
+        dependencyManager,
+        dependencyEntitiesIndex,
+        this.editorStore.graphManagerState.dependenciesBuildState,
+        {},
+        dependency_buildReport,
+      );
       dependency_buildReport.timings[
-        GRAPH_MANAGER_EVENT.GRAPH_DEPENDENCIES_FETCHED
-      ] = stopWatch.getRecord(GRAPH_MANAGER_EVENT.GRAPH_DEPENDENCIES_FETCHED);
+        GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS
+      ] = stopWatch.getRecord(
+        GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS,
+      );
 
       // build graph
-      const graph_buildReport =
-        (yield this.editorStore.graphManagerState.graphManager.buildGraph(
-          this.editorStore.graphManagerState.graph,
-          entities,
-          this.editorStore.graphManagerState.graphBuildState,
-          {
-            TEMPORARY__preserveSectionIndex:
-              this.editorStore.applicationStore.config.options
-                .TEMPORARY__preserveSectionIndex,
-            strict: this.enableStrictMode,
-          },
-        )) as GraphBuilderReport;
+      const graph_buildReport = createGraphBuilderReport();
+      yield this.editorStore.graphManagerState.graphManager.buildGraph(
+        this.editorStore.graphManagerState.graph,
+        entities,
+        this.editorStore.graphManagerState.graphBuildState,
+        {
+          TEMPORARY__preserveSectionIndex:
+            this.editorStore.applicationStore.config.options
+              .TEMPORARY__preserveSectionIndex,
+          strict: this.enableStrictMode,
+        },
+        graph_buildReport,
+      );
 
       // build generations
-      const generation_buildReport =
-        (yield this.editorStore.graphManagerState.graphManager.buildGenerations(
-          this.editorStore.graphManagerState.graph,
-          this.graphGenerationState.generatedEntities,
-          this.editorStore.graphManagerState.generationsBuildState,
-        )) as GraphBuilderReport;
+      const generation_buildReport = createGraphBuilderReport();
+      yield this.editorStore.graphManagerState.graphManager.buildGenerations(
+        this.editorStore.graphManagerState.graph,
+        this.graphGenerationState.generatedEntities,
+        this.editorStore.graphManagerState.generationsBuildState,
+        {},
+        generation_buildReport,
+      );
 
       // report
-      stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED);
+      stopWatch.record(GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS);
       const graphBuilderReportData = {
         timings: {
-          [GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED]: stopWatch.getRecord(
-            GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED,
+          [GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS]: stopWatch.getRecord(
+            GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS,
           ),
         },
         dependencies: dependency_buildReport,
+        dependenciesCount:
+          this.editorStore.graphManagerState.graph.dependencyManager
+            .numberOfDependencies,
         graph: graph_buildReport,
         generations: generation_buildReport,
+        generationsCount: this.graphGenerationState.generatedEntities.size,
       };
       this.editorStore.applicationStore.log.info(
-        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_INITIALIZED),
+        LogEvent.create(GRAPH_MANAGER_EVENT.INITIALIZE_GRAPH__SUCCESS),
         graphBuilderReportData,
       );
-      GraphManagerTelemetry.logEvent_GraphInitialized(
+      GraphManagerTelemetry.logEvent_GraphInitializationSucceeded(
         this.editorStore.applicationStore.telemetryService,
         graphBuilderReportData,
       );
@@ -564,6 +577,14 @@ export class EditorGraphState {
       return FormModeCompilationOutcome.SKIPPED;
     }
 
+    const stopWatch = new StopWatch();
+    const report = reportGraphAnalytics(
+      this.editorStore.graphManagerState.graph,
+    );
+    LegendStudioTelemetry.logEvent_GraphCompilationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+    );
+
     const currentGraphHash =
       this.editorStore.changeDetectionState.currentGraphHash;
 
@@ -584,6 +605,7 @@ export class EditorGraphState {
           {
             keepSourceInformation: true,
           },
+          report,
         )) as CompilationResult;
 
       this.warnings = compilationResult.warnings
@@ -606,6 +628,12 @@ export class EditorGraphState {
         }
       }
 
+      report.timings.total = stopWatch.elapsed;
+      LegendStudioTelemetry.logEvent_GraphCompilationSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        report,
+      );
+
       return FormModeCompilationOutcome.SUCCEEDED;
     } catch (error) {
       assertErrorThrown(error);
@@ -712,6 +740,14 @@ export class EditorGraphState {
       return;
     }
 
+    const stopWatch = new StopWatch();
+    const report = reportGraphAnalytics(
+      this.editorStore.graphManagerState.graph,
+    );
+    LegendStudioTelemetry.logEvent_TextCompilationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+    );
+
     const currentGraphHash =
       this.editorStore.grammarTextEditorState.currentTextGraphHash;
 
@@ -726,6 +762,8 @@ export class EditorGraphState {
         (yield this.editorStore.graphManagerState.graphManager.compileText(
           this.editorStore.grammarTextEditorState.graphGrammarText,
           this.editorStore.graphManagerState.graph,
+          {},
+          report,
         )) as TextCompilationResult;
 
       const entities = compilationResult.entities;
@@ -748,7 +786,9 @@ export class EditorGraphState {
         }
       }
 
+      stopWatch.record();
       yield flowResult(this.updateGraphAndApplicationInTextMode(entities));
+      stopWatch.record(GRAPH_MANAGER_EVENT.UPDATE_AND_REBUILD_GRAPH__SUCCESS);
 
       // Remove `SectionIndex when computing changes in text mode as engine after
       // transforming grammarToJson would return `SectionIndex` which is not
@@ -760,6 +800,16 @@ export class EditorGraphState {
           ),
         ),
       );
+
+      report.timings = {
+        ...report.timings,
+        ...Object.fromEntries(stopWatch.records),
+        total: stopWatch.elapsed,
+      };
+      LegendStudioTelemetry.logEvent_GraphCompilationSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        report,
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.mostRecentTextModeCompilationGraphHash = currentGraphHash;
@@ -1111,7 +1161,7 @@ export class EditorGraphState {
       );
 
       this.editorStore.applicationStore.log.info(
-        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_UPDATED_AND_REBUILT),
+        LogEvent.create(GRAPH_MANAGER_EVENT.UPDATE_AND_REBUILD_GRAPH__SUCCESS),
         '[TOTAL]',
         Date.now() - startTime,
         'ms',
@@ -1124,7 +1174,9 @@ export class EditorGraphState {
       yield this.editorStore.changeDetectionState.preComputeGraphElementHashes();
       this.editorStore.changeDetectionState.start();
       this.editorStore.applicationStore.log.info(
-        LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
+        LogEvent.create(
+          CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTART__SUCCESS,
+        ),
         '[ASYNC]',
       );
 
@@ -1184,7 +1236,7 @@ export class EditorGraphState {
       this.reprocessExplorerTreeInTextMode();
 
       this.editorStore.applicationStore.log.info(
-        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_UPDATED_AND_REBUILT),
+        LogEvent.create(GRAPH_MANAGER_EVENT.UPDATE_AND_REBUILD_GRAPH__SUCCESS),
         '[TOTAL]',
         Date.now() - startTime,
         'ms',

package/src/stores/EditorSDLCState.ts

@@ -382,7 +382,7 @@ export class EditorSDLCState {
         this.editorStore.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
           entities,
           LogEvent.create(
-            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_LOCAL_HASHES_INDEX_BUILT,
+            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
           ),
         ),
       );
@@ -412,7 +412,7 @@ export class EditorSDLCState {
         this.editorStore.changeDetectionState.workspaceBaseRevisionState.buildEntityHashesIndex(
           workspaceBaseEntities,
           LogEvent.create(
-            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_WORKSPACE_HASHES_INDEX_BUILT,
+            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_WORKSPACE_HASHES_INDEX__SUCCESS,
           ),
         ),
       );
@@ -441,7 +441,7 @@ export class EditorSDLCState {
         this.editorStore.changeDetectionState.projectLatestRevisionState.buildEntityHashesIndex(
           projectLatestEntities,
           LogEvent.create(
-            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_PROJECT_LATEST_HASHES_INDEX_BUILT,
+            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_PROJECT_LATEST_HASHES_INDEX__SUCCESS,
           ),
         ),
       );

package/src/stores/EditorStore.ts

@@ -814,7 +814,7 @@ export class EditorStore implements CommandRegistrar {
         entities,
       );
       this.applicationStore.log.info(
-        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_ENTITIES_FETCHED),
+        LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS),
         Date.now() - startTime,
         'ms',
       );
@@ -838,7 +838,7 @@ export class EditorStore implements CommandRegistrar {
             this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
               entities,
               LogEvent.create(
-                CHANGE_DETECTION_EVENT.CHANGE_DETECTION_LOCAL_HASHES_INDEX_BUILT,
+                CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
               ),
             ),
           );
@@ -879,7 +879,7 @@ export class EditorStore implements CommandRegistrar {
         this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
           entities,
           LogEvent.create(
-            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_LOCAL_HASHES_INDEX_BUILT,
+            CHANGE_DETECTION_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
           ),
         ),
 
@@ -892,7 +892,9 @@ export class EditorStore implements CommandRegistrar {
         this.changeDetectionState.computeAggregatedProjectLatestChanges(true),
       ]);
       this.applicationStore.log.info(
-        LogEvent.create(CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTARTED),
+        LogEvent.create(
+          CHANGE_DETECTION_EVENT.CHANGE_DETECTION_RESTART__SUCCESS,
+        ),
         '[ASNYC]',
       );
       // ======= FINISHED (RE)START CHANGE DETECTION =======

package/src/stores/EmbeddedQueryBuilderState.ts

@@ -32,6 +32,7 @@ type EmbeddedQueryBuilderConfiguration = {
   setupQueryBuilderState: () => QueryBuilderState;
   disableCompile?: boolean | undefined;
   actionConfigs: EmbeddedQueryBuilderActionConfiguration[];
+  applicationContext: string;
 };
 
 export class EmbeddedQueryBuilderState {

package/src/stores/LegendStudioAppEvent.ts

@@ -15,6 +15,14 @@
  */
 
 export enum LEGEND_STUDIO_APP_EVENT {
+  COMPILE_GRAPH__LAUNCH = 'editor.compilation.compile-graph.launch',
+  COMPILE_TEXT__LAUNCH = 'editor.compilation.compile-text.launch',
+  TEST_DATA_GENERATION__LAUNCH = 'editor.test.test-data-generation.launch',
+
+  TEXT_MODE_COMPILATION__SUCCESS = 'editor.text-mode.compilation.success',
+  FORM_MODE_COMPILATION__SUCCESS = 'editor.form-mode.compilation.success',
+  TEST_DATA_GENERATION__SUCCESS = 'editor.test.test-data-generation.success',
+
   // FAILURE
   // TODO: consider to spliting all of these generic errors into more specific events
   GENERIC_FAILURE = 'application.failure.generic',
@@ -31,8 +39,8 @@ export enum LEGEND_STUDIO_APP_EVENT {
   // TODO: consider to split this generic errors into more specific events
   SDLC_MANAGER_FAILURE = 'sdlc.manager.failure',
 
-  WORKSPACE_UPDATED = 'sdlc.workspace-update.success',
-  WORKSPACE_LOCAL_CHANGES_PUSHED = 'sdlc.local-changes-push.success',
+  UPDATE_WORKSPACE__SUCCESS = 'sdlc.workspace-update.success',
+  PUSH_LOCAL_CHANGES__SUCCESS = 'sdlc.local-changes-push.success',
 
   // Depot
   // TODO: consider to split this generic errors into more specific events

package/src/stores/LegendStudioApplicationNavigationContext.ts

@@ -40,10 +40,19 @@ export enum LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY {
   FUNCTION_EDITOR = 'studio.editor.function-editor',
 
   MAPPING_EDITOR = 'studio.editor.mapping-editor',
+  CLASS_MAPPING_EDITOR = 'studio.editor.mapping-editor.class-mapping-editor',
+  OPERATION_CLASS_MAPPING_EDITOR = 'studio.editor.mapping-editor.operation-class-mapping-editor',
+  ENUMERATION_MAPPING_EDITOR = 'studio.editor.mapping-editor.enumeration-mapping-editor',
+  MAPPING_EXECUTION_EDITOR = 'studio.editor.mapping-editor.execution-editor',
+  MAPPING_TEST_EDITOR = 'studio.editor.mapping-editor.test-editor',
+
   RUNTIME_EDITOR = 'studio.editor.runtime-editor',
+
   CONNECTION_EDITOR = 'studio.editor.connection-editor',
+  DATABASE_BUILDER = 'studio.editor.connection-editor.database-builder',
 
   SERVICE_EDITOR = 'studio.editor.service-editor',
+  SERVICE_EDITOR_EXECUTION = 'studio.editor.service-editor.execution',
   SERVICE_EDITOR_TEST = 'studio.editor.service-editor.test',
 
   DATA_ELEMENT_EDITOR = 'studio.editor.data-element-editor',

package/src/stores/LegendStudioBaseStore.ts

@@ -29,6 +29,7 @@ import {
   ActionAlertType,
   ApplicationTelemetry,
   matchPath,
+  APPLICATION_EVENT,
 } from '@finos/legend-application';
 import {
   action,
@@ -46,20 +47,18 @@ import type { LegendStudioApplicationConfig } from '../application/LegendStudioA
 import { LegendStudioEventService } from './LegendStudioEventService.js';
 import { LEGEND_STUDIO_SDLC_BYPASSED_ROUTE_PATTERN } from './LegendStudioRouter.js';
 
-const UNKNOWN_USER_ID = '(unknown)';
-
 export type LegendStudioApplicationStore = ApplicationStore<
   LegendStudioApplicationConfig,
   LegendStudioPluginManager
 >;
 
 export class LegendStudioBaseStore {
-  applicationStore: LegendStudioApplicationStore;
-  sdlcServerClient: SDLCServerClient;
-  depotServerClient: DepotServerClient;
-  pluginManager: LegendStudioPluginManager;
+  readonly applicationStore: LegendStudioApplicationStore;
+  readonly sdlcServerClient: SDLCServerClient;
+  readonly depotServerClient: DepotServerClient;
+  readonly pluginManager: LegendStudioPluginManager;
 
-  initState = ActionState.create();
+  readonly initState = ActionState.create();
 
   isSDLCAuthorized: boolean | undefined = false;
   SDLCServerTermsOfServicesUrlsToView: string[] = [];
@@ -93,9 +92,7 @@ export class LegendStudioBaseStore {
 
   *initialize(): GeneratorFn<void> {
     if (!this.initState.isInInitialState) {
-      this.applicationStore.notifyIllegalState(
-        'Studio store is re-initialized',
-      );
+      this.applicationStore.notifyIllegalState('Base store is re-initialized');
       return;
     }
     this.initState.inProgress();
@@ -111,29 +108,32 @@ export class LegendStudioBaseStore {
       // setup SDLC server client
       yield flowResult(this.initializeSDLCServerClient());
 
-      let currentUserID = UNKNOWN_USER_ID;
       try {
         const currentUser = User.serialization.fromJson(
           (yield this.sdlcServerClient.getCurrentUser()) as PlainObject<User>,
         );
         this.sdlcServerClient.setCurrentUser(currentUser);
-        currentUserID = currentUser.userId;
+        this.applicationStore.setCurrentUser(currentUser.userId);
       } catch (error) {
         assertErrorThrown(error);
         this.applicationStore.log.error(
-          LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
+          LogEvent.create(
+            APPLICATION_EVENT.APPLICATION_IDENTITY_AUTO_FETCH__FAILURE,
+          ),
           error,
         );
         this.applicationStore.notifyWarning(error.message);
       }
 
       // setup telemetry service
-      this.applicationStore.telemetryService.setUserId(currentUserID);
+      this.applicationStore.telemetryService.setUserId(
+        this.applicationStore.currentUser,
+      );
     } else {
       this.isSDLCAuthorized = undefined;
     }
 
-    ApplicationTelemetry.logEvent_ApplicationInitialized(
+    ApplicationTelemetry.logEvent_ApplicationInitializationSucceeded(
       this.applicationStore.telemetryService,
       {
         application: {
@@ -150,6 +150,7 @@ export class LegendStudioBaseStore {
         },
       },
     );
+
     LegendStudioEventService.create(
       this.applicationStore.eventService,
     ).notify_ApplicationLoaded();
@@ -157,6 +158,14 @@ export class LegendStudioBaseStore {
     this.initState.complete();
   }
 
+  get needsToAcceptSDLCServerTermsOfServices(): boolean {
+    return Boolean(this.SDLCServerTermsOfServicesUrlsToView.length);
+  }
+
+  dismissSDLCServerTermsOfServicesAlert(): void {
+    this.SDLCServerTermsOfServicesUrlsToView = [];
+  }
+
   private *initializeSDLCServerClient(): GeneratorFn<void> {
     try {
       this.isSDLCAuthorized =
@@ -245,12 +254,4 @@ export class LegendStudioBaseStore {
       }
     }
   }
-
-  get needsToAcceptSDLCServerTermsOfServices(): boolean {
-    return Boolean(this.SDLCServerTermsOfServicesUrlsToView.length);
-  }
-
-  dismissSDLCServerTermsOfServicesAlert(): void {
-    this.SDLCServerTermsOfServicesUrlsToView = [];
-  }
 }

package/src/stores/LegendStudioCodeSnippets.ts

@@ -236,7 +236,9 @@ export const BLANK_SERVICE_SNIPPET = `Service \${1:new::NewService}
   documentation: \${4:'documentation'};
   autoActivateUpdates: \${5:true};
   execution: \${6:}
-  test: \${7:}
+  testSuites:
+  [
+  ]
 }`;
 
 export const SERVICE_WITH_SINGLE_EXECUTION_SNIPPET = `Service \${1:new::NewService}
@@ -261,13 +263,9 @@ export const SERVICE_WITH_SINGLE_EXECUTION_SNIPPET = `Service \${1:new::NewServi
     // example of using runtime pointer
     // runtime: model::SomeRuntime;
   }
-  test: Single
-  {
-    data: 'data'; // this test data will be shared across tests
-    asserts:
-    [
-    ];
-  }
+  testSuites:
+  [
+  ]
 }`;
 
 export const SERVICE_WITH_MULTI_EXECUTION_SNIPPET = `Service \${1:new::NewService}
@@ -301,20 +299,9 @@ export const SERVICE_WITH_MULTI_EXECUTION_SNIPPET = `Service \${1:new::NewServic
     //   runtime: model::SomeRuntime;
     // }
   }
-  test: Multi
-  {
-    tests['key_1']:
-    {
-      data: 'data';
-      asserts:
-      [
-      ];
-    }
-    // tests['key_2']:
-    // {
-    //   data: 'data';
-    // }
-  }
+  testSuites:
+  [
+  ]
 }`;
 
 // ------------------------------------- Generation -------------------------------------

package/src/stores/LegendStudioEventService.ts

@@ -31,6 +31,6 @@ export class LegendStudioEventService {
   }
 
   notify_ApplicationLoaded(): void {
-    this.eventService.notify(APPLICATION_EVENT.APPLICATION_LOADED, {});
+    this.eventService.notify(APPLICATION_EVENT.APPLICATION_LOAD__SUCCESS, {});
   }
 }

package/src/stores/LegendStudioTelemetry.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2020-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 { GraphManagerOperationReport } from '@finos/legend-graph';
+import type { TelemetryService } from '@finos/legend-shared';
+import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioAppEvent.js';
+
+type Compilation_TelemetryData = GraphManagerOperationReport & {
+  dependenciesCount: number;
+};
+
+type TestDataGeneration_TelemetryData = GraphManagerOperationReport & {
+  dependenciesCount: number;
+};
+
+export class LegendStudioTelemetry {
+  static logEvent_GraphCompilationLaunched(
+    telemetryService: TelemetryService,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_STUDIO_APP_EVENT.COMPILE_GRAPH__LAUNCH,
+      {},
+    );
+  }
+
+  static logEvent_TextCompilationLaunched(
+    telemetryService: TelemetryService,
+  ): void {
+    telemetryService.logEvent(LEGEND_STUDIO_APP_EVENT.COMPILE_TEXT__LAUNCH, {});
+  }
+
+  static logEvent_TestDataGenerationLaunched(
+    telemetryService: TelemetryService,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_STUDIO_APP_EVENT.TEST_DATA_GENERATION__LAUNCH,
+      {},
+    );
+  }
+
+  static logEvent_GraphCompilationSucceeded(
+    telemetryService: TelemetryService,
+    data: Compilation_TelemetryData,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_STUDIO_APP_EVENT.FORM_MODE_COMPILATION__SUCCESS,
+      data,
+    );
+  }
+
+  static logEvent_TextCompilationSucceeded(
+    telemetryService: TelemetryService,
+    data: Compilation_TelemetryData,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_STUDIO_APP_EVENT.TEXT_MODE_COMPILATION__SUCCESS,
+      data,
+    );
+  }
+
+  static logEvent_TestDataGenerationSucceeded(
+    telemetryService: TelemetryService,
+    data: TestDataGeneration_TelemetryData,
+  ): void {
+    telemetryService.logEvent(
+      LEGEND_STUDIO_APP_EVENT.TEST_DATA_GENERATION__SUCCESS,
+      data,
+    );
+  }
+}