@finos/legend-application-studio 28.21.45 → 28.21.47

package/src/stores/editor/editor-state/element-editor-state/testable/TestableEditorState.ts

@@ -60,6 +60,12 @@ import {
 } from './TestAssertionState.js';
 import type { ElementEditorState } from '../ElementEditorState.js';
 import { ExecutionPlanState } from '@finos/legend-query-builder';
+import {
+  LegendStudioTelemetryHelper,
+  TESTABLE_RUN_MODE,
+  type TESTABLE_KIND,
+  summarizeTestResults,
+} from '../../../../../__lib__/LegendStudioTelemetryHelper.js';
 
 export class TestableTestResultState {
   readonly editorStore: EditorStore;
@@ -202,6 +208,10 @@ export abstract class TestableTestEditorState {
     this.isReadOnly = isReadOnly;
   }
 
+  abstract get testableKind(): TESTABLE_KIND;
+
+  abstract get testablePath(): string;
+
   setSelectedTab(val: TESTABLE_TEST_TAB): void {
     this.selectedTab = val;
   }
@@ -335,18 +345,47 @@ export abstract class TestableTestEditorState {
     ).length;
   }
   *runTest(): GeneratorFn<void> {
+    const parentSuite =
+      this.test.__parent instanceof TestSuite ? this.test.__parent : undefined;
+    const telemetryBase = {
+      testableKind: this.testableKind,
+      testablePath: this.testablePath,
+      suiteId: parentSuite?.id,
+      mode: TESTABLE_RUN_MODE.RUN_TEST,
+      testCount: 1,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.resetResult();
       this.runningTestAction.inProgress();
       const result = (yield flowResult(this.fetchTestResult())) as TestResult;
       this.handleTestResult(result);
       this.runningTestAction.complete();
+      LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults([result]),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(
         `Error running test: ${error.message}`,
       );
       this.runningTestAction.fail();
+      LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     }
   }
 
@@ -410,7 +449,24 @@ export abstract class TestableTestSuiteEditorState {
     this.editorStore = editorStore;
   }
 
