@bitblit/ratchet-epsilon-common 6.0.146-alpha → 6.0.147-alpha

package/src/sample/test-error-server.ts

@@ -0,0 +1,140 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { IncomingMessage, Server, ServerResponse } from 'http';
+import net from 'net';
+
+/**
+ * A simplistic server for testing your lambdas locally
+ */
+export class TestErrorServer {
+  private server: Server;
+  private aborted: boolean = false;
+
+  constructor(private port: number = 9999) {}
+
+  async runServer(): Promise<boolean> {
+    Logger.info('Starting Test Error net server on port %d', this.port);
+
+    return new Promise<boolean>((_res, _rej) => {
+      const server = new net.Server({});
+      // The server listens to a socket for a client to make a connection request.
+      // Think of a socket as an end point.
+      server.listen(this.port, () => {
+        Logger.info('Server listening for connection requests on socket localhost: %s', this.port);
+      });
+
+      // When a client requests a connection with the server, the server creates a new
+      // socket dedicated to that client.
+      server.on('connection', async (socket) => {
+        Logger.info('X: A new connection has been established.');
+
+        //await PromiseRatchet.wait(30000);
+        // Now that a TCP connection has been established, the server can send data to
+        // the client by writing to its socket.
+        socket.write('Hello, client.');
+
+        // The server can also receive data from the client by reading from its socket.
+        socket.on('data', (chunk) => {
+          Logger.info('Data received from client: %s', chunk);
+        });
+
+        // When the client requests to end the TCP connection with the server, the server
+        // ends the connection.
+        socket.on('end', () => {
+          Logger.info('Closing connection with the client');
+        });
+
+        // Don't forget to catch error, for your own sake.
+        socket.on('error', (err) => {
+          Logger.info('Error: %s', err);
+        });
+      });
+
+      /*
+      this.server = http.createServer(this.requestHandler.bind(this)).listen(this.port);
+      Logger.info('Test Error server is listening');
+
+      // Also listen for SIGINT
+      process.on('SIGINT', () => {
+        Logger.info('Caught SIGINT - shutting down test server...');
+        this.aborted = true;
+      });
+
+      return this.checkFinished();
+
+       */
+    });
+  }
+
+  async requestHandler(request: IncomingMessage, response: ServerResponse): Promise<any> {
+    Logger.info('Got request %d - closing socket', request);
+    request.setTimeout(100);
+    //await PromiseRatchet.wait(3000);
+    response.end('x');
+    /*response.socket.end(() => {
+      //return null;
+    });
+
+     */
+    /*(e) => {
+      Logger.info('Out: %s', e);
+    });
+
+     */
+    /*const context: Context = {
+      awsRequestId: 'LOCAL-' + StringRatchet.createType4Guid(),
+      getRemainingTimeInMillis(): number {
+        return 300000;
+      },
+    } as Context; //TBD
+    const evt: APIGatewayEvent = await this.messageToApiGatewayEvent(request, context);
+    const logEventLevel: LoggerLevelName = EventUtil.eventIsAGraphQLIntrospection(evt) ? LoggerLevelName.silly : LoggerLevelName.info;
+
+    Logger.logByLevel(logEventLevel, 'Processing event: %j', evt);
+
+    if (evt.path == '/epsilon-poison-pill') {
+      this.aborted = true;
+      return true;
+    } else {
+      const result: ProxyResult = await this.globalHandler.lambdaHandler(evt, context);
+      const written: boolean = await this.writeProxyResultToServerResponse(result, response);
+      return written;
+    }
+
+     */
+  }
+
+  /*
+  private async writeProxyResultToServerResponse(proxyResult: ProxyResult, response: ServerResponse): Promise<boolean> {
+    const isGraphQLSchemaResponse: boolean = !!proxyResult && !!proxyResult.body && proxyResult.body.indexOf('{"data":{"__schema"') > -1;
+
+    if (!isGraphQLSchemaResponse) {
+      Logger.debug('Result: %j', proxyResult);
+    }
+
+    response.statusCode = proxyResult.statusCode;
+    if (proxyResult.headers) {
+      Object.keys(proxyResult.headers).forEach((hk) => {
+        response.setHeader(hk, String(proxyResult.headers[hk]));
+      });
+    }
+    if (proxyResult.multiValueHeaders) {
+      Object.keys(proxyResult.multiValueHeaders).forEach((hk) => {
+        response.setHeader(hk, proxyResult.multiValueHeaders[hk].join(','));
+      });
+    }
+    const toWrite: Buffer = proxyResult.isBase64Encoded ? Buffer.from(proxyResult.body, 'base64') : Buffer.from(proxyResult.body);
+
+    response.end(toWrite);
+    return !!proxyResult.body;
+  }
+
+   */
+
+  public static async runFromCliArgs(_args: string[]): Promise<void> {
+    Logger.info('test-error-server requested (cli is %s) - starting', process?.argv);
+    const testServer: TestErrorServer = new TestErrorServer();
+    await testServer.runServer();
+    Logger.info('Got res server');
+    process.exit(0);
+  }
+}

