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

package/src/inter-api/inter-api-util.spec.ts

@@ -0,0 +1,77 @@
+import { SNSEvent } from 'aws-lambda';
+import { InterApiUtil } from './inter-api-util.js';
+import { InterApiConfig } from '../config/inter-api/inter-api-config.js';
+
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { SQSClient } from '@aws-sdk/client-sqs';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+
+describe('#interApiUtil', function () {
+  let _mockSns;
+  let _mockSqs;
+  let mockBgMgr;
+
+  const evt: SNSEvent = {
+    Records: [
+      {
+        EventSource: 'aws:sns',
+        EventVersion: '1.0',
+        EventSubscriptionArn: 'arn:aws:sns:us-east-1:012345678901:GenericApiEventTopicDev:6efec6a5-1f02-4fc5-b0f7-fa7c013cf8bb',
+        Sns: {
+          Type: 'Notification',
+          MessageId: '205de1e8-7ba6-52f5-b706-b815f442c512',
+          TopicArn: 'arn:aws:sns:us-east-1:012345678901:GenericApiEventTopicDev',
+          Subject: null,
+          Message:
+            '{"type":"EPSILON_INTER_API_EVENT","interApiEvent":{"source":"OriginalApi","type":"Sample","data":{"notes":"SOURCE API: OriginalApi","timestampEpochMS":1636011428200}}}',
+          Timestamp: '2021-11-04T07:37:08.241Z',
+          SignatureVersion: '1',
+          Signature: 'LyS2ybM/Epsq5sFqPJd==',
+          SigningCertUrl: 'https://sns.us-east-1.amazonaws.com/SimpleNotificationService-7ff5318490ec183fbaddaa2a969abfda.pem',
+          UnsubscribeUrl:
+            'https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:012345678901:GenericApiEventTopicDev:6efec6a5-1f02-4fc5-b0f7-fa7c013cf8bb',
+          MessageAttributes: {},
+        },
+      },
+    ],
+  };
+
+  beforeEach(() => {
+    _mockSns = mock<SNSClient>();
+    _mockSqs = mock<SQSClient>();
+    mockBgMgr = mock<BackgroundManagerLike>(); //new AwsSqsSnsBackgroundManager({} as BackgroundAwsConfig, mockSqs, mockSns);
+  });
+
+  test('should translate processes', async () => {
+    mockBgMgr.createEntry.mockResolvedValue({ t: 1 });
+    mockBgMgr.addEntriesToQueue.mockResolvedValue(['a]']);
+
+    const cfg: InterApiConfig = {
+      aws: {
+        source: 'test',
+        snsArn: 'test',
+        localMode: true,
+      },
+      processMappings: [
+        {
+          typeRegex: '.*',
+          sourceRegex: '.*',
+          disabled: false,
+          backgroundProcessTypes: ['TESTBG'],
+        },
+      ],
+    };
+
+    const output: string[] = await InterApiUtil.processInterApiEvent(evt, cfg, mockBgMgr);
+
+    expect(output).not.toBeNull();
+    expect(output.length).toEqual(1);
+  });
+
+  test('should verify that an event is an inter-api even', async () => {
+    const res: boolean = InterApiUtil.isInterApiSnsEvent(evt);
+    expect(res).toBeTruthy();
+  }, 500);
+});

package/src/inter-api/inter-api-util.ts

