@finos/legend-application-studio 28.21.46 → 28.21.47

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

@@ -153,15 +153,19 @@ export class DEPREACTED_GlobalFileGenerationState {
   /**
    * Generated file generations in the graph.
    * NOTE: This method does not update graph and application only the files are generated.
+   *
+   * Errors are handled (logged + notified) here and returned rather than
+   * re-thrown so the caller can keep generating; the caller owns the
+   * `editor.generation.*` telemetry outcome.
    */
   *DEPREACTED_generateFiles(
     generationOutputIndex: Map<string, GenerationOutput[]>,
-  ): GeneratorFn<void> {
+  ): GeneratorFn<Error | undefined> {
     try {
       const generationSpecs =
         this.editorStore.graphManagerState.graph.ownGenerationSpecifications;
       if (!generationSpecs.length) {
-        return;
+        return undefined;
       }
       assertTrue(
         generationSpecs.length === 1,
@@ -192,25 +196,17 @@ export class DEPREACTED_GlobalFileGenerationState {
         }
         generationOutputIndex.set(fileGeneration.value.path, result);
       }
+      return undefined;
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
-      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
-        this.editorStore.applicationStore.telemetryService,
-        this.editorStore.editorMode.getSourceInfo(),
-        {
-          mode: GENERATION_MODE.GLOBAL,
-          enableArtifactGeneration:
-            this.graphGenerationState.enableArtifactGeneration,
-          errorMessage: error.message,
-        },
-      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+      return error;
     }
   }
 
@@ -336,13 +332,30 @@ export class GraphGenerationState {
       telemetryBase,
     );
     try {
-      yield flowResult(this.generateModels());
-      yield flowResult(this.generateArtifacts());
-      LegendStudioTelemetryHelper.logEvent_GenerationSucceeded(
-        this.editorStore.applicationStore.telemetryService,
-        sourceInfo,
-        { ...telemetryBase, durationMs: Date.now() - startedAt },
-      );
+      // NOTE: both steps handle (log + notify) their own errors and return
+      // them instead of throwing, so artifact generation still runs when
+      // model generation fails. We only decide the telemetry outcome here so
+      // each run emits exactly one terminal event.
+      const modelGenerationError = (yield flowResult(this.generateModels())) as
+        | Error
+        | undefined;
+      const artifactGenerationError = (yield flowResult(
+        this.generateArtifacts(),
+      )) as Error | undefined;
+      const generationError = modelGenerationError ?? artifactGenerationError;
+      if (generationError) {
+        LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+          this.editorStore.applicationStore.telemetryService,
+          sourceInfo,
+          { ...telemetryBase, errorMessage: generationError.message },
+        );
+      } else {
+        LegendStudioTelemetryHelper.logEvent_GenerationSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          sourceInfo,
+          { ...telemetryBase, durationMs: Date.now() - startedAt },
+        );
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -362,13 +375,17 @@ export class GraphGenerationState {
     }
   }
 