package/src/util/aws-util.ts

@@ -0,0 +1,89 @@
+import {
+  APIGatewayEvent,
+  APIGatewayEventRequestContextV2,
+  APIGatewayEventRequestContextWithAuthorizer,
+  APIGatewayProxyEventV2,
+} from 'aws-lambda';
+
+// This class holds any random stuff I need to deal with AWS weirdness
+export class AwsUtil {
+  public static apiGatewayV2ToApiGatewayV1(srcEvt: APIGatewayProxyEventV2): APIGatewayEvent {
+    const rval: APIGatewayEvent = {
+      requestContext: AwsUtil.apiGatewayV2RequestContextToApiGatewayV1RequestContext(srcEvt.requestContext),
+      httpMethod: srcEvt.requestContext.http.method,
+      path: srcEvt.requestContext.http.path,
+      queryStringParameters: srcEvt.queryStringParameters,
+      headers: srcEvt.headers,
+      body: srcEvt.body,
+      isBase64Encoded: srcEvt.isBase64Encoded,
+      multiValueHeaders: null,
+      multiValueQueryStringParameters: null,
+      pathParameters: srcEvt.pathParameters,
+      stageVariables: srcEvt.stageVariables,
+      resource: null,
+    };
+    return rval;
+  }
+
+  public static apiGatewayV2RequestContextToApiGatewayV1RequestContext(
+    srcEvt: APIGatewayEventRequestContextV2,
+  ): APIGatewayEventRequestContextWithAuthorizer<any> {
+    const rval: APIGatewayEventRequestContextWithAuthorizer<any> = {
+      accountId: srcEvt.accountId,
+      apiId: srcEvt.apiId,
+      authorizer: null, //srcEvtTAuthorizerContext;
+
+      domainName: srcEvt.domainName,
+      domainPrefix: srcEvt.domainPrefix,
+
+      requestId: srcEvt.requestId,
+      routeKey: srcEvt.routeKey,
+      stage: srcEvt.stage,
+
+      requestTime: srcEvt.time,
+      requestTimeEpoch: srcEvt.timeEpoch,
+
+      //connectedAt?: number | undefined;
+      //connectionId?: string | undefined;
+      //eventType?: string | undefined;
+      //extendedRequestId?: string | undefined;
+      protocol: srcEvt.http.protocol,
+      httpMethod: srcEvt.http.method,
+      identity: null, // APIGatewayEventIdentity;
+      //messageDirection?: string | undefined;
+      //messageId?: string | null | undefined;
+      path: srcEvt.http.path,
+      resourceId: null, //string;
+      resourcePath: null, //string;
+    };
+    return rval;
+  }
+
+  public static findInMap<T>(toFind: string, map: Map<string, T>): T {
+    let rval: T = null;
+    map.forEach((val, key) => {
+      if (AwsUtil.matchExact(key, toFind)) {
+        rval = val;
+      }
+    });
+    return rval;
+  }
+
+  public static matchExact(r, str) {
+    const match = str.match(r);
+    return match != null && str == match[0];
+  }
+
+  // Returns either the value if non-function, the result if function, and default if neither
+  public static resolvePotentialFunctionToResult<T>(src: any, def: T): T {
+    let rval: T = def;
+    if (src) {
+      if (typeof src === 'function') {
+        rval = src();
+      } else {
+        rval = src;
+      }
+    }
+    return rval;
+  }
+}

package/src/util/context-global-data.ts

