@hotmeshio/hotmesh 0.0.55 → 0.0.57

package/services/task/index.ts

@@ -1,250 +0,0 @@
-import {
-  HMSH_EXPIRE_DURATION,
-  HMSH_FIDELITY_SECONDS, 
-  HMSH_SCOUT_INTERVAL_SECONDS} from '../../modules/enums';
-import { XSleepFor, sleepFor } from '../../modules/utils';
-import { ILogger } from '../logger';
-import { Pipe } from '../pipe';
-import { StoreService } from '../store';
-import { HookInterface, HookRule, HookSignal } from '../../types/hook';
-import { KeyType } from '../../types/hotmesh';
-import { JobCompletionOptions, JobState } from '../../types/job';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { WorkListTaskType } from '../../types/task';
-import { VALSEP, WEBSEP } from '../../modules/key';
-
-class TaskService {
-  store: StoreService<RedisClient, RedisMulti>;
-  logger: ILogger;
-  cleanupTimeout: NodeJS.Timeout | null = null;
-  isScout: boolean = false;
-  errorCount = 0;
-
-  constructor(
-    store: StoreService<RedisClient, RedisMulti>,
-    logger: ILogger
-  ) {
-    this.logger = logger;
-    this.store = store;
-  }
-
-  async processWebHooks(hookEventCallback: HookInterface): Promise<void> {
-    const workItemKey = await this.store.getActiveTaskQueue();
-    if (workItemKey) {
-      const [topic, sourceKey, scrub, ...sdata] = workItemKey.split(WEBSEP);
-      const data = JSON.parse(sdata.join(WEBSEP));
-      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 {
-        await this.store.deleteProcessedTaskQueue(
-          workItemKey,
-          sourceKey,
-          destinationKey,
-          scrub === 'true'
-        );
-      }
-      setImmediate(() => this.processWebHooks(hookEventCallback));
-    }
-  }
-
-  async enqueueWorkItems(keys: string[]): Promise<void> {
-    await this.store.addTaskQueues(keys);
-  }
-
-  async registerJobForCleanup(jobId: string, inSeconds = HMSH_EXPIRE_DURATION, options: JobCompletionOptions): Promise<void> {
-    if (inSeconds > 0) {
-      await this.store.expireJob(jobId, inSeconds);
-      const fromNow = Date.now() + (inSeconds * 1000);
-      const fidelityMS = HMSH_FIDELITY_SECONDS * 1000;
-      const timeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
-      await this.store.registerDependenciesForCleanup(
-        jobId,
-        timeSlot,
-        options,
-      );
-    }
-  }
-
-  async registerTimeHook(
-    jobId: string,
-    gId: string,
-    activityId: string,
-    type: WorkListTaskType,
-    inSeconds = HMSH_FIDELITY_SECONDS,
-    dad: string,
-    multi?: RedisMulti,
-  ): Promise<void> {
-    const fromNow = Date.now() + (inSeconds * 1000);
-    const fidelityMS = HMSH_FIDELITY_SECONDS * 1000;
-    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'));
-    if (isScout) {
-      if (!wasScout) {
-        setTimeout(() => {
-          this.isScout = false;
-        }, HMSH_SCOUT_INTERVAL_SECONDS * 1_000);
-      }
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Callback handler that takes an item from a work list and
-   * processes according to its type
-   */
-  async processTimeHooks(timeEventCallback: (jobId: string, gId: string, activityId: string, type: WorkListTaskType) => Promise<void>, listKey?: string): Promise<void> {
-    if (await this.shouldScout()) {
-      try {
-        const workListTask = await this.store.getNextTask(listKey);
-
-        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(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 sleepFor(0);
-          this.errorCount = 0;
-          this.processTimeHooks(timeEventCallback, listKey);
-        } else if (workListTask) {
-          //a worklist was just emptied; try again immediately
-          await sleepFor(0);
-          this.errorCount = 0;
-          this.processTimeHooks(timeEventCallback);
-        } else {
-          //no worklists exist; sleep before checking
-          let sleep = XSleepFor(HMSH_FIDELITY_SECONDS * 1000);
-          this.cleanupTimeout = sleep.timerId;
-          await sleep.promise;
-          this.errorCount = 0;
-          this.processTimeHooks(timeEventCallback);
-        }
-      } 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 sleepFor(1_000 * this.errorCount++);
-        if (this.errorCount < 5) {
-          this.processTimeHooks(timeEventCallback);
-        }
-      }
-    } else {
-      //didn't get the scout role; try again in 'one-ish' minutes
-      let sleep = XSleepFor(HMSH_SCOUT_INTERVAL_SECONDS * 1_000 * 2 * Math.random());
-      this.cleanupTimeout = sleep.timerId;
-      await sleep.promise;
-      this.processTimeHooks(timeEventCallback);
-    }
-  }
-
-  cancelCleanup() {
-    if (this.cleanupTimeout !== undefined) {
-      clearTimeout(this.cleanupTimeout);
-      this.cleanupTimeout = undefined;
-    }
-  }
-
-  async getHookRule(topic: string): Promise<HookRule | undefined> {
-    const rules = await this.store.getHookRules();
-    return rules?.[topic]?.[0] as HookRule;
-  }
-
-  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;
-      const resolved = Pipe.resolve(mapExpression, context);
-      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(WEBSEP);
-
-      const hook: HookSignal = {
-        topic,
-        resolved,
-        jobId: compositeJobKey,
-      }
-      await this.store.setHookSignal(hook, multi);
-      return jobId;
-    } else {
-      throw new Error('signaler.registerWebHook:error: hook rule not found');
-    }
-  }
-
-  async processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string, string] | undefined> {
-    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.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(WEBSEP);
-      return [jid.join(WEBSEP), hookRule.to, dad, gid];
-    } else {
-      throw new Error('signal-not-found');
-    }
-  }
-
-  async deleteWebHookSignal(topic: string, data: Record<string, unknown>): Promise<number> {
-    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.resolve(mapExpression, context);
-      return await this.store.deleteHookSignal(topic, resolved);
-    } else {
-      throw new Error('signaler.process:error: hook rule not found');
-    }
-  }
-}
-
-export { TaskService };

package/services/telemetry/index.ts

@@ -1,273 +0,0 @@
-import packageJson from '../../package.json';
-import { MapperService } from '../mapper';
-import {
-  ActivityMetadata,
-  ActivityType,
-  Consumes } from '../../types/activity';
-import { JobState } from '../../types/job';
-import {
-  StringAnyType,
-  StringScalarType,
-  StringStringType } from '../../types/serializer';
-import { StreamData, StreamDataType, StreamRole } from '../../types/stream';
-import {
-  Span,
-  SpanContext,
-  SpanKind,
-  trace,
-  Context,
-  context, 
-  SpanStatusCode } from '../../types/telemetry';
-import { polyfill } from '../../modules/utils';
-
-class TelemetryService {
-  span: Span;
-  jobSpan: Span;
-  config: ActivityType;
-  traceId: string | null;
-  spanId: string | null;
-  appId: string;
-  metadata: ActivityMetadata;
-  context: JobState;
-  leg = 1;
-
-  constructor(
-    appId: string,
-    config?: ActivityType,
-    metadata?: ActivityMetadata,
-    context?: JobState,
-  ) {
-    this.appId = appId;
-    //these are REQUIRED for job and activity spans
-    this.config = config;
-    this.metadata = metadata;
-    this.context = context;
-  }
-
-  getJobParentSpanId(): string | undefined {
-    return this.context.metadata.spn;
-  }
-
-  getActivityParentSpanId(leg: number): string | undefined {
-    if (leg === 1) {
-      return this.context[this.config.parent].output?.metadata?.l2s;
-    } else {
-      return this.context['$self'].output?.metadata?.l1s;
-    }
-  }
-
-  getTraceId(): string | undefined {
-    return this.context.metadata.trc;
-  }
-
-  startJobSpan(): TelemetryService {
-    const spanName = `JOB/${this.appId}/${this.config.subscribes}/1`;
-    const traceId = this.getTraceId();
-    const spanId = this.getJobParentSpanId();
-    const attributes = this.getSpanAttrs(1);
-    const span: Span = this.startSpan(traceId, spanId, spanName, attributes);
-    this.jobSpan = span;
-    this.setTelemetryContext(span, 1);
-    return this;
-  }
-
-  startActivitySpan(leg = this.leg): TelemetryService {
-    const spanName = `${this.config.type.toUpperCase()}/${this.appId}/${this.metadata.aid}/${leg}`;
-    const traceId = this.getTraceId();
-    const spanId = this.getActivityParentSpanId(leg);
-    const attributes = this.getSpanAttrs(leg);
-    const span: Span = this.startSpan(traceId, spanId, spanName, attributes);
-    this.setTelemetryContext(span, leg);
-    this.span = span;
-    return this;
-  }
-
-  startStreamSpan(data: StreamData, role: StreamRole): TelemetryService {
-    let type: string;
-    if (role === StreamRole.SYSTEM) {
-      type = 'SYSTEM';
-    } else if (role === StreamRole.WORKER) {
-      type = 'EXECUTE';
-    } else if (data.type === StreamDataType.RESULT || data.type === StreamDataType.RESPONSE) {
-      type = 'FANIN';
-    } else {
-      type = 'FANOUT';
-    }
-    const topic = data.metadata.topic ? `/${data.metadata.topic}` : '';
-    const spanName = `${type}/${this.appId}/${data.metadata.aid}${topic}`;
-    const attributes = this.getStreamSpanAttrs(data);
-    const span: Span = this.startSpan(data.metadata.trc, data.metadata.spn, spanName, attributes);
-    this.span = span;
-    return this;
-  }
-
-  startSpan(traceId: string, spanId: string, spanName: string, attributes: StringScalarType): Span {
-    this.traceId = traceId;
-    this.spanId = spanId;
-    const tracer = trace.getTracer(packageJson.name, packageJson.version);
-    let parentContext = this.getParentSpanContext();
-    const span = tracer.startSpan(
-      spanName,
-      { kind: SpanKind.CLIENT, attributes, root: !parentContext },
-      parentContext
-    );
-    return span;
-  }
-
-  mapActivityAttributes(): void {
-    //export user-defined span attributes (app.activity.data.*)
-    if (this.config.telemetry) {
-      const telemetryAtts = new MapperService(this.config.telemetry, this.context).mapRules();
-      const namespacedAtts = {
-        ...Object.keys(telemetryAtts).reduce((result, key) => {
-          if (['string', 'boolean', 'number'].includes(typeof telemetryAtts[key])) {
-            result[`app.activity.data.${key}`] = telemetryAtts[key];
-          }
-          return result;
-        }, {})
-      };
-      this.span?.setAttributes(namespacedAtts as StringScalarType);
-    }
-  }
-
-  setActivityAttributes(attributes: StringScalarType): void {
-    this.span?.setAttributes(attributes);
-  }
-
-  setStreamAttributes(attributes: StringScalarType): void {
-    this.span?.setAttributes(attributes);
-  }
-
-  setJobAttributes(attributes: StringScalarType): void {
-    this.jobSpan?.setAttributes(attributes);
-  }
-
-  endJobSpan(): void {
-    this.endSpan(this.jobSpan);
-  }
-
-  endActivitySpan(): void {
-    this.endSpan(this.span);
-  }
-
-  endStreamSpan(): void {
-    this.endSpan(this.span);
-  }
-
-  endSpan(span: Span): void {
-    span && span.end();
-  }
-
-  getParentSpanContext(): undefined | Context {
-    if (this.traceId && this.spanId) {
-      const restoredSpanContext: SpanContext = {
-        traceId: this.traceId,
-        spanId: this.spanId,
-        isRemote: true,
-        traceFlags: 1, // (todo: revisit sampling strategy/config)
-      };
-      const parentContext = trace.setSpanContext(context.active(), restoredSpanContext);
-      return parentContext;
-    }
-  }
-
-  getSpanAttrs(leg: number): StringAnyType {
-    return {
-      ...Object.keys(this.context.metadata).reduce((result, key) => {
-        if (key !== 'trc') {
-          result[`app.job.${key}`] = this.context.metadata[key];
-        }
-        return result;
-      }, {}),
-      ...Object.keys(this.metadata).reduce((result, key) => {
-        result[`app.activity.${key}`] = this.metadata[key];
-        return result;
-      }, {}),
-      'app.activity.leg': leg,
-    };
-  };
-
-  getStreamSpanAttrs(input: StreamData): StringAnyType {
-    return {
-      ...Object.keys(input.metadata).reduce((result, key) => {
-        if (key !== 'trc' && key !== 'spn') {
-          result[`app.stream.${key}`] = input.metadata[key];
-        }
-        return result;
-      }, {})
-    };
-  };
-
-  setTelemetryContext(span: Span, leg: number) {
-    if (!this.context.metadata.trc) {
-      this.context.metadata.trc = span.spanContext().traceId;
-    }
-    if (leg === 1) {
-      if (!this.context['$self'].output.metadata) {
-        this.context['$self'].output.metadata = {};
-      }
-      this.context['$self'].output.metadata.l1s = span.spanContext().spanId;
-    } else {
-      if (!this.context['$self'].output.metadata) {
-        this.context['$self'].output.metadata = {};
-      }
-      this.context['$self'].output.metadata.l2s = span.spanContext().spanId;
-    }
-  }
-
-  setActivityError(message: string) {
-    this.span?.setStatus({ code: SpanStatusCode.ERROR, message });
-  }
-
-  setStreamError(message: string) {
-    this.span?.setStatus({ code: 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: Consumes, config: ActivityType, metadata: ActivityMetadata, leg: number): void {
-    if (leg === 1) {
-      if (!(config.parent in consumes)) {
-        consumes[config.parent] = [];
-      }
-      consumes[config.parent].push(`${config.parent}/output/metadata/l2s`);
-    } else {
-      if (!(metadata.aid in consumes)) {
-        consumes[metadata.aid] = [];
-      }
-      consumes[metadata.aid].push(`${metadata.aid}/output/metadata/l1s`);
-    }
-  }
-
-  static bindJobTelemetryToState(state: StringStringType, config: ActivityType, context:JobState) {
-    if (config.type === 'trigger') {
-      state['metadata/trc'] = context.metadata.trc;
-    }
-  }
-
-  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) {
-      //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 {
-      const target = `l${leg}s`;
-      state[`${metadata.aid}/output/metadata/${target}`] = context['$self'].output.metadata[target];
-    }
-  }
-}
-
-export { TelemetryService };