@hotmeshio/hotmesh 0.0.36 → 0.0.38

package/modules/errors.ts

@@ -122,6 +122,23 @@ class InactiveJobError extends Error {
     this.status = status;
   }
 }
+class GenerationalError extends Error {
+  expected: string;
+  actual: string;
+  jobId: string;
+  activityId: string;
+  dimensionalAddress: string;
+
+  constructor(expected: string, actual: string, jobId: string, activityId: string, dimensionalAddress: string) {
+    super("Generational Error");
+    this.expected = expected;
+    this.actual = actual;
+    this.jobId = jobId;
+    this.activityId = activityId;
+    this.dimensionalAddress = dimensionalAddress;
+  }
+}
+
 class ExecActivityError extends Error {
   constructor() {
     super("Error occurred while executing activity");
@@ -155,6 +172,7 @@ export {
   DurableWaitForSignalError,
   DuplicateJobError,
   ExecActivityError,
+  GenerationalError,
   GetStateError,
   InactiveJobError,
   MapDataError,

package/modules/key.ts

@@ -31,25 +31,25 @@ const HMNS = "hmsh";
 
 //these are the entity types that are stored in the key/value store
 enum KeyType {
-  APP,
-  ENGINE_ID,
-  HOOKS,
-  JOB_DEPENDENTS,
-  JOB_STATE,
-  JOB_STATS_GENERAL,
-  JOB_STATS_MEDIAN,
-  JOB_STATS_INDEX,
-  HOTMESH,
-  QUORUM,
-  SCHEMAS,
-  SIGNALS,
-  STREAMS,
-  SUBSCRIPTIONS,
-  SUBSCRIPTION_PATTERNS,
-  SYMKEYS,
-  SYMVALS,
-  TIME_RANGE,
-  WORK_ITEMS,
+  APP = 'APP',
+  ENGINE_ID = 'ENGINE',
+  HOOKS = 'HOOKS',
+  JOB_DEPENDENTS = 'JOB_DEPENDENTS',
+  JOB_STATE = 'JOB_STATE',
+  JOB_STATS_GENERAL = 'JOB_STATS_GENERAL',
+  JOB_STATS_MEDIAN = 'JOB_STATS_MEDIAN',
+  JOB_STATS_INDEX = 'JOB_STATS_INDEX',
+  HOTMESH = 'HOTMESH',
+  QUORUM = 'QUORUM',
+  SCHEMAS = 'SCHEMAS',
+  SIGNALS = 'SIGNALS',
+  STREAMS = 'STREAMS',
+  SUBSCRIPTIONS = 'SUBSCRIPTIONS',
+  SUBSCRIPTION_PATTERNS = 'SUBSCRIPTION_PATTERNS',
+  SYMKEYS = 'SYMKEYS',
+  SYMVALS = 'SYMVALS',
+  TIME_RANGE = 'TIME_RANGE',
+  WORK_ITEMS = 'WORK_ITEMS',
 }
 
 //when minting a key, the following parameters are used to create a unique key per entity
@@ -64,6 +64,7 @@ type KeyStoreParams = {
   facet?: string;       //data path starting at root with values separated by colons (e.g. "object/type:bar")
   topic?: string;       //topic name (e.g., "foo" or "" for top-level)
   timeValue?: number;   //time value (rounded to minute) (for delete range)
+  scoutType?: 'signal' | 'time'; //a single member of the quorum serves as the 'scout' for the group, triaging tasks for the collective
 };
 
 class KeyService {
@@ -86,7 +87,7 @@ class KeyService {
       case KeyType.ENGINE_ID:
         return `${namespace}:${params.appId}:e:${params.engineId}`;
       case KeyType.WORK_ITEMS:
-        return `${namespace}:${params.appId}:w:`;
+        return `${namespace}:${params.appId}:w:${params.scoutType || ''}`;
       case KeyType.TIME_RANGE:
         return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
       case KeyType.APP:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/services/activities/activity.ts

@@ -1,4 +1,9 @@
-import { CollationError, GetStateError, InactiveJobError } from '../../modules/errors';
+import { EXPIRE_DURATION } from '../../modules/enums';
+import {
+  CollationError,
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import {
   formatISODate,
   getValueByPath,
@@ -30,7 +35,6 @@ import {
   StreamDataType,
   StreamStatus } from '../../types/stream';
 import { TransitionRule } from '../../types/transition';
-import { EXPIRE_DURATION } from '../../modules/enums';
 
 /**
  * The base class for all activities
@@ -71,6 +75,21 @@ class Activity {
     this.leg = leg;
   }
 
+  /**
+   * Upon entering leg 1 of a duplexed activty, verify
+   * all aspects of the entry including job and activty state
+   */
+  async verifyEntry() {
+    this.setLeg(1);
+    await this.getState();
+    CollatorService.assertJobActive(
+      this.context.metadata.js,
+      this.context.metadata.jid,
+      this.metadata.aid
+    );
+    await CollatorService.notarizeEntry(this);
+  }
+
   //********  DUPLEX RE-ENTRY POINT  ********//
   async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200, type: 'hook' | 'output' = 'output'): Promise<void> {
     this.setLeg(2);
@@ -116,6 +135,9 @@ class Activity {
       } else if (error instanceof InactiveJobError) {
         this.logger.info('process-event-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.info('process-event-get-job-error', { error });
         return;
@@ -337,7 +359,7 @@ class Activity {
   }
 
   async getState() {
-    //assemble list of paths necessary to create 'job state' from the 'symbol hash'
+    const gid = this.context.metadata.gid;
     const jobSymbolHashName = `$${this.config.subscribes}`;
     const consumes: Consumes = {
       [jobSymbolHashName]: MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`)
@@ -365,11 +387,28 @@ class Activity {
     //`state` is a flat hash; context is a tree
     const [state, status] = await this.store.getState(jid, consumes, dIds);
     this.context = restoreHierarchy(state) as JobState;
+    this.assertGenerationalId(this.context.metadata.gid, gid);
     this.initDimensionalAddress(dad);
     this.initSelf(this.context);
     this.initPolicies(this.context);
   }
 
+  /**
+   * if the job is created/deleted/created with the same key,
+   * the 'gid' ensures no stale messages enter the stream
+   */
+  assertGenerationalId(jobGID: string, msgGID?: string) {
+    if (msgGID !== jobGID) {
+      throw new GenerationalError(
+        jobGID,
+        msgGID,
+        this.context.metadata.jid,
+        this.context.metadata.aid,
+        this.context.metadata.dad
+      );
+    }
+  }
+
   initDimensionalAddress(dad: string): void {
     this.metadata.dad = dad;
   }
@@ -434,6 +473,7 @@ class Activity {
             metadata: {
               guid: guid(),
               jid: this.context.metadata.jid,
+              gid: this.context.metadata.gid,
               dad: adjacentDad,
               aid: toActivityId,
               spn: this.context['$self'].output.metadata?.l2s,
@@ -466,7 +506,7 @@ class Activity {
     if (adjacencyList.length && jobStatus > 0) {
       const multi = this.store.getMulti();
       for (const execSignal of adjacencyList) {
-        await this.engine.streamSignaler?.publishMessage(null, execSignal, multi);
+        await this.engine.router?.publishMessage(null, execSignal, multi);
       }
       mIds = (await multi.exec()) as string[];
     }

package/services/activities/await.ts

@@ -1,7 +1,11 @@
-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';
+import { TelemetryService } from '../telemetry';
 import {
   ActivityData,
   ActivityMetadata,
@@ -10,7 +14,6 @@ import {
 import { JobState } from '../../types/job';
 import { MultiResponseFlags, RedisMulti } from '../../types/redis';
 import { StreamData, StreamDataType } from '../../types/stream';
-import { TelemetryService } from '../telemetry';
 import { Pipe } from '../pipe';
 import { guid } from '../../modules/utils';
 
@@ -29,14 +32,11 @@ class Await extends Activity {
 
   //********  INITIAL ENTRY POINT (A)  ********//
   async process(): Promise<string> {
-    this.logger.debug('await-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('await-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();
@@ -62,6 +62,9 @@ class Await 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('await-get-state-error', { error });
         return;
@@ -72,7 +75,7 @@ class Await extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('await-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('await-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -82,6 +85,7 @@ class Await 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 Await extends Activity {
         retry: this.config.retry
       };
     }
-    return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi)) as string;
+    return (await this.engine.router?.publishMessage(null, streamData, multi)) as string;
   }
 }
 

package/services/activities/cycle.ts

@@ -1,4 +1,7 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
 import { Activity, ActivityType } from './activity';
@@ -28,14 +31,11 @@ class Cycle extends Activity {
 
   //********  LEG 1 ENTRY  ********//
   async process(): Promise<string> {
-    this.logger.debug('cycle-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('cycle-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //verify entry is allowed
-      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();
@@ -65,6 +65,9 @@ class Cycle extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('cycle-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('cycle-get-state-error', { error });
         return;
@@ -75,7 +78,7 @@ class Cycle extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -95,15 +98,16 @@ class Cycle extends Activity {
     const streamData: StreamData = {
       metadata: {
         guid: guid(),
-        dad: CollatorService.resolveReentryDimension(this),
         jid: this.context.metadata.jid,
+        gid: this.context.metadata.gid,
+        dad: CollatorService.resolveReentryDimension(this),
         aid: this.config.ancestor,
         spn: this.context['$self'].output.metadata?.l1s,
         trc: this.context.metadata.trc,
       },
       data: this.context.data
     };
-    return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi)) as string;
+    return (await this.engine.router?.publishMessage(null, streamData, multi)) as string;
   }
 }
 

package/services/activities/hook.ts

@@ -1,9 +1,12 @@
-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';
 import { Pipe } from '../pipe';
-import { StoreSignaler } from '../signaler/store';
+import { TaskService } from '../task';
 import { TelemetryService } from '../telemetry';
 import { 
   ActivityData,
@@ -19,7 +22,7 @@ import { StringScalarType } from '../../types/serializer';
 import { StreamCode, StreamStatus } from '../../types/stream';
 
 /**
- * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
+ * Supports `signal hook`, `time hook`, and `cycle hook` patterns
  */
 class Hook extends Activity {
   config: HookActivity;
@@ -36,48 +39,25 @@ class Hook extends Activity {
 
   //********  INITIAL ENTRY POINT (A)  ********//
   async process(): Promise<string> {
-    this.logger.debug('hook-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('hook-process', {
+      jid: this.context.metadata.jid,
+      gid: this.context.metadata.gid,
+      aid: this.metadata.aid,
+    });
     let telemetry: TelemetryService;
+
     try {
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
+      await this.verifyEntry();
 
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
-      let multiResponse: MultiResponseFlags;
 
-      const multi = this.store.getMulti();
       if (this.doesHook()) {
         //sleep and wait to awaken upon a signal
-        await this.registerHook(multi);
-        this.mapOutputData();
-        this.mapJobData();
-        await this.setState(multi);
-        await CollatorService.authorizeReentry(this, multi);
-
-        await this.setStatus(0, multi);
-        await multi.exec();
-        telemetry.mapActivityAttributes();
+        await this.doHook(telemetry);
       } else {
         //end the activity and transition to its children
-        this.adjacencyList = await this.filterAdjacent();
-        this.mapOutputData();
-        this.mapJobData();
-        await this.setState(multi);
-        await CollatorService.notarizeEarlyCompletion(this, multi);
-
-        await this.setStatus(this.adjacencyList.length - 1, multi);
-        multiResponse = await multi.exec() as MultiResponseFlags;
-        telemetry.mapActivityAttributes();
-        const jobStatus = this.resolveStatus(multiResponse);
-        const attrs: StringScalarType = { 'app.job.jss': jobStatus };
-        const messageIds = await this.transition(this.adjacencyList, jobStatus);
-        if (messageIds.length) {
-          attrs['app.activity.mids'] = messageIds.join(',')
-        }
-        telemetry.setActivityAttributes(attrs);
+        await this.doPassThrough(telemetry);
       }
 
       return this.context.metadata.aid;
@@ -85,6 +65,9 @@ class Hook extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('hook-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('hook-get-state-error', { error });
         return;
@@ -95,16 +78,52 @@ class Hook extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('hook-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('hook-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
-  //********  SIGNAL RE-ENTRY POINT  ********//
+  /**
+   * does this activity use a time-hook or web-hook
+   */
   doesHook(): boolean {
-    //does this activity use a time-hook or web-hook
     return !!(this.config.hook?.topic || this.config.sleep);
   }
 
+  async doHook(telemetry: TelemetryService) {
+    const multi = this.store.getMulti();
+    await this.registerHook(multi);
+    this.mapOutputData();
+    this.mapJobData();
+    await this.setState(multi);
+    await CollatorService.authorizeReentry(this, multi);
+
+    await this.setStatus(0, multi);
+    await multi.exec();
+    telemetry.mapActivityAttributes();
+  }
+
+  async doPassThrough(telemetry: TelemetryService) {
+    const multi = this.store.getMulti();
+    let multiResponse: MultiResponseFlags;
+    
+    this.adjacencyList = await this.filterAdjacent();
+    this.mapOutputData();
+    this.mapJobData();
+    await this.setState(multi);
+    await CollatorService.notarizeEarlyCompletion(this, multi);
+
+    await this.setStatus(this.adjacencyList.length - 1, multi);
+    multiResponse = await multi.exec() as MultiResponseFlags;
+    telemetry.mapActivityAttributes();
+    const jobStatus = this.resolveStatus(multiResponse);
+    const attrs: StringScalarType = { 'app.job.jss': jobStatus };
+    const messageIds = await this.transition(this.adjacencyList, jobStatus);
+    if (messageIds.length) {
+      attrs['app.activity.mids'] = messageIds.join(',')
+    }
+    telemetry.setActivityAttributes(attrs);
+  }
+
   async getHookRule(topic: string): Promise<HookRule | undefined> {
     const rules = await this.store.getHookRules();
     return rules?.[topic]?.[0] as HookRule;
@@ -112,18 +131,20 @@ class Hook extends Activity {
 
   async registerHook(multi?: RedisMulti): Promise<string | void> {
     if (this.config.hook?.topic) {
-      const signaler = new StoreSignaler(this.store, this.logger);
-      return await signaler.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
+      const taskService = new TaskService(this.store, this.logger);
+      return await taskService.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
     } else if (this.config.sleep) {
       const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
       const jobId = this.context.metadata.jid;
+      const gId = this.context.metadata.gid;
       const activityId = this.metadata.aid;
       const dId = this.metadata.dad;
-      await this.engine.task.registerTimeHook(jobId, `${activityId}${dId||''}`, 'sleep', durationInSeconds);
+      await this.engine.taskService.registerTimeHook(jobId, gId, `${activityId}${dId||''}`, 'sleep', durationInSeconds);
       return jobId;
     }
   }
 
+  //********  SIGNAL RE-ENTRY POINT  ********//
   async processWebHookEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<JobStatus | void> {
     this.logger.debug('hook-process-web-hook-event', {
       topic: this.config.hook.topic,
@@ -131,23 +152,25 @@ class Hook extends Activity {
       status,
       code,
     });
-    const signaler = new StoreSignaler(this.store, this.logger);
+    const taskService = new TaskService(this.store, this.logger);
     const data = { ...this.data };
-    const signal = await signaler.processWebHookSignal(this.config.hook.topic, data);
+    const signal = await taskService.processWebHookSignal(this.config.hook.topic, data);
     if (signal) {
-      const [jobId, aid, dad] = signal;
+      const [jobId, _aid, dad, gId] = signal;
       this.context.metadata.jid = jobId;
+      this.context.metadata.gid = gId;
       this.context.metadata.dad = dad;
       await this.processEvent(status, code, 'hook');
-      if (code === 200) { //otherwise 202 for pending/keepalive
-        await signaler.deleteWebHookSignal(this.config.hook.topic, data);
-      }
+      if (code === 200) {
+        await taskService.deleteWebHookSignal(this.config.hook.topic, data);
+      } //else => 202/keep alive
     } //else => already resolved
   }
 
   async processTimeHookEvent(jobId: string): Promise<JobStatus | void> {
     this.logger.debug('hook-process-time-hook-event', {
       jid: jobId,
+      gid: this.context.metadata.gid,
       aid: this.metadata.aid
     });
     await this.processEvent(StreamStatus.SUCCESS, 200, 'hook');

package/services/activities/interrupt.ts

@@ -1,10 +1,13 @@
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { EngineService } from '../engine';
 import { Activity, ActivityType } from './activity';
 import {
   ActivityData,
   ActivityMetadata,
   InterruptActivity } from '../../types/activity';
-import { GetStateError, InactiveJobError } from '../../modules/errors';
 import { MultiResponseFlags } from '../../types';
 import { CollatorService } from '../collator';
 import { JobInterruptOptions, JobState } from '../../types/job';
@@ -28,25 +31,26 @@ class Interrupt extends Activity {
 
   //********  LEG 1 ENTRY  ********//
   async process(): Promise<string> {
-    this.logger.debug('interrupt-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('interrupt-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid); // Ensure job active
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
   
       if (this.isInterruptingSelf()) {
-        return await this.interruptSelf(telemetry);
+        await this.interruptSelf(telemetry);
       } else {
-        return await this.interruptAnother(telemetry);
+        await this.interruptAnother(telemetry);
       }
     } catch (error) {
       if (error instanceof InactiveJobError) {
         this.logger.error('interrupt-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('interrupt-get-state-error', { error });
         return;
@@ -57,7 +61,7 @@ class Interrupt extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('interrupt-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('interrupt-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -118,7 +122,6 @@ class Interrupt extends Activity {
   
     return this.context.metadata.aid;
   }
-  
 
   isInterruptingSelf(): boolean {
     if (!this.config.target) {

package/services/activities/signal.ts

@@ -1,4 +1,7 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { Activity, ActivityType } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
@@ -30,14 +33,11 @@ class Signal extends Activity {
 
   //********  LEG 1 ENTRY  ********//
   async process(): Promise<string> {
-    this.logger.debug('signal-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('signal-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //verify entry is allowed
-      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);
 
@@ -73,6 +73,9 @@ class Signal extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('signal-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('signal-get-state-error', { error });
         return;
@@ -83,7 +86,7 @@ class Signal extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('signal-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('signal-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }