@milaboratories/pframes-rs-node 1.0.18 → 1.0.19

package/README.md

@@ -27,4 +27,17 @@ Debugging is only supported using VSCode with the following extencions installed
 1. Clone and build the latest `platforma-desktop-v2`
 2. Set the correct RELATIVE path to `platforma-desktop-v2` in `.vscode/settings.json` variable `platformaDesktopPath`
 3. Build this package by following the build steps from above
-4. Use launch configuration for your platform to start debug session
+4. Use VSCode launch configuration for your platform to start debug session
+
+### Performance profiling
+1. Clone and build the latest `platforma-desktop-v2`
+2. Set the correct RELATIVE path to `platforma-desktop-v2` in `.vscode/settings.json` variable `platformaDesktopPath`
+3. Build this package by following the build steps from above
+4. Launch VSCode task (Cmd+Shift+P -> Tasks: Run Task -> Perf-profile platforma-desktop) for profiling
+5. Execute the test scenario and quite platforma-desktop
+6. Firefox profiler with recorded performance profile would automatically open in you browser of choice
+    (Warning! Firefox profiler does not work in Safari and with AdBlock enabled)
+
+### Dump pframes requests
+1. Run `platforma-desktop-v2` with `MI_DUMP_PFRAMES_RS=/absolute/path/to/dump/requests npm run dev`
+2. Archive the `/absolute/path/to/dump/requests` folder and pass to the developer

package/export/dump.ts

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Readable, Writable } from 'node:stream';
+import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await fs.promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDirExists(fileOrDir: string): Promise<void> {
+  if (!(await fileExists(fileOrDir))) {
+    await fs.promises.mkdir(fileOrDir, { recursive: true });
+  }
+}
+
+async function writeFile(
+  filePath: string,
+  data: string | Uint8Array
+): Promise<void> {
+  const tempPath = `${filePath}.tmp`;
+  if (await fileExists(tempPath)) {
+    await fs.promises.rm(tempPath, { recursive: true });
+  }
+
+  const buffer = typeof data === 'string' ? Buffer.from(data, 'utf8') : data;
+  const source = Readable.from(buffer);
+  const destination = fs.createWriteStream(tempPath, { flags: 'wx' });
+  await Readable.toWeb(source).pipeTo(Writable.toWeb(destination));
+
+  await fs.promises.rename(tempPath, filePath);
+}
+
+export async function dump(
+  relativePath: string[],
+  data: { [key: string]: Object } | Uint8Array,
+  logger?: PFrameInternal.Logger
+): Promise<void> {
+  if (!process.env.MI_DUMP_PFRAMES_RS) return;
+  try {
+    const fileDir = path.join(
+      process.env.MI_DUMP_PFRAMES_RS,
+      ...relativePath.slice(0, -1)
+    );
+    await ensureDirExists(fileDir);
+
+    const filePath = path.join(process.env.MI_DUMP_PFRAMES_RS, ...relativePath);
+    const fileData = ArrayBuffer.isView(data)
+      ? (data as Uint8Array)
+      : JSON.stringify(data);
+    await writeFile(filePath, fileData);
+  } catch (error: unknown) {
+    logger?.('warn', `error while dumping PFrames data: ${error}`);
+  }
+}

package/export/wrapper.ts

