@hotmeshio/hotmesh 0.0.52 → 0.0.54

package/services/activities/await.ts

@@ -2,9 +2,11 @@ import {
   GenerationalError,
   GetStateError,
   InactiveJobError } from '../../modules/errors';
+import { guid } from '../../modules/utils';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
+import { Pipe } from '../pipe';
 import { TelemetryService } from '../telemetry';
 import {
   ActivityData,
@@ -14,8 +16,6 @@ import {
 import { JobState } from '../../types/job';
 import { MultiResponseFlags, RedisMulti } from '../../types/redis';
 import { StreamData, StreamDataType } from '../../types/stream';
-import { Pipe } from '../pipe';
-import { guid } from '../../modules/utils';
 
 class Await extends Activity {
   config: AwaitActivity;
@@ -60,16 +60,16 @@ class Await extends Activity {
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof InactiveJobError) {
-        this.logger.error('await-inactive-job-error', { error });
+        this.logger.error('await-inactive-job-error', { ...error });
         return;
       } else if (error instanceof GenerationalError) {
-        this.logger.info('process-event-generational-job-error', { error });
+        this.logger.info('process-event-generational-job-error', { ...error });
         return;
       } else if (error instanceof GetStateError) {
-        this.logger.error('await-get-state-error', { error });
+        this.logger.error('await-get-state-error', { ...error });
         return;
       } else {
-        this.logger.error('await-process-error', { error });
+        this.logger.error('await-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;

package/services/activities/cycle.ts

@@ -2,18 +2,19 @@ import {
   GenerationalError,
   GetStateError,
   InactiveJobError } from '../../modules/errors';
+import { guid } from '../../modules/utils';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
-import { Activity, ActivityType } from './activity';
+import { Activity } from './activity';
 import {
   ActivityData,
   ActivityMetadata,
+  ActivityType,
   CycleActivity } from '../../types/activity';
 import { JobState } from '../../types/job';
 import { MultiResponseFlags, RedisMulti } from '../../types/redis';
 import { StreamData } from '../../types/stream';
 import { TelemetryService } from '../telemetry';
-import { guid } from '../../modules/utils';
 
 class Cycle extends Activity {
   config: CycleActivity;
@@ -63,16 +64,16 @@ class Cycle extends Activity {
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof InactiveJobError) {
-        this.logger.error('cycle-inactive-job-error', { error });
+        this.logger.error('cycle-inactive-job-error', { ...error });
         return;
       } else if (error instanceof GenerationalError) {
-        this.logger.info('process-event-generational-job-error', { error });
+        this.logger.info('process-event-generational-job-error', { ...error });
         return;
       } else if (error instanceof GetStateError) {
-        this.logger.error('cycle-get-state-error', { error });
+        this.logger.error('cycle-get-state-error', { ...error });
         return;
       } else {
-        this.logger.error('cycle-process-error', { error });
+        this.logger.error('cycle-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;

package/services/activities/hook.ts

@@ -63,16 +63,16 @@ class Hook extends Activity {
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof InactiveJobError) {
-        this.logger.error('hook-inactive-job-error', { error });
+        this.logger.error('hook-inactive-job-error', { ...error });
         return;
       } else if (error instanceof GenerationalError) {
-        this.logger.info('process-event-generational-job-error', { error });
+        this.logger.info('process-event-generational-job-error', { ...error });
         return;
       } else if (error instanceof GetStateError) {
-        this.logger.error('hook-get-state-error', { error });
+        this.logger.error('hook-get-state-error', { ...error });
         return;
       } else {
-        this.logger.error('hook-process-error', { error });
+        this.logger.error('hook-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;
@@ -86,7 +86,14 @@ class Hook extends Activity {
    * does this activity use a time-hook or web-hook
    */
   doesHook(): boolean {
-    return !!(this.config.hook?.topic || this.config.sleep);
+    if (this.config.sleep) {
+      const duration = Pipe.resolve(
+        this.config.sleep,
+        this.context,
+      );
+      return !isNaN(duration) && Number(duration) > 0
+    }
+    return !!this.config.hook?.topic;
   }
 
   async doHook(telemetry: TelemetryService) {

package/services/activities/interrupt.ts

@@ -2,17 +2,18 @@ import {
   GenerationalError,
   GetStateError,
   InactiveJobError } from '../../modules/errors';
+import { CollatorService } from '../collator';
+import { Activity } from './activity';
 import { EngineService } from '../engine';
-import { Activity, ActivityType } from './activity';
+import { Pipe } from '../pipe';
+import { TelemetryService } from '../telemetry';
 import {
   ActivityData,
   ActivityMetadata,
+  ActivityType,
   InterruptActivity } from '../../types/activity';
-import { MultiResponseFlags } from '../../types';
-import { CollatorService } from '../collator';
 import { JobInterruptOptions, JobState } from '../../types/job';
-import { TelemetryService } from '../telemetry';
-import { Pipe } from '../pipe';
+import { MultiResponseFlags } from '../../types/redis';
 
 class Interrupt extends Activity {
   config: InterruptActivity;
@@ -46,16 +47,16 @@ class Interrupt extends Activity {
       }
     } catch (error) {
       if (error instanceof InactiveJobError) {
-        this.logger.error('interrupt-inactive-job-error', { error });
+        this.logger.error('interrupt-inactive-job-error', { ...error });
         return;
       } else if (error instanceof GenerationalError) {
-        this.logger.info('process-event-generational-job-error', { error });
+        this.logger.info('process-event-generational-job-error', { ...error });
         return;
       } else if (error instanceof GetStateError) {
-        this.logger.error('interrupt-get-state-error', { error });
+        this.logger.error('interrupt-get-state-error', { ...error });
         return;
       } else {
-        this.logger.error('interrupt-process-error', { error });
+        this.logger.error('interrupt-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;
@@ -142,6 +143,15 @@ class Interrupt extends Activity {
       descend: this.config.descend !== undefined 
         ? Pipe.resolve(this.config.descend, this.context) 
         : undefined,
+      code: this.config.code !== undefined 
+        ? Pipe.resolve(this.config.code, this.context) 
+        : undefined,
+      expire: this.config.expire !== undefined
+        ? Pipe.resolve(this.config.expire, this.context)
+        : undefined,
+      stack: this.config.stack !== undefined
+        ? Pipe.resolve(this.config.stack, this.context)
+        : undefined,
     };
   }
 

package/services/activities/signal.ts

@@ -2,7 +2,7 @@ import {
   GenerationalError,
   GetStateError,
   InactiveJobError } from '../../modules/errors';
-import { Activity, ActivityType } from './activity';
+import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
 import { MapperService } from '../mapper';
@@ -11,6 +11,7 @@ import { TelemetryService } from '../telemetry';
 import {
   ActivityData,
   ActivityMetadata,
+  ActivityType,
   SignalActivity } from '../../types/activity';
 import { JobState } from '../../types/job';
 import { MultiResponseFlags } from '../../types/redis';
@@ -71,16 +72,16 @@ class Signal extends Activity {
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof InactiveJobError) {
-        this.logger.error('signal-inactive-job-error', { error });
+        this.logger.error('signal-inactive-job-error', { ...error });
         return;
       } else if (error instanceof GenerationalError) {
-        this.logger.info('process-event-generational-job-error', { error });
+        this.logger.info('process-event-generational-job-error', { ...error });
         return;
       } else if (error instanceof GetStateError) {
-        this.logger.error('signal-get-state-error', { error });
+        this.logger.error('signal-get-state-error', { ...error });
         return;
       } else {
-        this.logger.error('signal-process-error', { error });
+        this.logger.error('signal-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;

package/services/activities/trigger.ts

@@ -1,5 +1,8 @@
 import { DuplicateJobError } from '../../modules/errors';
-import { formatISODate, getTimeSeries, guid } from '../../modules/utils';
+import {
+  formatISODate,
+  getTimeSeries,
+  guid } from '../../modules/utils';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
@@ -12,7 +15,7 @@ import {
   ActivityMetadata,
   ActivityType,
   TriggerActivity } from '../../types/activity';
-import { JobState } from '../../types/job';
+import { JobState, ExtensionType } from '../../types/job';
 import { RedisMulti } from '../../types/redis';
 import { StringScalarType } from '../../types/serializer';
 import { WorkListTaskType } from '../../types/task';
@@ -30,7 +33,7 @@ class Trigger extends Activity {
       super(config, data, metadata, hook, engine, context);
   }
 
-  async process(): Promise<string> {
+  async process(options?: ExtensionType): Promise<string> {
     this.logger.debug('trigger-process', { subscribes: this.config.subscribes });
     let telemetry: TelemetryService;
     try {
@@ -45,6 +48,9 @@ class Trigger extends Activity {
       this.adjacencyList = await this.filterAdjacent();
       await this.setStatus(this.adjacencyList.length);
 
+      this.bindSearchData(options);
+      this.bindMarkerData(options);
+
       const multi = this.store.getMulti();
       await this.setState(multi);
       await this.setStats(multi);
@@ -67,9 +73,9 @@ class Trigger extends Activity {
       return this.context.metadata.jid;
     } catch (error) {
       if (error instanceof DuplicateJobError) {
-        this.logger.error('duplicate-job-error', { error });
+        this.logger.error('duplicate-job-error', { job_id: error.jobId });
       } else {
-        this.logger.error('trigger-process-error', { error });
+        this.logger.error('trigger-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;
@@ -80,13 +86,44 @@ class Trigger extends Activity {
     }
   }
 
+  safeKey(key:string): string {
+    return `_${key}`;
+  }
+
+  bindSearchData(options?: ExtensionType): void {
+    if (options?.search) {
+      Object.keys(options.search).forEach((key) => {
+        this.context.data[this.safeKey(key)] = options.search[key].toString();
+      });
+    }
+  }
+
+  bindMarkerData(options?: ExtensionType): void {
+    if (options?.marker) {
+      Object.keys(options.marker).forEach((key) => {
+        if (key.startsWith('-')) {
+          this.context.data[key] = options.marker[key].toString();
+        }
+      });
+    }
+  }
+
   async setStatus(amount: number): Promise<void> {
     this.context.metadata.js = amount;
   }
 
   async execAdjacentParent() {
     if (this.context.metadata.px) {
-      await this.engine.execAdjacentParent(this.context, {metadata: this.context.metadata, data: { job_id: this.context.metadata.jid }});
+      const timestamp = formatISODate(new Date());
+      const jobStartedConfirmationMessage = {
+        metadata: this.context.metadata,
+        data: {
+          job_id: this.context.metadata.jid,
+          jc: timestamp,
+          ju: timestamp,
+        }
+      };
+      await this.engine.execAdjacentParent(this.context, jobStartedConfirmationMessage);
     }
   }
 

package/services/activities/worker.ts

@@ -2,9 +2,12 @@ import {
   GenerationalError,
   GetStateError,
   InactiveJobError } from '../../modules/errors';
+import { guid } from '../../modules/utils';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
+import { Pipe } from '../pipe';
+import { TelemetryService } from '../telemetry';
 import {
   ActivityData,
   ActivityMetadata,
@@ -13,9 +16,6 @@ import {
 import { JobState } from '../../types/job';
 import { MultiResponseFlags, RedisMulti } from '../../types/redis';
 import { StreamData} from '../../types/stream';
-import { TelemetryService } from '../telemetry';
-import { Pipe } from '../pipe';
-import { guid } from '../../modules/utils';
 
 class Worker extends Activity {
   config: WorkerActivity;
@@ -61,16 +61,16 @@ class Worker extends Activity {
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof InactiveJobError) {
-        this.logger.error('await-inactive-job-error', { error });
+        this.logger.error('await-inactive-job-error', { ...error });
         return;
       } else if (error instanceof GenerationalError) {
-        this.logger.info('process-event-generational-job-error', { error });
+        this.logger.info('process-event-generational-job-error', { ...error });
         return;
       } else if (error instanceof GetStateError) {
-        this.logger.error('worker-get-state-error', { error });
+        this.logger.error('worker-get-state-error', { ...error });
         return;
       } else {
-        this.logger.error('worker-process-error', { error });
+        this.logger.error('worker-process-error', { ...error });
       }
       telemetry.setActivityError(error.message);
       throw error;

package/services/compiler/deployer.ts

@@ -9,6 +9,7 @@ import { HotMeshGraph, HotMeshManifest } from '../../types/hotmesh';
 import { RedisClient, RedisMulti } from '../../types/redis';
 import { StringAnyType, Symbols } from '../../types/serializer';
 import { Pipe } from '../pipe';
+import { Validator } from './validator';
 
 const DEFAULT_METADATA_RANGE_SIZE = 26; //metadata is 26 slots ([a-z] * 1)
 const DEFAULT_DATA_RANGE_SIZE = 260; //data is 260 slots ([a-zA-Z] * 5)
@@ -201,6 +202,9 @@ class Deployer {
             //DAGs have one parent; easy to optimize for
             graph.activities[to].parent = fromActivity;
           }
+          //temporarily bind the transitions to the parent activity,
+          // so the consumer/producer registrar picks up the bindings
+          graph.activities[fromActivity].transitions = toTransitions;
         }
       }
     }
@@ -257,9 +261,29 @@ class Deployer {
             let newPath = [...path, key];
             traverse(obj[key], newPath);
           } else {
-            const finalPath = `data/${[...path, key].join('/')}`;
-            if (!result.includes(finalPath)) {
-              result.push(finalPath);
+            //wildcard mapping (e.g., 'friends[25]')
+            //when this is resolved, it will be expanded to
+            //`'friends/0', ..., 'friends/24'`, providing 25 dynamic
+            //slots in the flow's output data
+            const pathName = [...path, key].join('/');
+            if (!pathName.includes('[')) {
+              const finalPath = `data/${pathName}`;
+              if (!result.includes(finalPath)) {
+                result.push(finalPath);
+              }
+            } else {
+              const [left, right] = pathName.split('[');
+              //check if this variable isLiteralKeyType (#, -, or _)
+              const [amount, _] = right.split(']');
+              if (!isNaN(parseInt(amount))) {
+                //loop to create all possible paths (0 to amount)
+                for (let i = 0; i < parseInt(amount); i++) {
+                  const finalPath = `data/${left}/${i}`;
+                  if (!result.includes(finalPath)) {
+                    result.push(finalPath);
+                  }
+                }
+              } //else ignore (amount might be '-' or '_')  `-` is marker data;   `_` is job data;
             }
           }
         }
@@ -280,7 +304,7 @@ class Deployer {
       trigger.PRODUCES = results;
     }
   }
-  
+
   resolveMappingDependencies() {
     const dynamicMappingRules: string[] = [];
     //recursive function to descend into the object and find all dynamic mapping rules
@@ -289,7 +313,7 @@ class Deployer {
         if (typeof obj[key] === 'string') {
           const stringValue = obj[key] as string;
           const dynamicMappingRuleMatch = stringValue.match(/^\{[^@].*}$/);
-          if (dynamicMappingRuleMatch) { 
+          if (dynamicMappingRuleMatch && !Validator.CONTEXT_VARS.includes(stringValue)) { 
             if (stringValue.split('.')[1] !== 'input') {
               dynamicMappingRules.push(stringValue);
               consumes.push(stringValue);
@@ -359,7 +383,10 @@ class Deployer {
     for (const graph of graphs) {
       const activities = graph.activities;
       for (const activityKey in activities) {
-        activitySchemas[activityKey] = activities[activityKey];
+        const target = activities[activityKey];
+        //remove transitions; no longer necessary for runtime
+        delete target.transitions;
+        activitySchemas[activityKey] = target;
       }
     }
     await this.store.setSchemas(activitySchemas, this.getVID());

package/services/compiler/validator.ts

@@ -11,7 +11,8 @@ class Validator {
   store: StoreService<RedisClient, RedisMulti> | null = null;
 
   static SYS_VARS = ['$app', '$self', '$graph', '$job'];
-
+  static CONTEXT_VARS = ['{$input}', '{$output}', '{$item}', '{$key}', '{$index}'];
+  
   constructor(manifest: HotMeshManifest) {
     this.manifest = manifest;
   }
@@ -92,8 +93,7 @@ class Validator {
         if (statement.startsWith('{') && statement.endsWith('}')) {
           const statementParts = statement.slice(1, -1).split('.');
           const referencedActivityId = statementParts[0];
-  
-          if (!(Validator.SYS_VARS.includes(referencedActivityId) || activityIds.includes(referencedActivityId) || this.isFunction(statement))) {
+          if (!(Validator.SYS_VARS.includes(referencedActivityId) || activityIds.includes(referencedActivityId) || this.isFunction(statement) || this.isContextVariable(statement))) {
             throw new Error(`Mapping statement references non-existent activity: ${statement}`);
           }
         }
@@ -105,6 +105,10 @@ class Validator {
     return value.startsWith('{@') && Pipe.resolveFunction(value);
   }
 
+  isContextVariable(value: string): boolean {
+    return ['{$input}', '{$output}', '{$item}', '{$key}', '{$index}'].includes(value);
+  }
+
   // 1.3) Validate the mapping/@pipe statements are valid
   validateMappingStatements() {
     // Implement the method content

package/services/durable/client.ts

@@ -1,4 +1,17 @@
-import { APP_ID, APP_VERSION, DEFAULT_COEFFICIENT, getWorkflowYAML } from './factory';
+import ms from 'ms';
+
+import {
+  APP_ID,
+  APP_VERSION,
+  getWorkflowYAML } from './schemas/factory';
+import {
+  HMSH_LOGLEVEL,
+  HMSH_EXPIRE_JOB_SECONDS,
+  HMSH_QUORUM_DELAY_MS,
+  HMSH_DURABLE_EXP_BACKOFF,
+  HMSH_DURABLE_MAX_ATTEMPTS,
+  HMSH_DURABLE_MAX_INTERVAL } from '../../modules/enums';
+import { sleepFor } from '../../modules/utils';
 import { WorkflowHandleService } from './handle';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import {
@@ -11,8 +24,6 @@ import { JobState } from '../../types/job';
 import { KeyService, KeyType } from '../../modules/key';
 import { Search } from './search';
 import { StreamStatus } from '../../types';
-import { HMSH_LOGLEVEL, HMSH_EXPIRE_JOB_SECONDS, HMSH_QUORUM_DELAY_MS } from '../../modules/enums';
-import { sleepFor } from '../../modules/utils';
 
 export class ClientService {
 
@@ -32,7 +43,7 @@ export class ClientService {
       await this.verifyWorkflowActive(hotMeshClient, targetNS);
       if (!ClientService.topics.includes(workflowTopic)) {
         ClientService.topics.push(workflowTopic);
-        await this.createStream(hotMeshClient, workflowTopic, namespace);
+        await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
       }
       return hotMeshClient;
     }
@@ -49,7 +60,7 @@ export class ClientService {
       }
     });
     ClientService.instances.set(targetNS, hotMeshClient);
-    await this.createStream(await hotMeshClient, workflowTopic, namespace);
+    await ClientService.createStream(await hotMeshClient, workflowTopic, namespace);
     await this.activateWorkflow(await hotMeshClient, targetNS);
     return hotMeshClient;
   }
@@ -60,7 +71,7 @@ export class ClientService {
    * has not yet been initialized, so this call ensures that the channel
    * exists and is ready to serve as a container for events.
    */
-  createStream = async(hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => {
+  static createStream = async(hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => {
     const store = hotMeshClient.engine.store;
     const params = { appId: namespace ?? APP_ID, topic: workflowTopic };
     const streamKey = store.mintKey(KeyType.STREAMS, params);
@@ -71,6 +82,23 @@ export class ClientService {
     }
   }
 
+  /**
+   * It is possible for a client to invoke a workflow without first
+   * creating the stream. This method will verify that the stream
+   * exists and if not, create it.
+   */
+  static verifyStream = async(workflowTopic: string, namespace?: string) => {
+    const targetNS = namespace ?? APP_ID;
+    if (ClientService.instances.has(targetNS)) {
+      const hotMeshClient = await ClientService.instances.get(targetNS);
+      if (!ClientService.topics.includes(workflowTopic)) {
+        ClientService.topics.push(workflowTopic);
+        await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
+      }
+      return hotMeshClient;
+    }
+  }
+
   /**
    * For those deployments with a redis stack backend (with the FT module),
    * this method will configure the search index for the workflow.
@@ -95,8 +123,8 @@ export class ClientService {
         const hotMeshPrefix = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
         const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
         await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
-      } catch (err) {
-        hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+      } catch (error) {
+        hotMeshClient.engine.logger.info('durable-client-search-err', { ...error });
       }
     }
   }
@@ -127,21 +155,18 @@ export class ClientService {
         parentWorkflowId: options.parentWorkflowId,
         workflowId: options.workflowId || HotMesh.guid(),
         workflowTopic: workflowTopic,
-        backoffCoefficient: options.config?.backoffCoefficient || DEFAULT_COEFFICIENT,
+        backoffCoefficient: options.config?.backoffCoefficient || HMSH_DURABLE_EXP_BACKOFF,
+        maximumAttempts: options.config?.maximumAttempts || HMSH_DURABLE_MAX_ATTEMPTS,
+        maximumInterval: ms(options.config?.maximumInterval || HMSH_DURABLE_MAX_INTERVAL) / 1000,
       }
+
       const context = { metadata: { trc, spn }, data: {}};
       const jobId = await hotMeshClient.pub(
         `${options.namespace ?? APP_ID}.execute`,
         payload,
-        context as JobState
+        context as JobState,
+        { search: options?.search?.data, marker: options?.marker},
       );
-      // Seed search data
-      if (jobId && options.search?.data) {
-        const searchSessionId = `-search-0`;
-        const search = new Search(jobId, hotMeshClient, searchSessionId);
-        const entries = Object.entries(options.search.data).flat();
-        await search.set(...entries);
-      }
       return new WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
     },
 
@@ -165,7 +190,9 @@ export class ClientService {
         arguments: [...options.args],
         id: options.workflowId,
         workflowTopic,
-        backoffCoefficient: options.config?.backoffCoefficient || DEFAULT_COEFFICIENT,
+        backoffCoefficient: options.config?.backoffCoefficient || HMSH_DURABLE_EXP_BACKOFF,
+        maximumAttempts: options.config?.maximumAttempts || HMSH_DURABLE_MAX_ATTEMPTS,
+        maximumInterval: ms(options.config?.maximumInterval || HMSH_DURABLE_MAX_INTERVAL) / 1000,
       }
       //seed search data if presentthe hook before entering
       const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
@@ -190,9 +217,9 @@ export class ClientService {
       const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
       try {
         return await this.search(hotMeshClient, index, query);
-      } catch (err) {
-        hotMeshClient.engine.logger.error('durable-client-search-err', { err });
-        throw err;
+      } catch (error) {
+        hotMeshClient.engine.logger.error('durable-client-search-err', { ...error });
+        throw error;
       }
     }
   }
@@ -218,7 +245,7 @@ export class ClientService {
         await hotMesh.deploy(getWorkflowYAML(appId, version));
         await hotMesh.activate(version);
       } catch (error) {
-        hotMesh.engine.logger.error('durable-client-deploy-activate-err', { error });
+        hotMesh.engine.logger.error('durable-client-deploy-activate-err', { ...error });
         throw error;
       }
     } else if(app && !app.active) {