@@ -0,0 +1,13 @@
+import { EpsilonInstance } from '../epsilon-instance';
+import { Context } from 'aws-lambda';
+
+export interface ContextGlobalData {
+  epsilonInstance: EpsilonInstance;
+  context: Context;
+  event: any;
+  logVariables: Record<string, string | number | boolean>;
+  processLabel: string;
+
+  overrideTraceId: string;
+  overrideTraceDepth: number;
+}

package/src/util/context-util.ts

@@ -0,0 +1,156 @@
+import { Context, ProxyResult } from 'aws-lambda';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { LoggingTraceIdGenerator } from '../config/logging-trace-id-generator.js';
+//import { BuiltInTraceIdGenerators } from '../built-in/built-in-trace-id-generators.js';
+import { InternalBackgroundEntry } from '../background/internal-background-entry.js';
+import { InterApiEntry } from '../inter-api/inter-api-entry.js';
+import { ContextGlobalData } from './context-global-data.js';
+import { GlobalRatchet } from '@bitblit/ratchet-common/lang/global-ratchet';
+
+// This class serves as a static holder for the AWS Lambda context, and also adds some
+// simple helper functions
+export class ContextUtil {
+  // This only really works because Node is single-threaded - otherwise need some kind of thread local
+  public static readonly CONTEXT_DATA_GLOBAL_NAME = 'EpsilonGlobalContextData';
+  /*
+  private static CURRENT_EPSILON_REFERENCE: EpsilonInstance;
+  private static CURRENT_CONTEXT: Context;
+  private static CURRENT_EVENT: any;
+  private static CURRENT_LOG_VARS: Record<string, string | number | boolean> = {};
+  private static CURRENT_PROCESS_LABEL: string;
+
+  private static CURRENT_OVERRIDE_TRACE_ID: string;
+  private static CURRENT_OVERRIDE_TRACE_DEPTH: number;*/
+
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  private static fetchContextData(): ContextGlobalData {
+    return GlobalRatchet.fetchGlobalVar(ContextUtil.CONTEXT_DATA_GLOBAL_NAME, {
+      epsilonInstance: null,
+      context: null,
+      event: null,
+      logVariables: {},
+      processLabel: 'UNSET',
+      overrideTraceDepth: null,
+      overrideTraceId: null,
+    });
+  }
+
+  public static initContext(epsilon: EpsilonInstance, evt: any, ctx: Context, processLabel: string): void {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    cd.epsilonInstance = epsilon;
+    cd.context = ctx;
+    cd.event = evt;
+    cd.processLabel = processLabel;
+  }
+
+  public static clearContext() {
+    GlobalRatchet.setGlobalVar(ContextUtil.CONTEXT_DATA_GLOBAL_NAME, null);
+  }
+
+  public static setOverrideTrace(traceId: string, traceDepth: number): void {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    cd.overrideTraceId = traceId || cd.overrideTraceId;
+    cd.overrideTraceDepth = traceDepth || cd.overrideTraceDepth;
+  }
+
+  public static setOverrideTraceFromInternalBackgroundEntry(entry: InternalBackgroundEntry<any>): void {
+    ContextUtil.setOverrideTrace(entry.traceId, entry.traceDepth);
+  }
+
+  public static setOverrideTraceFromInterApiEntry(interApiEntry: InterApiEntry<any>): void {
+    ContextUtil.setOverrideTrace(interApiEntry.traceId, interApiEntry.traceDepth);
+  }
+
+  public static addHeadersToRecord(input: Record<string, any>, depthOffset: number = 0): void {
+    if (input) {
+      input[ContextUtil.traceHeaderName()] = ContextUtil.currentTraceId();
+      input[ContextUtil.traceDepthHeaderName()] = StringRatchet.safeString(ContextUtil.currentTraceDepth() + depthOffset);
+    } else {
+      ErrorRatchet.throwFormattedErr('Cannot add headers to null/undefined input');
+    }
+  }
+
+  public static addTraceToProxyResult(pr: ProxyResult): void {
+    pr.headers = pr.headers || {};
+    ContextUtil.addHeadersToRecord(pr.headers);
+  }
+
+  public static addTraceToHttpRequestInit(ri: RequestInit): void {
+    ri.headers = ri.headers || {};
+    ContextUtil.addHeadersToRecord(ri.headers, 1);
+  }
+
+  public static setProcessLabel(processLabel: string): void {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    cd.processLabel = processLabel;
+  }
+
+  public static currentRequestId(): string {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    return cd?.context?.awsRequestId;
+  }
+
+  public static defaultedCurrentRequestId(defaultValueIfMissing: string = StringRatchet.createType4Guid()): string {
+    return ContextUtil.currentRequestId() ?? defaultValueIfMissing;
+  }
+
+  public static remainingTimeMS(): number {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    return cd?.context?.getRemainingTimeInMillis();
+  }
+
+  public static currentProcessLabel(): string {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    return cd?.processLabel || 'unset';
+  }
+
+  private static traceHeaderName(): string {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    const headerName: string = cd?.epsilonInstance?.config?.loggerConfig?.traceHeaderName || 'X-TRACE-ID';
+    return headerName;
+  }
+
+  private static traceDepthHeaderName(): string {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    const headerName: string = cd?.epsilonInstance?.config?.loggerConfig?.traceDepthHeaderName || 'X-TRACE-DEPTH';
+    return headerName;
+  }
+
+  public static currentTraceId(): string {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+
+    const traceFn: LoggingTraceIdGenerator =
+      cd?.epsilonInstance?.config?.loggerConfig?.traceIdGenerator || ContextUtil.defaultedCurrentRequestId;
+    const traceId: string = cd?.overrideTraceId || cd?.event?.headers?.[ContextUtil.traceHeaderName()] || traceFn(cd?.event, cd?.context);
+    return traceId;
+  }
+
+  public static currentTraceDepth(): number {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+
+    const caller: number =
+      cd?.overrideTraceDepth || NumberRatchet.safeNumber(cd?.event?.headers?.[ContextUtil.traceDepthHeaderName()]) || 1;
+    return caller;
+  }
+
+  public static addLogVariable(name: string, val: string | number | boolean): void {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    cd.logVariables[name] = val;
+  }
+
+  public static fetchLogVariable(name: string): string | number | boolean {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    return cd?.logVariables?.[name];
+  }
+
+  public static fetchLogVariables(): Record<string, string | number | boolean> {
+    const cd: ContextGlobalData = ContextUtil.fetchContextData();
+    return Object.assign({}, cd?.logVariables || {});
+  }
+}

