@finos/legend-application-data-cube 0.3.11 → 0.3.13

package/src/stores/LegendDataCubeBaseStore.ts

@@ -17,6 +17,7 @@
 import {
   APPLICATION_EVENT,
   DEFAULT_TAB_SIZE,
+  LegendApplicationTelemetryHelper,
   type ApplicationStore,
 } from '@finos/legend-application';
 import type { LegendDataCubePluginManager } from '../application/LegendDataCubePluginManager.js';
@@ -211,6 +212,10 @@ export class LegendDataCubeBaseStore {
         },
       );
       this.initializeState.pass();
+      LegendApplicationTelemetryHelper.logEvent_ApplicationInitializationSucceeded(
+        this.application.telemetryService,
+        this.application,
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.application.logService.error(

package/src/stores/LegendDataCubeDataCubeEngine.ts

@@ -112,6 +112,7 @@ import {
   LogEvent,
   UnsupportedOperationError,
   type PlainObject,
+  type StopWatch,
   assertErrorThrown,
   NetworkClientError,
   HttpStatus,
@@ -120,6 +121,7 @@ import {
   guaranteeType,
   guaranteeNonNullable,
   filterByType,
+  type TimingsRecord,
 } from '@finos/legend-shared';
 import type { LegendDataCubeApplicationStore } from './LegendDataCubeBaseStore.js';
 import { LegendDataCubeDuckDBEngine } from './LegendDataCubeDuckDBEngine.js';
@@ -173,6 +175,191 @@ export class LegendDataCubeDataCubeEngine extends DataCubeEngine {
 
   // ---------------------------------- IMPLEMENTATION ----------------------------------
 
+  override getDataFromSource(source?: DataCubeSource): PlainObject {
+    if (source instanceof LegendQueryDataCubeSource) {
+      const queryInfo = source.info;
+      return {
+        project: {
+          groupId: queryInfo.groupId,
+          artifactId: queryInfo.artifactId,
+          versionId: queryInfo.versionId,
+        },
+        query: {
+          id: queryInfo.id,
+          name: queryInfo.name,
+        },
+        sourceType: LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE,
+      };
+    } else if (source instanceof UserDefinedFunctionDataCubeSource) {
+      const deserializedModel = V1_deserializePureModelContext(source.model);
+
+      const sdlcInfo =
+        deserializedModel instanceof V1_PureModelContextPointer &&
+        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
+          ? deserializedModel.sdlcInfo
+          : undefined;
+      return {
+        project:
+          sdlcInfo !== undefined
+            ? {
+                groupId: sdlcInfo.groupId,
+                artifactId: sdlcInfo.artifactId,
+                versionId: sdlcInfo.version,
+              }
+            : undefined,
+        function: {
+          path: source.functionPath,
+          runtime: source.runtime,
+        },
+        sourceType: ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE,
+      };
+    } else if (source instanceof LocalFileDataCubeSource) {
+      const deserializedModel = V1_deserializePureModelContext(source.model);
+
+      const sdlcInfo =
+        deserializedModel instanceof V1_PureModelContextPointer &&
+        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
+          ? deserializedModel.sdlcInfo
+          : undefined;
+      return {
+        project:
+          sdlcInfo !== undefined
+            ? {
+                groupId: sdlcInfo.groupId,
+                artifactId: sdlcInfo.artifactId,
+                versionId: sdlcInfo.version,
+              }
+            : undefined,
+        file: {
+          name: source.fileName,
+          format: source.fileFormat,
+          runtime: source.runtime,
+          db: source.db,
+          schema: source.schema,
+          table: source.table,
+        },
+        sourceType: LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE,
+      };
+    } else if (source instanceof AdhocQueryDataCubeSource) {
+      const deserializedModel = V1_deserializePureModelContext(source.model);
+
+      const sdlcInfo =
+        deserializedModel instanceof V1_PureModelContextPointer &&
+        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
+          ? deserializedModel.sdlcInfo
+          : undefined;
+
+      return {
+        project:
+          sdlcInfo !== undefined
+            ? {
+                groupId: sdlcInfo.groupId,
+                artifactId: sdlcInfo.artifactId,
+                versionId: sdlcInfo.version,
+              }
+            : undefined,
+        adhocQuery: {
+          mapping: source.mapping,
+          runtime: source.runtime,
+        },
+        sourceType: ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE,
+      };
+    }
+    return {};
+  }
+
+  getDataFromRawSource(source?: PlainObject): PlainObject {
+    if (!source) {
+      return {};
+    }
+
+    if (source._type === LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE) {
+      const rawSource =
+        RawLegendQueryDataCubeSource.serialization.fromJson(source);
+
+      return {
+        query: {
+          id: rawSource.queryId,
+        },
+        sourceType: source._type,
+      };
+    } else if (source._type === ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE) {
+      const rawSource =
+        RawUserDefinedFunctionDataCubeSource.serialization.fromJson(source);
+      const deserializedModel = V1_deserializePureModelContext(rawSource.model);
+
+      const sdlcInfo =
+        deserializedModel instanceof V1_PureModelContextPointer &&
+        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
+          ? deserializedModel.sdlcInfo
+          : undefined;
+
+      return {
+        project:
+          sdlcInfo !== undefined
+            ? {
+                groupId: sdlcInfo.groupId,
+                artifactId: sdlcInfo.artifactId,
+                versionId: sdlcInfo.version,
+              }
+            : undefined,
+        function: {
+          path: rawSource.functionPath,
+          runtime: rawSource.runtime,
+        },
+        sourceType: source._type,
+      };
+    } else if (source._type === LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE) {
+      const rawSource =
+        RawLocalFileQueryDataCubeSource.serialization.fromJson(source);
+
+      return {
+        file: {
+          name: rawSource.fileName,
+          format: rawSource.fileFormat,
+        },
+        sourceType: source._type,
+      };
+    } else if (source._type === ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE) {
+      const rawSource =
+        RawAdhocQueryDataCubeSource.serialization.fromJson(source);
+      const deserializedModel = V1_deserializePureModelContext(rawSource.model);
+
+      const sdlcInfo =
+        deserializedModel instanceof V1_PureModelContextPointer &&
+        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
+          ? deserializedModel.sdlcInfo
+          : undefined;
+
+      return {
+        project:
+          sdlcInfo !== undefined
+            ? {
+                groupId: sdlcInfo.groupId,
+                artifactId: sdlcInfo.artifactId,
+                versionId: sdlcInfo.version,
+              }
+            : undefined,
+        adhocQuery: {
+          mapping: rawSource.mapping,
+          runtime: rawSource.runtime,
+        },
+        sourceType: source._type,
+      };
+    }
+    return {};
+  }
+
+  override finalizeTimingRecord(
+    stopWatch: StopWatch,
+    timings?: TimingsRecord,
+  ): TimingsRecord | undefined {
+    return this._application.timeService.finalizeTimingsRecord(
+      stopWatch,
+      timings,
+    );
+  }
+
   override async processSource(value: PlainObject): Promise<DataCubeSource> {
     switch (value._type) {
       case ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE: {

package/src/stores/builder/LegendDataCubeBuilderStore.tsx

@@ -68,8 +68,7 @@ import { LegendDataCubeSourceViewer } from '../../components/builder/LegendDataC
 import { LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE } from '../model/LocalFileDataCubeSource.js';
 import type { LegendDataCubeSourceLoaderState } from './source/LegendDataCubeSourceLoaderState.js';
 import { LocalFileDataCubeSourceLoaderState } from './source/LocalFileDataCubeSourceLoaderState.js';
-import { DATACUBE_APP_EVENT } from '../../__lib__/DataCubeEvent.js';
-import { LegendApplicationTelemetryHelper } from '@finos/legend-application';
+import { LEGEND_DATACUBE_APP_EVENT } from '../../__lib__/LegendDataCubeEvent.js';
 
 export class LegendDataCubeBuilderState {
   readonly uuid = uuid();
@@ -384,17 +383,25 @@ export class LegendDataCubeBuilderStore {
 
         this.finalizeLoad(specification, persistentDataCube, dataCubeId);
         this.loadState.pass();
-        this.creator.logFromRawSource(
-          DATACUBE_APP_EVENT.LOAD_DATACUBE__SUCCESS,
-          specification.source,
+        this.engine.sendTelemetry(
+          LEGEND_DATACUBE_APP_EVENT.LOAD_DATACUBE__SUCCESS,
+          {
+            ...this.engine.getDataFromRawSource(specification.source),
+            dataCubeId: dataCubeId,
+          },
         );
       } catch (error) {
         assertErrorThrown(error);
         const message = `DataCube Load Failure: ${error.message}`;
-        this.creator.logFromRawSource(
-          DATACUBE_APP_EVENT.LOAD_DATACUBE__FAILURE,
-          this.builder?.initialSpecification.source,
-          message,
+        this.engine.sendTelemetry(
+          LEGEND_DATACUBE_APP_EVENT.LOAD_DATACUBE__FAILURE,
+          {
+            ...this.engine.getDataFromRawSource(
+              this.builder?.initialSpecification.source,
+            ),
+            dataCubeId: dataCubeId,
+            error: message,
+          },
         );
         this.alertService.alertError(error, {
           message: message,
@@ -408,11 +415,6 @@ export class LegendDataCubeBuilderStore {
         this.taskService.endTask(task);
       }
     }
-
-    LegendApplicationTelemetryHelper.logEvent_ApplicationInitializationSucceeded(
-      this.application.telemetryService,
-      this.application,
-    );
   }
 
   private finalizeLoad(
@@ -513,9 +515,11 @@ export class LegendDataCubeBuilderStore {
 
       this.saverDisplay.close();
       this.saveState.pass();
-      this.creator.logFromSource(
-        DATACUBE_APP_EVENT.CREATE_DATACUBE__SUCCESS,
-        this.builder.source,
+      this.engine.sendTelemetry(
+        LEGEND_DATACUBE_APP_EVENT.CREATE_DATACUBE__SUCCESS,
+        this.engine.getDataFromSource(
+          this.builder.dataCube.getProcessedSource(),
+        ),
       );
     } catch (error) {
       assertErrorThrown(error);
@@ -524,10 +528,14 @@ export class LegendDataCubeBuilderStore {
         message: message,
       });
       this.saveState.fail();
-      this.creator.logFromSource(
-        DATACUBE_APP_EVENT.CREATE_DATACUBE__FAILURE,
-        this.builder.source,
-        message,
+      this.engine.sendTelemetry(
+        LEGEND_DATACUBE_APP_EVENT.CREATE_DATACUBE__FAILURE,
+        {
+          ...this.engine.getDataFromSource(
+            this.builder.dataCube.getProcessedSource(),
+          ),
+          error: message,
+        },
       );
     } finally {
       this.taskService.endTask(task);
@@ -581,21 +589,31 @@ export class LegendDataCubeBuilderStore {
 
       this.saverDisplay.close();
       this.saveState.pass();
-      this.creator.logFromSource(
+      this.engine.sendTelemetry(
         options?.saveAsNew
-          ? DATACUBE_APP_EVENT.CREATE_DATACUBE__SUCCESS
-          : DATACUBE_APP_EVENT.UPDATE_DATACUBE__SUCCESS,
-        this.builder.source,
+          ? LEGEND_DATACUBE_APP_EVENT.CREATE_DATACUBE__SUCCESS
+          : LEGEND_DATACUBE_APP_EVENT.UPDATE_DATACUBE__SUCCESS,
+        {
+          ...this.engine.getDataFromSource(
+            this.builder.dataCube.getProcessedSource(),
+          ),
+          autoEnableCache: !!options?.autoEnableCache,
+        },
       );
     } catch (error) {
       assertErrorThrown(error);
       const message = `DataCube Update Failure: ${error.message}`;
-      this.creator.logFromSource(
+      this.engine.sendTelemetry(
         options?.saveAsNew
-          ? DATACUBE_APP_EVENT.CREATE_DATACUBE__FAILURE
-          : DATACUBE_APP_EVENT.UPDATE_DATACUBE__FAILURE,
-        this.builder.source,
-        message,
+          ? LEGEND_DATACUBE_APP_EVENT.CREATE_DATACUBE__FAILURE
+          : LEGEND_DATACUBE_APP_EVENT.UPDATE_DATACUBE__FAILURE,
+        {
+          ...this.engine.getDataFromSource(
+            this.builder.dataCube.getProcessedSource(),
+          ),
+          autoEnableCache: !!options?.autoEnableCache,
+          error: message,
+        },
       );
       this.alertService.alertError(error, {
         message: message,
@@ -623,7 +641,9 @@ export class LegendDataCubeBuilderStore {
 
     try {
       const persistentDataCubeToDelete =
-        await this.baseStore.graphManager.getDataCube(dataCubeId);
+        this.dataCubeToDelete instanceof PersistentDataCube
+          ? this.dataCubeToDelete
+          : await this.baseStore.graphManager.getDataCube(dataCubeId);
       const specification = DataCubeSpecification.serialization.fromJson(
         persistentDataCubeToDelete.content,
       );
@@ -655,17 +675,19 @@ export class LegendDataCubeBuilderStore {
       this.setDataCubeToDelete(undefined);
       this.deleteConfirmationDisplay.close();
       this.deleteState.pass();
-      this.creator.logFromRawSource(
-        DATACUBE_APP_EVENT.DELETE_DATACUBE__SUCCESS,
-        specification.source,
+      this.engine.sendTelemetry(
+        LEGEND_DATACUBE_APP_EVENT.DELETE_DATACUBE__SUCCESS,
+        {
+          ...this.engine.getDataFromRawSource(specification.source),
+          dataCubeDeletedId: dataCubeId,
+        },
       );
     } catch (error) {
       assertErrorThrown(error);
       const message = `DataCube Delete Failure: ${error.message}`;
-      this.creator.logFromRawSource(
-        DATACUBE_APP_EVENT.DELETE_DATACUBE__FAILURE,
-        undefined,
-        message,
+      this.engine.sendTelemetry(
+        LEGEND_DATACUBE_APP_EVENT.DELETE_DATACUBE__FAILURE,
+        { error: message, dataCubeFailedToDeleteId: this.dataCubeToDelete.id },
       );
       this.alertService.alertError(error, {
         message: message,

package/src/stores/builder/LegendDataCubeCreatorState.tsx

@@ -29,17 +29,9 @@ import {
   type LegendDataCubeSourceBuilderState,
 } from './source/LegendDataCubeSourceBuilderState.js';
 import {
-  ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE,
-  ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE,
-  AdhocQueryDataCubeSource,
   type DataCubeAlertService,
-  type DataCubeSource,
-  DataCubeTelemetryHelper,
   DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
   type DisplayState,
-  RawAdhocQueryDataCubeSource,
-  RawUserDefinedFunctionDataCubeSource,
-  UserDefinedFunctionDataCubeSource,
 } from '@finos/legend-data-cube';
 import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
 import { LegendDataCubeCreator } from '../../components/builder/LegendDataCubeCreator.js';
@@ -51,22 +43,7 @@ import {
 import { generateBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
 import { LocalFileDataCubeSourceBuilderState } from './source/LocalFileDataCubeSourceBuilderState.js';
 import { UserDefinedFunctionDataCubeSourceBuilderState } from './source/UserDefinedFunctionDataCubeSourceBuilderState.js';
-import {
-  LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE,
-  LegendQueryDataCubeSource,
-  RawLegendQueryDataCubeSource,
-} from '../model/LegendQueryDataCubeSource.js';
-import {
-  V1_deserializePureModelContext,
-  V1_PureModelContextPointer,
-  V1_LegendSDLC,
-} from '@finos/legend-graph';
-import {
-  LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE,
-  LocalFileDataCubeSource,
-  RawLocalFileQueryDataCubeSource,
-} from '../model/LocalFileDataCubeSource.js';
-import { DATACUBE_APP_EVENT } from '../../__lib__/DataCubeEvent.js';
+import { LEGEND_DATACUBE_APP_EVENT } from '../../__lib__/LegendDataCubeEvent.js';
 
 const DEFAULT_SOURCE_TYPE = LegendDataCubeSourceBuilderType.LEGEND_QUERY;
 
@@ -153,226 +130,6 @@ export class LegendDataCubeCreatorState {
     }
   }
 
-  logFromSource(
-    eventType: string,
-    source?: DataCubeSource,
-    errorMessage?: string,
-  ) {
-    if (!source) {
-      DataCubeTelemetryHelper.logEvent_Datacube(
-        this._application.telemetryService,
-        {
-          error: errorMessage,
-        },
-        eventType,
-      );
-      return;
-    }
-
-    if (source instanceof LegendQueryDataCubeSource) {
-      const queryInfo = source.info;
-
-      DataCubeTelemetryHelper.logEvent_Datacube_LegendQuery(
-        this._application.telemetryService,
-        {
-          project: {
-            groupId: queryInfo.groupId,
-            artifactId: queryInfo.artifactId,
-            versionId: queryInfo.versionId,
-          },
-          query: {
-            id: queryInfo.id,
-            name: queryInfo.name,
-          },
-          error: errorMessage,
-        },
-        eventType,
-      );
-    } else if (source instanceof UserDefinedFunctionDataCubeSource) {
-      const deserializedModel = V1_deserializePureModelContext(source.model);
-
-      const sdlcInfo =
-        deserializedModel instanceof V1_PureModelContextPointer &&
-        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
-          ? deserializedModel.sdlcInfo
-          : undefined;
-
-      DataCubeTelemetryHelper.logEvent_Datacube_AdhocFunction(
-        this._application.telemetryService,
-        {
-          project:
-            sdlcInfo !== undefined
-              ? {
-                  groupId: sdlcInfo.groupId,
-                  artifactId: sdlcInfo.artifactId,
-                  versionId: sdlcInfo.version,
-                }
-              : undefined,
-          function: {
-            path: source.functionPath,
-            runtime: source.runtime,
-          },
-          error: errorMessage,
-        },
-        eventType,
-      );
-    } else if (source instanceof LocalFileDataCubeSource) {
-      DataCubeTelemetryHelper.logEvent_Datacube_LocalFile(
-        this._application.telemetryService,
-        {
-          file: {
-            name: source.fileName,
-            format: source.fileFormat,
-          },
-          error: errorMessage,
-        },
-        eventType,
-      );
-    } else if (source instanceof AdhocQueryDataCubeSource) {
-      const deserializedModel = V1_deserializePureModelContext(source.model);
-
-      const sdlcInfo =
-        deserializedModel instanceof V1_PureModelContextPointer &&
-        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
-          ? deserializedModel.sdlcInfo
-          : undefined;
-
-      DataCubeTelemetryHelper.logEvent_Datacube_AdhocQuery(
-        this._application.telemetryService,
-        {
-          project:
-            sdlcInfo !== undefined
-              ? {
-                  groupId: sdlcInfo.groupId,
-                  artifactId: sdlcInfo.artifactId,
-                  versionId: sdlcInfo.version,
-                }
-              : undefined,
-          adhocQuery: {
-            mapping: source.mapping,
-            runtime: source.runtime,
-          },
-          error: errorMessage,
-        },
-        eventType,
-      );
-    }
-  }
-
-  logFromRawSource(
-    eventType: string,
-    source?: PlainObject,
-    errorMessage?: string,
-    dataCubeId?: string,
-  ) {
-    if (!source) {
-      DataCubeTelemetryHelper.logEvent_Datacube(
-        this._application.telemetryService,
-        {
-          dataCubeId: dataCubeId,
-          error: errorMessage,
-        },
-        eventType,
-      );
-      return;
-    }
-
-    if (source._type === LEGEND_QUERY_DATA_CUBE_SOURCE_TYPE) {
-      const rawSource =
-        RawLegendQueryDataCubeSource.serialization.fromJson(source);
-
-      DataCubeTelemetryHelper.logEvent_Datacube_LegendQuery(
-        this._application.telemetryService,
-        {
-          query: {
-            id: rawSource.queryId,
-          },
-          dataCubeId: dataCubeId,
-          error: errorMessage,
-        },
-        eventType,
-      );
-    } else if (source._type === ADHOC_FUNCTION_DATA_CUBE_SOURCE_TYPE) {
-      const rawSource =
-        RawUserDefinedFunctionDataCubeSource.serialization.fromJson(source);
-      const deserializedModel = V1_deserializePureModelContext(rawSource.model);
-
-      const sdlcInfo =
-        deserializedModel instanceof V1_PureModelContextPointer &&
-        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
-          ? deserializedModel.sdlcInfo
-          : undefined;
-
-      DataCubeTelemetryHelper.logEvent_Datacube_AdhocFunction(
-        this._application.telemetryService,
-        {
-          project:
-            sdlcInfo !== undefined
-              ? {
-                  groupId: sdlcInfo.groupId,
-                  artifactId: sdlcInfo.artifactId,
-                  versionId: sdlcInfo.version,
-                }
-              : undefined,
-          function: {
-            path: rawSource.functionPath,
-            runtime: rawSource.runtime,
-          },
-          dataCubeId: dataCubeId,
-          error: errorMessage,
-        },
-        eventType,
-      );
-    } else if (source._type === LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE) {
-      const rawSource =
-        RawLocalFileQueryDataCubeSource.serialization.fromJson(source);
-
-      DataCubeTelemetryHelper.logEvent_Datacube_LocalFile(
-        this._application.telemetryService,
-        {
-          file: {
-            name: rawSource.fileName,
-            format: rawSource.fileFormat,
-          },
-          dataCubeId: dataCubeId,
-          error: errorMessage,
-        },
-        eventType,
-      );
-    } else if (source._type === ADHOC_QUERY_DATA_CUBE_SOURCE_TYPE) {
-      const rawSource =
-        RawAdhocQueryDataCubeSource.serialization.fromJson(source);
-      const deserializedModel = V1_deserializePureModelContext(rawSource.model);
-
-      const sdlcInfo =
-        deserializedModel instanceof V1_PureModelContextPointer &&
-        deserializedModel.sdlcInfo instanceof V1_LegendSDLC
-          ? deserializedModel.sdlcInfo
-          : undefined;
-
-      DataCubeTelemetryHelper.logEvent_Datacube_AdhocQuery(
-        this._application.telemetryService,
-        {
-          project:
-            sdlcInfo !== undefined
-              ? {
-                  groupId: sdlcInfo.groupId,
-                  artifactId: sdlcInfo.artifactId,
-                  versionId: sdlcInfo.version,
-                }
-              : undefined,
-          adhocQuery: {
-            mapping: rawSource.mapping,
-            runtime: rawSource.runtime,
-          },
-          dataCubeId: dataCubeId,
-          error: errorMessage,
-        },
-        eventType,
-      );
-    }
-  }
-
   async finalize(sourceData?: PlainObject) {
     if (!sourceData && !this.sourceBuilder.isValid) {
       throw new IllegalStateError(
@@ -404,14 +161,16 @@ export class LegendDataCubeCreatorState {
         this.changeSourceBuilder(DEFAULT_SOURCE_TYPE, true);
         this.display.close();
         this.finalizeState.pass();
-        this.logFromSource(DATACUBE_APP_EVENT.NEW_DATACUBE__SUCCESS, source);
+        this._engine.sendTelemetry(
+          LEGEND_DATACUBE_APP_EVENT.NEW_DATACUBE__SUCCESS,
+          this._engine.getDataFromSource(source),
+        );
       } catch (error) {
         assertErrorThrown(error);
         const message = `DataCube Creation Failure: ${error.message}`;
-        this.logFromRawSource(
-          DATACUBE_APP_EVENT.NEW_DATACUBE__FAILURE,
-          sourceData,
-          message,
+        this._engine.sendTelemetry(
+          LEGEND_DATACUBE_APP_EVENT.NEW_DATACUBE__FAILURE,
+          { ...this._engine.getDataFromRawSource(sourceData), error: message },
         );
         this._alertService.alertError(error, {
           message: message,
@@ -421,10 +180,9 @@ export class LegendDataCubeCreatorState {
     } catch (error) {
       assertErrorThrown(error);
       const message = `DataCube Creation Failure: ${error.message}`;
-      this.logFromSource(
-        DATACUBE_APP_EVENT.NEW_DATACUBE__FAILURE,
-        undefined,
-        message,
+      this._engine.sendTelemetry(
+        LEGEND_DATACUBE_APP_EVENT.NEW_DATACUBE__FAILURE,
+        { error: message },
       );
       this._alertService.alertError(error, {
         message: message,

package/tsconfig.json

@@ -52,7 +52,7 @@
   ],
   "files": [
     "./src/index.ts",
-    "./src/__lib__/DataCubeEvent.ts",
+    "./src/__lib__/LegendDataCubeEvent.ts",
     "./src/__lib__/LegendDataCubeNavigation.ts",
     "./src/__lib__/LegendDataCubeSetting.ts",
     "./src/__lib__/LegendDataCubeUserData.ts",