@@ -0,0 +1,71 @@
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { SNSEvent } from 'aws-lambda';
+import { EpsilonConstants } from '../epsilon-constants.js';
+import { InterApiEntry } from './inter-api-entry.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { BackgroundEntry } from '../background/background-entry.js';
+import { InterApiConfig } from '../config/inter-api/inter-api-config.js';
+import { ContextUtil } from '../util/context-util.js';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
+
+export class InterApiUtil {
+  public static isInterApiSnsEvent(event: any): boolean {
+    return !!InterApiUtil.extractEntryFromEvent(event);
+  }
+
+  public static extractEntryFromEvent(evt: SNSEvent): InterApiEntry<any> {
+    let rval: InterApiEntry<any> = null;
+
+    if (evt) {
+      if (LambdaEventDetector.isSingleSnsEvent(evt)) {
+        const cast: SNSEvent = evt as SNSEvent;
+        const msg: string = cast.Records[0].Sns.Message;
+        if (StringRatchet.trimToNull(msg)) {
+          const parsed: any = JSON.parse(msg);
+          if (!!parsed && parsed['type'] === EpsilonConstants.INTER_API_SNS_EVENT) {
+            rval = parsed['interApiEvent'];
+          }
+        }
+      }
+    }
+
+    return rval;
+  }
+
+  public static async processInterApiEvent(evt: SNSEvent, cfg: InterApiConfig, mgr: BackgroundManagerLike): Promise<string[]> {
+    let rval: string[] = [];
+    RequireRatchet.notNullOrUndefined(evt, 'InterApiEntry');
+    RequireRatchet.notNullOrUndefined(mgr, 'BackgroundManager');
+
+    const interApiEntry: InterApiEntry<any> = InterApiUtil.extractEntryFromEvent(evt);
+    ContextUtil.setOverrideTraceFromInterApiEntry(interApiEntry);
+    Logger.info('Processing inter-api event : %j', evt);
+    const backgroundEntries: BackgroundEntry<any>[] = [];
+    cfg.processMappings.forEach((map) => {
+      if (!map.disabled && interApiEntry.source.match(map.sourceRegex) && interApiEntry.type.match(map.typeRegex)) {
+        map.backgroundProcessTypes.forEach((taskName) => {
+          const entry: BackgroundEntry<any> = mgr.createEntry(taskName, interApiEntry.data);
+          backgroundEntries.push(entry);
+        });
+      }
+    });
+    if (backgroundEntries.length > 0) {
+      Logger.info('Adding %d entries to queue', backgroundEntries.length);
+      rval = await mgr.addEntriesToQueue(backgroundEntries, true);
+    } else {
+      Logger.info('No entries mapped for this event');
+    }
+    return rval;
+  }
+
+  public static addTraceToInterApiEntry(ent: InterApiEntry<any>): InterApiEntry<any> {
+    if (ent) {
+      ent.traceId = ent.traceId || ContextUtil.currentTraceId();
+      ent.traceDepth = ent.traceDepth || ContextUtil.currentTraceDepth() + 1;
+    }
+    return ent;
+  }
+}

package/src/inter-api-manager.ts

@@ -0,0 +1,75 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { EpsilonConstants } from './epsilon-constants.js';
+import { InterApiEntry } from './inter-api/inter-api-entry.js';
+import { InterApiAwsConfig } from './config/inter-api/inter-api-aws-config.js';
+import { InterApiUtil } from './inter-api/inter-api-util.js';
+import { PublishCommand, PublishCommandOutput, SNSClient } from '@aws-sdk/client-sns';
+
+/**
+ * Handles all submission of events to the inter-api SNS topic (if any)
+ */
+export class InterApiManager {
+  constructor(
+    private _aws: InterApiAwsConfig,
+    private _sns: SNSClient,
+  ) {}
+
+  public get config(): InterApiAwsConfig {
+    return this._aws;
+  }
+
+  public get sns(): SNSClient {
+    return this._sns;
+  }
+
+  public createEntry<T>(type: string, data?: T): InterApiEntry<T> {
+    const rval: InterApiEntry<T> = {
+      source: this._aws.source,
+      type: type,
+      data: data,
+    };
+    return rval;
+  }
+
+  public async fireInterApiEventByParts<T>(type: string, data?: T): Promise<string> {
+    const entry: InterApiEntry<T> = this.createEntry(type, data);
+    const rval: string = await this.fireInterApiEvent(entry);
+    return rval;
+  }
+
+  public async fireInterApiEvent<T>(entry: InterApiEntry<T>): Promise<string> {
+    let rval: string = null;
+    if (this.config.localMode) {
+      Logger.info('Fire inter-api event ignored because running locally (was %j)', entry);
+      rval = 'INTER-API-IGNORED';
+    } else {
+      try {
+        // Guard against bad entries up front
+        Logger.info('Firing inter-api event (remote) : %j ', entry);
+        const toWrite: any = {
+          type: EpsilonConstants.INTER_API_SNS_EVENT,
+          interApiEvent: InterApiUtil.addTraceToInterApiEntry(entry),
+        };
+        const msg: string = JSON.stringify(toWrite);
+        const snsId: string = await this.writeMessageToSnsTopic(msg);
+        Logger.debug('Inter-api Wrote message : %s to SNS : %s', rval, msg, snsId);
+      } catch (err) {
+        Logger.error('Failed to fireImmediateProcessRequest : %s', err, err);
+      }
+    }
+    return rval;
+  }
+
+  public async writeMessageToSnsTopic(message: string): Promise<string> {
+    let rval: string = null;
+    const params = {
+      Message: message,
+      TopicArn: this._aws.snsArn,
+    };
+
+    Logger.debug('Writing message to SNS topic : j', params);
+    const result: PublishCommandOutput = await this.sns.send(new PublishCommand(params));
+    rval = result.MessageId;
+    return rval;
+  }
+}

