@hotmeshio/hotmesh 0.0.36 → 0.0.38

package/services/activities/trigger.ts

@@ -35,6 +35,7 @@ class Trigger extends Activity {
     try {
       this.setLeg(2);
       await this.getState();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startJobSpan();
       telemetry.startActivitySpan(this.leg);
@@ -70,7 +71,7 @@ class Trigger extends Activity {
     } finally {
       telemetry?.endJobSpan();
       telemetry?.endActivitySpan();
-      this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid });
+      this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid, gid: this.context.metadata.gid });
     }
   }
 
@@ -108,8 +109,10 @@ class Trigger extends Activity {
     this.context = {
       metadata: {
         ...this.metadata,
+        gid: guid(),
         ngn: this.context.metadata.ngn,
         pj: this.context.metadata.pj,
+        pg: this.context.metadata.pg,
         pd: this.context.metadata.pd,
         pa: this.context.metadata.pa,
         app: id,
@@ -187,6 +190,7 @@ class Trigger extends Activity {
         resolvedDepKey,
         this.context.metadata.tpc,
         this.context.metadata.jid,
+        this.context.metadata.gid,
         multi,
       );
     }

package/services/activities/worker.ts

@@ -1,4 +1,7 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
@@ -29,14 +32,11 @@ class Worker extends Activity {
 
   //********  INITIAL ENTRY POINT (A)  ********//
   async process(): Promise<string> {
-    this.logger.debug('worker-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('worker-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //confirm entry is allowed and restore state
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
       this.mapInputData();
@@ -63,6 +63,9 @@ class Worker extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('await-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('worker-get-state-error', { error });
         return;
@@ -73,7 +76,7 @@ class Worker extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -83,6 +86,7 @@ class Worker extends Activity {
       metadata: {
         guid: guid(),
         jid: this.context.metadata.jid,
+        gid: this.context.metadata.gid,
         dad: this.metadata.dad,
         aid: this.metadata.aid,
         topic,
@@ -96,7 +100,7 @@ class Worker extends Activity {
         retry: this.config.retry
       };
     }
-    return (await this.engine.streamSignaler?.publishMessage(topic, streamData, multi)) as string;
+    return (await this.engine.router?.publishMessage(topic, streamData, multi)) as string;
   }
 }
 

package/services/durable/meshos.ts

@@ -1,5 +1,5 @@
 import { Durable } from '.';
-import { asyncLocalStorage } from './asyncLocalStorage';
+import { asyncLocalStorage } from '../../modules/storage';
 import { ClientService as Client } from './client';
 import { WorkflowHandleService } from './handle';
 import { Search } from './search';

package/services/durable/worker.ts

@@ -7,7 +7,7 @@ import {
   DurableSleepForError,
   DurableTimeoutError, 
   DurableWaitForSignalError} from '../../modules/errors';
-import { asyncLocalStorage } from './asyncLocalStorage';
+import { asyncLocalStorage } from '../../modules/storage';
 import { APP_ID, APP_VERSION, getWorkflowYAML } from './factory';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import {

package/services/durable/workflow.ts

@@ -6,7 +6,7 @@ import {
   DurableSleepForError,
   DurableWaitForSignalError } from '../../modules/errors';
 import { KeyService, KeyType } from '../../modules/key';
-import { asyncLocalStorage } from './asyncLocalStorage';
+import { asyncLocalStorage } from '../../modules/storage';
 import { ClientService as Client } from './client';
 import { ConnectionService as Connection } from './connection';
 import { DEFAULT_COEFFICIENT } from './factory';

package/services/engine/index.ts

@@ -4,7 +4,7 @@ import {
   STATUS_CODE_SUCCESS,
   STATUS_CODE_PENDING,
   STATUS_CODE_TIMEOUT, 
-  DURABLE_EXPIRE_SECONDS} from '../../modules/enums';
+  DURABLE_EXPIRE_SECONDS } from '../../modules/enums';
 import {
   formatISODate,
   getSubscriptionTopic,
@@ -23,9 +23,8 @@ import { Trigger } from '../activities/trigger';
 import { CompilerService } from '../compiler';
 import { ILogger } from '../logger';
 import { ReporterService } from '../reporter';
+import { Router } from '../router';
 import { SerializerService } from '../serializer';
-import { StoreSignaler } from '../signaler/store';
-import { StreamSignaler } from '../signaler/stream';
 import { StoreService } from '../store';
 import { RedisStoreService as RedisStore } from '../store/clients/redis';
 import { IORedisStoreService as IORedisStore } from '../store/clients/ioredis';
@@ -84,12 +83,11 @@ class EngineService {
   apps: HotMeshApps | null;
   appId: string;
   guid: string;
+  router: Router | null;
   store: StoreService<RedisClient, RedisMulti> | null;
   stream: StreamService<RedisClient, RedisMulti> | null;
   subscribe: SubService<RedisClient, RedisMulti> | null;
-  storeSignaler: StoreSignaler | null;
-  streamSignaler: StreamSignaler | null;
-  task: TaskService | null;
+  taskService: TaskService | null;
   logger: ILogger;
   cacheMode: CacheMode = 'cache';
   untilVersion: string | null = null;
@@ -110,9 +108,9 @@ class EngineService {
       await instance.initStoreChannel(config.engine.store);
       await instance.initSubChannel(config.engine.sub);
       await instance.initStreamChannel(config.engine.stream);
-      instance.streamSignaler = instance.initStreamSignaler(config);
+      instance.router = instance.initRouter(config);
 
-      instance.streamSignaler.consumeMessages(
+      instance.router.consumeMessages(
         instance.stream.mintKey(
           KeyType.STREAMS,
           { appId: instance.appId },
@@ -122,12 +120,8 @@ class EngineService {
         instance.processStreamMessage.bind(instance)
       );
 
-      //the storeSignaler service is used by the engine to create `webhooks`
-      //todo: unify/move to the task service (it manages all `signal` types)
-      instance.storeSignaler = new StoreSignaler(instance.store, logger);
-
       //the task service is used by the engine to process `webhooks` and `timehooks`
-      instance.task = new TaskService(instance.store, logger);
+      instance.taskService = new TaskService(instance.store, logger);
 
       return instance;
     }
@@ -181,8 +175,8 @@ class EngineService {
     );
   }
 
-  initStreamSignaler(config: HotMeshConfig): StreamSignaler {
-    return new StreamSignaler(
+  initRouter(config: HotMeshConfig): Router {
+    return new Router(
       {
         namespace: this.namespace,
         appId: this.appId,
@@ -231,21 +225,20 @@ class EngineService {
   }
 
   async processWebHooks() {
-    this.task.processWebHooks((this.hook).bind(this));
+    this.taskService.processWebHooks((this.hook).bind(this));
   }
 
   async processTimeHooks() {
-    this.task.processTimeHooks((this.hookTime).bind(this));
+    this.taskService.processTimeHooks((this.hookTime).bind(this));
   }
 
   async throttle(delayInMillis: number) {
-    this.streamSignaler.setThrottle(delayInMillis);
+    this.router.setThrottle(delayInMillis);
   }
 
   // ************* METADATA/MODEL METHODS *************
   async initActivity(topic: string, data: JobData = {}, context?: JobState): Promise<Await|Cycle|Hook|Signal|Trigger|Worker|Interrupt> {
     const [activityId, schema] = await this.getSchema(topic);
-    polyfill
     const ActivityHandler = Activities[polyfill.resolveActivityType(schema.type)];
     if (ActivityHandler) {
       const utc = formatISODate(new Date());
@@ -329,6 +322,7 @@ class EngineService {
   async processStreamMessage(streamData: StreamDataResponse): Promise<void> {
     this.logger.debug('engine-process-stream-message', {
       jid: streamData.metadata.jid,
+      gid: streamData.metadata.gid,
       dad: streamData.metadata.dad,
       aid: streamData.metadata.aid,
       status: streamData.status || StreamStatus.SUCCESS,
@@ -338,41 +332,83 @@ class EngineService {
     const context: PartialJobState = {
       metadata: {
         jid: streamData.metadata.jid,
+        gid: streamData.metadata.gid,
         dad: streamData.metadata.dad,
         aid: streamData.metadata.aid,
       },
       data: streamData.data,
     };
-    if (streamData.type === StreamDataType.TIMEHOOK || streamData.type === StreamDataType.WEBHOOK || streamData.type === StreamDataType.TRANSITION) {
-      const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, context.data, context as JobState) as Hook;
-      if (streamData.type === StreamDataType.TIMEHOOK) {
-        await activityHandler.processTimeHookEvent(streamData.metadata.jid);
-      } else if (streamData.type === StreamDataType.TRANSITION) {
-        await activityHandler.process();
-      } else {
-        //a 202 code keeps the hook alive (hooks are single-use by default)
-        await activityHandler.processWebHookEvent(streamData.status, streamData.code);
-      }
+    if (streamData.type === StreamDataType.TIMEHOOK) {
+      //TIMEHOOK AWAKEN
+      const activityHandler = await this.initActivity(
+        `.${streamData.metadata.aid}`,
+        context.data,
+        context as JobState,
+        ) as Hook;
+      await activityHandler.processTimeHookEvent(streamData.metadata.jid);
+    } else if (streamData.type === StreamDataType.WEBHOOK) {
+      //WEBHOOK AWAKEN (SIGNAL IN)
+      const activityHandler = await this.initActivity(
+        `.${streamData.metadata.aid}`,
+        context.data,
+        context as JobState,
+        ) as Hook;
+      await activityHandler.processWebHookEvent(
+        streamData.status,
+        streamData.code
+      );
+    } else if (streamData.type === StreamDataType.TRANSITION) {
+      //TRANSITION (ADJACENT ACTIVITY)
+      const activityHandler = await this.initActivity(
+        `.${streamData.metadata.aid}`,
+        context.data,
+        context as JobState,
+      ) as Hook; //todo: `as Activity` (type is more generic)
+      await activityHandler.process();
     } else if (streamData.type === StreamDataType.AWAIT) {
+      //TRIGGER JOB
       context.metadata = {
         ...context.metadata,
         pj: streamData.metadata.jid,
+        pg: streamData.metadata.gid,
         pd: streamData.metadata.dad,
         pa: streamData.metadata.aid,
         trc: streamData.metadata.trc,
         spn: streamData.metadata.spn,
        };
-      const activityHandler = await this.initActivity(streamData.metadata.topic, streamData.data, context as JobState) as Trigger;
+      const activityHandler = await this.initActivity(
+        streamData.metadata.topic,
+        streamData.data,
+        context as JobState
+      ) as Trigger;
       await activityHandler.process();
     } else if (streamData.type === StreamDataType.RESULT) {
-      const activityHandler = await this.initActivity(`.${context.metadata.aid}`, streamData.data, context as JobState) as Await;
-      await activityHandler.processEvent(streamData.status, streamData.code);
+      //AWAIT RESULT
+      const activityHandler = await this.initActivity(
+        `.${context.metadata.aid}`,
+        streamData.data,
+        context as JobState,
+      ) as Await;
+      await activityHandler.processEvent(
+        streamData.status,
+        streamData.code,
+      );
     } else {
-      const activityHandler = await this.initActivity(`.${streamData.metadata.aid}`, streamData.data, context as JobState) as Worker;
-      await activityHandler.processEvent(streamData.status, streamData.code, 'output');
+      //WORKER RESULT
+      const activityHandler = await this.initActivity(
+        `.${streamData.metadata.aid}`,
+        streamData.data,
+        context as JobState,
+      ) as Worker;
+      await activityHandler.processEvent(
+        streamData.status,
+        streamData.code,
+        'output'
+      );
     }
     this.logger.debug('engine-process-stream-message-end', {
       jid: streamData.metadata.jid,
+      gid: streamData.metadata.gid,
       aid: streamData.metadata.aid
     });
   }
@@ -387,6 +423,7 @@ class EngineService {
         metadata: {
           guid: guid(),
           jid: context.metadata.pj,
+          gid: context.metadata.pg,
           dad: context.metadata.pd,
           aid: context.metadata.pa,
           trc: context.metadata.trc,
@@ -406,7 +443,7 @@ class EngineService {
         streamData.status = StreamStatus.SUCCESS;
         streamData.code = STATUS_CODE_SUCCESS;
       }
-      return (await this.streamSignaler?.publishMessage(null, streamData)) as string;
+      return (await this.router?.publishMessage(null, streamData)) as string;
     }
   }
   hasParentJob(context: JobState): boolean {
@@ -437,7 +474,7 @@ class EngineService {
 
   // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
   async hook(topic: string, data: JobData, status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<string> {
-    const hookRule = await this.storeSignaler.getHookRule(topic);
+    const hookRule = await this.taskService.getHookRule(topic);
     const [aid] = await this.getSchema(`.${hookRule.to}`);
     const streamData: StreamData = {
       type: StreamDataType.WEBHOOK,
@@ -450,9 +487,9 @@ class EngineService {
       },
       data,
     };
-    return await this.streamSignaler.publishMessage(null, streamData) as string;
+    return await this.router.publishMessage(null, streamData) as string;
   }
-  async hookTime(jobId: string, activityId: string, type?: 'sleep'|'expire'|'interrupt'): Promise<string | void> {
+  async hookTime(jobId: string, gId: string, activityId: string, type?: 'sleep'|'expire'|'interrupt'): Promise<string | void> {
     if (type === 'interrupt') {
       return await this.interrupt(
         activityId, //note: 'activityId' is the actually job topic
@@ -470,16 +507,17 @@ class EngineService {
       metadata: {
         guid: guid(),
         jid: jobId,
-        aid,
+        gid: gId,
         dad,
+        aid,
       },
       data: { timestamp: Date.now() },
     };
-    await this.streamSignaler.publishMessage(null, streamData);
+    await this.router.publishMessage(null, streamData);
   }
   async hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
     const config = await this.getVID();
-    const hookRule = await this.storeSignaler.getHookRule(hookTopic);
+    const hookRule = await this.taskService.getHookRule(hookTopic);
     if (hookRule) {
       const subscriptionTopic = await getSubscriptionTopic(hookRule.to, this.store, config)
       const resolvedQuery = await this.resolveQuery(subscriptionTopic, keyResolver);
@@ -597,7 +635,7 @@ class EngineService {
     }
   }
   async add(streamData: StreamData|StreamDataResponse): Promise<string> {
-    return await this.streamSignaler.publishMessage(null, streamData) as string;
+    return await this.router.publishMessage(null, streamData) as string;
   }
 
   registerJobCallback(jobId: string, jobCallback: JobMessageCallback) {
@@ -632,7 +670,7 @@ class EngineService {
       this.pubPermSubs(context, jobOutput, options.emit);
     }
     if (!options.emit) {
-      this.task.registerJobForCleanup(
+      this.taskService.registerJobForCleanup(
         context.metadata.jid,
         this.resolveExpires(context, options),
         options,
@@ -647,7 +685,7 @@ class EngineService {
    * it will be expired immediately.
    */
   resolveExpires(context: JobState, options: JobCompletionOptions): number {
-    return context.metadata.expire ?? options.expire ?? DURABLE_EXPIRE_SECONDS;
+    return options.expire ?? context.metadata.expire ?? DURABLE_EXPIRE_SECONDS;
   }
 
 

package/services/hotmesh/index.ts

@@ -4,8 +4,8 @@ import { RedisConnection } from '../connector/clients/redis';
 import { RedisConnection as IORedisConnection } from '../connector/clients/ioredis';
 import { EngineService } from '../engine';
 import { LoggerService, ILogger } from '../logger';
-import { StreamSignaler } from '../signaler/stream';
 import { QuorumService } from '../quorum';
+import { Router } from '../router';
 import { WorkerService } from '../worker';
 import {
   JobState,
@@ -16,7 +16,7 @@ import {
 import {
   HotMeshConfig,
   HotMeshManifest } from '../../types/hotmesh';
-import { JobMessageCallback } from '../../types/quorum';
+import { JobMessageCallback, QuorumProfile } from '../../types/quorum';
 import {
   JobStatsInput,
   GetStatsOptions,
@@ -137,6 +137,9 @@ class HotMeshService {
   }
 
   // ************* COMPILER METHODS *************
+  async rollCall(delay?: number): Promise<QuorumProfile[]> {
+    return await this.quorum?.rollCall(delay);
+  }
   async plan(path: string): Promise<HotMeshManifest> {
     return await this.engine?.plan(path);
   }
@@ -147,10 +150,6 @@ class HotMeshService {
     //activation is a quorum operation
     return await this.quorum?.activate(version, delay);
   }
-  async inventory(version: string, delay?: number): Promise<number> {
-    //get count of all peers
-    return await this.quorum?.inventory(delay);
-  }
 
   // ************* REPORTER METHODS *************
   async getStats(topic: string, query: JobStatsInput): Promise<StatsResponse> {
@@ -193,14 +192,14 @@ class HotMeshService {
   static async stop() {
     if (!this.disconnecting) {
       this.disconnecting = true;
-      await StreamSignaler.stopConsuming();
+      await Router.stopConsuming();
       await RedisConnection.disconnectAll();
       await IORedisConnection.disconnectAll();
     }
   }
 
   stop() {
-    this.engine?.task.cancelCleanup();
+    this.engine?.taskService.cancelCleanup();
   }
 
   async compress(terms: string[]): Promise<boolean> {

package/services/quorum/index.ts

@@ -14,6 +14,7 @@ import { RedisClientType as IORedisClientType } from '../../types/ioredisclient'
 import {
   QuorumMessage,
   QuorumMessageCallback,
+  QuorumProfile,
   SubscriptionCallback,
   ThrottleMessage
 } from '../../types/quorum';
@@ -26,10 +27,10 @@ const QUORUM_DELAY = 250;
 
 class QuorumService {
   namespace: string;
-  apps: HotMeshApps | null;
   appId: string;
   guid: string;
   engine: EngineService;
+  profiles: QuorumProfile[] = [];
   store: StoreService<RedisClient, RedisMulti> | null;
   subscribe: SubService<RedisClient, RedisMulti> | null;
   logger: ILogger;
@@ -108,9 +109,12 @@ class QuorumService {
       if (message.type === 'activate') {
         self.engine.setCacheMode(message.cache_mode, message.until_version);
       } else if (message.type === 'ping') {
-        this.sayPong(self.appId, self.guid, message.originator);
+        self.sayPong(self.appId, self.guid, message.originator, message.details);
       } else if (message.type === 'pong' && self.guid === message.originator) {
         self.quorum = self.quorum + 1;
+        if (message.profile) {
+          self.profiles.push(message.profile);
+        }
       } else if (message.type === 'throttle') {
         self.engine.throttle(message.throttle);
       } else if (message.type === 'work') {
@@ -127,20 +131,38 @@ class QuorumService {
     };
   }
 
-  async sayPong(appId: string, guid: string, originator: string) {
+  async sayPong(appId: string, guid: string, originator: string, details = false) {
+    let profile: QuorumProfile;
+    if (details) {
+      profile = {
+        engine_id: this.guid,
+        namespace: this.namespace,
+        app_id: this.appId,
+        stream: this.engine.stream.mintKey(KeyType.STREAMS, { appId: this.appId })
+      };
+    }
     this.store.publish(
       KeyType.QUORUM, 
-      { type: 'pong', guid, originator },
+      {
+        type: 'pong',
+        guid, originator,
+        profile,
+      },
       appId,
     );
   }
 
-  async requestQuorum(delay = QUORUM_DELAY): Promise<number> {
+  async requestQuorum(delay = QUORUM_DELAY, details = false): Promise<number> {
     const quorum = this.quorum;
     this.quorum = 0;
+    this.profiles.length = 0;
     await this.store.publish(
       KeyType.QUORUM,
-      { type: 'ping', originator: this.guid },
+      { 
+        type: 'ping',
+        originator: this.guid,
+        details,
+      },
       this.appId,
     );
     await sleepFor(delay);
@@ -166,12 +188,26 @@ class QuorumService {
 
 
   // ************* COMPILER METHODS *************
-  async inventory(delay = QUORUM_DELAY): Promise<number> {
-    await this.requestQuorum(delay);
-    const q1 = await this.requestQuorum(delay);
-    const q2 = await this.requestQuorum(delay);
-    const q3 = await this.requestQuorum(delay);
-    return Math.round((q1 + q2 + q3) / 3);
+  async rollCall(delay = QUORUM_DELAY): Promise<QuorumProfile[]> {
+    await this.requestQuorum(delay, true);
+    const targetStreams = [];
+    const multi = this.store.getMulti();
+    this.profiles.forEach((profile: QuorumProfile) => {
+      if (!targetStreams.includes(profile.stream)) {
+        targetStreams.push(profile.stream);
+        this.store.xlen(profile.stream, multi);
+      }
+    });
+    const stream_depths = await multi.exec() as number[];
+    this.profiles.forEach(async (profile: QuorumProfile) => {
+      const index = targetStreams.indexOf(profile.stream);
+      if (index != -1) {
+        profile.stream_depth = Array.isArray(stream_depths[index]) ?
+          stream_depths[index][1] :
+          stream_depths[index];
+      }
+    });
+    return this.profiles;
   }
   async activate(version: string, delay = QUORUM_DELAY): Promise<boolean> {
     version = version.toString();

package/services/{signaler/stream.ts → router/index.ts}

@@ -27,8 +27,8 @@ import {
   StreamStatus
 } from '../../types/stream';
 
-class StreamSignaler {
-  static signalers: Set<StreamSignaler> = new Set();
+class Router {
+  static instances: Set<Router> = new Set();
   appId: string;
   guid: string;
   role: StreamRole;
@@ -70,7 +70,7 @@ class StreamSignaler {
 
   async consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse|void>): Promise<void> {
     this.logger.info(`stream-consumer-starting`, { group, consumer, stream });
-    StreamSignaler.signalers.add(this);
+    Router.instances.add(this);
     this.shouldConsume = true;
     await this.createGroup(stream, group);
     let lastCheckedPendingMessagesAt = Date.now();
@@ -254,7 +254,7 @@ class StreamSignaler {
   }
   
   static async stopConsuming() {
-    for (const instance of [...StreamSignaler.signalers]) {
+    for (const instance of [...Router.instances]) {
       instance.stopConsuming();
     }
     await sleepFor(BLOCK_TIME_MS);
@@ -356,4 +356,4 @@ class StreamSignaler {
   }
 }
 
-export { StreamSignaler };
+export { Router };

package/services/serializer/index.ts

@@ -19,7 +19,7 @@ export const MDATA_SYMBOLS = {
     KEYS: ['au', 'err', 'l2s']
   },
   JOB: {
-    KEYS: ['ngn', 'tpc', 'pj', 'pd', 'pa', 'key', 'app', 'vrs', 'jid', 'aid', 'ts', 'jc', 'ju', 'js', 'err', 'trc']
+    KEYS: ['ngn', 'tpc', 'pj', 'pg', 'pd', 'pa', 'key', 'app', 'vrs', 'jid', 'gid', 'aid', 'ts', 'jc', 'ju', 'js', 'err', 'trc']
   },
   JOB_UPDATE: {
     KEYS: ['ju', 'err']

package/services/store/clients/ioredis.ts

@@ -131,6 +131,15 @@ class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType>
       throw error;
     }
   }
+
+  async xlen(key: string, multi? : RedisMultiType): Promise<number|RedisMultiType> {
+    try {
+      return await (multi || this.redisClient).xlen(key);
+    } catch (error) {
+      this.logger.error(`Error getting stream depth: ${key}`, { error });
+      throw error;
+    }
+  }
 }
 
 export { IORedisStoreService };

package/services/store/clients/redis.ts

@@ -42,6 +42,7 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
       rpush: 'RPUSH',
       xack: 'XACK',
       xdel: 'XDEL',
+      xlen: 'XLEN',
     };
   }
 
@@ -167,6 +168,21 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
       throw error;
     }
   }
+
+  async xlen(key: string, multi? : RedisMultiType): Promise<number|RedisMultiType> {
+    try {
+      if (multi) {
+        multi.XLEN(key);
+        return multi;
+      } else {
+        return await this.redisClient.XLEN(key);
+      }
+    } catch (error) {
+      this.logger.error(`Error getting stream depth: ${key}`, { error });
+      throw error;
+    }
+  }
+
 }
 
 export { RedisStoreService };