package/src/util/cron-util.spec.ts

@@ -0,0 +1,190 @@
+import { ScheduledEvent } from 'aws-lambda';
+import fs from 'fs';
+import path from 'path';
+import { CronUtil } from './cron-util.js';
+import { CronConfig } from '../config/cron/cron-config.js';
+import { AbstractCronEntry } from '../config/cron/abstract-cron-entry.js';
+import { EsmRatchet } from '@bitblit/ratchet-common/lang/esm-ratchet';
+import { describe, expect, test } from 'vitest';
+
+describe('#cronUtil', function () {
+  test('should test matching event to entry', async () => {
+    const sEvent: ScheduledEvent = JSON.parse(
+      fs
+        .readFileSync(
+          path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'),
+        )
+        .toString(),
+    );
+
+    const cfg: CronConfig = {
+      context: 'prod',
+      timezone: 'America/Los_Angeles',
+      entries: [], // only works since this isn't checked
+    };
+
+    const cron1: AbstractCronEntry = {
+      contextMatchFilter: new RegExp('prod'),
+    };
+
+    const match1: boolean = CronUtil.eventMatchesEntry(sEvent, cron1, cfg);
+    expect(match1).toBeTruthy();
+
+    const cron2: AbstractCronEntry = {
+      contextMatchFilter: new RegExp('dev'),
+    };
+
+    const match2: boolean = CronUtil.eventMatchesEntry(sEvent, cron2, cfg);
+    expect(match2).toBeFalsy();
+
+    const cron3: AbstractCronEntry = {
+      eventFilter: new RegExp('.*MyScheduledRule.*'),
+    };
+
+    const match3: boolean = CronUtil.eventMatchesEntry(sEvent, cron3, cfg);
+    expect(match3).toBeTruthy();
+
+    const cron4: AbstractCronEntry = {
+      eventFilter: new RegExp('.*NotMyRule.*'),
+    };
+
+    const match4: boolean = CronUtil.eventMatchesEntry(sEvent, cron4, cfg);
+    expect(match4).toBeFalsy();
+  });
+
+  test('should match times', async () => {
+    const sEvent: ScheduledEvent = JSON.parse(
+      fs
+        .readFileSync(
+          path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'),
+        )
+        .toString(),
+    );
+    const cfg: CronConfig = {
+      context: 'prod',
+      timezone: 'America/Los_Angeles',
+      entries: [], // only works since this isn't checked
+    };
+
+    const _entry1: AbstractCronEntry = {};
+
+    const cron1: AbstractCronEntry = {
+      contextMatchFilter: new RegExp('prod'),
+    };
+
+    const match1: boolean = CronUtil.eventMatchesEntry(sEvent, cron1, cfg);
+    expect(match1).toBeTruthy();
+
+    const cron2: AbstractCronEntry = {
+      contextMatchFilter: new RegExp('dev'),
+    };
+
+    const match2: boolean = CronUtil.eventMatchesEntry(sEvent, cron2, cfg);
+    expect(match2).toBeFalsy();
+
+    const cron3: AbstractCronEntry = {
+      eventFilter: new RegExp('.*MyScheduledRule.*'),
+    };
+
+    const match3: boolean = CronUtil.eventMatchesEntry(sEvent, cron3, cfg);
+    expect(match3).toBeTruthy();
+
+    const cron4: AbstractCronEntry = {
+      eventFilter: new RegExp('.*NotMyRule.*'),
+    };
+
+    const match4: boolean = CronUtil.eventMatchesEntry(sEvent, cron4, cfg);
+    expect(match4).toBeFalsy();
+  });
+
+  test('should match time with override', async () => {
+    const sEvent: ScheduledEvent = JSON.parse(
+      fs
+        .readFileSync(
+          path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'),
+        )
+        .toString(),
+    );
+    const cfg: CronConfig = {
+      context: 'prod',
+      timezone: 'America/Los_Angeles',
+      entries: [], // only works since this isn't checked
+    };
+
+    const _entry1: AbstractCronEntry = {};
+
+    const cron1: AbstractCronEntry = {
+      hourFilter: [3],
+    };
+
+    const cron2: AbstractCronEntry = {
+      overrideTimezone: 'etc/utc',
+      hourFilter: [3],
+    };
+
+    //Timestamp in milliseconds: 1652931000000
+    //Date and time (GMT): Thursday, May 19, 2022 3:30:00 AM
+    const testTimestampEpochMS: number = 1652931000000;
+
+    const match1: boolean = CronUtil.eventMatchesEntry(sEvent, cron1, cfg, testTimestampEpochMS);
+    const match2: boolean = CronUtil.eventMatchesEntry(sEvent, cron2, cfg, testTimestampEpochMS);
+    expect(match1).toBeFalsy();
+    expect(match2).toBeTruthy();
+  });
+
+  test('should match day of month filters', async () => {
+    const sEvent: ScheduledEvent = JSON.parse(
+      fs
+        .readFileSync(
+          path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'),
+        )
+        .toString(),
+    );
+    const cfg: CronConfig = {
+      context: 'prod',
+      timezone: 'etc/utc',
+      entries: [], // only works since this isn't checked
+    };
+
+    const _entry1: AbstractCronEntry = {};
+
+    //Timestamp in milliseconds: 1652931000000
+    //Date and time (GMT): Thursday, May 19, 2022 3:30:00 AM
+    const testTimestampEpochMS: number = 1652931000000;
+
+    const dayOfMonth: AbstractCronEntry = {
+      dayOfMonthFilter: [19],
+    };
+
+    const matchDay: boolean = CronUtil.eventMatchesEntry(sEvent, dayOfMonth, cfg, testTimestampEpochMS);
+    expect(matchDay).toBeTruthy();
+  });
+
+  test('should match month of year filter', async () => {
+    const sEvent: ScheduledEvent = JSON.parse(
+      fs
+        .readFileSync(
+          path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/epsilon/sample-json/sample-schedule-event-1.json'),
+        )
+        .toString(),
+    );
+    const cfg: CronConfig = {
+      context: 'prod',
+      timezone: 'etc/utc',
+      entries: [], // only works since this isn't checked
+    };
+
+    const _entry1: AbstractCronEntry = {};
+
+    //Timestamp in milliseconds: 1652931000000
+    //Date and time (GMT): Thursday, May 19, 2022 3:30:00 AM
+    const testTimestampEpochMS: number = 1652931000000;
+
+    const monthOfYear: AbstractCronEntry = {
+      monthOfYearFilter: [5],
+    };
+
+    const matchMonth: boolean = CronUtil.eventMatchesEntry(sEvent, monthOfYear, cfg, testTimestampEpochMS);
+    expect(matchMonth).toBeTruthy();
+  });
+});