package/src/lambda-event-handler/cron-epsilon-lambda-event-handler.spec.ts

@@ -0,0 +1,130 @@
+import { ScheduledEvent } from 'aws-lambda';
+import { BackgroundHandler } from '../background/background-handler.js';
+import { CronConfig } from '../config/cron/cron-config.js';
+import { BackgroundConfig } from '../config/background/background-config.js';
+
+import { CronEpsilonLambdaEventHandler } from './cron-epsilon-lambda-event-handler.js';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
+import { SingleThreadLocalBackgroundManager } from '../background/manager/single-thread-local-background-manager.js';
+import { SQSClient } from '@aws-sdk/client-sqs';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { DateTime } from 'luxon';
+
+// jest.mock('@bitblit/background');
+
+describe('#cronEpsilonLambdaEventHandler', function () {
+  let _mockSqs;
+  let _mockSns;
+
+  beforeEach(() => {
+    _mockSqs = mock<SQSClient>();
+    _mockSns = mock<SNSClient>();
+  });
+
+  // CAW 2021-03-10 : Disabling for now since jest mock not working when run in batch from command line...unclear why
+  test.skip('should verify that cron data functions get executed', async () => {
+    // Logger.setLevel(LoggerLevelName.silly);
+    const evt: ScheduledEvent = {
+      id: '1',
+      version: '1',
+      account: 'test',
+      time: 'test',
+      region: '',
+      resources: ['test'],
+      source: null,
+      detail: {},
+      'detail-type': null,
+    };
+    const cronConfig: CronConfig = {
+      timezone: 'America/Los_Angeles',
+      context: 'Test',
+      entries: [
+        {
+          backgroundTaskType: 'test',
+          fireImmediate: true,
+          data: () => {
+            return { curDate: new Date().toISOString(), fixed: 'abc' };
+          },
+        },
+      ],
+    };
+    const smConfig: BackgroundConfig = {
+      processors: [],
+      httpSubmissionPath: '/background/',
+      implyTypeFromPathSuffix: true,
+      httpMetaEndpoint: '/background-meta',
+    };
+    const background = new BackgroundHandler(null, null);
+    background.getConfig = vi.fn(() => smConfig);
+
+    const backgroundManager: BackgroundManagerLike = new SingleThreadLocalBackgroundManager();
+
+    const res: boolean = await CronEpsilonLambdaEventHandler.processCronEvent(evt, cronConfig, backgroundManager, background);
+    expect(res).toBeTruthy();
+  }, 500);
+});
+
+describe('cronEpsilonLambdaEventHandler.getCronTimeToUse', () => {
+  const currentTimestampEpochMS = new Date().getTime();
+
+  const sampleEvent: ScheduledEvent = {
+    version: '0',
+    id: '403a3159-cf4d-4cbe-315d-ed688c429988',
+    'detail-type': 'Scheduled Event',
+    source: 'aws.events',
+    account: '000011112222',
+    time: '2024-08-30T13:16:24Z',
+    region: 'us-east-1',
+    resources: ['arn:aws:events:us-east-1:000011112222:rule/MyRule1'],
+    detail: {},
+  };
+
+  // @ts-expect-error private method
+  const getCronTimeToUse = CronEpsilonLambdaEventHandler.getCronTimeToUse;
+
+  test('should return current timestamp when evt is undefined', () => {
+    const result = getCronTimeToUse(undefined, currentTimestampEpochMS);
+    expect(result).toBe(currentTimestampEpochMS);
+  });
+
+  test('should return current timestamp when evt.time is undefined', () => {
+    const result = getCronTimeToUse({} as ScheduledEvent, currentTimestampEpochMS);
+    expect(result).toBe(currentTimestampEpochMS);
+  });
+
+  test('should return event time in milliseconds when evt.time is a valid ISO string', () => {
+    const recentISOTime = DateTime.fromMillis(currentTimestampEpochMS).toUTC().plus({ seconds: 30 }).toISO();
+    const eventTimeInMillis = DateTime.fromISO(recentISOTime).toMillis();
+    const result = getCronTimeToUse(
+      {
+        ...sampleEvent,
+        time: recentISOTime,
+      },
+      currentTimestampEpochMS,
+    );
+    expect(result).toBe(eventTimeInMillis);
+  });
+
+  test('should return current timestamp when evt.time is an invalid ISO string', () => {
+    const invalidISOTime = 'invalid-time';
+    const result = getCronTimeToUse(
+      {
+        ...sampleEvent,
+        time: invalidISOTime,
+      },
+      currentTimestampEpochMS,
+    );
+    expect(result).toBe(currentTimestampEpochMS);
+  });
+
+  test('should return current timestamp when time difference exceeds threshold', () => {
+    const oldISOTime = '2023-10-10T10:00:00.000Z';
+    const largeTimeDifference =
+      currentTimestampEpochMS + (CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES + 1) * 60 * 1000;
+
+    const result = getCronTimeToUse({ ...sampleEvent, time: oldISOTime }, largeTimeDifference);
+    expect(result).toBe(largeTimeDifference);
+  });
+});