+  abstract get testableKind(): TESTABLE_KIND;
+
+  abstract get testablePath(): string;
+
   *runSuite(): GeneratorFn<void> {
+    const telemetryBase = {
+      testableKind: this.testableKind,
+      testablePath: this.testablePath,
+      suiteId: this.suite.id,
+      mode: TESTABLE_RUN_MODE.RUN_SUITE,
+      testCount: this.suite.tests.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.runningSuiteState.inProgress();
       this.testStates.forEach((t) => t.resetResult());
@@ -429,33 +485,61 @@ export abstract class TestableTestSuiteEditorState {
         state?.handleTestResult(result);
       });
       this.runningSuiteState.complete();
+      LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.runningSuiteState.fail();
+      LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     } finally {
       this.testStates.forEach((t) => t.runningTestAction.complete());
     }
   }
 
   *runFailingTests(): GeneratorFn<void> {
+    const unitTestIds = this.testStates
+      .map((testState) => {
+        const result = testState.testResultState.result;
+        if (
+          (result instanceof TestExecuted &&
+            result.testExecutionStatus === TestExecutionStatus.FAIL) ||
+          result instanceof TestError
+        ) {
+          testState.runningTestAction.inProgress();
+          return new UniqueTestId(this.suite, testState.test);
+        }
+        return undefined;
+      })
+      .filter(isNonNullable);
+    const telemetryBase = {
+      testableKind: this.testableKind,
+      testablePath: this.testablePath,
+      suiteId: this.suite.id,
+      mode: TESTABLE_RUN_MODE.RUN_FAILING,
+      testCount: unitTestIds.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.runningSuiteState.inProgress();
       const input = new RunTestsTestableInput(this.testable);
-      input.unitTestIds = this.testStates
-        .map((testState) => {
-          const result = testState.testResultState.result;
-          if (
-            (result instanceof TestExecuted &&
-              result.testExecutionStatus === TestExecutionStatus.FAIL) ||
-            result instanceof TestError
-          ) {
-            testState.runningTestAction.inProgress();
-            return new UniqueTestId(this.suite, testState.test);
-          }
-          return undefined;
-        })
-        .filter(isNonNullable);
+      input.unitTestIds = unitTestIds;
       const testResults =
         (yield this.editorStore.graphManagerState.graphManager.runTests(
           [input],
@@ -466,10 +550,24 @@ export abstract class TestableTestSuiteEditorState {
         state?.handleTestResult(result);
       });
       this.runningSuiteState.complete();
+      LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.runningSuiteState.fail();
+      LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     } finally {
       this.testStates.forEach((t) => t.runningTestAction.complete());
     }
@@ -517,6 +615,10 @@ export abstract class TestablePackageableElementEditorState {
 
   abstract init(): void;
 
+  abstract get testableKind(): TESTABLE_KIND;
+
+  abstract get testablePath(): string;
+
   get suiteCount(): number {
     return this.testable.tests.length;
   }
@@ -593,12 +695,25 @@ export abstract class TestablePackageableElementEditorState {
   }
 
   *runAllFailingSuites(): GeneratorFn<void> {
+    const input = new RunTestsTestableInput(this.testable);
+    this.failingSuites.forEach((s) => {
+      s.tests.forEach((t) => input.unitTestIds.push(new UniqueTestId(s, t)));
+    });
+    const telemetryBase = {
+      testableKind: this.testableKind,
+      testablePath: this.testablePath,
+      suiteId: undefined,
+      mode: TESTABLE_RUN_MODE.RUN_ALL_FAILING,
+      testCount: input.unitTestIds.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.isRunningFailingSuitesState.inProgress();
-      const input = new RunTestsTestableInput(this.testable);
-      this.failingSuites.forEach((s) => {
-        s.tests.forEach((t) => input.unitTestIds.push(new UniqueTestId(s, t)));
-      });
       const testResults =
         (yield this.editorStore.graphManagerState.graphManager.runTests(
           [input],
@@ -606,10 +721,24 @@ export abstract class TestablePackageableElementEditorState {
         )) as TestResult[];
       this.handleNewResults(testResults);
       this.isRunningFailingSuitesState.complete();
+      LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.isRunningFailingSuitesState.fail();
+      LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     } finally {
       this.selectedTestSuite?.testStates.forEach((t) =>
         t.runningTestAction.complete(),
@@ -618,6 +747,23 @@ export abstract class TestablePackageableElementEditorState {
   }
 
   *runTestable(): GeneratorFn<void> {
+    const totalTestCount = this.suites.reduce(
+      (acc, s) => acc + s.tests.length,
+      0,
+    );
+    const telemetryBase = {
+      testableKind: this.testableKind,
+      testablePath: this.testablePath,
+      suiteId: undefined,
+      mode: TESTABLE_RUN_MODE.RUN_TESTABLE,
+      testCount: totalTestCount,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.setTestableResults(undefined);
       this.isRunningTestableSuitesState.inProgress();
@@ -633,10 +779,24 @@ export abstract class TestablePackageableElementEditorState {
         )) as TestResult[];
       this.handleNewResults(testResults);
       this.isRunningTestableSuitesState.complete();
+      LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.isRunningTestableSuitesState.fail();
+      LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     } finally {
       this.selectedTestSuite?.testStates.forEach((t) =>
         t.runningTestAction.complete(),
@@ -645,6 +805,19 @@ export abstract class TestablePackageableElementEditorState {
   }
 
   *runSuite(suite: TestSuite): GeneratorFn<void> {
+    const telemetryBase = {
+      testableKind: this.testableKind,
+      testablePath: this.testablePath,
+      suiteId: suite.id,
+      mode: TESTABLE_RUN_MODE.RUN_SUITE,
+      testCount: suite.tests.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.runningSuite = suite;
       this.clearTestResultsForSuite(suite);
@@ -663,10 +836,24 @@ export abstract class TestablePackageableElementEditorState {
         )) as TestResult[];
 
       this.handleNewResults(testResults);
+      LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.isRunningTestableSuitesState.fail();
+      LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     } finally {
       this.selectedTestSuite?.testStates.forEach((t) =>
         t.runningTestAction.complete(),

package/src/stores/editor/editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.ts

@@ -43,6 +43,10 @@ import {
   ProjectType,
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  PROJECT_CONFIG_UPDATE_ACTION,
+} from '../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { SNAPSHOT_ALIAS, StoreProjectData } from '@finos/legend-server-depot';
 import { ProjectDependencyEditorState } from './ProjectDependencyEditorState.js';
 
@@ -231,7 +235,15 @@ export class ProjectConfigurationEditorState extends EditorState {
 
   *updateProjectConfiguration(
     updateConfigurationCommand: UpdateProjectConfigurationCommand,
+    updateAction: PROJECT_CONFIG_UPDATE_ACTION,
   ): GeneratorFn<void> {
+    const startTime = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    LegendStudioTelemetryHelper.logEvent_ProjectConfigUpdateLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      { action: updateAction },
+    );
     try {
       this.updatingConfigurationState.inProgress();
 
@@ -262,12 +274,22 @@ export class ProjectConfigurationEditorState extends EditorState {
       this.editorStore.tabManagerState.openTab(
         this.editorStore.projectConfigurationEditorState,
       );
+      LegendStudioTelemetryHelper.logEvent_ProjectConfigUpdateSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { action: updateAction, durationMs: Date.now() - startTime },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_ProjectConfigUpdateFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { action: updateAction, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.updatingConfigurationState.complete();
@@ -292,7 +314,12 @@ export class ProjectConfigurationEditorState extends EditorState {
           latestStructure,
           `update project configuration from ${this.editorStore.applicationStore.config.appName}: update to latest project structure`,
         );
-        yield flowResult(this.updateProjectConfiguration(updateCommand));
+        yield flowResult(
+          this.updateProjectConfiguration(
+            updateCommand,
+            PROJECT_CONFIG_UPDATE_ACTION.UPDATE_TO_LATEST_STRUCTURE,
+          ),
+        );
       } catch (error) {
         assertErrorThrown(error);
         this.editorStore.applicationStore.logService.error(
@@ -320,7 +347,12 @@ export class ProjectConfigurationEditorState extends EditorState {
         }: changed project type to ${prettyCONSTName(newProjectType)}`,
       );
       updateCommand.projectType = newProjectType;
-      yield flowResult(this.updateProjectConfiguration(updateCommand));
+      yield flowResult(
+        this.updateProjectConfiguration(
+          updateCommand,
+          PROJECT_CONFIG_UPDATE_ACTION.CHANGE_PROJECT_TYPE,
+        ),
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -380,7 +412,10 @@ export class ProjectConfigurationEditorState extends EditorState {
             ),
         );
       yield flowResult(
-        this.updateProjectConfiguration(updateProjectConfigurationCommand),
+        this.updateProjectConfiguration(
+          updateProjectConfigurationCommand,
+          PROJECT_CONFIG_UPDATE_ACTION.UPDATE_CONFIGS,
+        ),
       );
     } catch (error) {
       assertErrorThrown(error);

package/src/stores/editor/sidebar-state/BulkServiceRegistrationState.ts

@@ -35,6 +35,10 @@ import {
   ServiceRegistrationState,
 } from '../editor-state/element-editor-state/service/ServiceRegistrationState.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  SERVICE_REGISTRATION_TRIGGER,
+} from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import { type ServiceRegistrationEnvironmentConfig } from '../../../application/LegendStudioApplicationConfig.js';
 
 export enum REGISTRATION_RESULT {
@@ -179,6 +183,19 @@ export class GlobalBulkServiceRegistrationState {
       .filter((bulkRegState) => bulkRegState.isSelected)
       .map((serviceState) => serviceState.service);
 
+    const startedAt = Date.now();
+    const telemetryBase = {
+      trigger: SERVICE_REGISTRATION_TRIGGER.BULK,
+      executionMode: this.serviceConfigState.serviceExecutionMode,
+      serviceCount: selectedServices.length,
+      activatePostRegistration: this.activatePostRegistration,
+    };
+    LegendStudioTelemetryHelper.logEvent_ServiceRegistrationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
+
     try {
       this.validateBulkServiceForRegistration(
         this.editorStore,
@@ -216,25 +233,78 @@ export class GlobalBulkServiceRegistrationState {
       const successfulResults = registrationResults.filter(
         (result) => result instanceof ServiceRegistrationSuccess,
       );
+      const failedResults = registrationResults.filter(
+        (result) => result instanceof ServiceRegistrationFail,
+      );
 
+      let activationFailedCount: number | undefined;
       if (this.activatePostRegistration) {
-        yield Promise.resolve(
+        // Wait for every activation to settle so a single rejected activation
+        // neither hides the registration results nor goes unhandled.
+        const activationResults = (yield Promise.allSettled(
           successfulResults.map((serviceResult) =>
             this.editorStore.graphManagerState.graphManager.activateService(
               config.executionUrl,
               serviceResult.serviceInstanceId,
             ),
           ),
+        )) as PromiseSettledResult<void>[];
+        const activationFailures = activationResults.filter(
+          (result): result is PromiseRejectedResult =>
+            result.status === 'rejected',
+        );
+        activationFailedCount = activationFailures.length;
+        activationFailures.forEach((result) =>
+          this.editorStore.applicationStore.logService.error(
+            LogEvent.create(
+              LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE,
+            ),
+            result.reason,
+          ),
         );
       }
       this.handleResults(registrationResults);
       this.isServiceRegistering.complete();
+      const outcomeCounts = {
+        registeredCount: successfulResults.length,
+        failedCount: failedResults.length,
+        activationFailedCount,
+      };
+      // A bulk run where nothing got registered is a failed run; partial
+      // success is reported on the success payload via the outcome counts.
+      const firstFailure = failedResults[0];
+      if (successfulResults.length === 0 && firstFailure) {
+        LegendStudioTelemetryHelper.logEvent_ServiceRegistrationFailure(
+          this.editorStore.applicationStore.telemetryService,
+          this.editorStore.editorMode.getSourceInfo(),
+          {
+            ...telemetryBase,
+            ...outcomeCounts,
+            errorMessage: firstFailure.errorMessage,
+          },
+        );
+      } else {
+        LegendStudioTelemetryHelper.logEvent_ServiceRegistrationSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          this.editorStore.editorMode.getSourceInfo(),
+          {
+            ...telemetryBase,
+            ...outcomeCounts,
+            durationMs: Date.now() - startedAt,
+          },
+        );
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_ServiceRegistrationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.serviceConfigState.registrationState.reset();

package/src/stores/editor/sidebar-state/LocalChangesState.ts

@@ -461,6 +461,10 @@ export abstract class LocalChangesState {
           revisionId: latestRevision.id,
         },
       );
+      this.editorStore.legendAIAppliedSuggestionRegistry.reportPushedChanges(
+        this.editorStore,
+        localChanges,
+      );
 
       // ======= (RE)START CHANGE DETECTION =======