package/src/util/cron-util.ts

@@ -0,0 +1,86 @@
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { ScheduledEvent } from 'aws-lambda';
+import { DateTime } from 'luxon';
+import { AbstractCronEntry } from '../config/cron/abstract-cron-entry.js';
+import { CronConfig } from '../config/cron/cron-config.js';
+
+export class CronUtil {
+  public static everyNMinuteFilter(n: number): number[] {
+    return CronUtil.everyNElementFilter(n, 60);
+  }
+
+  public static everyNDaysOfYearFilter(n: number): number[] {
+    return CronUtil.everyNElementFilter(n, 365);
+  }
+
+  public static everyNElementFilter(n: number, m: number): number[] {
+    RequireRatchet.notNullOrUndefined(n);
+    RequireRatchet.notNullOrUndefined(m);
+    const half: number = Math.floor(m / 2);
+
+    if (!n || n < 2 || n > half || m % n !== 0) {
+      ErrorRatchet.throwFormattedErr(
+        'Invalid config - this function only makes sense for 2 < N < %d and %d evenly divisible by N',
+        half,
+        m,
+      );
+      throw new Error('Invalid config - this function only makes sense for 2 < N < 31 and 60 evenly divisible by N');
+    }
+    const rval: number[] = [];
+    for (let i = 0; i < 60; i += n) {
+      rval.push(i);
+    }
+    return rval;
+  }
+
+  public static numberMatchesFilter(num: number, filter: number[]): boolean {
+    return !filter || filter.length === 0 || filter.includes(num);
+  }
+
+  public static eventMatchesEntry(
+    event: ScheduledEvent,
+    entry: AbstractCronEntry,
+    cfg: CronConfig,
+    testTimeEpochMS: number = new Date().getTime(),
+  ): boolean {
+    let rval: boolean = false;
+    if (!!event && !!entry && !!cfg.timezone) {
+      if (!!event.resources && event.resources.length > 0) {
+        const eventSourceName: string = event.resources[0];
+        const targetTZ: string = StringRatchet.trimToNull(entry.overrideTimezone) || cfg.timezone;
+        const nowInTZ: DateTime = DateTime.fromMillis(testTimeEpochMS).setZone(targetTZ);
+        rval = !entry.eventFilter || entry.eventFilter.test(eventSourceName);
+        rval = rval && CronUtil.numberMatchesFilter(nowInTZ.minute, entry.minuteFilter);
+        rval = rval && CronUtil.numberMatchesFilter(nowInTZ.hour, entry.hourFilter);
+        rval = rval && CronUtil.numberMatchesFilter(nowInTZ.weekday, entry.dayOfWeekFilter);
+        rval = rval && CronUtil.numberMatchesFilter(nowInTZ.day, entry.dayOfMonthFilter);
+        rval = rval && CronUtil.numberMatchesFilter(nowInTZ.month, entry.monthOfYearFilter);
+        rval = rval && (!entry.contextMatchFilter || entry.contextMatchFilter.test(StringRatchet.trimToEmpty(cfg.context)));
+        rval = rval && (!entry.contextNoMatchFilter || !entry.contextNoMatchFilter.test(StringRatchet.trimToEmpty(cfg.context)));
+      }
+    }
+
+    return rval;
+  }
+
+  public static cronEntryName(entry: AbstractCronEntry, idx: number = null): string {
+    RequireRatchet.notNullOrUndefined(entry);
+    let rval: string = null;
+    if (entry) {
+      rval = entry.name;
+      rval = rval || entry['backgroundTaskType'];
+      if (!rval && !!entry['directHandler']) {
+        if (idx) {
+          rval = 'Direct Entry ' + idx;
+        } else {
+          rval = 'Direct Entry (No idx specified)';
+        }
+      }
+    } else {
+      rval = 'ERROR: no entry passed';
+    }
+    return rval;
+  }
+}