package/src/lambda-event-handler/cron-epsilon-lambda-event-handler.ts

@@ -0,0 +1,132 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { Context, ProxyResult, ScheduledEvent } from 'aws-lambda';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { AwsUtil } from '../util/aws-util.js';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { CronConfig } from '../config/cron/cron-config.js';
+import { BackgroundHandler } from '../background/background-handler.js';
+import { BackgroundEntry } from '../background/background-entry.js';
+import { CronUtil } from '../util/cron-util.js';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { DateTime } from 'luxon';
+
+export class CronEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<ScheduledEvent> {
+  public static readonly CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES = 5;
+
+  constructor(private _epsilon: EpsilonInstance) {}
+
+  public extractLabel(evt: ScheduledEvent, _context: Context): string {
+    return 'CronEvt:' + evt.source;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return LambdaEventDetector.isValidCronEvent(evt);
+  }
+
+  public async processEvent(evt: ScheduledEvent, _context: Context): Promise<ProxyResult> {
+    let rval: ProxyResult = null;
+    Logger.debug('Epsilon: CRON: %j', evt);
+    if (!this._epsilon.config.cron) {
+      Logger.debug('Skipping - CRON disabled');
+      rval = {
+        statusCode: 200,
+        body: JSON.stringify({ message: 'CRON skipped - disabled' }),
+        isBase64Encoded: false,
+      };
+    } else {
+      const _output: boolean = await CronEpsilonLambdaEventHandler.processCronEvent(
+        evt,
+        this._epsilon.config.cron,
+        this._epsilon.backgroundManager,
+        this._epsilon.backgroundHandler,
+      );
+      rval = {
+        statusCode: 200,
+        body: JSON.stringify({ message: 'CRON complete' }),
+        isBase64Encoded: false,
+      };
+    }
+    return rval;
+  }
+
+  public static async processCronEvent(
+    evt: ScheduledEvent,
+    cronConfig: CronConfig,
+    backgroundManager: BackgroundManagerLike,
+    background: BackgroundHandler,
+  ): Promise<boolean> {
+    let rval: boolean = false;
+    if (cronConfig && evt && evt.resources[0]) {
+      // Run all the background ones
+      if (cronConfig.entries) {
+        if (background) {
+          const cronTimestampEpochMS = CronEpsilonLambdaEventHandler.getCronTimeToUse(evt);
+
+          const toEnqueue: BackgroundEntry<any>[] = [];
+          for (const smCronEntry of cronConfig.entries) {
+            //for (let i = 0; i < cronConfig.entries.length; i++) {
+            //const smCronEntry: CronBackgroundEntry = cronConfig.entries[i];
+            if (CronUtil.eventMatchesEntry(evt, smCronEntry, cronConfig, cronTimestampEpochMS)) {
+              Logger.info('CRON Firing : %s', CronUtil.cronEntryName(smCronEntry));
+
+              const backgroundEntry: BackgroundEntry<any> = {
+                type: smCronEntry.backgroundTaskType,
+                data: AwsUtil.resolvePotentialFunctionToResult<any>(smCronEntry.data, {}),
+              };
+              Logger.silly('Resolved entry : %j', backgroundEntry);
+              if (smCronEntry.fireImmediate) {
+                await backgroundManager.fireImmediateProcessRequest(backgroundEntry);
+                rval = true;
+              } else {
+                toEnqueue.push(backgroundEntry);
+              }
+            }
+          }
+          if (toEnqueue.length > 0) {
+            await backgroundManager.addEntriesToQueue(toEnqueue, true);
+            rval = true;
+          }
+        } else {
+          Logger.warn('Cron defines background tasks, but no background manager provided');
+        }
+      }
+    }
+    return rval;
+  }
+
+  private static getCronTimeToUse(evt?: ScheduledEvent, currentTimestampEpochMS: number = new Date().getTime()): number {
+    let rval = currentTimestampEpochMS;
+
+    if (!evt?.time) {
+      return rval;
+    }
+
+    try {
+      const dateTimeOfEvent = DateTime.fromISO(evt.time);
+      if (!dateTimeOfEvent.isValid) {
+        throw new Error('Invalid date');
+      }
+      rval = dateTimeOfEvent.toMillis();
+      if (isNaN(rval)) {
+        throw new Error('Invalid date');
+      }
+    } catch (err) {
+      Logger.warn('Could not parse event time : %s, using system time instead', evt.time, err);
+      return rval;
+    }
+
+    if (
+      Math.abs(rval - currentTimestampEpochMS) >
+      CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES * 60 * 1000
+    ) {
+      Logger.warn(
+        'Event time and current time mismatch by more than %d minutes, using current time instead',
+        CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES,
+      );
+      rval = currentTimestampEpochMS;
+    }
+
+    return rval;
+  }
+}