-  *generateModels(): GeneratorFn<void> {
+  /**
+   * Errors are handled (logged + notified) here and returned rather than
+   * re-thrown; see {@link GraphGenerationState.globalGenerate}.
+   */
+  *generateModels(): GeneratorFn<Error | undefined> {
     try {
       this.generatedEntities = new Map<string, Entity[]>(); // reset the map of generated entities
       const generationSpecs =
         this.editorStore.graphManagerState.graph.ownGenerationSpecifications;
       if (!generationSpecs.length) {
-        return;
+        return undefined;
       }
       assertTrue(
         generationSpecs.length === 1,
@@ -404,41 +421,37 @@ export class GraphGenerationState {
           this.editorStore.graphState.updateGenerationGraphAndApplication(),
         );
       }
+      return undefined;
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
-      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
-        this.editorStore.applicationStore.telemetryService,
-        this.editorStore.editorMode.getSourceInfo(),
-        {
-          mode: GENERATION_MODE.GLOBAL,
-          enableArtifactGeneration: this.enableArtifactGeneration,
-          errorMessage: error.message,
-        },
-      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+      return error;
     }
   }
 
   /**
    * Generated artifacts generations in graph
    * NOTE: This method does not update graph and application only the files are generated.
+   *
+   * Errors are handled (logged + notified) here and returned rather than
+   * re-thrown; see {@link GraphGenerationState.globalGenerate}.
    */
-  *generateArtifacts(): GeneratorFn<void> {
+  *generateArtifacts(): GeneratorFn<Error | undefined> {
     try {
       this.emptyGeneratedArtifacts();
       const generationOutputIndex = new Map<string, GenerationOutput[]>();
       // handle deprecated file generations
-      yield flowResult(
+      const fileGenerationError = (yield flowResult(
         this.globalFileGenerationState.DEPREACTED_generateFiles(
           generationOutputIndex,
         ),
-      );
+      )) as Error | undefined;
       let artifacts = new ArtifactGenerationExtensionResult();
       if (this.enableArtifactGeneration) {
         artifacts =
@@ -450,24 +463,17 @@ export class GraphGenerationState {
 
       // handle results
       this.processGenerationResult(artifacts, generationOutputIndex);
+      return fileGenerationError;
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
-      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
-        this.editorStore.applicationStore.telemetryService,
-        this.editorStore.editorMode.getSourceInfo(),
-        {
-          mode: GENERATION_MODE.GLOBAL,
-          enableArtifactGeneration: this.enableArtifactGeneration,
-          errorMessage: error.message,
-        },
-      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+      return error;
     }
   }
 

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

@@ -68,7 +68,9 @@ import {
   isStubbed_StoreConnections,
   getAllIdentifiedConnections,
   generateIdentifiedConnectionId,
+  type LakehouseBaseRuntime,
   LakehouseRuntime,
+  LakehouseSingleStoreRuntime,
   ConcreteFunctionDefinition,
 } from '@finos/legend-graph';
 import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
@@ -899,42 +901,36 @@ export enum LakehouseRuntimeType {
   CONNECTION = 'CONNECTION',
 }
 
-export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
-  declare runtimeValue: LakehouseRuntime;
+export abstract class LakehouseBaseRuntimeEditorState extends EngineRuntimeEditorState {
+  /**
+   * NOTE: a fresh instance is built by `RuntimeEditorState.setRuntimeValueEditorState`
+   * whenever the compute engine swap replaces the concrete runtime class, so this
+   * changes exactly when that swap happens -- used to force a remount of the
+   * compute-engine-specific fields (e.g. Warehouse) in the UI.
+   */
+  readonly uuid = uuid();
+  declare runtimeValue: LakehouseBaseRuntime;
   availableEnvs: IngestDeploymentServerConfig[] | undefined;
+  /**
+   * Only `LakehouseRuntime` can switch out of environment mode today; a
+   * subclass whose runtime gains connection support just needs to set this.
+   */
   lakehouseRuntimeType = LakehouseRuntimeType.ENVIRONMENT;
 
-  constructor(state: RuntimeEditorState, value: LakehouseRuntime) {
+  constructor(state: RuntimeEditorState, value: LakehouseBaseRuntime) {
     super(state, value);
     makeObservable(this, {
       availableEnvs: observable,
+      lakehouseRuntimeType: observable,
       fetchLakehouseSummaries: flow,
       setEnvSummaries: action,
-      lakehouseRuntimeType: observable,
-      setLakehouseRuntimeType: action,
       envOptions: computed,
     });
     this.runtimeValue = value;
-    // fix when metamodel is more clear on this
-    if (value.connectionPointer) {
-      this.lakehouseRuntimeType = LakehouseRuntimeType.CONNECTION;
-    }
-  }
-
-  setLakehouseRuntimeType(val: LakehouseRuntimeType): void {
-    if (val !== this.lakehouseRuntimeType) {
-      this.lakehouseRuntimeType = val;
-      if (val === LakehouseRuntimeType.CONNECTION) {
-        this.runtimeValue.environment = undefined;
-        this.runtimeValue.warehouse = undefined;
-      } else {
-        this.setConnection(undefined);
-      }
-    }
   }
 
-  setConnection(val: PackageableConnection | undefined): void {
-    lakehouseRuntime_setConnection(this.runtimeValue, val);
+  protected get isEnvironmentModeActive(): boolean {
+    return this.lakehouseRuntimeType === LakehouseRuntimeType.ENVIRONMENT;
   }
 
   get envOptions(): { label: string; value: string }[] {
@@ -972,7 +968,7 @@ export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
         )) as unknown as IngestDeploymentServerConfig[] | undefined;
         this.setEnvSummaries(res);
         if (
-          this.lakehouseRuntimeType === LakehouseRuntimeType.ENVIRONMENT &&
+          this.isEnvironmentModeActive &&
           !this.runtimeValue.environment &&
           this.envOptions.length
         ) {
@@ -985,6 +981,40 @@ export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
   }
 }
 
+export class LakehouseSingleStoreRuntimeEditorState extends LakehouseBaseRuntimeEditorState {
+  declare runtimeValue: LakehouseSingleStoreRuntime;
+}
+
+export class LakehouseRuntimeEditorState extends LakehouseBaseRuntimeEditorState {
+  declare runtimeValue: LakehouseRuntime;
+
+  constructor(state: RuntimeEditorState, value: LakehouseRuntime) {
+    super(state, value);
+    makeObservable(this, {
+      setLakehouseRuntimeType: action,
+    });
+    if (value.connectionPointer) {
+      this.lakehouseRuntimeType = LakehouseRuntimeType.CONNECTION;
+    }
+  }
+
+  setLakehouseRuntimeType(val: LakehouseRuntimeType): void {
+    if (val !== this.lakehouseRuntimeType) {
+      this.lakehouseRuntimeType = val;
+      if (val === LakehouseRuntimeType.CONNECTION) {
+        this.runtimeValue.environment = undefined;
+        this.runtimeValue.warehouse = undefined;
+      } else {
+        this.setConnection(undefined);
+      }
+    }
+  }
+
+  setConnection(val: PackageableConnection | undefined): void {
+    lakehouseRuntime_setConnection(this.runtimeValue, val);
+  }
+}
+
 export class RuntimeEditorState {
   /**
    * NOTE: used to force component remount on state change
@@ -1002,20 +1032,51 @@ export class RuntimeEditorState {
   ) {
     makeObservable(this, {
       runtimeValueEditorState: observable,
+      setRuntimeValueEditorState: action,
     });
 
     this.editorStore = editorStore;
     this.runtime = runtime;
     this.isEmbeddedRuntime = isEmbeddedRuntime;
-    const runtimeValue =
-      runtime instanceof RuntimePointer
-        ? runtime.packageableRuntime.value.runtimeValue
-        : guaranteeType(runtime, EngineRuntime);
-    this.runtimeValueEditorState =
-      runtimeValue instanceof LakehouseRuntime
-        ? new LakehouseRuntimeEditorState(this, runtimeValue)
+    this.runtimeValueEditorState = this.buildRuntimeValueEditorState(
+      this.resolveRuntimeValue(),
+    );
+  }
+
+  private resolveRuntimeValue(): EngineRuntime {
+    return this.runtime instanceof RuntimePointer
+      ? this.runtime.packageableRuntime.value.runtimeValue
+      : guaranteeType(this.runtime, EngineRuntime);
+  }
+
+  private buildRuntimeValueEditorState(
+    runtimeValue: EngineRuntime,
+  ): EngineRuntimeEditorState {
+    return runtimeValue instanceof LakehouseRuntime
+      ? new LakehouseRuntimeEditorState(this, runtimeValue)
+      : runtimeValue instanceof LakehouseSingleStoreRuntime
+        ? new LakehouseSingleStoreRuntimeEditorState(this, runtimeValue)
         : new EngineRuntimeEditorState(this, runtimeValue);
   }
+
+  /**
+   * Rebuilds the concrete runtime-value editor state after the underlying
+   * runtime's concrete type changes in place (e.g. Lakehouse compute-engine
+   * swap between `LakehouseRuntime` and `LakehouseSingleStoreRuntime`).
+   * Carries over already-fetched Lakehouse environment options so callers
+   * don't need to refetch (which requires an auth token round-trip).
+   */
+  setRuntimeValueEditorState(runtimeValue: EngineRuntime): void {
+    const previous = this.runtimeValueEditorState;
+    const next = this.buildRuntimeValueEditorState(runtimeValue);
+    if (
+      previous instanceof LakehouseBaseRuntimeEditorState &&
+      next instanceof LakehouseBaseRuntimeEditorState
+    ) {
+      next.setEnvSummaries(previous.availableEnvs);
+    }
+    this.runtimeValueEditorState = next;
+  }
 }
 
 export class PackageableRuntimeEditorState extends ElementEditorState {

package/src/stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.ts

@@ -49,7 +49,6 @@ import {
   type ExecutionResultWithMetadata,
   TDSExecutionResult,
   getColumn,
-  PrimitiveType,
   PRIMITIVE_TYPE,
   TDSRow,
   type Schema,
@@ -105,7 +104,7 @@ const buildTableToTDSQueryNonNumericWithColumnGrammar = (
   const db = table.schema._OWNER.path;
   const PREVIEW_COLUMN_NAME = 'Count Value';
   const columnGetter = getTDSColumnDerivedProperyFromType(
-    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING,
+    getPrimitiveTypeFromRelationalType(column.type),
   );
   return `|${db}->tableReference(
     '${schemaName}',
@@ -135,7 +134,7 @@ const buildTableToTDSQueryNumericWithColumnGrammar = (
   const schemaName = table.schema.name;
   const db = table.schema._OWNER.path;
   const columnGetter = getTDSColumnDerivedProperyFromType(
-    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING,
+    getPrimitiveTypeFromRelationalType(column.type),
   );
   return `|${db}->tableReference(
     '${schemaName}',
@@ -181,9 +180,10 @@ const buildTableToTDSQueryNumericWithColumnGrammar = (
   )`;
 };
 
-const buildTableToTDSQueryColumnQuery = (column: Column): [string, boolean] => {
-  const type =
-    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING;
+export const buildTableToTDSQueryColumnQuery = (
+  column: Column,
+): [string, boolean] => {
+  const type = getPrimitiveTypeFromRelationalType(column.type);
   const numerics = [
     PRIMITIVE_TYPE.NUMBER,
     PRIMITIVE_TYPE.INTEGER,

package/src/stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.ts

@@ -30,6 +30,7 @@ import {
   AccessPoint,
   AccessPointGroup,
   CodeCompletionResult,
+  CompilationError,
   DataElement,
   DataElementReference,
   DataProduct,
@@ -136,7 +137,18 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
   readonly editorStore: EditorStore;
   readonly val: LakehouseAccessPointState;
   lambdaRelationColumns: string[] | undefined;
+  /**
+   * The engine's error message for this access point's lambda, when the engine
+   * answered that it could not compute the lambda's relation type.
+   */
+  lambdaRelationTypeError: string | undefined;
   isUpdatingRelationColumns = false;
+  /**
+   * Hash of the lambda the engine last answered for, with either its relation
+   * columns or an error for this lambda. A failure that is not an answer for
+   * this lambda (network, whole-batch failure) must leave it unset, so the next
+   * update asks the engine again.
+   */
   lastComputedLambdaHash: string | undefined;
   lastComputedLambdaString: string | undefined;
 
@@ -149,8 +161,10 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
 
     makeObservable(this, {
       lambdaRelationColumns: observable,
+      lambdaRelationTypeError: observable,
       isUpdatingRelationColumns: observable,
       setLambdaRelationColumns: action,
+      setLambdaRelationTypeError: action,
       updateLambdaRelationColumns: flow,
     });
   }
@@ -159,6 +173,10 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
     this.lambdaRelationColumns = columns;
   }
 
+  setLambdaRelationTypeError(message: string | undefined): void {
+    this.lambdaRelationTypeError = message;
+  }
+
   setIsUpdatingRelationColumns(value: boolean): void {
     this.isUpdatingRelationColumns = value;
   }
@@ -174,6 +192,7 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
     }
 
     this.setIsUpdatingRelationColumns(true);
+    this.setLambdaRelationTypeError(undefined);
     try {
       const relationType =
         (yield this.editorStore.graphManagerState.graphManager.getLambdaRelationType(
@@ -183,10 +202,22 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
       this.setLambdaRelationColumns(
         relationType.columns.map((column) => column.name),
       );
-    } catch {
+      this.lastComputedLambdaHash = lambdaHash;
+    } catch (error) {
+      assertErrorThrown(error);
       this.setLambdaRelationColumns(undefined);
+      if (error instanceof CompilationError) {
+        // the engine compiled this lambda and answered with an error for it
+        this.setLambdaRelationTypeError(error.message);
+        this.lastComputedLambdaHash = lambdaHash;
+      } else {
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+          `Can't get relation type for access point '${this.val.accessPoint.id}'`,
+          error,
+        );
+      }
     } finally {
-      this.lastComputedLambdaHash = lambdaHash;
       this.setIsUpdatingRelationColumns(false);
     }
   }
@@ -363,7 +394,10 @@ export class LakehouseAccessPointState extends AccessPointState {
     const lambdaColumns = this.lambdaState.lambdaRelationColumns;
 
     if (lambdaColumns === undefined) {
-      return `Fix compiler errors and make sure AccessPoint ${this.accessPoint.id} returns a Relation type`;
+      const engineError = this.lambdaState.lambdaRelationTypeError;
+      return `Fix compiler errors and make sure AccessPoint ${this.accessPoint.id} returns a Relation type${
+        engineError ? `. Engine error: ${engineError}` : ''
+      }`;
     }
 
     return `Sample values columns must match: [${lambdaColumns.join(', ')}]`;
@@ -931,9 +965,10 @@ export class DataProductEditorState extends ElementEditorState {
     if (entries.length === 0) {
       return;
     }
-    entries.forEach((entry) =>
-      entry.apState.lambdaState.setIsUpdatingRelationColumns(true),
-    );
+    entries.forEach((entry) => {
+      entry.apState.lambdaState.setIsUpdatingRelationColumns(true);
+      entry.apState.lambdaState.setLambdaRelationTypeError(undefined);
+    });
     try {
       const lambdas = new Map<string, RawLambda>(
         entries.map((entry) => [
@@ -941,28 +976,51 @@ export class DataProductEditorState extends ElementEditorState {
           entry.apState.accessPoint.func,
         ]),
       );
-      const { results } =
+      const { results, errors } =
         (yield this.editorStore.graphManagerState.graphManager.getBatchLambdasRelationType(
           lambdas,
           this.editorStore.graphManagerState.graph,
         )) as BatchLambdasRelationTypeResult;
       entries.forEach((entry) => {
+        const lambdaState = entry.apState.lambdaState;
         const relationType = results.get(entry.apState.uuid);
-        entry.apState.lambdaState.setLambdaRelationColumns(
-          relationType
-            ? relationType.columns.map((column) => column.name)
-            : undefined,
-        );
+        const engineError = errors.get(entry.apState.uuid);
+        if (relationType) {
+          lambdaState.setLambdaRelationColumns(
+            relationType.columns.map((column) => column.name),
+          );
+          lambdaState.lastComputedLambdaHash = entry.hash;
+        } else if (engineError) {
+          // the engine answered with an error for this lambda
+          lambdaState.setLambdaRelationColumns(undefined);
+          lambdaState.setLambdaRelationTypeError(engineError.message);
+          lambdaState.lastComputedLambdaHash = entry.hash;
+        } else {
+          // the engine did not answer for this lambda: leave the hash unset so
+          // the next update asks again
+          lambdaState.setLambdaRelationColumns(undefined);
+          this.editorStore.applicationStore.logService.error(
+            LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+            `Engine returned neither a relation type nor an error for access point '${entry.apState.accessPoint.id}'`,
+          );
+        }
       });
-    } catch {
+    } catch (error) {
+      assertErrorThrown(error);
+      // the whole batch failed, so no access point got an answer: leave their
+      // hashes unset so the next update asks again
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+        `Can't get relation types for access points`,
+        error,
+      );
       entries.forEach((entry) =>
         entry.apState.lambdaState.setLambdaRelationColumns(undefined),
       );
     } finally {
-      entries.forEach((entry) => {
-        entry.apState.lambdaState.lastComputedLambdaHash = entry.hash;
-        entry.apState.lambdaState.setIsUpdatingRelationColumns(false);
-      });
+      entries.forEach((entry) =>
+        entry.apState.lambdaState.setIsUpdatingRelationColumns(false),
+      );
     }
   }
 

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,
@@ -1058,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/service/ServiceRegistrationState.ts

@@ -301,7 +301,8 @@ export class ServiceRegistrationState extends ServiceConfigState {
       { servicePath, envCount: this.registrationOptions.length },
     );
     const envs: string[] = [];
-    let errorCount = 0;
+    const failedEnvs: string[] = [];
+    let lastErrorMessage: string | undefined;
     const servicePattern = this.service.pattern.startsWith('/')
       ? this.service.pattern.substring(1)
       : this.service.pattern;
@@ -317,37 +318,49 @@ export class ServiceRegistrationState extends ServiceConfigState {
         }
       } catch (error) {
         assertErrorThrown(error);
-        errorCount += 1;
+        failedEnvs.push(envConfig.env);
+        lastErrorMessage = error.message;
         this.editorStore.applicationStore.logService.warn(
           LogEvent.create(
             LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_CHECK_FAILURE,
           ),
           `Can't check registration status for env '${envConfig.env}': ${error.message}`,
         );
-        LegendStudioTelemetryHelper.logEvent_ServiceRegistrationCheckFailure(
-          this.editorStore.applicationStore.telemetryService,
-          sourceInfo,
-          {
-            servicePath,
-            env: envConfig.env,
-            errorMessage: error.message,
-          },
-        );
       }
     }
     this.setRegisteredEnvs(envs);
     this.deploymentCheckState.complete();
-    LegendStudioTelemetryHelper.logEvent_ServiceRegistrationCheckSucceeded(
-      this.editorStore.applicationStore.telemetryService,
-      sourceInfo,
-      {
-        servicePath,
-        envCount: this.registrationOptions.length,
-        durationMs: Date.now() - startedAt,
-        registeredEnvCount: envs.length,
-        errorCount,
-      },
-    );
+    // 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> {
@@ -430,7 +443,12 @@ export class ServiceRegistrationState extends ServiceConfigState {
       LegendStudioTelemetryHelper.logEvent_ServiceRegistrationSucceeded(
         this.editorStore.applicationStore.telemetryService,
         this.editorStore.editorMode.getSourceInfo(),
-        { ...telemetryBase, durationMs: Date.now() - startedAt },
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startedAt,
+          registeredCount: 1,
+          failedCount: 0,
+        },
       );
     } catch (error) {
       assertErrorThrown(error);