@milaboratories/pl-client 2.7.0 → 2.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-client",
-  "version": "2.7.0",
+  "version": "2.7.2",
   "description": "New TS/JS client for Platform API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -17,21 +17,21 @@
     "./src/**/*"
   ],
   "dependencies": {
-    "@grpc/grpc-js": "^1.12.4",
+    "@grpc/grpc-js": "^1.12.5",
     "@protobuf-ts/grpc-transport": "^2.9.4",
     "@protobuf-ts/runtime": "^2.9.4",
     "@protobuf-ts/runtime-rpc": "^2.9.4",
     "canonicalize": "^2.0.0",
     "denque": "^2.1.0",
     "lru-cache": "^11.0.2",
-    "https-proxy-agent": "^7.0.5",
+    "https-proxy-agent": "^7.0.6",
     "cacheable-lookup": "^6.1.0",
     "long": "^5.2.3",
-    "undici": "^7.1.0",
+    "undici": "^7.2.0",
     "utility-types": "^3.11.0",
     "yaml": "^2.6.1",
-    "@milaboratories/ts-helpers": "^1.1.3",
-    "@milaboratories/pl-http": "^1.0.1"
+    "@milaboratories/pl-http": "^1.0.2",
+    "@milaboratories/ts-helpers": "^1.1.3"
   },
   "devDependencies": {
     "typescript": "~5.5.4",

package/src/core/client.ts

@@ -23,6 +23,7 @@ import { Dispatcher } from 'undici';
 import { LRUCache } from 'lru-cache';
 import { ResourceDataCacheRecord } from './cache';
 import { DefaultFinalResourceDataPredicate, FinalResourceDataPredicate } from './final';
+import { addStat, AllTxStat, initialTxStat, TxStat } from './stat';
 
 export type TxOps = PlCallOps & {
   sync?: boolean;
@@ -59,6 +60,10 @@ export class PlClient {
 
   private _serverInfo: MaintenanceAPI_Ping_Response | undefined = undefined;
 
+  private _txCommittedStat: TxStat = initialTxStat();
+  private _txConflictStat: TxStat = initialTxStat();
+  private _txErrorStat: TxStat = initialTxStat();
+
   //
   // Caching
   //
@@ -110,6 +115,30 @@ export class PlClient {
     }
   }
 
+  public get txCommittedStat(): TxStat {
+    return { ...this._txCommittedStat };
+  }
+
+  public get txConflictStat(): TxStat {
+    return { ...this._txConflictStat };
+  }
+
+  public get txErrorStat(): TxStat {
+    return { ...this._txErrorStat };
+  }
+
+  public get txTotalStat(): TxStat {
+    return addStat(addStat(this._txCommittedStat, this._txConflictStat), this._txErrorStat);
+  }
+
+  public get allTxStat(): AllTxStat {
+    return {
+      committed: this.txCommittedStat,
+      conflict: this.txConflictStat,
+      error: this.txErrorStat
+    };
+  }
+
   public async ping(): Promise<MaintenanceAPI_Ping_Response> {
     return (await this.ll.grpcPl.ping({})).response;
   }
@@ -234,13 +263,18 @@ export class PlClient {
       try {
         // executing transaction body
         result = await body(tx);
+        // collecting stat
+        this._txCommittedStat = addStat(this._txCommittedStat, tx.stat);
         ok = true;
       } catch (e: unknown) {
         // the only recoverable
         if (e instanceof TxCommitConflict) {
           // ignoring
-          // TODO collect stats
+          // collecting stat
+          this._txConflictStat = addStat(this._txConflictStat, tx.stat);
         } else {
+          // collecting stat
+          this._txErrorStat = addStat(this._txErrorStat, tx.stat);
           throw e;
         }
       } finally {

package/src/core/config.ts

@@ -87,9 +87,9 @@ export const DEFAULT_AUTH_MAX_REFRESH = 12 * 24 * 60 * 60;
 export const DEFAULT_MAX_CACHE_BYTES = 128_000_000; // 128 Mb
 
 export const DEFAULT_RETRY_BACKOFF_ALGORITHM = 'exponential';
-export const DEFAULT_RETRY_MAX_ATTEMPTS = 10;
-export const DEFAULT_RETRY_INITIAL_DELAY = 4; // 4 ms
-export const DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER = 2; // + 100% on each round
+export const DEFAULT_RETRY_MAX_ATTEMPTS = 16; // 1st attempt + 15 retries
+export const DEFAULT_RETRY_INITIAL_DELAY = 14; // 14 ms * <jitter> of sleep after first failure
+export const DEFAULT_RETRY_EXPONENTIAL_BACKOFF_MULTIPLIER = 1.5; // + 50% on each round
 export const DEFAULT_RETRY_LINEAR_BACKOFF_STEP = 50; // + 50 ms
 export const DEFAULT_RETRY_JITTER = 0.3; // 30%
 

package/src/core/stat.ts

@@ -0,0 +1,102 @@
+export type TxStat = {
+  txCount: number;
+
+  rootsCreated: number;
+  structsCreated: number;
+  structsCreatedDataBytes: number;
+  ephemeralsCreated: number;
+  ephemeralsCreatedDataBytes: number;
+  valuesCreated: number;
+  valuesCreatedDataBytes: number;
+
+  kvSetRequests: number;
+  kvSetBytes: number;
+
+  inputsLocked: number;
+  outputsLocked: number;
+  fieldsCreated: number;
+  fieldsSet: number;
+  fieldsGet: number;
+
+  rGetDataCacheHits: number;
+  rGetDataCacheFields: number;
+  rGetDataCacheBytes: number;
+  rGetDataNetRequests: number;
+  rGetDataNetFields: number;
+  rGetDataNetBytes: number;
+
+  kvListRequests: number;
+  kvListEntries: number;
+  kvListBytes: number;
+
+  kvGetRequests: number;
+  kvGetBytes: number;
+};
+
+export function initialTxStat(): TxStat {
+  return {
+    txCount: 0,
+    rootsCreated: 0,
+    structsCreated: 0,
+    structsCreatedDataBytes: 0,
+    ephemeralsCreated: 0,
+    ephemeralsCreatedDataBytes: 0,
+    valuesCreated: 0,
+    valuesCreatedDataBytes: 0,
+    kvSetRequests: 0,
+    kvSetBytes: 0,
+    inputsLocked: 0,
+    outputsLocked: 0,
+    fieldsCreated: 0,
+    fieldsSet: 0,
+    fieldsGet: 0,
+    rGetDataCacheHits: 0,
+    rGetDataCacheFields: 0,
+    rGetDataCacheBytes: 0,
+    rGetDataNetRequests: 0,
+    rGetDataNetFields: 0,
+    rGetDataNetBytes: 0,
+    kvListRequests: 0,
+    kvListEntries: 0,
+    kvListBytes: 0,
+    kvGetRequests: 0,
+    kvGetBytes: 0
+  };
+}
+
+export function addStat(a: TxStat, b: TxStat): TxStat {
+  return {
+    txCount: a.txCount + b.txCount,
+    rootsCreated: a.rootsCreated + b.rootsCreated,
+    structsCreated: a.structsCreated + b.structsCreated,
+    structsCreatedDataBytes: a.structsCreatedDataBytes + b.structsCreatedDataBytes,
+    ephemeralsCreated: a.ephemeralsCreated + b.ephemeralsCreated,
+    ephemeralsCreatedDataBytes: a.ephemeralsCreatedDataBytes + b.ephemeralsCreatedDataBytes,
+    valuesCreated: a.valuesCreated + b.valuesCreated,
+    valuesCreatedDataBytes: a.valuesCreatedDataBytes + b.valuesCreatedDataBytes,
+    kvSetRequests: a.kvSetRequests + b.kvSetRequests,
+    kvSetBytes: a.kvSetBytes + b.kvSetBytes,
+    inputsLocked: a.inputsLocked + b.inputsLocked,
+    outputsLocked: a.outputsLocked + b.outputsLocked,
+    fieldsCreated: a.fieldsCreated + b.fieldsCreated,
+    fieldsSet: a.fieldsSet + b.fieldsSet,
+    fieldsGet: a.fieldsGet + b.fieldsGet,
+    rGetDataCacheHits: a.rGetDataCacheHits + b.rGetDataCacheHits,
+    rGetDataCacheFields: a.rGetDataCacheFields + b.rGetDataCacheFields,
+    rGetDataCacheBytes: a.rGetDataCacheBytes + b.rGetDataCacheBytes,
+    rGetDataNetRequests: a.rGetDataNetRequests + b.rGetDataNetRequests,
+    rGetDataNetFields: a.rGetDataNetFields + b.rGetDataNetFields,
+    rGetDataNetBytes: a.rGetDataNetBytes + b.rGetDataNetBytes,
+    kvListRequests: a.kvListRequests + b.kvListRequests,
+    kvListEntries: a.kvListEntries + b.kvListEntries,
+    kvListBytes: a.kvListBytes + b.kvListBytes,
+    kvGetRequests: a.kvGetRequests + b.kvGetRequests,
+    kvGetBytes: a.kvGetBytes + b.kvGetBytes
+  };
+}
+
+export type AllTxStat = {
+  committed: TxStat;
+  conflict: TxStat;
+  error: TxStat;
+};

package/src/core/transaction.ts

@@ -30,6 +30,7 @@ import { isNotFoundError } from './errors';
 import { FinalResourceDataPredicate } from './final';
 import { LRUCache } from 'lru-cache';
 import { ResourceDataCacheRecord } from './cache';
+import { initialTxStat, TxStat } from './stat';
 
 /** Reference to resource, used only within transaction */
 export interface ResourceRef {
@@ -154,6 +155,8 @@ export class PlTransaction {
 
   private globalTxIdWasAwaited: boolean = false;
 
+  public readonly stat: TxStat = initialTxStat();
+
   constructor(
     private readonly ll: LLPlTransaction,
     public readonly name: string,
@@ -182,6 +185,9 @@ export class PlTransaction {
         console.warn(err);
       }
     });
+
+    // Adding stats
+    this.stat.txCount++;
   }
 
   private async drainAndAwaitPendingOps(): Promise<void> {
@@ -367,6 +373,7 @@ export class PlTransaction {
   }
 
   public createRoot(type: ResourceType): ResourceRef {
+    this.stat.rootsCreated++;
     return this.createResource(
       true,
       (localId) => ({ oneofKind: 'resourceCreateRoot', resourceCreateRoot: { type, id: localId } }),
@@ -375,6 +382,8 @@ export class PlTransaction {
   }
 
   public createStruct(type: ResourceType, data?: Uint8Array | string): ResourceRef {
+    this.stat.structsCreated++;
+    this.stat.structsCreatedDataBytes += data?.length ?? 0;
     return this.createResource(
       false,
       (localId) => ({
@@ -390,6 +399,8 @@ export class PlTransaction {
   }
 
   public createEphemeral(type: ResourceType, data?: Uint8Array | string): ResourceRef {
+    this.stat.ephemeralsCreated++;
+    this.stat.ephemeralsCreatedDataBytes += data?.length ?? 0;
     return this.createResource(
       false,
       (localId) => ({
@@ -409,6 +420,8 @@ export class PlTransaction {
     data: Uint8Array | string,
     errorIfExists: boolean = false
   ): ResourceRef {
+    this.stat.valuesCreated++;
+    this.stat.valuesCreatedDataBytes += data?.length ?? 0;
     return this.createResource(
       false,
       (localId) => ({
@@ -496,8 +509,16 @@ export class PlTransaction {
       // checking if we can return result from cache
       const fromCache = this.sharedResourceDataCache.get(rId);
       if (fromCache && fromCache.cacheTxOpenTimestamp < this.txOpenTimestamp) {
-        if (!loadFields) return fromCache.basicData;
-        else if (fromCache.data) return fromCache.data;
+        if (!loadFields) {
+          this.stat.rGetDataCacheHits++;
+          this.stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
+          return fromCache.basicData;
+        } else if (fromCache.data) {
+          this.stat.rGetDataCacheHits++;
+          this.stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
+          this.stat.rGetDataCacheFields += fromCache.data.fields.length;
+          return fromCache.data;
+        }
       }
     }
 
@@ -509,6 +530,10 @@ export class PlTransaction {
       (r) => protoToResource(notEmpty(r.resourceGet.resource))
     );
 
+    this.stat.rGetDataNetRequests++;
+    this.stat.rGetDataNetBytes += result.data?.length ?? 0;
+    this.stat.rGetDataNetFields += result.fields.length;
+
     // we will cache only final resource data states
     // caching result even if we were ignore the cache
     if (!isResourceRef(rId) && !isLocalResourceId(rId) && this.finalPredicate(result)) {
@@ -575,6 +600,7 @@ export class PlTransaction {
    * have their values, if inputs list is not locked.
    */
   public lockInputs(rId: AnyResourceRef): void {
+    this.stat.inputsLocked++;
     this.sendVoidAsync({
       oneofKind: 'resourceLockInputs',
       resourceLockInputs: { resourceId: toResourceId(rId) }
@@ -586,6 +612,7 @@ export class PlTransaction {
    * This is required for resource to pass deduplication.
    */
   public lockOutputs(rId: AnyResourceRef): void {
+    this.stat.outputsLocked++;
     this.sendVoidAsync({
       oneofKind: 'resourceLockOutputs',
       resourceLockOutputs: { resourceId: toResourceId(rId) }
@@ -602,6 +629,7 @@ export class PlTransaction {
   //
 
   public createField(fId: AnyFieldRef, fieldType: FieldType, value?: AnyRef): void {
+    this.stat.fieldsCreated++;
     this.sendVoidAsync({
       oneofKind: 'fieldCreate',
       fieldCreate: { type: fieldTypeToProto(fieldType), id: toFieldId(fId) }
@@ -620,6 +648,7 @@ export class PlTransaction {
   }
 
   public setField(fId: AnyFieldRef, ref: AnyRef): void {
+    this.stat.fieldsSet++;
     if (isResource(ref))
       this.sendVoidAsync({
         oneofKind: 'fieldSet',
@@ -642,6 +671,7 @@ export class PlTransaction {
   }
 
   public setFieldError(fId: AnyFieldRef, ref: AnyResourceRef): void {
+    this.stat.fieldsSet++;
     this.sendVoidAsync({
       oneofKind: 'fieldSetError',
       fieldSetError: { field: toFieldId(fId), errResourceId: toResourceId(ref) }
@@ -649,6 +679,7 @@ export class PlTransaction {
   }
 
   public async getField(fId: AnyFieldRef): Promise<FieldData> {
+    this.stat.fieldsGet++;
     return await this.sendSingleAndParse(
       { oneofKind: 'fieldGet', fieldGet: { field: toFieldId(fId) } },
       (r) => protoToField(notEmpty(r.fieldGet.field))
@@ -672,13 +703,19 @@ export class PlTransaction {
   //
 
   public async listKeyValues(rId: AnyResourceRef): Promise<KeyValue[]> {
-    return await this.sendMultiAndParse(
+    const result = await this.sendMultiAndParse(
       {
         oneofKind: 'resourceKeyValueList',
         resourceKeyValueList: { resourceId: toResourceId(rId), startFrom: '', limit: 0 }
       },
       (r) => r.map((e) => e.resourceKeyValueList.record!)
     );
+
+    this.stat.kvListRequests++;
+    this.stat.kvListEntries += result.length;
+    for (const kv of result) this.stat.kvListBytes += kv.key.length + kv.value.length;
+
+    return result;
   }
 
   public async listKeyValuesString(rId: AnyResourceRef): Promise<KeyValueString[]> {
@@ -699,6 +736,8 @@ export class PlTransaction {
   }
 
   public setKValue(rId: AnyResourceRef, key: string, value: Uint8Array | string): void {
+    this.stat.kvSetRequests++;
+    this.stat.kvSetBytes++;
     this.sendVoidAsync({
       oneofKind: 'resourceKeyValueSet',
       resourceKeyValueSet: {
@@ -720,13 +759,18 @@ export class PlTransaction {
   }
 
   public async getKValue(rId: AnyResourceRef, key: string): Promise<Uint8Array> {
-    return await this.sendSingleAndParse(
+    const result = await this.sendSingleAndParse(
       {
         oneofKind: 'resourceKeyValueGet',
         resourceKeyValueGet: { resourceId: toResourceId(rId), key }
       },
       (r) => r.resourceKeyValueGet.value
     );
+
+    this.stat.kvGetRequests++;
+    this.stat.kvGetBytes += result.length;
+
+    return result;
   }
 
   public async getKValueString(rId: AnyResourceRef, key: string): Promise<string> {
@@ -741,7 +785,7 @@ export class PlTransaction {
     rId: AnyResourceRef,
     key: string
   ): Promise<Uint8Array | undefined> {
-    return await this.sendSingleAndParse(
+    const result = await this.sendSingleAndParse(
       {
         oneofKind: 'resourceKeyValueGetIfExists',
         resourceKeyValueGetIfExists: { resourceId: toResourceId(rId), key }
@@ -749,6 +793,11 @@ export class PlTransaction {
       (r) =>
         r.resourceKeyValueGetIfExists.exists ? r.resourceKeyValueGetIfExists.value : undefined
     );
+
+    this.stat.kvGetRequests++;
+    this.stat.kvGetBytes += result?.length ?? 0;
+
+    return result;
   }
 
   public async getKValueStringIfExists(