package/src/lambda-event-handler/dynamo-epsilon-lambda-event-handler.ts

@@ -0,0 +1,42 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { Context, DynamoDBStreamEvent, ProxyResult } from 'aws-lambda';
+import { GenericAwsEventHandlerFunction } from '../config/generic-aws-event-handler-function.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { AwsUtil } from '../util/aws-util.js';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { NoHandlersFoundError } from '../config/no-handlers-found-error.js';
+
+export class DynamoEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<DynamoDBStreamEvent> {
+  constructor(private _epsilon: EpsilonInstance) {}
+
+  public extractLabel(evt: DynamoDBStreamEvent, _context: Context): string {
+    return 'DDBEvt:' + evt.Records[0].eventName + ':' + evt.Records[0].eventSource;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return LambdaEventDetector.isValidDynamoDBEvent(evt);
+  }
+
+  public async processEvent(evt: DynamoDBStreamEvent, _context: Context): Promise<ProxyResult> {
+    let rval: any = null;
+    if (this._epsilon.config && this._epsilon.config.dynamoDb && evt && evt.Records && evt.Records.length > 0) {
+      const finder: string = evt.Records[0].eventSourceARN;
+      const handler: GenericAwsEventHandlerFunction<DynamoDBStreamEvent> = AwsUtil.findInMap<
+        GenericAwsEventHandlerFunction<DynamoDBStreamEvent>
+      >(finder, this._epsilon.config.dynamoDb.handlers);
+      if (handler) {
+        rval = await handler(evt);
+      } else {
+        Logger.info('Found no Dynamo handler for : %s', finder);
+        throw new NoHandlersFoundError();
+      }
+    }
+    return rval;
+  }
+
+  public async processUncaughtError(event: DynamoDBStreamEvent, context: Context, err: any): Promise<ProxyResult> {
+    Logger.error('Error slipped out to outer edge (Dynamo).  Logging and rethrowing : %s', err, err);
+    throw err;
+  }
+}

package/src/lambda-event-handler/generic-sns-epsilon-lambda-event-handler.ts