@@ -1,3 +1,4 @@
+import { ulid } from 'ulid';
 import {
   PColumnInfo,
   PColumnSpec,
@@ -15,11 +16,22 @@ import {
 import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
 import type { NodeFrameSymbol, NodeTableSymbol } from './addon-def';
 import { AddonSymbol } from './addon';
+import { dump } from './dump';
 
 export class PFrame implements PFrameInternal.PFrameV3 {
+  public readonly id: string = ulid();
   private readonly frame: NodeFrameSymbol;
 
-  constructor(logger?: PFrameInternal.Logger) {
+  constructor(public readonly logger?: PFrameInternal.Logger) {
+    dump(
+      [`${this.id}`, `${this.id}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'create'
+      },
+      this.logger
+    );
+
     try {
       this.frame = AddonSymbol.pFrameCreate(logger);
     } catch (err: unknown) {
@@ -33,6 +45,28 @@ export class PFrame implements PFrameInternal.PFrameV3 {
   }
 
   addColumnSpec(columnId: PObjectId, columnSpec: PColumnSpec): void {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'addColumnSpec',
+        requestData: {
+          columnId,
+          columnSpec
+        }
+      },
+      this.logger
+    );
+
+    dump(
+      [`${this.id}`, `data`, `${columnId}.spec`],
+      {
+        ...columnSpec
+      },
+      this.logger
+    );
+
     try {
       return AddonSymbol.pFrameAddColumnSpec(this.frame, columnId, columnSpec);
     } catch (err: unknown) {
@@ -47,8 +81,69 @@ export class PFrame implements PFrameInternal.PFrameV3 {
   }
 
   setDataSource(dataSource: PFrameInternal.PFrameDataSource): void {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'setDataSource'
+      },
+      this.logger
+    );
+
+    let wrappedDataSource = {
+      preloadBlob: async (
+        blobIds: PFrameInternal.PFrameBlobId[]
+      ): Promise<void> => {
+        const requestId = ulid();
+        dump(
+          [`${this.id}`, `${requestId}.json`],
+          {
+            timeStamp: Date.now(),
+            requestType: 'preloadBlob',
+            requestData: {
+              blobIds
+            }
+          },
+          this.logger
+        );
+
+        const t0 = performance.now();
+        try {
+          return dataSource.preloadBlob(blobIds);
+        } finally {
+          const t1 = performance.now();
+          this.logger?.(
+            'info',
+            `PFrame preloaded ${blobIds.length} blobs, took ${Math.round(t1 - t0)}ms`
+          );
+        }
+      },
+      resolveBlobContent: async (
+        blobId: PFrameInternal.PFrameBlobId
+      ): Promise<Uint8Array> => {
+        const requestId = ulid();
+        dump(
+          [`${this.id}`, `${requestId}.json`],
+          {
+            timeStamp: Date.now(),
+            requestType: 'resolveBlobContent',
+            requestData: {
+              blobId
+            }
+          },
+          this.logger
+        );
+
+        const blob = await dataSource.resolveBlobContent(blobId);
+        dump([`${this.id}`, `data`, `${blobId}`], blob, this.logger);
+
+        return blob;
+      }
+    };
+
     try {
-      return AddonSymbol.pFrameSetDataSource(this.frame, dataSource);
+      return AddonSymbol.pFrameSetDataSource(this.frame, wrappedDataSource);
     } catch (err: unknown) {
       throw new Error(
         `PFrame setDataSource request failed, ` +
@@ -60,6 +155,28 @@ export class PFrame implements PFrameInternal.PFrameV3 {
   }
 
   setColumnData(columnId: PObjectId, dataInfo: PFrameInternal.DataInfo): void {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'setColumnData',
+        requestData: {
+          columnId,
+          dataInfo
+        }
+      },
+      this.logger
+    );
+
+    dump(
+      [`${this.id}`, `data`, `${columnId}.datainfo`],
+      {
+        ...dataInfo
+      },
+      this.logger
+    );
+
     try {
       return AddonSymbol.pFrameSetColumnData(this.frame, columnId, dataInfo);
     } catch (err: unknown) {
@@ -74,6 +191,16 @@ export class PFrame implements PFrameInternal.PFrameV3 {
   }
 
   dispose(): void {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'dispose'
+      },
+      this.logger
+    );
+
     try {
       AddonSymbol.pFrameDispose(this.frame);
     } catch (err: unknown) {
@@ -92,6 +219,18 @@ export class PFrame implements PFrameInternal.PFrameV3 {
   async findColumns(
     request: PFrameInternal.FindColumnsRequest
   ): Promise<PFrameInternal.FindColumnsResponse> {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'findColumns',
+        requestData: request
+      },
+      this.logger
+    );
+
+    const t0 = performance.now();
     try {
       return await AddonSymbol.pFrameFindColumns(this.frame, request);
     } catch (err: unknown) {
@@ -101,12 +240,30 @@ export class PFrame implements PFrameInternal.PFrameV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.logger?.(
+        'info',
+        `PFrame findColumns request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
   async deleteColumn(
     request: PFrameInternal.DeleteColumnFromColumnsRequest
   ): Promise<PFrameInternal.DeleteColumnFromColumnsResponse> {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'deleteColumn',
+        requestData: request
+      },
+      this.logger
+    );
+
+    const t0 = performance.now();
     try {
       return await AddonSymbol.pFrameDeleteColumn(this.frame, request);
     } catch (err: unknown) {
@@ -116,10 +273,30 @@ export class PFrame implements PFrameInternal.PFrameV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.logger?.(
+        'info',
+        `PFrame deleteColumn request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
   async getColumnSpec(columnId: PObjectId): Promise<PColumnSpec> {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'getColumnSpec',
+        requestData: {
+          columnId
+        }
+      },
+      this.logger
+    );
+
+    const t0 = performance.now();
     try {
       return await AddonSymbol.pFrameGetColumnSpec(this.frame, columnId);
     } catch (err: unknown) {
@@ -129,10 +306,27 @@ export class PFrame implements PFrameInternal.PFrameV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.logger?.(
+        'info',
+        `PFrame getColumnSpec request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
   async listColumns(): Promise<PColumnInfo[]> {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'listColumns'
+      },
+      this.logger
+    );
+
+    const t0 = performance.now();
     try {
       return await AddonSymbol.pFrameListColumns(this.frame);
     } catch (err: unknown) {
@@ -141,6 +335,12 @@ export class PFrame implements PFrameInternal.PFrameV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.logger?.(
+        'info',
+        `PFrame listColumns request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
@@ -148,13 +348,27 @@ export class PFrame implements PFrameInternal.PFrameV3 {
     request: PFrameInternal.CreateTableRequest,
     signal?: AbortSignal
   ): Promise<PFrameInternal.PTableV3> {
+    const requestId = ulid();
+    const dumpData = {
+      timeStamp: Date.now(),
+      requestType: 'createTable',
+      requestData: request
+    };
+    dump([`${this.id}`, `${requestId}.json`], dumpData, this.logger);
+    dump(
+      [`${this.id}`, `${requestId}`, `${requestId}.json`],
+      dumpData,
+      this.logger
+    );
+
+    const t0 = performance.now();
     try {
       const boxed = await AddonSymbol.pFrameCreateTable(
         this.frame,
         request,
         signal
       );
-      return new PTable(boxed);
+      return new PTable(this, requestId, boxed);
     } catch (err: unknown) {
       throw new Error(
         `PFrame createTable request failed, ` +
@@ -162,6 +376,12 @@ export class PFrame implements PFrameInternal.PFrameV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.logger?.(
+        'info',
+        `PFrame createTable request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
@@ -169,6 +389,18 @@ export class PFrame implements PFrameInternal.PFrameV3 {
     request: UniqueValuesRequest,
     signal?: AbortSignal
   ): Promise<UniqueValuesResponse> {
+    const requestId = ulid();
+    dump(
+      [`${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'getUniqueValues',
+        requestData: request
+      },
+      this.logger
+    );
+
+    const t0 = performance.now();
     try {
       return await AddonSymbol.pFrameGetUniqueValues(
         this.frame,
@@ -182,14 +414,34 @@ export class PFrame implements PFrameInternal.PFrameV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.logger?.(
+        'info',
+        `PFrame getUniqueValues request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 }
 
 class PTable implements PFrameInternal.PTableV3 {
-  constructor(private readonly table: NodeTableSymbol) {}
+  constructor(
+    private readonly frame: PFrame,
+    public readonly id: string,
+    private readonly table: NodeTableSymbol
+  ) {}
 
   getShape(): PTableShape {
+    const requestId = ulid();
+    dump(
+      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'getShape'
+      },
+      this.frame.logger
+    );
+
     try {
       return AddonSymbol.pTableGetShape(this.table);
     } catch (err: unknown) {
@@ -202,6 +454,16 @@ class PTable implements PFrameInternal.PTableV3 {
   }
 
   getSpec(): PTableColumnSpec[] {
+    const requestId = ulid();
+    dump(
+      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'getSpec'
+      },
+      this.frame.logger
+    );
+
     try {
       return AddonSymbol.pTableGetSpec(this.table);
     } catch (err: unknown) {
@@ -214,6 +476,19 @@ class PTable implements PFrameInternal.PTableV3 {
   }
 
   getColumnIndices(columnIds: PTableColumnId[]): number[] {
+    const requestId = ulid();
+    dump(
+      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'getColumnIndices',
+        requestData: {
+          columnIds
+        }
+      },
+      this.frame.logger
+    );
+
     try {
       return AddonSymbol.pTableGetColumnIndices(this.table, columnIds);
     } catch (err: unknown) {
@@ -230,8 +505,23 @@ class PTable implements PFrameInternal.PTableV3 {
     columnIndices: number[],
     range?: TableRange
   ): Promise<PTableVector[]> {
+    const requestId = ulid();
+    dump(
+      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'getData',
+        requestData: {
+          columnIndices,
+          range: range ?? null
+        }
+      },
+      this.frame.logger
+    );
+
+    const t0 = performance.now();
     try {
-      return AddonSymbol.pTableGetData(this.table, columnIndices, range);
+      return await AddonSymbol.pTableGetData(this.table, columnIndices, range);
     } catch (err: unknown) {
       throw new Error(
         `PTable getData request failed, ` +
@@ -240,6 +530,12 @@ class PTable implements PFrameInternal.PTableV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.frame.logger?.(
+        'info',
+        `PTable getData request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
@@ -247,9 +543,28 @@ class PTable implements PFrameInternal.PTableV3 {
     request: PTableRecordFilter[],
     signal?: AbortSignal
   ): Promise<PFrameInternal.PTableV3> {
+    const requestId = ulid();
+    const dumpData = {
+      timeStamp: Date.now(),
+      table: this.id,
+      requestType: 'filter',
+      requestData: request
+    };
+    dump(
+      [`${this.frame.id}`, `${requestId}.json`],
+      dumpData,
+      this.frame.logger
+    );
+    dump(
+      [`${this.frame.id}`, `${requestId}`, `${requestId}.json`],
+      dumpData,
+      this.frame.logger
+    );
+
+    const t0 = performance.now();
     try {
       const boxed = await AddonSymbol.pTableFilter(this.table, request, signal);
-      return new PTable(boxed);
+      return new PTable(this.frame, requestId, boxed);
     } catch (err: unknown) {
       throw new Error(
         `PTable filter request failed, ` +
@@ -257,6 +572,12 @@ class PTable implements PFrameInternal.PTableV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.frame.logger?.(
+        'info',
+        `PTable filter request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
@@ -264,9 +585,28 @@ class PTable implements PFrameInternal.PTableV3 {
     request: PTableSorting[],
     signal?: AbortSignal
   ): Promise<PFrameInternal.PTableV3> {
+    const requestId = ulid();
+    const dumpData = {
+      timeStamp: Date.now(),
+      table: this.id,
+      requestType: 'sort',
+      requestData: request
+    };
+    dump(
+      [`${this.frame.id}`, `${requestId}.json`],
+      dumpData,
+      this.frame.logger
+    );
+    dump(
+      [`${this.frame.id}`, `${requestId}`, `${requestId}.json`],
+      dumpData,
+      this.frame.logger
+    );
+
+    const t0 = performance.now();
     try {
       const boxed = await AddonSymbol.pTableSort(this.table, request, signal);
-      return new PTable(boxed);
+      return new PTable(this.frame, requestId, boxed);
     } catch (err: unknown) {
       throw new Error(
         `PTable sort request failed, ` +
@@ -274,10 +614,26 @@ class PTable implements PFrameInternal.PTableV3 {
           `error:\n` +
           `${(err as Error).toString()}`
       );
+    } finally {
+      const t1 = performance.now();
+      this.frame.logger?.(
+        'info',
+        `PTable sort request took ${Math.round(t1 - t0)}ms`
+      );
     }
   }
 
   dispose() {
+    const requestId = ulid();
+    dump(
+      [`${this.frame.id}`, `${this.id}`, `${requestId}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: 'dispose'
+      },
+      this.frame.logger
+    );
+
     try {
       AddonSymbol.pTableDispose(this.table);
     } catch (err: unknown) {

package/export_dist/dump.d.ts

@@ -0,0 +1,5 @@
+import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+export declare function dump(relativePath: string[], data: {
+    [key: string]: Object;
+} | Uint8Array, logger?: PFrameInternal.Logger): Promise<void>;
+//# sourceMappingURL=dump.d.ts.map

package/export_dist/dump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dump.d.ts","sourceRoot":"","sources":["../export/dump.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAkC5E,wBAAsB,IAAI,CACxB,YAAY,EAAE,MAAM,EAAE,EACtB,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,UAAU,EAC5C,MAAM,CAAC,EAAE,cAAc,CAAC,MAAM,GAC7B,OAAO,CAAC,IAAI,CAAC,CAiBf"}