@hotmeshio/hotmesh 0.0.19 → 0.0.21

package/services/durable/worker.ts

@@ -6,6 +6,7 @@ import {
   DurableSleepError,
   DurableTimeoutError, 
   DurableWaitForSignalError} from '../../modules/errors';
+import { KeyService, KeyType } from '../../modules/key';
 import { asyncLocalStorage } from './asyncLocalStorage';
 import { APP_ID, APP_VERSION, getWorkflowYAML } from './factory';
 import { HotMeshService as HotMesh } from '../hotmesh';
@@ -16,13 +17,12 @@ import {
   WorkerConfig,
   WorkerOptions,
   WorkflowDataType, 
-  WorkflowSearchOptions} from "../../types/durable";
+  WorkflowSearchOptions} from '../../types/durable';
 import { RedisClass, RedisOptions } from '../../types/redis';
 import {
   StreamData,
   StreamDataResponse,
   StreamStatus } from '../../types/stream';
-import { KeyService, KeyType } from '../../modules/key';
 
 export class WorkerService {
   static activityRegistry: Registry = {}; //user's activities
@@ -31,25 +31,26 @@ export class WorkerService {
   workflowRunner: HotMesh;
   activityRunner: HotMesh;
 
-  static getHotMesh = async (worflowTopic: string, options?: WorkerOptions) => {
-    if (WorkerService.instances.has(worflowTopic)) {
-      return await WorkerService.instances.get(worflowTopic);
+  static getHotMesh = async (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => {
+    if (WorkerService.instances.has(workflowTopic)) {
+      return await WorkerService.instances.get(workflowTopic);
     }
     const hotMeshClient = HotMesh.init({
-      appId: APP_ID,
+      logLevel: options?.logLevel as 'debug' ?? 'info',
+      appId: config.namespace ?? APP_ID,
       engine: { redis: { ...WorkerService.connection } }
     });
-    WorkerService.instances.set(worflowTopic, hotMeshClient);
+    WorkerService.instances.set(workflowTopic, hotMeshClient);
     await WorkerService.activateWorkflow(await hotMeshClient);
     return hotMeshClient;
   }
 
   static async activateWorkflow(hotMesh: HotMesh) {
-    const app = await hotMesh.engine.store.getApp(APP_ID);
+    const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
     const appVersion = app?.version;
     if(!appVersion) {
       try {
-        await hotMesh.deploy(getWorkflowYAML(APP_ID, APP_VERSION));
+        await hotMesh.deploy(getWorkflowYAML(hotMesh.engine.appId, APP_VERSION));
         await hotMesh.activate(APP_VERSION);
       } catch (err) {
         hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
@@ -65,11 +66,6 @@ export class WorkerService {
     }
   }
 
-  /**
-   * NOTE: Because the worker imports the workflows dynamically AFTER
-   * the activities are loaded, there will be items in the registry,
-   * allowing proxyActivities to succeed.
-   */
   static registerActivities<ACT>(activities: ACT): Registry  {
     if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
       WorkerService.activityRegistry[activities.name] = activities as Function;
@@ -85,10 +81,11 @@ export class WorkerService {
 
   /**
    * For those deployments with a redis stack backend (with the FT module),
-   * this method will configure the search index for the workflow.
+   * this method will configure the search index for the workflow. For all
+   * others, this method will fail gracefully. In all cases, the values
+   * will be stored in the workflow's central HASH data structure, allowing
+   * for manual traversal and inspection as well.
    */
-  //todo: bind this to the Search service; update constructor to expect hotMeshClient as first param (id is optional
-  //refactor and delete other one as well)
   static async configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void> {
     if (search?.schema) {
       const store = hotMeshClient.engine.store;
@@ -116,7 +113,6 @@ export class WorkerService {
   }
 
   static async create(config: WorkerConfig) {
-    //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
     const workflow = config.workflow;
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
@@ -155,7 +151,8 @@ export class WorkerService {
       options: config.connection.options as RedisOptions
     };
     const hotMeshWorker = await HotMesh.init({
-      appId: APP_ID,
+      logLevel: config.options?.logLevel as 'debug' ?? 'info',
+      appId: config.namespace ?? APP_ID,
       engine: { redis: redisConfig },
       workers: [
         { topic: activityTopic,
@@ -205,12 +202,13 @@ export class WorkerService {
       options: config.connection.options as RedisOptions
     };
     const hotMeshWorker = await HotMesh.init({
-      appId: APP_ID,
+      logLevel: config.options?.logLevel as 'debug' ?? 'info',
+      appId: config.namespace ?? APP_ID,
       engine: { redis: redisConfig },
       workers: [{
         topic: workflowTopic,
         redis: redisConfig,
-        callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic).bind(this)
+        callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic, config).bind(this)
       }]
     });
     WorkerService.instances.set(workflowTopic, hotMeshWorker);
@@ -226,15 +224,22 @@ export class WorkerService {
     },
   };
 
-  wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string): Function {
+  wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string, config: WorkerConfig): Function {
     return async (data: StreamData): Promise<StreamDataResponse> => {
      const counter = { counter: 0 };
       try {
         //incoming data payload has arguments and workflowId
         const workflowInput = data.data as unknown as WorkflowDataType;
         const context = new Map();
+        context.set('namespace', config.namespace ?? APP_ID);
         context.set('counter', counter);
         context.set('workflowId', workflowInput.workflowId);
+        if (data.data.workflowDimension) {
+          //every hook function runs in an isolated dimension controlled
+          //by the index assigned when the signal was received; even if the
+          //hook function re-runs, its scope will always remain constant
+          context.set('workflowDimension', data.data.workflowDimension);
+        }
         context.set('workflowTopic', workflowTopic);
         context.set('workflowName', workflowTopic.split('-').pop());
         context.set('workflowTrace', data.metadata.trc);
@@ -259,9 +264,10 @@ export class WorkerService {
             metadata: { ...data.metadata },
             data: {
               code: err.code,
-              message: JSON.stringify({ duration: err.duration, index: err.index }),
+              message: JSON.stringify({ duration: err.duration, index: err.index, dimension: err.dimension }),
               duration: err.duration,
-              index: err.index
+              index: err.index,
+              dimension: err.dimension
             }
           } as StreamDataResponse;
 

package/services/durable/workflow.ts

@@ -1,31 +1,43 @@
 import ms from 'ms';
 
+import {
+  DurableIncompleteSignalError,
+  DurableSleepError,
+  DurableWaitForSignalError } from '../../modules/errors';
+import { KeyService, KeyType } from '../../modules/key';
 import { asyncLocalStorage } from './asyncLocalStorage';
-import { WorkerService } from './worker';
 import { ClientService as Client } from './client';
 import { ConnectionService as Connection } from './connection';
-import { ActivityConfig, ProxyType, WorkflowConfig, WorkflowOptions, WorkflowSearchOptions } from "../../types/durable";
-import { JobOutput, JobState } from '../../types';
-import { ACTIVITY_PUBLISHES_TOPIC, ACTIVITY_SUBSCRIBES_TOPIC, SLEEP_SUBSCRIBES_TOPIC, WFS_SUBSCRIBES_TOPIC } from './factory';
-import { DurableIncompleteSignalError, DurableSleepError, DurableWaitForSignalError } from '../../modules/errors';
+import { DEFAULT_COEFFICIENT } from './factory';
 import { Search } from './search';
+import { WorkerService } from './worker';
+import { HotMeshService as HotMesh } from '../hotmesh';
+import {
+  ActivityConfig,
+  HookOptions,
+  ProxyType,
+  WorkflowOptions } from "../../types/durable";
+import { JobOutput, JobState } from '../../types/job';
+import { StreamStatus } from '../../types/stream';
 
 export class WorkflowService {
 
   /**
-   * Spawn a child workflow. await the result.
+   * Spawn a child workflow. await and return the result.
    */
   static async executeChild<T>(options: WorkflowOptions): Promise<T> {
     const store = asyncLocalStorage.getStore();
-    if (!store) {
-      throw new Error('durable-store-not-found');
-    }
+    const namespace = store.get('namespace');
     const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
     const workflowTrace = store.get('workflowTrace');
     const workflowSpan = store.get('workflowSpan');
     const COUNTER = store.get('counter');
     const execIndex = COUNTER.counter = COUNTER.counter + 1;
-    const childJobId = `${workflowId}-$${options.workflowName}-${execIndex}`;
+    //this is risky but MUST be allowed. Users MAY set the workflowId,
+    //but if there is a naming collision, the data from the target entity will be used
+    //as there is know way of knowing if the item was generated via a prior run of the workflow
+    const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
     const parentWorkflowId = `${workflowId}-f`;
 
     const client = new Client({
@@ -35,24 +47,65 @@ export class WorkflowService {
     let handle = await client.workflow.getHandle(
       options.taskQueue,
       options.workflowName,
-      childJobId
+      childJobId,
+      namespace,
     );
 
     try {
-      return await handle.result() as T;
+      return await handle.result(true) as T;
     } catch (error) {
       handle = await client.workflow.start({
         ...options,
+        namespace,
         workflowId: childJobId,
         parentWorkflowId,
         workflowTrace,
         workflowSpan,
       });
+      //todo: options.startToCloseTimeout
       const result = await handle.result();
       return result as T;
     }
   }
 
+  /**
+   * spawn a child workflow. return the childJobId.
+   */
+  static async startChild<T>(options: WorkflowOptions): Promise<string> {
+    const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const workflowTrace = store.get('workflowTrace');
+    const workflowSpan = store.get('workflowSpan');
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+    const parentWorkflowId = `${workflowId}-f`;
+    const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+
+    try {
+      //get the status; if there is no error, return childJobId (what was spawned)
+      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
+      await hotMeshClient.getStatus(childJobId);
+      return childJobId;
+    } catch (error) {
+      const client = new Client({
+        connection: await Connection.connect(WorkerService.connection),
+      });
+  
+      await client.workflow.start({
+        ...options,
+        namespace,
+        workflowId: childJobId,
+        parentWorkflowId,
+        workflowTrace,
+        workflowSpan,
+      });
+      return childJobId;
+    }
+  }
+
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
     if (options.activities) {
       WorkerService.registerActivities(options.activities)
@@ -71,51 +124,117 @@ export class WorkflowService {
 
   static async search(): Promise<Search> {
     const store = asyncLocalStorage.getStore();
-    if (!store) {
-      throw new Error('durable-store-not-found');
-    }
     const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
     const workflowTopic = store.get('workflowTopic');
+    const namespace = store.get('namespace');
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    //this ID is used as a item key with a hash (dash prefix ensures no collision)
+    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
+    const searchSessionId = `-search${workflowDimension}-${execIndex}`;
+    return new Search(workflowId, hotMeshClient, searchSessionId);
+  }
 
-    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
-    return new Search(workflowId, hotMeshClient);
+  /**
+   * those methods that may only be called once must be protected by flagging
+   * their execution with a unique key (the key is stored in the workflow state)
+   */
+  static async isSideEffectAllowed(hotMeshClient: HotMesh, prefix:string): Promise<boolean> {
+    const store = asyncLocalStorage.getStore();
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    //this ID is used as a item key with a hash (dash prefix ensures no collision)
+    const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+    //this ID is used as a item key with a hash (dash prefix ensures no collision)
+    const keyParams = {
+      appId: hotMeshClient.appId,
+      jobId: ''
+    }
+    const hotMeshPrefix = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
+    const workflowGuid = `${hotMeshPrefix}${workflowId}`;
+    const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1') as string);
+    return guidValue === 1;
+  }
+
+  /**
+   * send signal data into any other paused thread (which is paused and
+   * awaiting the signal) from within a hook-thread or the main-thread
+   */
+  static async signal(signalId: string, data: Record<any, any>): Promise<string> {
+    const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
+    const hotMeshClient = await WorkerService.getHotMesh(`${namespace}.wfs.signal`, { namespace });
+    if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
+      return await hotMeshClient.hook(`${namespace}.wfs.signal`, { id: signalId, data });
+    }
+  }
+
+  /**
+   * spawn a hook from either the main thread or a hook thread with
+   * the provided options; worflowId/TaskQueue/Name are optional and will
+   * default to the current workflowId/WorkflowTopic if not provided
+   */
+  static async hook(options: HookOptions): Promise<string> {
+    const store = asyncLocalStorage.getStore();
+    const namespace = store.get('namespace');
+    const hotMeshClient = await WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
+    if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
+      const store = asyncLocalStorage.getStore();
+      let workflowId: string;
+      let workflowTopic: string;
+      if (options.workflowId && options.taskQueue && options.workflowName) {
+        workflowId = options.workflowId;
+        workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+      } else {
+        workflowId = store.get('workflowId');
+        workflowTopic = store.get('workflowTopic');
+      }
+      const payload = {
+        arguments: [...options.args],
+        id: workflowId,
+        workflowTopic,
+        backoffCoefficient: options.config?.backoffCoefficient || DEFAULT_COEFFICIENT,
+      }
+      return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, StreamStatus.PENDING, 202);
+    }
   }
 
   static async sleep(duration: string): Promise<number> {
     const seconds = ms(duration) / 1000;
 
     const store = asyncLocalStorage.getStore();
-    if (!store) {
-      throw new Error('durable-store-not-found');
-    }
     const COUNTER = store.get('counter');
     const execIndex = COUNTER.counter = COUNTER.counter + 1;
     const workflowId = store.get('workflowId');
     const workflowTopic = store.get('workflowTopic');
-    const sleepJobId = `${workflowId}-$sleep-${execIndex}`;
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const namespace = store.get('namespace');
+    const sleepJobId = `${workflowId}-$sleep${workflowDimension}-${execIndex}`;
 
     try {
-      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
-      await hotMeshClient.getState(SLEEP_SUBSCRIBES_TOPIC, sleepJobId);
+      const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
+      await hotMeshClient.getState(`${hotMeshClient.appId}.sleep.execute`, sleepJobId);
       //if no error is thrown, we've already slept, return the delay
       return seconds;
     } catch (e) {
       //if an error, the sleep job was not found...rethrow error; sleep job
       // will be automatically created according to the DAG rules (they
       // spawn a new sleep job if error code 595 is thrown by the worker)
-      throw new DurableSleepError(workflowId, seconds, execIndex);
+      throw new DurableSleepError(workflowId, seconds, execIndex, workflowDimension);
     }
   }
 
   static async waitForSignal(signals: string[], options?: Record<string, string>): Promise<Record<any, any>[]> {
     const store = asyncLocalStorage.getStore();
-    if (!store) {
-      throw new Error('durable-store-not-found');
-    }
     const COUNTER = store.get('counter');
     const workflowId = store.get('workflowId');
     const workflowTopic = store.get('workflowTopic');
-    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic);
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const namespace = store.get('namespace');
+    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
 
     //iterate the list of signals and check for done
     let allAreComplete = true;
@@ -123,10 +242,10 @@ export class WorkflowService {
     const signalResults: any[] = [];
     for (const signal of signals) {
       const execIndex = COUNTER.counter = COUNTER.counter + 1;
-      const wfsJobId = `${workflowId}-$wfs-${execIndex}`;
+      const wfsJobId = `${workflowId}-$wfs${workflowDimension}-${execIndex}`;
       try {
         if (allAreComplete) {
-          const state = await hotMeshClient.getState(WFS_SUBSCRIBES_TOPIC, wfsJobId);
+          const state = await hotMeshClient.getState(`${hotMeshClient.appId}.wfs.execute`, wfsJobId);
           if (state.data?.signalData) {
             //user data is nested to isolate from the signal id; unpackage it
             const signalData = state.data.signalData as { id: string, data: Record<any, any> };
@@ -160,23 +279,22 @@ export class WorkflowService {
   static wrapActivity<T>(activityName: string, options?: ActivityConfig): T {
     return async function() {
       const store = asyncLocalStorage.getStore();
-      if (!store) {
-        throw new Error('durable-store-not-found');
-      }
       const COUNTER = store.get('counter');
       //increment by state (not value) to avoid race conditions
       const execIndex = COUNTER.counter = COUNTER.counter + 1;
       const workflowId = store.get('workflowId');
+      const workflowDimension = store.get('workflowDimension') ?? '';
       const workflowTopic = store.get('workflowTopic');
       const trc = store.get('workflowTrace');
       const spn = store.get('workflowSpan');
+      const namespace = store.get('namespace');
       const activityTopic = `${workflowTopic}-activity`;
-      const activityJobId = `${workflowId}-$${activityName}-${execIndex}`;
+      const activityJobId = `${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
 
       let activityState: JobOutput
       try {
-        const hotMeshClient = await WorkerService.getHotMesh(activityTopic);
-        activityState = await hotMeshClient.getState(ACTIVITY_SUBSCRIBES_TOPIC, activityJobId);
+        const hotMeshClient = await WorkerService.getHotMesh(activityTopic, { namespace });
+        activityState = await hotMeshClient.getState(`${hotMeshClient.appId}.activity.execute`, activityJobId);
         if (activityState.metadata.err) {
           await hotMeshClient.scrub(activityJobId);
           throw new Error(activityState.metadata.err);
@@ -185,9 +303,9 @@ export class WorkflowService {
         }
         //one time subscription
         return await new Promise((resolve, reject) => {
-          hotMeshClient.sub(`${ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`, async (topic, message) => {
+          hotMeshClient.sub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`, async (topic, message) => {
             const response = message.data?.response;
-            hotMeshClient.unsub(`${ACTIVITY_PUBLISHES_TOPIC}.${activityJobId}`);
+            hotMeshClient.unsub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`);
             // Resolve the Promise when the callback is triggered with a message
             resolve(response);
           });
@@ -204,9 +322,9 @@ export class WorkflowService {
           activityName,
         };
         //start the job
-        const hotMeshClient = await WorkerService.getHotMesh(activityTopic);
+        const hotMeshClient = await WorkerService.getHotMesh(activityTopic, { namespace });
         const context = { metadata: { trc, spn }, data: {}};
-        const jobOutput = await hotMeshClient.pubsub(ACTIVITY_SUBSCRIBES_TOPIC, payload, context as JobState, duration);
+        const jobOutput = await hotMeshClient.pubsub(`${hotMeshClient.appId}.activity.execute`, payload, context as JobState, duration);
         return jobOutput.data.response as T;
       }
     } as T;

package/services/engine/index.ts

@@ -60,6 +60,7 @@ import {
   StatsResponse
 } from '../../types/stats';
 import {
+  StreamCode,
   StreamData,
   StreamDataResponse,
   StreamDataType,
@@ -344,7 +345,8 @@ class EngineService {
       } else if (streamData.type === StreamDataType.TRANSITION) {
         await activityHandler.process();
       } else {
-        await activityHandler.processWebHookEvent();
+        //a 202 code keeps the hook alive (hooks are single-use by default)
+        await activityHandler.processWebHookEvent(streamData.status, streamData.code);
       }
     } else if (streamData.type === StreamDataType.AWAIT) {
       context.metadata = {
@@ -362,7 +364,7 @@ class EngineService {
       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);
+      await activityHandler.processEvent(streamData.status, streamData.code, 'output');
     }
     this.logger.debug('engine-process-stream-message-end', {
       jid: streamData.metadata.jid,
@@ -417,21 +419,15 @@ class EngineService {
   }
 
   // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
-  async hook(topic: string, data: JobData, dad?: string): Promise<string> {
+  async hook(topic: string, data: JobData, status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<string> {
     const hookRule = await this.storeSignaler.getHookRule(topic);
-    const [aid, schema] = await this.getSchema(`.${hookRule.to}`);
-    if (!dad) {
-      //assume dimensional address is singular (0)
-      // for ancestors and self if not provided
-      // todo: register
-      dad = ',0'.repeat(schema.ancestors.length + 1);
-    }
+    const [aid] = await this.getSchema(`.${hookRule.to}`);
     const streamData: StreamData = {
       type: StreamDataType.WEBHOOK,
+      status,
+      code,
       metadata: {
-        //jid is unknown at this point; will be resolved using the data
         aid,
-        dad,
         topic
       },
       data,

package/services/hotmesh/index.ts

@@ -20,7 +20,7 @@ import {
   IdsResponse,
   StatsResponse } from '../../types/stats';
 import { ConnectorService } from '../connector';
-import { StreamData, StreamDataResponse } from '../../types/stream';
+import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
 
 class HotMeshService {
   namespace: string;
@@ -165,8 +165,8 @@ class HotMeshService {
   }
 
   // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
-  async hook(topic: string, data: JobData, dad?: string): Promise<string> {
-    return await this.engine?.hook(topic, data, dad);
+  async hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string> {
+    return await this.engine?.hook(topic, data, status, code);
   }
   async hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
     return await this.engine?.hookAll(hookTopic, data, query, queryFacets);

package/services/signaler/store.ts

@@ -19,7 +19,7 @@ class StoreSignaler {
     return rules?.[topic]?.[0] as HookRule;
   }
 
-  async registerWebHook(topic: string, context: JobState, multi?: RedisMulti): Promise<string> {
+  async registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string> {
     const hookRule = await this.getHookRule(topic);
     if (hookRule) {
       const mapExpression = hookRule.conditions.match[0].expected;
@@ -28,7 +28,8 @@ class StoreSignaler {
       const hook: HookSignal = {
         topic,
         resolved,
-        jobId,
+        //hookSignalId is composed of `<dad>::<jid>`
+        jobId: `${dad}::${jobId}`,
       }
       await this.store.setHookSignal(hook, multi);
       return jobId;
@@ -37,25 +38,34 @@ class StoreSignaler {
     }
   }
 
-  async processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<string> {
+  async processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string] | undefined> {
     const hookRule = await this.getHookRule(topic);
     if (hookRule) {
       //NOTE: both formats are supported: $self.hook.data OR $hook.data
       const context = { $self: { hook: { data }}, $hook: { data }};
       const mapExpression = hookRule.conditions.match[0].actual;
       const resolved = Pipe.resolve(mapExpression, context);
-      const jobId = await this.store.getHookSignal(topic, resolved);
-      return jobId;
+      const hookSignalId = await this.store.getHookSignal(topic, resolved);
+      if (!hookSignalId) {
+        //messages can be double-processed; not an issue; return undefined
+        //users can also provide a bogus topic; not an issue; return undefined
+        return undefined;
+      }
+      const [dad, jid] = hookSignalId.split('::');
+      //return [jid, aid, dad]
+      return [jid, hookRule.to, dad];
     } else {
-      throw new Error('signaler.process:error: hook rule not found');
+      throw new Error('signal-not-found');
     }
   }
 
   async deleteWebHookSignal(topic: string, data: Record<string, unknown>): Promise<number> {
     const hookRule = await this.getHookRule(topic);
     if (hookRule) {
-      //todo: use the rule to generate `resolved`
-      const resolved = (data as { id: string}).id;
+      //NOTE: both formats are supported: $self.hook.data OR $hook.data
+      const context = { $self: { hook: { data }}, $hook: { data }};
+      const mapExpression = hookRule.conditions.match[0].actual;
+      const resolved = Pipe.resolve(mapExpression, context);
       return await this.store.deleteHookSignal(topic, resolved);
     } else {
       throw new Error('signaler.process:error: hook rule not found');

package/services/signaler/stream.ts

@@ -150,6 +150,7 @@ class StreamSignaler {
     try {
       output = await callback(input);
     } catch (error) {
+      console.error(error);
       this.logger.error(`stream-call-function-error`, { error });
       output = this.structureUnhandledError(input, error);
     }

package/services/store/clients/redis.ts

@@ -86,7 +86,7 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
       return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
     } catch (error) {
       const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-      this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+      this.logger.info(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
       throw error;
     }
   }

package/services/store/index.ts

@@ -504,6 +504,8 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
         delete state[':'];
       }
       return [state, status];
+    } else {
+      throw new Error(`Job ${jobId} not found`);
     }
   }
 

package/services/telemetry/index.ts

@@ -252,10 +252,15 @@ class TelemetryService {
 
   static bindActivityTelemetryToState(state: StringAnyType, config: ActivityType, metadata: ActivityMetadata, context: JobState, leg: number): void {
     if (config.type === 'trigger') {
+      //trigger activities run non-duplexed and only have a single leg (2)
       state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
       state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l2s;
     } else if (polyfill.resolveActivityType(config.type) === 'hook' && leg === 1) {
-      //activities run non-duplexed and only have a single leg
+      //hook activities run non-duplexed and only have a single leg (1)
+      state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
+      state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
+    } else if (config.type === 'signal' && leg === 1) {
+      //signal activities run non-duplexed and only have a single leg (1)
       state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
       state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
     } else {