@hotmeshio/hotmesh 0.1.14 → 0.1.16

package/build/services/store/index.d.ts

@@ -42,11 +42,6 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
     mintKey(type: KeyType, params: KeyStoreParams): string;
     invalidateCache(): void;
-    /**
-     * At any given time only a single engine will
-     * check for and process work items in the
-     * time and signal task queues.
-     */
     reserveScoutRole(scoutType: 'time' | 'signal' | 'activate', delay?: number): Promise<boolean>;
     releaseScoutRole(scoutType: 'time' | 'signal' | 'activate'): Promise<boolean>;
     getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
@@ -65,16 +60,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     setApp(id: string, version: string): Promise<HotMeshApp>;
     activateAppVersion(id: string, version: string): Promise<boolean>;
     registerAppVersion(appId: string, version: string): Promise<any>;
-    /**
-     * Registers the job, `jobId`, with `originJobId`. In the future,
-     * when `originJobId` is interrupted/expired, the items in the
-     * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
-     */
     registerJobDependency(depType: WorkListTaskType, originJobId: string, topic: string, jobId: string, gId: string, pd?: string, multi?: U): Promise<any>;
-    /**
-     * Ensures a `hook signal` is delisted when its parent activity/job
-     * is interrupted/expired.
-     */
     registerSignalDependency(jobId: string, signalKey: string, dad: string, multi?: U): Promise<any>;
     setStats(jobKey: string, jobId: string, dateTime: string, stats: StatsType, appVersion: AppVID, multi?: U): Promise<any>;
     hGetAllResult(result: any): any;
@@ -83,24 +69,10 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     setStatus(collationKeyStatus: number, jobId: string, appId: string, multi?: U): Promise<any>;
     getStatus(jobId: string, appId: string): Promise<number>;
     setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, multi?: U): Promise<string>;
-    /**
-     * Returns custom search fields and values.
-     * NOTE: The `fields` param should NOT prefix items with an underscore.
-     */
     getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
     getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
     getRaw(jobId: string): Promise<StringStringType>;
-    /**
-     * collate is a generic method for incrementing a value in a hash
-     * in order to track their progress during processing.
-     */
     collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, multi?: U): Promise<number>;
-    /**
-     * synthentic collation affects those activities in the graph
-     * that represent the synthetic DAG that was materialized during compilation;
-     * Synthetic targeting ensures that re-entry due to failure can be distinguished from
-     * purposeful re-entry.
-     */
     collateSynthetic(jobId: string, guid: string, amount: number, multi?: U): Promise<number>;
     setStateNX(jobId: string, appId: string, status?: number): Promise<boolean>;
     getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
@@ -121,19 +93,8 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string, scrub?: boolean): Promise<void>;
     processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
     expireJob(jobId: string, inSeconds: number, redisMulti?: U): Promise<void>;
-    /**
-     * register the descendants of an expired origin flow to be
-     * expired at a future date; options indicate whether this
-     * is a standard `expire` or an `interrupt`
-     */
     registerDependenciesForCleanup(jobId: string, deletionTime: number, options: JobCompletionOptions): Promise<void>;
     getDependencies(jobId: string): Promise<string[]>;
-    /**
-     * registers a hook activity to be awakened (uses ZSET to
-     * store the 'sleep group' and LIST to store the events
-     * for the given sleep group. Sleep groups are
-     * organized into 'n'-second blocks (LISTS))
-     */
     registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, deletionTime: number, dad: string, multi?: U): Promise<void>;
     getNextTask(listKey?: string): Promise<[
         listKey: string,
@@ -142,23 +103,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
         activityId: string,
         type: WorkListTaskType
     ] | boolean>;
-    /**
-     * when processing time jobs, the target LIST ID returned
-     * from the ZSET query can be prefixed to denote what to
-     * do with the work list. (not everything is known in advance,
-     * so the ZSET key defines HOW to approach the work in the
-     * generic LIST (lists typically contain target job ids)
-     * @param {string} listKey - composite key
-     */
     resolveTaskKeyContext(listKey: string): [WorkListTaskType, string];
