@finos/legend-application-studio 28.21.45 → 28.21.47

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,

package/src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts

@@ -68,7 +68,7 @@ import {
   Database,
   DataProduct,
   IngestDefinition,
-  LakehouseRuntime,
+  LakehouseBaseRuntime,
   PackageableElementExplicitReference,
   observe_ValueSpecification,
   observe_RelationElementsData,
@@ -111,6 +111,7 @@ import {
   createBareExternalFormat,
 } from '../../../../utils/TestableUtils.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
+import { TESTABLE_KIND } from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { testSuite_addTest } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import {
   buildDefaultInstanceValue,
@@ -437,6 +438,14 @@ export class FunctionTestState extends TestableTestEditorState {
   newParameterValueName = '';
   showNewParameterModal = false;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.FUNCTION_ACTIVATOR;
+  }
+
+  override get testablePath(): string {
+    return this.functionTestableState.function.path;
+  }
+
   constructor(
     editorStore: EditorStore,
     parentSuiteState: FunctionTestSuiteState,
@@ -847,6 +856,14 @@ export class FunctionTestSuiteState extends TestableTestSuiteEditorState {
 
   showCreateModal = false;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.FUNCTION_ACTIVATOR;
+  }
+
+  override get testablePath(): string {
+    return this.functionTestableState.function.path;
+  }
+
   constructor(
     editorStore: EditorStore,
     functionTestableState: FunctionTestableState,
@@ -930,6 +947,14 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
   createSuiteModal = false;
   cachedAccessors: Accessor[] = [];
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.FUNCTION_ACTIVATOR;
+  }
+
+  override get testablePath(): string {
+    return this.function.path;
+  }
+
   constructor(functionEditorState: FunctionEditorState) {
     super(functionEditorState, functionEditorState.functionElement);
     makeObservable(this, {
@@ -1033,7 +1058,7 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
             `Function Test Suite Only supports One Runtime at this time. Found ${engineRuntimes.length}`,
           );
           const engineRuntime = guaranteeNonNullable(engineRuntimes[0]);
-          if (!(engineRuntime instanceof LakehouseRuntime)) {
+          if (!(engineRuntime instanceof LakehouseBaseRuntime)) {
             assertTrue(
               !(
                 engineRuntime.connectionStores.length &&

package/src/stores/editor/editor-state/element-editor-state/ingest/IngestTestableState.ts

@@ -53,6 +53,7 @@ import {
   TestableTestEditorState,
   TestableTestSuiteEditorState,
 } from '../testable/TestableEditorState.js';
+import { TESTABLE_KIND } from '../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import type { EditorStore } from '../../../EditorStore.js';
 import type { IngestDefinitionEditorState } from './IngestDefinitionEditorState.js';
 import { RelationElementState } from '../data/EmbeddedDataState.js';
@@ -108,6 +109,14 @@ export class IngestTestState extends TestableTestEditorState {
   readonly uuid = uuid();
   testDataRelationState: RelationElementState | undefined;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.INGEST;
+  }
+
+  override get testablePath(): string {
+    return this.suiteState.testableState.ingest.path;
+  }
+
   constructor(suiteState: IngestTestSuiteState, test: IngestMatViewTest) {
     super(
       suiteState.testableState.ingest,
@@ -342,6 +351,14 @@ export class IngestTestSuiteState extends TestableTestSuiteEditorState {
   testDataState: IngestTestDataState;
   readonly uuid = uuid();
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.INGEST;
+  }
+
+  override get testablePath(): string {
+    return this.testableState.ingest.path;
+  }
+
   constructor(
     editorStore: EditorStore,
     testableState: IngestTestableState,

package/src/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestableState.ts

@@ -87,6 +87,12 @@ import {
   isRelationalMappingTestSuite,
 } from './MappingTestingHelper.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  TESTABLE_RUN_MODE,
+  TESTABLE_KIND,
+  summarizeTestResults,
+} from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 
 export class StoreTestDataState {
   readonly editorStore: EditorStore;
@@ -218,6 +224,14 @@ export class MappingTestState extends TestableTestEditorState {
   override test: MappingTest;
   dataState: MappingTestDataState;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.MAPPING;
+  }
+
+  override get testablePath(): string {
+    return this.mappingTestableState.mapping.path;
+  }
+
   constructor(
     editorStore: EditorStore,
     parentSuiteState: MappingTestSuiteState,
@@ -348,6 +362,14 @@ export class MappingTestSuiteState extends TestableTestSuiteEditorState {
   showCreateModal = false;
   queryState: MappingTestSuiteQueryState;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.MAPPING;
+  }
+
+  override get testablePath(): string {
+    return this.mappingTestableState.mapping.path;
+  }
+
   constructor(
     editorStore: EditorStore,
     mappingTestableState: MappingTestableState,
@@ -563,6 +585,14 @@ export class MappingTestableState extends TestablePackageableElementEditorState
   declare selectedTestSuite: MappingTestSuiteState | undefined;
   declare runningSuite: MappingTestSuite | undefined;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.MAPPING;
+  }
+
+  override get testablePath(): string {
+    return this.mapping.path;
+  }
+
   constructor(mappingEditorState: MappingEditorState) {
     super(mappingEditorState, mappingEditorState.mapping);
     makeObservable(this, {
@@ -644,6 +674,19 @@ export class MappingTestableState extends TestablePackageableElementEditorState
   }
 
   override *runSuite(suite: MappingTestSuite): 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);
@@ -682,10 +725,24 @@ export class MappingTestableState extends 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/element-editor-state/service/ServiceRegistrationState.ts

@@ -32,6 +32,10 @@ import {
   compareSemVerVersions,
 } from '@finos/legend-shared';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  SERVICE_REGISTRATION_TRIGGER,
+} from '../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import {
   type Service,
   type PureExecution,
@@ -288,7 +292,17 @@ export class ServiceRegistrationState extends ServiceConfigState {
 
   *checkServiceRegistration(): GeneratorFn<void> {
     this.deploymentCheckState.inProgress();
+    const startedAt = Date.now();
+    const servicePath = this.service.path;
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    LegendStudioTelemetryHelper.logEvent_ServiceRegistrationCheckLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      { servicePath, envCount: this.registrationOptions.length },
+    );
     const envs: string[] = [];
+    const failedEnvs: string[] = [];
+    let lastErrorMessage: string | undefined;
     const servicePattern = this.service.pattern.startsWith('/')
       ? this.service.pattern.substring(1)
       : this.service.pattern;
@@ -304,6 +318,8 @@ export class ServiceRegistrationState extends ServiceConfigState {
         }
       } catch (error) {
         assertErrorThrown(error);
+        failedEnvs.push(envConfig.env);
+        lastErrorMessage = error.message;
         this.editorStore.applicationStore.logService.warn(
           LogEvent.create(
             LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_CHECK_FAILURE,
@@ -314,9 +330,52 @@ export class ServiceRegistrationState extends ServiceConfigState {
     }
     this.setRegisteredEnvs(envs);
     this.deploymentCheckState.complete();
+    // A precheck run only counts as failed when no env could be probed at
+    // all; partial per-env errors are reported on the success payload.
+    const envCount = this.registrationOptions.length;
+    const durationMs = Date.now() - startedAt;
+    if (lastErrorMessage !== undefined && failedEnvs.length === envCount) {
+      LegendStudioTelemetryHelper.logEvent_ServiceRegistrationCheckFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        {
+          servicePath,
+          envCount,
+          durationMs,
+          errorCount: failedEnvs.length,
+          failedEnvs,
+          errorMessage: lastErrorMessage,
+        },
+      );
+    } else {
+      LegendStudioTelemetryHelper.logEvent_ServiceRegistrationCheckSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        {
+          servicePath,
+          envCount,
+          durationMs,
+          registeredEnvCount: envs.length,
+          errorCount: failedEnvs.length,
+          failedEnvs,
+        },
+      );
+    }
   }
 
   *registerService(): GeneratorFn<void> {
+    const startedAt = Date.now();
+    const telemetryBase = {
+      trigger: SERVICE_REGISTRATION_TRIGGER.SINGLE,
+      executionMode: this.serviceExecutionMode,
+      serviceCount: 1,
+      activatePostRegistration: this.activatePostRegistration,
+    };
+    LegendStudioTelemetryHelper.logEvent_ServiceRegistrationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.registrationState.inProgress();
       this.validateServiceForRegistration();
@@ -381,12 +440,27 @@ export class ServiceRegistrationState extends ServiceConfigState {
           },
         ],
       });
+      LegendStudioTelemetryHelper.logEvent_ServiceRegistrationSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startedAt,
+          registeredCount: 1,
+          failedCount: 0,
+        },
+      );
     } 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.registrationState.reset();

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestDataState.ts

@@ -117,19 +117,12 @@ export const createMockPrimitiveValueSpecificationFromRelationalDataType = (
   relationalDataType: RelationalDataType,
   graph: PureModel,
   observerContext: ObserverContext,
-): ValueSpecification | undefined => {
-  const primitiveTypeFromRelational =
-    getPrimitiveTypeFromRelationalType(relationalDataType);
-
-  if (primitiveTypeFromRelational) {
-    return createMockPrimitiveValueSpecification(
-      primitiveTypeFromRelational,
-      graph,
-      observerContext,
-    );
-  }
-  return undefined;
-};
+): ValueSpecification =>
+  createMockPrimitiveValueSpecification(
+    getPrimitiveTypeFromRelationalType(relationalDataType),
+    graph,
+    observerContext,
+  );
 
 export class ServiceTestDataParametersState extends LambdaParametersState {
   connectionTestDataState: ConnectionTestDataState;
@@ -280,14 +273,12 @@ export class TableRowIdentifierState {
         this.connectionTestDataState.editorStore.changeDetectionState
           .observerContext,
       );
-    if (valueSpec) {
-      const rowIdentifierState = new RowIdentifierState(
-        this.connectionTestDataState,
-        column,
-        valueSpec,
-      );
-      this.rowIdentifierStates.push(rowIdentifierState);
-    }
+    const rowIdentifierState = new RowIdentifierState(
+      this.connectionTestDataState,
+      column,
+      valueSpec,
+    );
+    this.rowIdentifierStates.push(rowIdentifierState);
   }
 
   removeRowIdentifierState(rowIdentifierState: RowIdentifierState): void {
@@ -472,6 +463,11 @@ export class ConnectionTestDataState {
       this.generatingTestDataState.pass();
     } catch (error) {
       assertErrorThrown(error);
+      LegendStudioTelemetryHelper.logEvent_TestDataGenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        error.message,
+      );
       this.editorStore.applicationStore.notificationService.notifyError(
         `Unable to generate test data: ${error.message}`,
       );
@@ -610,6 +606,11 @@ export class ConnectionTestDataState {
       this.generatingTestDataWithSeedDataState.pass();
     } catch (error) {
       assertErrorThrown(error);
+      LegendStudioTelemetryHelper.logEvent_TestDataGenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        error.message,
+      );
       this.editorStore.applicationStore.notificationService.notifyError(
         `Unable to generate test data: ${error.message}`,
       );

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestEditorState.ts

@@ -30,6 +30,7 @@ import {
   TESTABLE_TEST_TAB,
   TestableTestEditorState,
 } from '../../testable/TestableEditorState.js';
+import { TESTABLE_KIND } from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import type { ServiceTestSuiteState } from './ServiceTestableState.js';
 import {
   service_addAssertKeyForTest,
@@ -428,6 +429,14 @@ export class ServiceTestState extends TestableTestEditorState {
   override test: ServiceTest;
   override testable: Service;
   setupState: ServiceTestSetupState;
+
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.SERVICE;
+  }
+
+  override get testablePath(): string {
+    return this.testable.path;
+  }
   constructor(suiteState: ServiceTestSuiteState, test: ServiceTest) {
     super(
       suiteState.testableState.serviceEditorState.service,

package/src/stores/editor/editor-state/element-editor-state/service/testable/ServiceTestableState.ts

@@ -66,6 +66,11 @@ import {
   SERIALIZATION_FORMAT,
   ServiceTestState,
 } from './ServiceTestEditorState.js';
+import {
+  LegendStudioTelemetryHelper,
+  SERVICE_TEST_SUITE_RUN_MODE,
+  summarizeTestResults,
+} from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 
 const createEmptyServiceTestSuite = (
   serviceTestableState: ServiceTestableState,
@@ -186,15 +191,27 @@ export class ServiceTestSuiteState {
   }
 
   *runSuite(): GeneratorFn<void> {
+    const service = this.testableState.serviceEditorState.service;
+    const input = new RunTestsTestableInput(service);
+    input.unitTestIds = this.suite.tests.map(
+      (t) => new UniqueTestId(this.suite, t),
+    );
+    const telemetryData = {
+      servicePath: service.path,
+      suiteId: this.suite.id,
+      mode: SERVICE_TEST_SUITE_RUN_MODE.RUN_SUITE,
+      testCount: input.unitTestIds.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_ServiceTestSuiteRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryData,
+    );
     try {
       this.runningTestState.inProgress();
       this.testStates.forEach((t) => t.resetResult());
       this.testStates.forEach((t) => t.runningTestAction.inProgress());
-      const service = this.testableState.serviceEditorState.service;
-      const input = new RunTestsTestableInput(service);
-      input.unitTestIds = this.suite.tests.map(
-        (t) => new UniqueTestId(this.suite, t),
-      );
       const testResults =
         (yield this.editorStore.graphManagerState.graphManager.runTests(
           [input],
@@ -205,34 +222,60 @@ export class ServiceTestSuiteState {
         state?.handleTestResult(result);
       });
       this.runningTestState.complete();
+      LegendStudioTelemetryHelper.logEvent_ServiceTestSuiteRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryData,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.runningTestState.fail();
+      LegendStudioTelemetryHelper.logEvent_ServiceTestSuiteRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryData, errorMessage: error.message },
+      );
     } finally {
       this.testStates.forEach((t) => t.runningTestAction.complete());
     }
   }
 
   *runFailingTests(): GeneratorFn<void> {
+    const service = this.testableState.serviceEditorState.service;
+    const input = new RunTestsTestableInput(service);
+    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);
+    const telemetryData = {
+      servicePath: service.path,
+      suiteId: this.suite.id,
+      mode: SERVICE_TEST_SUITE_RUN_MODE.RUN_FAILING,
+      testCount: input.unitTestIds.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_ServiceTestSuiteRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryData,
+    );
     try {
       this.runningTestState.inProgress();
-      const service = this.testableState.serviceEditorState.service;
-      const input = new RunTestsTestableInput(service);
-      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);
       const testResults =
         (yield this.editorStore.graphManagerState.graphManager.runTests(
           [input],
@@ -243,10 +286,24 @@ export class ServiceTestSuiteState {
         state?.handleTestResult(result);
       });
       this.runningTestState.complete();
+      LegendStudioTelemetryHelper.logEvent_ServiceTestSuiteRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryData,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.runningTestState.fail();
+      LegendStudioTelemetryHelper.logEvent_ServiceTestSuiteRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryData, errorMessage: error.message },
+      );
     } finally {
       this.testStates.forEach((t) => t.runningTestAction.complete());
     }