@@ -0,0 +1,38 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { Context, ProxyResult, SNSEvent } from 'aws-lambda';
+import { GenericAwsEventHandlerFunction } from '../config/generic-aws-event-handler-function.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { AwsUtil } from '../util/aws-util.js';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { NoHandlersFoundError } from '../config/no-handlers-found-error.js';
+
+export class GenericSnsEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<SNSEvent> {
+  constructor(private _epsilon: EpsilonInstance) {}
+
+  public extractLabel(evt: SNSEvent, _context: Context): string {
+    return 'SNSEvt:' + evt.Records[0].EventSource;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return LambdaEventDetector.isValidSnsEvent(evt);
+  }
+
+  public async processEvent(evt: SNSEvent, _context: Context): Promise<ProxyResult> {
+    let rval: any = null;
+    if (this._epsilon.config && this._epsilon.config.sns && evt && evt.Records.length > 0) {
+      const finder: string = evt.Records[0].Sns.TopicArn;
+      const handler: GenericAwsEventHandlerFunction<SNSEvent> = AwsUtil.findInMap<GenericAwsEventHandlerFunction<SNSEvent>>(
+        finder,
+        this._epsilon.config.sns.handlers,
+      );
+      if (handler) {
+        rval = await handler(evt);
+      } else {
+        Logger.info('Found no SNS handler for : %s', finder);
+        throw new NoHandlersFoundError();
+      }
+    }
+    return rval;
+  }
+}

package/src/lambda-event-handler/generic-sqs-epsilon-lambda-event-handler.ts

@@ -0,0 +1,43 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { Context, ProxyResult, SQSEvent } from 'aws-lambda';
+import { GenericAwsEventHandlerFunction } from '../config/generic-aws-event-handler-function.js';
+import { AwsUtil } from '../util/aws-util.js';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { NoHandlersFoundError } from '../config/no-handlers-found-error.js';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+export class GenericSqsEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<SQSEvent> {
+  constructor(private _epsilon: EpsilonInstance) {}
+
+  public extractLabel(evt: SQSEvent, _context: Context): string {
+    return 'SQSEvt:' + evt.Records[0].eventSourceARN;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return LambdaEventDetector.isValidSqsEvent(evt);
+  }
+
+  public async processEvent(evt: SQSEvent, _context: Context): Promise<ProxyResult> {
+    let rval: any = null;
+    if (this._epsilon.config && this._epsilon.config.sqs && evt && evt.Records.length > 0) {
+      const finder: string = evt.Records[0].eventSourceARN;
+      const handler: GenericAwsEventHandlerFunction<SQSEvent> = AwsUtil.findInMap<GenericAwsEventHandlerFunction<SQSEvent>>(
+        finder,
+        this._epsilon.config.sqs.handlers,
+      );
+      if (handler) {
+        rval = await handler(evt);
+      } else {
+        Logger.info('Found no SQS handler for : %s', finder);
+        throw new NoHandlersFoundError();
+      }
+    }
+    return rval;
+  }
+
+  public async processUncaughtError(event: SQSEvent, context: Context, err: any): Promise<ProxyResult> {
+    Logger.error('Error slipped out to outer edge (SQS).  Logging and rethrowing : %s', err, err);
+    throw err;
+  }
+}

package/src/lambda-event-handler/inter-api-epsilon-lambda-event-handler.ts

@@ -0,0 +1,33 @@
+import { EpsilonLambdaEventHandler } from '../config/epsilon-lambda-event-handler.js';
+import { Context, ProxyResult, SNSEvent } from 'aws-lambda';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { InterApiUtil } from '../inter-api/inter-api-util.js';
+import { InterApiEntry } from '../inter-api/inter-api-entry.js';
+
+export class InterApiEpsilonLambdaEventHandler implements EpsilonLambdaEventHandler<SNSEvent> {
+  constructor(private _epsilon: EpsilonInstance) {}
+
+  public extractLabel(evt: SNSEvent, _context: Context): string {
+    const ent: InterApiEntry<any> = InterApiUtil.extractEntryFromEvent(evt);
+    return 'InterApi:' + ent.source + ':' + ent.type;
+  }
+
+  public handlesEvent(evt: any): boolean {
+    return this._epsilon.config.interApiConfig && InterApiUtil.isInterApiSnsEvent(evt);
+  }
+
+  public async processEvent(evt: SNSEvent, _context: Context): Promise<ProxyResult> {
+    const tmp: string[] = await InterApiUtil.processInterApiEvent(
+      evt,
+      this._epsilon.config.interApiConfig,
+      this._epsilon.backgroundManager,
+    );
+    const rval: ProxyResult = {
+      statusCode: 200,
+      body: JSON.stringify(tmp),
+      isBase64Encoded: false,
+    };
+
+    return rval;
+  }
+}