-    /**
-     * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
-     * This method is called by the engine and not by an activity and is
-     * followed by a call to execute job completion/cleanup tasks
-     * associated with a job completion event.
-     *
-     * Todo: move most of this logic to the engine (too much logic for the store)
-     */
     interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<void>;
     scrub(jobId: string): Promise<void>;
     findJobs(queryString?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, string[]]>;

package/build/services/store/index.js

@@ -77,7 +77,6 @@ class StoreService {
         return result > 0 || result === 'OK' || result === true;
     }
     async zAdd(key, score, value, redisMulti) {
-        //default call signature uses 'ioredis' NPM Package format
         return await (redisMulti || this.redisClient)[this.commands.zadd](key, score, value);
     }
     async zRangeByScoreWithScores(key, score, value) {
@@ -102,11 +101,6 @@ class StoreService {
     invalidateCache() {
         this.cache.invalidate();
     }
-    /**
-     * At any given time only a single engine will
-     * check for and process work items in the
-     * time and signal task queues.
-     */
     async reserveScoutRole(scoutType, delay = enums_1.HMSH_SCOUT_INTERVAL_SECONDS) {
         const key = this.mintKey(key_1.KeyType.WORK_ITEMS, {
             appId: this.appId,
@@ -140,7 +134,6 @@ class StoreService {
         throw new Error('settings not found');
     }
     async setSettings(manifest) {
-        //HotMesh heartbeat. If a connection is made, the version will be set
         const params = {};
         const key = this.mintKey(key_1.KeyType.HOTMESH, params);
         return await this.redisClient[this.commands.hset](key, manifest);
@@ -151,10 +144,8 @@ class StoreService {
             activityId: target,
             appId: this.appId,
         });
-        //reserve the slot in a `pending` state (range will be established in the next step)
         const response = await this.redisClient[this.commands.hsetnx](rangeKey, target, '?:?');
         if (response) {
-            //if the key didn't exist, set the inclusive range and seed metadata fields
             const upperLimit = await this.redisClient[this.commands.hincrby](rangeKey, ':cursor', size);
             const lowerLimit = upperLimit - size;
             const inclusiveRange = `${lowerLimit}:${upperLimit - 1}`;
@@ -164,7 +155,6 @@ class StoreService {
             return [lowerLimit + serializer_1.MDATA_SYMBOLS.SLOTS, upperLimit - 1, {}];
         }
         else {
-            //if the key already existed, get the lower limit and add the number of symbols
             const range = await this.redisClient[this.commands.hget](rangeKey, target);
             const [lowerLimitString] = range.split(':');
             if (lowerLimitString === '?') {
@@ -187,7 +177,6 @@ class StoreService {
         }
     }
     async getAllSymbols() {
-        //get hash with all reserved symbol ranges
         const rangeKey = this.mintKey(key_1.KeyType.SYMKEYS, { appId: this.appId });
         const ranges = await this.redisClient[this.commands.hgetall](rangeKey);
         const rangeKeys = Object.keys(ranges).sort();
@@ -365,11 +354,6 @@ class StoreService {
         };
         return await this.redisClient[this.commands.hset](key, payload);
     }
-    /**
-     * Registers the job, `jobId`, with `originJobId`. In the future,
-     * when `originJobId` is interrupted/expired, the items in the
-     * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
-     */
     async registerJobDependency(depType, originJobId, topic, jobId, gId, pd = '', multi) {
         const privateMulti = multi || this.getMulti();
         const dependencyParams = {
@@ -383,15 +367,10 @@ class StoreService {
             return await privateMulti.exec();
         }
     }
-    /**
-     * Ensures a `hook signal` is delisted when its parent activity/job
-     * is interrupted/expired.
-     */
     async registerSignalDependency(jobId, signalKey, dad, multi) {
         const privateMulti = multi || this.getMulti();
         const dependencyParams = { appId: this.appId, jobId };
         const dependencyKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, dependencyParams);
-        //persiste dependency tasks as multi-segment composite keys
         const delistTask = ['delist', 'signal', jobId, dad, signalKey].join(key_1.VALSEP);
         privateMulti[this.commands.rpush](dependencyKey, delistTask);
         if (!multi) {
@@ -427,7 +406,6 @@ class StoreService {
         }
     }
     hGetAllResult(result) {
-        //default response signature uses 'redis' NPM Package format
         return result;
     }
     async getJobStats(jobKeys) {
@@ -456,13 +434,12 @@ class StoreService {
     async getJobIds(indexKeys, idRange) {
         const multi = this.getMulti();
         for (const idsKey of indexKeys) {
-            multi[this.commands.lrange](idsKey, idRange[0], idRange[1]); //0,-1 returns all ids
+            multi[this.commands.lrange](idsKey, idRange[0], idRange[1]);
         }
         const results = await multi.exec();
         const output = {};
         for (const [index, result] of results.entries()) {
             const key = indexKeys[index];
-            //todo: resolve this discrepancy between redis/ioredis
             const idsList = result[1] || result;
             if (idsList && idsList.length > 0) {
                 output[key] = idsList;
@@ -504,22 +481,25 @@ class StoreService {
         await (multi || this.redisClient)[this.commands.hset](hashKey, hashData);
         return jobId;
     }
-    /**
-     * Returns custom search fields and values.
-     * NOTE: The `fields` param should NOT prefix items with an underscore.
-     */
     async getQueryState(jobId, fields) {
         const key = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
-        const _fields = fields.map((field) => `_${field}`);
+        const _fields = fields.map((field) => {
+            if (field.startsWith('"')) {
+                return field.slice(1, -1);
+            }
+            return `_${field}`;
+        });
         const jobDataArray = await this.redisClient[this.commands.hmget](key, _fields);
         const jobData = {};
         fields.forEach((field, index) => {
+            if (field.startsWith('"')) {
+                field = field.slice(1, -1);
+            }
             jobData[field] = jobDataArray[index];
         });
         return jobData;
     }
     async getState(jobId, consumes, dIds) {
-        //get abbreviated field list (the symbols for the paths)
         const key = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const symbolNames = Object.keys(consumes);
         const symKeys = await this.getSymbolKeys(symbolNames);
@@ -527,7 +507,7 @@ class StoreService {
         const fields = this.serializer.abbreviate(consumes, symbolNames, [':']);
         const jobDataArray = await this.redisClient[this.commands.hmget](key, fields);
         const jobData = {};
-        let atLeast1 = false; //if status field (':') isn't present assume 404
+        let atLeast1 = false;
         fields.forEach((field, index) => {
             if (jobDataArray[index]) {
                 atLeast1 = true;
@@ -561,16 +541,12 @@ class StoreService {
         }
         return job;
     }
-    /**
-     * collate is a generic method for incrementing a value in a hash
-     * in order to track their progress during processing.
-     */
     async collate(jobId, activityId, amount, dIds, multi) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, {
             appId: this.appId,
             jobId,
         });
-        const collationKey = `${activityId}/output/metadata/as`; //activity state
+        const collationKey = `${activityId}/output/metadata/as`;
         const symbolNames = [activityId];
         const symKeys = await this.getSymbolKeys(symbolNames);
         const symVals = await this.getSymbolValues();
@@ -580,12 +556,6 @@ class StoreService {
         const targetId = Object.keys(hashData)[0];
         return await (multi || this.redisClient)[this.commands.hincrbyfloat](jobKey, targetId, amount);
     }
-    /**
-     * synthentic collation affects those activities in the graph
-     * that represent the synthetic DAG that was materialized during compilation;
-     * Synthetic targeting ensures that re-entry due to failure can be distinguished from
-     * purposeful re-entry.
-     */
     async collateSynthetic(jobId, guid, amount, multi) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, {
             appId: this.appId,
@@ -746,12 +716,10 @@ class StoreService {
     }
     async setHookSignal(hook, multi) {
         const key = this.mintKey(key_1.KeyType.SIGNALS, { appId: this.appId });
-        //destructure the hook key
         const { topic, resolved, jobId } = hook;
         const signalKey = `${topic}:${resolved}`;
         const payload = { [signalKey]: jobId };
         await (multi || this.redisClient)[this.commands.hset](key, payload);
-        //jobId needs even more destructuring
         const [_aid, dad, _gid, jid] = jobId.split(key_1.VALSEP);
         return await this.registerSignalDependency(jid, signalKey, dad, multi);
     }
@@ -790,7 +758,6 @@ class StoreService {
         const didRemove = await this.redisClient[this.commands.zrem](zsetKey, workItemKey);
         if (didRemove) {
             if (scrub) {
-                //indexes can be designed to be self-cleaning; `engine.hookAll` exposes this option
                 this.redisClient[this.commands.expire](processedKey, 0);
                 this.redisClient[this.commands.expire](key.split(':').slice(0, 5).join(':'), 0);
             }
@@ -812,11 +779,6 @@ class StoreService {
             await (redisMulti || this.redisClient)[this.commands.expire](jobKey, inSeconds);
         }
     }
-    /**
-     * register the descendants of an expired origin flow to be
-     * expired at a future date; options indicate whether this
-     * is a standard `expire` or an `interrupt`
-     */
     async registerDependenciesForCleanup(jobId, deletionTime, options) {
         const depParams = { appId: this.appId, jobId };
         const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
@@ -830,18 +792,11 @@ class StoreService {
         const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
         return this.redisClient[this.commands.lrange](depKey, 0, -1);
     }
-    /**
-     * registers a hook activity to be awakened (uses ZSET to
-     * store the 'sleep group' and LIST to store the events
-     * for the given sleep group. Sleep groups are
-     * organized into 'n'-second blocks (LISTS))
-     */
     async registerTimeHook(jobId, gId, activityId, type, deletionTime, dad, multi) {
         const listKey = this.mintKey(key_1.KeyType.TIME_RANGE, {
             appId: this.appId,
             timeValue: deletionTime,
         });
-        //construct the composite key (the key has enough info to signal the hook)
         const timeEvent = [type, activityId, gId, dad, jobId].join(key_1.VALSEP);
         const len = await (multi || this.redisClient)[this.commands.rpush](listKey, timeEvent);
         if (multi || len === 1) {
@@ -856,7 +811,6 @@ class StoreService {
             let [pType, pKey] = this.resolveTaskKeyContext(listKey);
             const timeEvent = await this.redisClient[this.commands.lpop](pKey);
             if (timeEvent) {
-                //deconstruct composite key
                 let [type, activityId, gId, _pd, ...jobId] = timeEvent.split(key_1.VALSEP);
                 const jid = jobId.join(key_1.VALSEP);
                 if (type === 'delist') {
@@ -875,14 +829,6 @@ class StoreService {
         }
         return false;
     }
-    /**
-     * when processing time jobs, the target LIST ID returned
-     * from the ZSET query can be prefixed to denote what to
-     * do with the work list. (not everything is known in advance,
-     * so the ZSET key defines HOW to approach the work in the
-     * generic LIST (lists typically contain target job ids)
-     * @param {string} listKey - composite key
-     */
     resolveTaskKeyContext(listKey) {
         if (listKey.startsWith(`${key_1.TYPSEP}INTERRUPT`)) {
             return ['interrupt', listKey.split(key_1.TYPSEP)[2]];
@@ -894,23 +840,12 @@ class StoreService {
             return ['sleep', listKey];
         }
     }
-    /**
-     * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
-     * This method is called by the engine and not by an activity and is
-     * followed by a call to execute job completion/cleanup tasks
-     * associated with a job completion event.
-     *
-     * Todo: move most of this logic to the engine (too much logic for the store)
-     */
     async interrupt(topic, jobId, options = {}) {
         try {
-            //verify job exists
             const status = await this.getStatus(jobId, this.appId);
             if (status <= 0) {
-                //verify still active; job already completed
                 throw new Error(`Job ${jobId} already completed`);
             }
-            //decrement job status (:) by 1bil
             const amount = -1000000000;
             const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, {
                 appId: this.appId,
@@ -918,17 +853,14 @@ class StoreService {
             });
             const result = await this.redisClient[this.commands.hincrbyfloat](jobKey, ':', amount);
             if (result <= amount) {
-                //verify active state; job already interrupted
                 throw new Error(`Job ${jobId} already completed`);
             }
-            //persist the error unless specifically told not to
             if (options.throw !== false) {
-                const errKey = `metadata/err`; //job errors are stored at the path `metadata/err`
-                const symbolNames = [`$${topic}`]; //the symbol for `metadata/err` is in redis and stored using the job topic
+                const errKey = `metadata/err`;
+                const symbolNames = [`$${topic}`];
                 const symKeys = await this.getSymbolKeys(symbolNames);
                 const symVals = await this.getSymbolValues();
                 this.serializer.resetSymbols(symKeys, symVals, {});
-                //persists the standard 410 error (job is `gone`)
                 const err = JSON.stringify({
                     code: options.code ?? enums_1.HMSH_CODE_INTERRUPT,
                     message: options.reason ?? `job [${jobId}] interrupted`,
@@ -1006,11 +938,9 @@ class StoreService {
     }
     async setThrottleRate(options) {
         const key = this.mintKey(key_1.KeyType.THROTTLE_RATE, { appId: this.appId });
-        //engine guids are session specific. no need to persist
         if (options.guid) {
             return;
         }
-        //if a topic, update one
         const rate = options.throttle.toString();
         if (options.topic) {
             await this.redisClient[this.commands.hset](key, {
@@ -1018,7 +948,6 @@ class StoreService {
             });
         }
         else {
-            //if no topic, update all
             const multi = this.getMulti();
             multi[this.commands.del](key);
             multi[this.commands.hset](key, { ':': rate });
@@ -1031,7 +960,6 @@ class StoreService {
         return response ?? {};
     }
     async getThrottleRate(topic) {
-        //always return a valid number range
         const resolveRate = (response, topic) => {
             const rate = topic in response ? Number(response[topic]) : 0;
             if (isNaN(rate))
@@ -1043,7 +971,6 @@ class StoreService {
         const response = await this.getThrottleRates();
         const globalRate = resolveRate(response, ':');
         if (topic === ':' || !(topic in response)) {
-            //use global rate unless worker specifies rate
             return globalRate;
         }
         return resolveRate(response, topic);

package/build/services/stream/clients/ioredis.js

@@ -51,10 +51,7 @@ class IORedisStreamService extends index_1.StreamService {
     }
     async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
         try {
-            //@ts-ignore
-            return await this.redisClient.xreadgroup(command, groupName, consumerName, 
-            // @ts-ignore
-            blockOption, blockTime, streamsOption, streamName, id);
+            return await this.redisClient.xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id);
         }
         catch (error) {
             this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, { ...error });

package/build/services/task/index.d.ts

@@ -16,16 +16,7 @@ declare class TaskService {
     enqueueWorkItems(keys: string[]): Promise<void>;
     registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions): Promise<void>;
     registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, inSeconds: number, dad: string, multi?: RedisMulti): Promise<void>;
-    /**
-     * Should this engine instance play the role of 'scout' on behalf
-     * of the entire quorum? The scout role is responsible for processing
-     * task lists on behalf of the collective.
-     */
     shouldScout(): Promise<boolean>;
-    /**
-     * Callback handler that takes an item from a work list and
-     * processes according to its type
-     */
     processTimeHooks(timeEventCallback: (jobId: string, gId: string, activityId: string, type: WorkListTaskType) => Promise<void>, listKey?: string): Promise<void>;
     cancelCleanup(): void;
     getHookRule(topic: string): Promise<HookRule | undefined>;

package/build/services/task/index.js

@@ -22,7 +22,6 @@ class TaskService {
             const destinationKey = `${sourceKey}:processed`;
             const jobId = await this.store.processTaskQueue(sourceKey, destinationKey);
             if (jobId) {
-                //todo: don't use 'id', make configurable using hook rule
                 await hookEventCallback(topic, { ...data, id: jobId });
             }
             else {
@@ -49,11 +48,6 @@ class TaskService {
         const awakenTimeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
         await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, dad, multi);
     }
-    /**
-     * Should this engine instance play the role of 'scout' on behalf
-     * of the entire quorum? The scout role is responsible for processing
-     * task lists on behalf of the collective.
-     */
     async shouldScout() {
         const wasScout = this.isScout;
         const isScout = wasScout || (this.isScout = await this.store.reserveScoutRole('time'));
@@ -67,10 +61,6 @@ class TaskService {
         }
         return false;
     }
-    /**
-     * Callback handler that takes an item from a work list and
-     * processes according to its type
-     */
     async processTimeHooks(timeEventCallback, listKey) {
         if (await this.shouldScout()) {
             try {
@@ -78,18 +68,14 @@ class TaskService {
                 if (Array.isArray(workListTask)) {
                     const [listKey, target, gId, activityId, type] = workListTask;
                     if (type === 'child') {
-                        //continue; this child is listed here for convenience, but
-                        //  will be expired by an origin ancestor and is listed there
                     }
                     else if (type === 'delist') {
-                        //delist the signalKey (target)
                         const key = this.store.mintKey(hotmesh_1.KeyType.SIGNALS, {
                             appId: this.store.appId,
                         });
                         await this.store.redisClient[this.store.commands.hdel](key, target);
                     }
                     else {
-                        //awaken/expire/interrupt
                         await timeEventCallback(target, gId, activityId, type);
                     }
                     await (0, utils_1.sleepFor)(0);
@@ -97,13 +83,11 @@ class TaskService {
                     this.processTimeHooks(timeEventCallback, listKey);
                 }
                 else if (workListTask) {
-                    //a worklist was just emptied; try again immediately
                     await (0, utils_1.sleepFor)(0);
                     this.errorCount = 0;
                     this.processTimeHooks(timeEventCallback);
                 }
                 else {
-                    //no worklists exist; sleep before checking
                     const sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_FIDELITY_SECONDS * 1000);
                     this.cleanupTimeout = sleep.timerId;
                     await sleep.promise;
@@ -112,8 +96,6 @@ class TaskService {
                 }
             }
             catch (err) {
-                //most common reasons: deleted job not found; container stopping; test stopping
-                //less common: redis/cluster down; retry with fallback (5s max main reassignment)
                 this.logger.warn('task-process-timehooks-error', err);
                 await (0, utils_1.sleepFor)(1000 * this.errorCount++);
                 if (this.errorCount < 5) {
@@ -122,7 +104,6 @@ class TaskService {
             }
         }
         else {
-            //didn't get the scout role; try again in 'one-ish' minutes
             const sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
             this.cleanupTimeout = sleep.timerId;
             await sleep.promise;
@@ -147,7 +128,6 @@ class TaskService {
             const jobId = context.metadata.jid;
             const gId = context.metadata.gid;
             const activityId = hookRule.to;
-            //composite keys are used to fully describe the task target
             const compositeJobKey = [activityId, dad, gId, jobId].join(key_1.WEBSEP);
             const hook = {
                 topic,
@@ -164,22 +144,13 @@ class TaskService {
     async processWebHookSignal(topic, data) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
-            //NOTE: both formats are supported by the mapping engine:
-            //      `$self.hook.data` OR `$hook.data`
             const context = { $self: { hook: { data } }, $hook: { data } };
             const mapExpression = hookRule.conditions.match[0].actual;
             const resolved = pipe_1.Pipe.resolve(mapExpression, context);
             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;
             }
-            //`aid` is part of composite key, but the hook `topic` is its public interface;
-            // this means that a new version of the graph can be deployed and the
-            // topic can be re-mapped to a different activity id. Outside callers
-            // can adhere to the unchanged contract (calling the same topic),
-            // while the internal system can be updated in real-time as necessary.
             const [_aid, dad, gid, ...jid] = hookSignalId.split(key_1.WEBSEP);
             return [jid.join(key_1.WEBSEP), hookRule.to, dad, gid];
         }
@@ -190,8 +161,6 @@ class TaskService {
     async deleteWebHookSignal(topic, data) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
-            //NOTE: both formats are supported by the mapping engine:
-            //      `$self.hook.data` OR `$hook.data`
             const context = { $self: { hook: { data } }, $hook: { data } };
             const mapExpression = hookRule.conditions.match[0].actual;
             const resolved = pipe_1.Pipe.resolve(mapExpression, context);

package/build/services/telemetry/index.d.ts

@@ -35,13 +35,6 @@ declare class TelemetryService {
     setTelemetryContext(span: Span, leg: number): void;
     setActivityError(message: string): void;
     setStreamError(message: string): void;
-    /**
-     * Adds the paths (HGET) necessary to restore telemetry state for an activity
-     * @param consumes
-     * @param config
-     * @param metadata
-     * @param leg
-     */
     static addTargetTelemetryPaths(consumes: Consumes, config: ActivityType, metadata: ActivityMetadata, leg: number): void;
     static bindJobTelemetryToState(state: StringStringType, config: ActivityType, context: JobState): void;
     static bindActivityTelemetryToState(state: StringAnyType, config: ActivityType, metadata: ActivityMetadata, context: JobState, leg: number): void;

package/build/services/telemetry/index.js

@@ -13,7 +13,6 @@ class TelemetryService {
     constructor(appId, config, metadata, context) {
         this.leg = 1;
         this.appId = appId;
-        //these are REQUIRED for job and activity spans
         this.config = config;
         this.metadata = metadata;
         this.context = context;
@@ -83,7 +82,6 @@ class TelemetryService {
         return span;
     }
     mapActivityAttributes() {
-        //export user-defined span attributes (app.activity.data.*)
         if (this.config.telemetry) {
             const telemetryAtts = new mapper_1.MapperService(this.config.telemetry, this.context).mapRules();
             const namespacedAtts = {
@@ -124,7 +122,7 @@ class TelemetryService {
                 traceId: this.traceId,
                 spanId: this.spanId,
                 isRemote: true,
-                traceFlags: 1, // (todo: revisit sampling strategy/config)
+                traceFlags: 1,
             };
             const parentContext = telemetry_1.trace.setSpanContext(telemetry_1.context.active(), restoredSpanContext);
             return parentContext;
@@ -178,13 +176,6 @@ class TelemetryService {
     setStreamError(message) {
         this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
     }
-    /**
-     * Adds the paths (HGET) necessary to restore telemetry state for an activity
-     * @param consumes
-     * @param config
-     * @param metadata
-     * @param leg
-     */
     static addTargetTelemetryPaths(consumes, config, metadata, leg) {
         if (leg === 1) {
             if (!(config.parent in consumes)) {
@@ -206,7 +197,6 @@ class TelemetryService {
     }
     static bindActivityTelemetryToState(state, config, metadata, context, leg) {
         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`] =
@@ -214,14 +204,12 @@ class TelemetryService {
         }
         else if (utils_1.polyfill.resolveActivityType(config.type) === 'hook' &&
             leg === 1) {
-            //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`] =

package/build/services/worker/index.d.ts

@@ -23,6 +23,7 @@ declare class WorkerService {
     reporting: boolean;
     inited: string;
     rollCallInterval: NodeJS.Timeout;
+    constructor();
     static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<WorkerService[]>;
     verifyWorkerFields(worker: HotMeshWorker): void;
     initStoreChannel(service: WorkerService, store: RedisClient): Promise<void>;
@@ -30,10 +31,6 @@ declare class WorkerService {
     initStreamChannel(service: WorkerService, stream: RedisClient): Promise<void>;
     initRouter(worker: HotMeshWorker, logger: ILogger): Promise<Router>;
     subscriptionHandler(): SubscriptionCallback;
-    /**
-     * A quorum-wide command to broadcaset system details.
-     *
-     */
     doRollCall(message: RollCallMessage): Promise<void>;
     cancelRollCall(): void;
     stop(): void;