@finos/legend-application-studio 28.21.45 → 28.21.47

package/lib/__lib__/LegendStudioTelemetryHelper.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { GRAPH_MANAGER_EVENT, } from '@finos/legend-graph';
+import { Availability, DataProduct, FunctionActivator, GRAPH_MANAGER_EVENT, IngestDefinition, Mapping, MultiExecutionServiceTestResult, PackageableElement, Service, TestError, TestExecuted, TestExecutionStatus, } from '@finos/legend-graph';
 import { APPLICATION_EVENT, } from '@finos/legend-application';
 import { LEGEND_STUDIO_APP_EVENT } from './LegendStudioEvent.js';
 export var SHOWCASE_MANAGER_ENTRY_POINT;
@@ -83,6 +83,323 @@ export var GRAPH_EDITOR_MODE_LABEL;
     GRAPH_EDITOR_MODE_LABEL["TEXT"] = "text";
     GRAPH_EDITOR_MODE_LABEL["STRICT_TEXT"] = "strict-text";
 })(GRAPH_EDITOR_MODE_LABEL || (GRAPH_EDITOR_MODE_LABEL = {}));
+export var FORM_MODE_COMPILATION_ERROR_KIND;
+(function (FORM_MODE_COMPILATION_ERROR_KIND) {
+    FORM_MODE_COMPILATION_ERROR_KIND["COMPILATION"] = "compilation";
+    FORM_MODE_COMPILATION_ERROR_KIND["ENGINE"] = "engine";
+    /** Non-engine error (e.g. network) surfaced while compiling. */
+    FORM_MODE_COMPILATION_ERROR_KIND["OTHER"] = "other";
+})(FORM_MODE_COMPILATION_ERROR_KIND || (FORM_MODE_COMPILATION_ERROR_KIND = {}));
+export var GRAPH_INITIALIZATION_ERROR_KIND;
+(function (GRAPH_INITIALIZATION_ERROR_KIND) {
+    GRAPH_INITIALIZATION_ERROR_KIND["DEPENDENCY"] = "dependency";
+    GRAPH_INITIALIZATION_ERROR_KIND["DESERIALIZATION"] = "deserialization";
+    GRAPH_INITIALIZATION_ERROR_KIND["NETWORK"] = "network";
+    GRAPH_INITIALIZATION_ERROR_KIND["OTHER"] = "other";
+})(GRAPH_INITIALIZATION_ERROR_KIND || (GRAPH_INITIALIZATION_ERROR_KIND = {}));
+export var SERVICE_REGISTRATION_TRIGGER;
+(function (SERVICE_REGISTRATION_TRIGGER) {
+    SERVICE_REGISTRATION_TRIGGER["SINGLE"] = "single";
+    SERVICE_REGISTRATION_TRIGGER["BULK"] = "bulk";
+    SERVICE_REGISTRATION_TRIGGER["SERVICE_QUERY_EDITOR"] = "service-query-editor";
+})(SERVICE_REGISTRATION_TRIGGER || (SERVICE_REGISTRATION_TRIGGER = {}));
+/**
+ * Discriminates the entry-point of `editor.generation.*` events.
+ * - `global`: sidebar "Generate" action, spans the whole project's generation spec
+ *   (models + artifacts).
+ * - `element-schema`: per-element external-format schema regeneration from an
+ *   element editor's "Generate" button.
+ */
+export var GENERATION_MODE;
+(function (GENERATION_MODE) {
+    GENERATION_MODE["GLOBAL"] = "global";
+    GENERATION_MODE["ELEMENT_SCHEMA"] = "element-schema";
+})(GENERATION_MODE || (GENERATION_MODE = {}));
+/**
+ * High-level bucket for a Studio tab so dashboards can slice tab activity
+ * across element editors vs. sidecar tabs (diff viewers, artifact viewers,
+ * model importer, etc.) without depending on the element metamodel.
+ */
+export var EDITOR_TAB_KIND;
+(function (EDITOR_TAB_KIND) {
+    EDITOR_TAB_KIND["ELEMENT"] = "element";
+    EDITOR_TAB_KIND["ENTITY_DIFF"] = "entity-diff";
+    EDITOR_TAB_KIND["ARTIFACT_GENERATION"] = "artifact-generation";
+    EDITOR_TAB_KIND["MODEL_IMPORTER"] = "model-importer";
+    EDITOR_TAB_KIND["PROJECT_CONFIGURATION"] = "project-configuration";
+    EDITOR_TAB_KIND["END_TO_END_WORKFLOW"] = "end-to-end-workflow";
+    EDITOR_TAB_KIND["OTHER"] = "other";
+})(EDITOR_TAB_KIND || (EDITOR_TAB_KIND = {}));
+export var EDITOR_TAB_OPEN_TRIGGER;
+(function (EDITOR_TAB_OPEN_TRIGGER) {
+    /** Default when the caller did not surface intent. */
+    EDITOR_TAB_OPEN_TRIGGER["PROGRAMMATIC"] = "programmatic";
+    /** Tab was recreated after graph rebuild via cachedTabs recovery. */
+    EDITOR_TAB_OPEN_TRIGGER["RESTORE"] = "restore";
+})(EDITOR_TAB_OPEN_TRIGGER || (EDITOR_TAB_OPEN_TRIGGER = {}));
+export var EDITOR_TAB_CLOSE_TRIGGER;
+(function (EDITOR_TAB_CLOSE_TRIGGER) {
+    /** User clicked the "x" on the tab, or middle-clicked the tab strip. */
+    EDITOR_TAB_CLOSE_TRIGGER["USER_CLOSE"] = "user-close";
+    /** User invoked "Close Others" from the tab context menu. */
+    EDITOR_TAB_CLOSE_TRIGGER["CLOSE_OTHERS"] = "close-others";
+    /** User invoked "Close All" from the tab context menu. */
+    EDITOR_TAB_CLOSE_TRIGGER["CLOSE_ALL"] = "close-all";
+    /** Tabs were flushed as part of a graph rebuild (cacheAndClose). */
+    EDITOR_TAB_CLOSE_TRIGGER["NAVIGATE_AWAY"] = "navigate-away";
+    /** Programmatic close from a store method. */
+    EDITOR_TAB_CLOSE_TRIGGER["PROGRAMMATIC"] = "programmatic";
+})(EDITOR_TAB_CLOSE_TRIGGER || (EDITOR_TAB_CLOSE_TRIGGER = {}));
+export var WORKFLOW_MANAGER_SCOPE;
+(function (WORKFLOW_MANAGER_SCOPE) {
+    WORKFLOW_MANAGER_SCOPE["WORKSPACE"] = "workspace";
+    WORKFLOW_MANAGER_SCOPE["PROJECT"] = "project";
+    WORKFLOW_MANAGER_SCOPE["PROJECT_VERSION"] = "project-version";
+})(WORKFLOW_MANAGER_SCOPE || (WORKFLOW_MANAGER_SCOPE = {}));
+export var WORKFLOW_MANAGER_JOB_ACTION;
+(function (WORKFLOW_MANAGER_JOB_ACTION) {
+    WORKFLOW_MANAGER_JOB_ACTION["RETRY"] = "retry";
+    WORKFLOW_MANAGER_JOB_ACTION["CANCEL"] = "cancel";
+    WORKFLOW_MANAGER_JOB_ACTION["RUN_MANUAL"] = "run-manual";
+})(WORKFLOW_MANAGER_JOB_ACTION || (WORKFLOW_MANAGER_JOB_ACTION = {}));
+/**
+ * SDLC review actions. `create` only fires from the author side;
+ * `approve` / `reopen` fire only from the reviewer side; `commit` and
+ * `close` fire from both.
+ */
+export var SDLC_REVIEW_ACTION;
+(function (SDLC_REVIEW_ACTION) {
+    SDLC_REVIEW_ACTION["CREATE"] = "create";
+    SDLC_REVIEW_ACTION["COMMIT"] = "commit";
+    SDLC_REVIEW_ACTION["CLOSE"] = "close";
+    SDLC_REVIEW_ACTION["REOPEN"] = "reopen";
+    SDLC_REVIEW_ACTION["APPROVE"] = "approve";
+})(SDLC_REVIEW_ACTION || (SDLC_REVIEW_ACTION = {}));
+/**
+ * Which side of the review the event fires from — the workspace author
+ * committing/closing their own review, or a reviewer approving / committing
+ * / reopening / closing someone else's review.
+ */
+export var SDLC_REVIEW_ROLE;
+(function (SDLC_REVIEW_ROLE) {
+    SDLC_REVIEW_ROLE["AUTHOR"] = "author";
+    SDLC_REVIEW_ROLE["REVIEWER"] = "reviewer";
+})(SDLC_REVIEW_ROLE || (SDLC_REVIEW_ROLE = {}));
+/**
+ * Workspace setup screen actions — user-triggered writes from the setup /
+ * project picker route. Structured replacement for the
+ * WORKSPACE_SETUP_FAILURE bucket plus previously-unlogged create-project
+ * and import-project flows.
+ */
+export var SETUP_ACTION;
+(function (SETUP_ACTION) {
+    SETUP_ACTION["CREATE_SANDBOX_PROJECT"] = "create-sandbox-project";
+    SETUP_ACTION["CREATE_PROJECT"] = "create-project";
+    SETUP_ACTION["IMPORT_PROJECT"] = "import-project";
+    SETUP_ACTION["CREATE_WORKSPACE"] = "create-workspace";
+})(SETUP_ACTION || (SETUP_ACTION = {}));
+/**
+ * Project configuration editor actions — user-triggered writes from the
+ * project configuration editor. Structured replacement for the
+ * SDLC_MANAGER_FAILURE bucket around config updates.
+ *
+ * The three actions map to the three top-level editor buttons; they all
+ * funnel through the same `updateProjectConfiguration` SDLC call, and the
+ * `action` field records which entry point the user came from.
+ */
+export var PROJECT_CONFIG_UPDATE_ACTION;
+(function (PROJECT_CONFIG_UPDATE_ACTION) {
+    // "Update" button on the config editor: dependency add/remove, platform
+    // configurations, run-dependency-tests toggle.
+    PROJECT_CONFIG_UPDATE_ACTION["UPDATE_CONFIGS"] = "update-configs";
+    // "Upgrade to latest project structure" button.
+    PROJECT_CONFIG_UPDATE_ACTION["UPDATE_TO_LATEST_STRUCTURE"] = "update-to-latest-structure";
+    // "Change project type" (managed / embedded) toggle.
+    PROJECT_CONFIG_UPDATE_ACTION["CHANGE_PROJECT_TYPE"] = "change-project-type";
+})(PROJECT_CONFIG_UPDATE_ACTION || (PROJECT_CONFIG_UPDATE_ACTION = {}));
+/**
+ * Project overview sidebar SDLC writes — user-triggered actions from the
+ * project overview panel. Structured replacement for the
+ * SDLC_MANAGER_FAILURE bucket around ProjectOverviewState.
+ */
+export var PROJECT_OVERVIEW_ACTION;
+(function (PROJECT_OVERVIEW_ACTION) {
+    // Delete another workspace from the overview list.
+    PROJECT_OVERVIEW_ACTION["DELETE_WORKSPACE"] = "delete-workspace";
+    // Edit project name / description / tags.
+    PROJECT_OVERVIEW_ACTION["UPDATE_PROJECT"] = "update-project";
+    // Cut a new release version (major / minor / patch semver).
+    PROJECT_OVERVIEW_ACTION["CREATE_VERSION"] = "create-version";
+    // Close out a patch branch and release it as a version.
+    PROJECT_OVERVIEW_ACTION["RELEASE_PATCH"] = "release-patch";
+    // Open a new patch branch (also creates the initial workspace on it).
+    PROJECT_OVERVIEW_ACTION["CREATE_PATCH"] = "create-patch";
+})(PROJECT_OVERVIEW_ACTION || (PROJECT_OVERVIEW_ACTION = {}));
+export var SERVICE_TEST_SUITE_RUN_MODE;
+(function (SERVICE_TEST_SUITE_RUN_MODE) {
+    SERVICE_TEST_SUITE_RUN_MODE["RUN_SUITE"] = "run-suite";
+    SERVICE_TEST_SUITE_RUN_MODE["RUN_FAILING"] = "run-failing";
+})(SERVICE_TEST_SUITE_RUN_MODE || (SERVICE_TEST_SUITE_RUN_MODE = {}));
+/**
+ * Categorises the element behind a `Testable` for the unified TESTABLE_RUN
+ * telemetry so downstream analytics can slice per element kind without
+ * relying on the element path.
+ */
+export var TESTABLE_KIND;
+(function (TESTABLE_KIND) {
+    TESTABLE_KIND["MAPPING"] = "mapping";
+    TESTABLE_KIND["DATA_PRODUCT"] = "data-product";
+    TESTABLE_KIND["INGEST"] = "ingest";
+    TESTABLE_KIND["FUNCTION_ACTIVATOR"] = "function-activator";
+    TESTABLE_KIND["AVAILABILITY"] = "availability";
+    TESTABLE_KIND["SERVICE"] = "service";
+    TESTABLE_KIND["OTHER"] = "other";
+})(TESTABLE_KIND || (TESTABLE_KIND = {}));
+/**
+ * Which kind of run was invoked from the testable editors. This mirrors the
+ * distinct UI actions surfaced to the user (run suite, run failing tests,
+ * run entire testable, run all failing suites).
+ */
+export var TESTABLE_RUN_MODE;
+(function (TESTABLE_RUN_MODE) {
+    TESTABLE_RUN_MODE["RUN_SUITE"] = "run-suite";
+    TESTABLE_RUN_MODE["RUN_FAILING"] = "run-failing";
+    TESTABLE_RUN_MODE["RUN_TESTABLE"] = "run-testable";
+    TESTABLE_RUN_MODE["RUN_ALL_FAILING"] = "run-all-failing";
+    TESTABLE_RUN_MODE["RUN_TEST"] = "run-test";
+})(TESTABLE_RUN_MODE || (TESTABLE_RUN_MODE = {}));
+/**
+ * Resolves the {@link TESTABLE_KIND} label for a testable element instance.
+ * Falls back to `OTHER` so telemetry never blocks on an unknown subtype.
+ */
+export const getTestableKind = (testable) => {
+    if (testable instanceof Service) {
+        return TESTABLE_KIND.SERVICE;
+    }
+    if (testable instanceof Mapping) {
+        return TESTABLE_KIND.MAPPING;
+    }
+    if (testable instanceof DataProduct) {
+        return TESTABLE_KIND.DATA_PRODUCT;
+    }
+    if (testable instanceof IngestDefinition) {
+        return TESTABLE_KIND.INGEST;
+    }
+    if (testable instanceof FunctionActivator) {
+        return TESTABLE_KIND.FUNCTION_ACTIVATOR;
+    }
+    if (testable instanceof Availability) {
+        return TESTABLE_KIND.AVAILABILITY;
+    }
+    return TESTABLE_KIND.OTHER;
+};
+/**
+ * Reads `.path` from a testable, which all real packageable-element testables
+ * expose. Returns an empty string if unavailable to keep telemetry non-fatal.
+ */
+export const getTestablePath = (testable) => testable instanceof PackageableElement ? testable.path : '';
+/**
+ * Bucketises test results into passed/failed/errored counts for the unified
+ * TESTABLE_RUN__SUCCESS payload. Handles {@link MultiExecutionServiceTestResult}
+ * by tallying each key-indexed sub-result so service multi-execution runs count
+ * every execution rather than the wrapper.
+ */
+export const summarizeTestResults = (results) => {
+    let passedCount = 0;
+    let failedCount = 0;
+    let erroredCount = 0;
+    const tally = (result) => {
+        if (result instanceof TestError) {
+            erroredCount += 1;
+        }
+        else if (result instanceof TestExecuted) {
+            if (result.testExecutionStatus === TestExecutionStatus.PASS) {
+                passedCount += 1;
+            }
+            else {
+                failedCount += 1;
+            }
+        }
+    };
+    for (const result of results) {
+        if (result instanceof MultiExecutionServiceTestResult) {
+            result.keyIndexedTestResults.forEach(tally);
+        }
+        else {
+            tally(result);
+        }
+    }
+    return { passedCount, failedCount, erroredCount };
+};
+/**
+ * Scope of a global test runner invocation from the sidebar.
+ */
+export var GLOBAL_TEST_RUN_SCOPE;
+(function (GLOBAL_TEST_RUN_SCOPE) {
+    GLOBAL_TEST_RUN_SCOPE["ALL"] = "all";
+    GLOBAL_TEST_RUN_SCOPE["DEPENDENCIES"] = "dependencies";
+})(GLOBAL_TEST_RUN_SCOPE || (GLOBAL_TEST_RUN_SCOPE = {}));
+/**
+ * Which editor surface a LegendAI suggestion was requested from.
+ */
+export var LEGENDAI_SUGGEST_SURFACE;
+(function (LEGENDAI_SUGGEST_SURFACE) {
+    LEGENDAI_SUGGEST_SURFACE["SERVICE"] = "service";
+    LEGENDAI_SUGGEST_SURFACE["DATASPACE"] = "dataspace";
+    LEGENDAI_SUGGEST_SURFACE["DATA_PRODUCT"] = "data-product";
+})(LEGENDAI_SUGGEST_SURFACE || (LEGENDAI_SUGGEST_SURFACE = {}));
+/**
+ * Which step of a suggestion request failed: serializing the model to grammar
+ * (done locally by the graph manager) or the LegendAI request itself.
+ */
+export var LEGENDAI_SUGGEST_STAGE;
+(function (LEGENDAI_SUGGEST_STAGE) {
+    LEGENDAI_SUGGEST_STAGE["SERIALIZE"] = "serialize";
+    LEGENDAI_SUGGEST_STAGE["REQUEST"] = "request";
+})(LEGENDAI_SUGGEST_STAGE || (LEGENDAI_SUGGEST_STAGE = {}));
+export var LEGENDAI_SUGGEST_ERROR_KIND;
+(function (LEGENDAI_SUGGEST_ERROR_KIND) {
+    /** Grammar serialization failed before LegendAI was called. */
+    LEGENDAI_SUGGEST_ERROR_KIND["SERIALIZATION"] = "serialization";
+    /** HTTP 401 / 403 — the user lacks LegendAI entitlements. */
+    LEGENDAI_SUGGEST_ERROR_KIND["ENTITLEMENT"] = "entitlement";
+    /** Any other HTTP 4xx. */
+    LEGENDAI_SUGGEST_ERROR_KIND["CLIENT"] = "client";
+    /** HTTP 5xx. */
+    LEGENDAI_SUGGEST_ERROR_KIND["SERVER"] = "server";
+    /** LegendAI answered but the suggestion was empty, so nothing was shown. */
+    LEGENDAI_SUGGEST_ERROR_KIND["EMPTY_RESPONSE"] = "empty-response";
+    LEGENDAI_SUGGEST_ERROR_KIND["OTHER"] = "other";
+})(LEGENDAI_SUGGEST_ERROR_KIND || (LEGENDAI_SUGGEST_ERROR_KIND = {}));
+/**
+ * What the user was looking at when they left the editor without applying or
+ * dismissing: a request still in flight, or a suggestion already on screen.
+ */
+export var LEGENDAI_SUGGEST_ABANDON_PHASE;
+(function (LEGENDAI_SUGGEST_ABANDON_PHASE) {
+    LEGENDAI_SUGGEST_ABANDON_PHASE["PENDING"] = "pending";
+    LEGENDAI_SUGGEST_ABANDON_PHASE["SHOWN"] = "shown";
+})(LEGENDAI_SUGGEST_ABANDON_PHASE || (LEGENDAI_SUGGEST_ABANDON_PHASE = {}));
+/**
+ * State of an applied suggestion's text at the time the element was pushed.
+ */
+export var LEGENDAI_SUGGEST_RETENTION;
+(function (LEGENDAI_SUGGEST_RETENTION) {
+    LEGENDAI_SUGGEST_RETENTION["UNCHANGED"] = "unchanged";
+    LEGENDAI_SUGGEST_RETENTION["EDITED"] = "edited";
+    LEGENDAI_SUGGEST_RETENTION["CLEARED"] = "cleared";
+    LEGENDAI_SUGGEST_RETENTION["ELEMENT_REMOVED"] = "element-removed";
+})(LEGENDAI_SUGGEST_RETENTION || (LEGENDAI_SUGGEST_RETENTION = {}));
+/**
+ * Data product only: how the suggested access point group metadata was matched
+ * to the group the user applied it on.
+ */
+export var LEGENDAI_SUGGEST_MATCH_STRATEGY;
+(function (LEGENDAI_SUGGEST_MATCH_STRATEGY) {
+    LEGENDAI_SUGGEST_MATCH_STRATEGY["NAME"] = "name";
+    LEGENDAI_SUGGEST_MATCH_STRATEGY["INDEX"] = "index";
+    LEGENDAI_SUGGEST_MATCH_STRATEGY["NONE"] = "none";
+})(LEGENDAI_SUGGEST_MATCH_STRATEGY || (LEGENDAI_SUGGEST_MATCH_STRATEGY = {}));
 export class LegendStudioTelemetryHelper {
     static logEvent_GraphCompilationLaunched(service, sourceInfo) {
         service.logEvent(LEGEND_STUDIO_APP_EVENT.COMPILE_GRAPH__LAUNCH, {
@@ -123,6 +440,93 @@ export class LegendStudioTelemetryHelper {
             sourceInfo,
         });
     }
+    static logEvent_GraphInitializationLaunched(service, sourceInfo) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.INITIALIZE_GRAPH__LAUNCH, {
+            sourceInfo,
+        });
+    }
+    static logEvent_GraphInitializationFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.INITIALIZE_GRAPH__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_GraphCompilationFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.FORM_MODE_COMPILATION__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_TestDataGenerationFailure(service, sourceInfo, errorMessage) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.TEST_DATA_GENERATION__FAILURE, {
+            sourceInfo,
+            errorMessage,
+        });
+    }
+    // Service registration
+    static logEvent_ServiceRegistrationLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ServiceRegistrationSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ServiceRegistrationFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Service registration precheck ("is this service already deployed?" probed
+    // against every configured env). One launch and exactly one terminal event
+    // (success / failure) per precheck run; per-env errors are aggregated into
+    // `errorCount` / `failedEnvs` rather than emitted individually.
+    static logEvent_ServiceRegistrationCheckLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_CHECK_LAUNCH, { sourceInfo, ...data });
+    }
+    static logEvent_ServiceRegistrationCheckSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_CHECK_SUCCESS, { sourceInfo, ...data });
+    }
+    static logEvent_ServiceRegistrationCheckFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_CHECK_FAILURE, { sourceInfo, ...data });
+    }
+    // Model / artifact / element-schema generation
+    static logEvent_GenerationLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.GENERATION_LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_GenerationSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.GENERATION_SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_GenerationFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Editor tab lifecycle
+    static logEvent_EditorTabOpened(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.EDITOR_TAB__OPEN, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_EditorTabClosed(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.EDITOR_TAB__CLOSE, {
+            sourceInfo,
+            ...data,
+        });
+    }
     // showcase manager
     static logEvent_ShowcaseManagerLaunch(service, data) {
         service.logEvent(LEGEND_STUDIO_APP_EVENT.SHOWCASE_MANAGER_LAUNCH, data);
@@ -211,6 +615,55 @@ export class LegendStudioTelemetryHelper {
     static logEvent_DataProductLegendAISuggestFailure(telemetryService, dataProductPath, errorMessage, sourceInfo) {
         telemetryService.logEvent(LEGEND_STUDIO_APP_EVENT.DATA_PRODUCT_LEGENDAI_SUGGEST__FAILURE, { dataProductPath, errorMessage, sourceInfo });
     }
+    // Unified LegendAI suggest (service / dataspace / data product)
+    static logEvent_LegendAISuggestExposure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__EXPOSURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestApplied(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__APPLY, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestDiscarded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__DISCARD, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestAbandoned(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__ABANDON, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_LegendAISuggestPersisted(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__PERSISTED, {
+            sourceInfo,
+            ...data,
+        });
+    }
     // Push to Dev Metadata
     static logEvent_DevMetadataPushLaunched(service, sourceInfo, groupId, artifactId, versionId, lakehouseElementCounts) {
         service.logEvent(LEGEND_STUDIO_APP_EVENT.METADATA_PUSH_TO_METADATA__LAUNCH, {
@@ -321,5 +774,260 @@ export class LegendStudioTelemetryHelper {
             ...data,
         });
     }
+    // Workflow manager
+    static logEvent_WorkflowManagerPanelOpened(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_PANEL__OPEN, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_WorkflowManagerPanelClosed(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_PANEL__CLOSE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_WorkflowManagerFetchWorkflowsLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_FETCH_WORKFLOWS__LAUNCH, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerFetchWorkflowsSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_FETCH_WORKFLOWS__SUCCESS, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerFetchWorkflowsFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_FETCH_WORKFLOWS__FAILURE, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerWorkflowExpand(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_WORKFLOW__EXPAND, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerWorkflowRefresh(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_WORKFLOW__REFRESH, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerFetchJobsLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_FETCH_JOBS__LAUNCH, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerFetchJobsSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_FETCH_JOBS__SUCCESS, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerFetchJobsFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_FETCH_JOBS__FAILURE, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerJobActionLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_ACTION__LAUNCH, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerJobActionSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_ACTION__SUCCESS, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerJobActionFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_ACTION__FAILURE, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerJobLogsOpened(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_LOGS__OPEN, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_WorkflowManagerJobLogsClosed(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_LOGS__CLOSE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_WorkflowManagerJobLogsRefresh(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_LOGS__REFRESH, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerJobLogsFetchSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_LOGS_FETCH__SUCCESS, { sourceInfo, ...data });
+    }
+    static logEvent_WorkflowManagerJobLogsFetchFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.WORKFLOW_MANAGER_JOB_LOGS_FETCH__FAILURE, { sourceInfo, ...data });
+    }
+    // Service test suite run
+    static logEvent_ServiceTestSuiteRunLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_TEST_SUITE_RUN__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ServiceTestSuiteRunSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_TEST_SUITE_RUN__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ServiceTestSuiteRunFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_TEST_SUITE_RUN__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Unified testable run (mapping / data product / ingest / function activator / availability)
+    static logEvent_TestableRunLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.TESTABLE_RUN__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_TestableRunSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.TESTABLE_RUN__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_TestableRunFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.TESTABLE_RUN__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Global test runner (sidebar) — cross-testable runs
+    static logEvent_GlobalTestRunLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.GLOBAL_TEST_RUN__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_GlobalTestRunSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.GLOBAL_TEST_RUN__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_GlobalTestRunFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.GLOBAL_TEST_RUN__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // SDLC review lifecycle
+    //
+    // Structured replacement for the SDLC_MANAGER_FAILURE bucket around review
+    // actions (create / commit / close / reopen / approve). Fires from both the
+    // author side (WorkspaceReviewState — carries sourceInfo from the workspace
+    // editor) and the reviewer side (ProjectReviewerStore — no editor mode, so
+    // sourceInfo is undefined; projectId / patchReleaseVersionId? / reviewId
+    // are carried explicitly on the payload).
+    //
+    // Non-lifecycle SDLC calls in the same files (fetches, refresh, workspace
+    // recreation after commit) stay on the generic SDLC_MANAGER_FAILURE bucket.
+    static logEvent_SdlcReviewActionLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SDLC_REVIEW_ACTION__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_SdlcReviewActionSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SDLC_REVIEW_ACTION__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_SdlcReviewActionFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SDLC_REVIEW_ACTION__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Workspace setup screen actions
+    //
+    // Structured replacement for the WORKSPACE_SETUP_FAILURE bucket plus the
+    // create-project / import-project flows that previously emitted no
+    // telemetry at all. Fires from the setup / project picker route, before
+    // any editor mode is active — so `sourceInfo` is always undefined.
+    static logEvent_SetupActionLaunched(service, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SETUP_ACTION__LAUNCH, {
+            sourceInfo: undefined,
+            ...data,
+        });
+    }
+    static logEvent_SetupActionSucceeded(service, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SETUP_ACTION__SUCCESS, {
+            sourceInfo: undefined,
+            ...data,
+        });
+    }
+    static logEvent_SetupActionFailure(service, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SETUP_ACTION__FAILURE, {
+            sourceInfo: undefined,
+            ...data,
+        });
+    }
+    // Project configuration update lifecycle
+    //
+    // Structured replacement for the SDLC_MANAGER_FAILURE bucket around the
+    // project configuration editor's writes (dependency add/remove, platform
+    // configuration, structure version bump, project type toggle). All three
+    // top-level flows funnel through `updateProjectConfiguration`, which is
+    // the single point where these events are emitted; the `action` field
+    // records which entry point the user came from.
+    static logEvent_ProjectConfigUpdateLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.PROJECT_CONFIG_UPDATE__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ProjectConfigUpdateSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.PROJECT_CONFIG_UPDATE__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ProjectConfigUpdateFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.PROJECT_CONFIG_UPDATE__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Project overview sidebar SDLC writes
+    //
+    // Structured replacement for the SDLC_MANAGER_FAILURE bucket around
+    // ProjectOverviewState's user-triggered writes (delete workspace, update
+    // project metadata, create version, release patch, create patch). Fires
+    // from inside the workspace editor so `sourceInfo` is populated; the
+    // payload also carries `projectId` explicitly so events remain sliceable
+    // without unpacking `sourceInfo`.
+    static logEvent_ProjectOverviewActionLaunched(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.PROJECT_OVERVIEW_ACTION__LAUNCH, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ProjectOverviewActionSucceeded(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.PROJECT_OVERVIEW_ACTION__SUCCESS, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    static logEvent_ProjectOverviewActionFailure(service, sourceInfo, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.PROJECT_OVERVIEW_ACTION__FAILURE, {
+            sourceInfo,
+            ...data,
+        });
+    }
+    // Ad-hoc workspace creation from the editor bootstrap
+    //
+    // Fires when a user deep-links to a workspace that doesn't exist and
+    // picks "Create workspace" from the recovery prompt in EditorStore.
+    // Distinct bucket from SETUP_ACTION.CREATE_WORKSPACE because the
+    // callsite, error-handling, and legacy log bucket
+    // (WORKSPACE_SETUP_FAILURE) are different. `sourceInfo` is omitted —
+    // no editor mode is active yet.
+    static logEvent_SdlcWorkspaceCreateLaunched(service, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SDLC_WORKSPACE_CREATE__LAUNCH, {
+            sourceInfo: undefined,
+            ...data,
+        });
+    }
+    static logEvent_SdlcWorkspaceCreateSucceeded(service, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SDLC_WORKSPACE_CREATE__SUCCESS, {
+            sourceInfo: undefined,
+            ...data,
+        });
+    }
+    static logEvent_SdlcWorkspaceCreateFailure(service, data) {
+        service.logEvent(LEGEND_STUDIO_APP_EVENT.SDLC_WORKSPACE_CREATE__FAILURE, {
+            sourceInfo: undefined,
+            ...data,
+        });
+    }
 }
 //# sourceMappingURL=LegendStudioTelemetryHelper.js.map