@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/cjs/util/context-util.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextUtil = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const built_in_trace_id_generators_1 = require("../built-in/built-in-trace-id-generators");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+class ContextUtil {
+    constructor() { }
+    static initContext(epsilon, evt, ctx, processLabel) {
+        ContextUtil.CURRENT_EPSILON_REFERENCE = epsilon;
+        ContextUtil.CURRENT_CONTEXT = ctx;
+        ContextUtil.CURRENT_EVENT = evt;
+        ContextUtil.CURRENT_LOG_VARS = {};
+        ContextUtil.CURRENT_PROCESS_LABEL = processLabel;
+    }
+    static clearContext() {
+        ContextUtil.CURRENT_EPSILON_REFERENCE = null;
+        ContextUtil.CURRENT_CONTEXT = null;
+        ContextUtil.CURRENT_EVENT = null;
+        ContextUtil.CURRENT_LOG_VARS = {};
+        ContextUtil.CURRENT_PROCESS_LABEL = null;
+        ContextUtil.CURRENT_OVERRIDE_TRACE_ID = null;
+        ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH = null;
+    }
+    static setOverrideTrace(traceId, traceDepth) {
+        ContextUtil.CURRENT_OVERRIDE_TRACE_ID = traceId || ContextUtil.CURRENT_OVERRIDE_TRACE_ID;
+        ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH = traceDepth || ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH;
+    }
+    static setOverrideTraceFromInternalBackgroundEntry(entry) {
+        ContextUtil.setOverrideTrace(entry.traceId, entry.traceDepth);
+    }
+    static setOverrideTraceFromInterApiEntry(interApiEntry) {
+        ContextUtil.setOverrideTrace(interApiEntry.traceId, interApiEntry.traceDepth);
+    }
+    static addHeadersToRecord(input, depthOffset = 0) {
+        if (input) {
+            input[ContextUtil.traceHeaderName()] = ContextUtil.currentTraceId();
+            input[ContextUtil.traceDepthHeaderName()] = ratchet_common_3.StringRatchet.safeString(ContextUtil.currentTraceDepth() + depthOffset);
+        }
+        else {
+            ratchet_common_2.ErrorRatchet.throwFormattedErr('Cannot add headers to null/undefined input');
+        }
+    }
+    static addTraceToProxyResult(pr) {
+        pr.headers = pr.headers || {};
+        ContextUtil.addHeadersToRecord(pr.headers);
+    }
+    static addTraceToHttpRequestInit(ri) {
+        ri.headers = ri.headers || {};
+        ContextUtil.addHeadersToRecord(ri.headers, 1);
+    }
+    static setProcessLabel(processLabel) {
+        ContextUtil.CURRENT_PROCESS_LABEL = processLabel;
+    }
+    static currentRequestId() {
+        const ctx = ContextUtil.CURRENT_CONTEXT;
+        return ctx ? ctx.awsRequestId : null;
+    }
+    static remainingTimeMS() {
+        const ctx = ContextUtil.CURRENT_CONTEXT;
+        return ctx ? ctx.getRemainingTimeInMillis() : null;
+    }
+    static currentProcessLabel() {
+        return ContextUtil.CURRENT_PROCESS_LABEL || 'unset';
+    }
+    static traceHeaderName() {
+        var _a, _b, _c;
+        const headerName = ((_c = (_b = (_a = ContextUtil === null || ContextUtil === void 0 ? void 0 : ContextUtil.CURRENT_EPSILON_REFERENCE) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.loggerConfig) === null || _c === void 0 ? void 0 : _c.traceHeaderName) || 'X-TRACE-ID';
+        return headerName;
+    }
+    static traceDepthHeaderName() {
+        var _a, _b, _c;
+        const headerName = ((_c = (_b = (_a = ContextUtil === null || ContextUtil === void 0 ? void 0 : ContextUtil.CURRENT_EPSILON_REFERENCE) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.loggerConfig) === null || _c === void 0 ? void 0 : _c.traceDepthHeaderName) || 'X-TRACE-DEPTH';
+        return headerName;
+    }
+    static currentTraceId() {
+        var _a, _b, _c, _d, _e;
+        const traceFn = ((_c = (_b = (_a = ContextUtil === null || ContextUtil === void 0 ? void 0 : ContextUtil.CURRENT_EPSILON_REFERENCE) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.loggerConfig) === null || _c === void 0 ? void 0 : _c.traceIdGenerator) || built_in_trace_id_generators_1.BuiltInTraceIdGenerators.fullAwsRequestId;
+        const traceId = ContextUtil.CURRENT_OVERRIDE_TRACE_ID ||
+            ((_e = (_d = ContextUtil.CURRENT_EVENT) === null || _d === void 0 ? void 0 : _d.headers) === null || _e === void 0 ? void 0 : _e[ContextUtil.traceHeaderName()]) ||
+            traceFn(ContextUtil.CURRENT_EVENT, ContextUtil.CURRENT_CONTEXT);
+        return traceId;
+    }
+    static currentTraceDepth() {
+        var _a, _b;
+        const caller = ContextUtil.CURRENT_OVERRIDE_TRACE_DEPTH ||
+            ratchet_common_1.NumberRatchet.safeNumber((_b = (_a = ContextUtil.CURRENT_EVENT) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b[ContextUtil.traceDepthHeaderName()]) ||
+            1;
+        return caller;
+    }
+    static addLogVariable(name, val) {
+        ContextUtil.CURRENT_LOG_VARS[name] = val;
+    }
+    static fetchLogVariable(name) {
+        var _a;
+        return (_a = ContextUtil.CURRENT_LOG_VARS) === null || _a === void 0 ? void 0 : _a[name];
+    }
+    static fetchLogVariables() {
+        return Object.assign({}, ContextUtil.CURRENT_LOG_VARS || {});
+    }
+}
+exports.ContextUtil = ContextUtil;
+ContextUtil.CURRENT_LOG_VARS = {};

package/dist/cjs/util/cron-util.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronUtil = void 0;
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const luxon_1 = require("luxon");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+class CronUtil {
+    static everyNMinuteFilter(n) {
+        return CronUtil.everyNElementFilter(n, 60);
+    }
+    static everyNDaysOfYearFilter(n) {
+        return CronUtil.everyNElementFilter(n, 365);
+    }
+    static everyNElementFilter(n, m) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(n);
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(m);
+        const half = Math.floor(m / 2);
+        if (!n || n < 2 || n > half || m % n !== 0) {
+            ratchet_common_2.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 = [];
+        for (let i = 0; i < 60; i += n) {
+            rval.push(i);
+        }
+        return rval;
+    }
+    static numberMatchesFilter(num, filter) {
+        return !filter || filter.length === 0 || filter.includes(num);
+    }
+    static eventMatchesEntry(event, entry, cfg, testTimeEpochMS = new Date().getTime()) {
+        let rval = false;
+        if (!!event && !!entry && !!cfg.timezone) {
+            if (!!event.resources && event.resources.length > 0) {
+                const eventSourceName = event.resources[0];
+                const targetTZ = ratchet_common_3.StringRatchet.trimToNull(entry.overrideTimezone) || cfg.timezone;
+                const nowInTZ = luxon_1.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(ratchet_common_3.StringRatchet.trimToEmpty(cfg.context)));
+                rval = rval && (!entry.contextNoMatchFilter || !entry.contextNoMatchFilter.test(ratchet_common_3.StringRatchet.trimToEmpty(cfg.context)));
+            }
+        }
+        return rval;
+    }
+    static cronEntryName(entry, idx = null) {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(entry);
+        let rval = 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;
+    }
+}
+exports.CronUtil = CronUtil;

package/dist/cjs/util/epsilon-config-parser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpsilonConfigParser = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const ratchet_misc_1 = require("@bitblit/ratchet-misc");
+const background_http_adapter_handler_1 = require("../background/background-http-adapter-handler");
+const background_handler_1 = require("../background/background-handler");
+const router_util_1 = require("../http/route/router-util");
+const web_handler_1 = require("../http/web-handler");
+const misconfigured_error_1 = require("../http/error/misconfigured-error");
+const epsilon_global_handler_1 = require("../epsilon-global-handler");
+class EpsilonConfigParser {
+    constructor() { }
+    static epsilonConfigToEpsilonGlobalHandler(config, backgroundManager) {
+        return new epsilon_global_handler_1.EpsilonGlobalHandler(EpsilonConfigParser.epsilonConfigToEpsilonInstance(config, backgroundManager));
+    }
+    static epsilonConfigToEpsilonInstance(config, backgroundManager) {
+        this.validateGlobalConfig(config);
+        ratchet_common_1.Logger.info('Creating epsilon : BM : %j', backgroundManager);
+        const parsed = EpsilonConfigParser.parseOpenApiDocument(config.openApiYamlString);
+        const modelValidator = EpsilonConfigParser.openApiDocToValidator(parsed);
+        const backgroundHttpAdapter = new background_http_adapter_handler_1.BackgroundHttpAdapterHandler(config.backgroundConfig, modelValidator, backgroundManager);
+        const backgroundHandler = config.backgroundConfig
+            ? new background_handler_1.BackgroundHandler(config.backgroundConfig, backgroundManager, modelValidator)
+            : null;
+        const epsilonRouter = config.httpConfig
+            ? router_util_1.RouterUtil.openApiYamlToRouterConfig(config.httpConfig, parsed, modelValidator, backgroundHttpAdapter)
+            : null;
+        const webHandler = epsilonRouter ? new web_handler_1.WebHandler(epsilonRouter) : null;
+        const inst = {
+            config: config,
+            parsedOpenApiDoc: parsed,
+            modelValidator: modelValidator,
+            webHandler: webHandler,
+            backgroundHandler: backgroundHandler,
+            backgroundManager: backgroundManager,
+        };
+        return inst;
+    }
+    static parseOpenApiDocument(yamlString) {
+        if (!yamlString) {
+            throw new misconfigured_error_1.MisconfiguredError('Cannot configure, missing either yaml or cfg');
+        }
+        const doc = js_yaml_1.default.load(yamlString);
+        return doc;
+    }
+    static openApiDocToValidator(doc) {
+        var _a;
+        let rval = null;
+        if ((_a = doc === null || doc === void 0 ? void 0 : doc.components) === null || _a === void 0 ? void 0 : _a.schemas) {
+            rval = ratchet_misc_1.ModelValidator.createFromParsedObject(doc.components.schemas);
+        }
+        return rval;
+    }
+    static validateGlobalConfig(config) {
+        if (!config) {
+            ratchet_common_2.ErrorRatchet.throwFormattedErr('Config may not be null');
+        }
+        if (!config.openApiYamlString) {
+            ratchet_common_2.ErrorRatchet.throwFormattedErr('Config must define an open api document');
+        }
+        if (!!config.cron && !config.cron.timezone) {
+            ratchet_common_2.ErrorRatchet.throwFormattedErr('Cron is defined, but timezone is not set');
+        }
+    }
+}
+exports.EpsilonConfigParser = EpsilonConfigParser;

package/dist/es/background/background-dynamo-log-table-handler.js

@@ -0,0 +1,33 @@
+import { BackgroundExecutionEventType } from './background-execution-event-type';
+import { ContextUtil } from '../util/context-util';
+export class BackgroundDynamoLogTableHandler {
+    constructor(dynamo, tableName, env, backgroundQueueName) {
+        this.dynamo = dynamo;
+        this.tableName = tableName;
+        this.env = env;
+        this.backgroundQueueName = backgroundQueueName;
+    }
+    async onEvent(event) {
+        const entry = {
+            env: this.env,
+            backgroundQueueName: this.backgroundQueueName,
+            requestId: ContextUtil.currentRequestId(),
+            guid: event.guid,
+            processTypeName: event.processorType,
+            state: event.type.toString(),
+            timestampEpochMs: new Date().getTime(),
+        };
+        if (event.type == BackgroundExecutionEventType.DataValidationError) {
+            const errors = event?.errors?.length ? event.errors : ['No-Error'];
+            entry.errors = errors;
+        }
+        else if (event.type == BackgroundExecutionEventType.ProcessStarting) {
+            entry.params = event.data;
+        }
+        else if (event.type == BackgroundExecutionEventType.ExecutionFailedError) {
+            const errors = event?.errors?.length ? event.errors : ['No-Error'];
+            entry.errors = errors;
+        }
+        await this.dynamo.simplePut(this.tableName, entry);
+    }
+}

package/dist/es/background/background-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/background-execution-event-type.js

@@ -0,0 +1,8 @@
+export var BackgroundExecutionEventType;
+(function (BackgroundExecutionEventType) {
+    BackgroundExecutionEventType["ProcessStarting"] = "ProcessStarting";
+    BackgroundExecutionEventType["DataValidationError"] = "DataValidationError";
+    BackgroundExecutionEventType["ExecutionSuccessfullyComplete"] = "ExecutionSuccessfullyComplete";
+    BackgroundExecutionEventType["ExecutionFailedError"] = "ExecutionRuntimeError";
+    BackgroundExecutionEventType["NoMatchProcessorName"] = "NoMatchProcessorName";
+})(BackgroundExecutionEventType || (BackgroundExecutionEventType = {}));

package/dist/es/background/background-execution-event.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/background-execution-listener.js

@@ -0,0 +1 @@
+export {};

package/dist/es/background/background-handler.js

@@ -0,0 +1,265 @@
+import { ErrorRatchet, Logger, StopWatch, StringRatchet } from '@bitblit/ratchet-common';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+import { EpsilonConstants } from '../epsilon-constants';
+import { BackgroundValidator } from './background-validator';
+import { BackgroundExecutionEventType } from './background-execution-event-type';
+import { ContextUtil } from '../util/context-util';
+import { AbstractBackgroundManager } from './manager/abstract-background-manager';
+export class BackgroundHandler {
+    constructor(cfg, mgr, modelValidator) {
+        this.cfg = cfg;
+        this.mgr = mgr;
+        this.modelValidator = modelValidator;
+        const cfgErrors = BackgroundValidator.validateConfig(cfg);
+        if (cfgErrors.length > 0) {
+            ErrorRatchet.throwFormattedErr('Invalid background config : %j', cfgErrors);
+        }
+        Logger.silly('Starting Background processor, %d processors', cfg.processors.length);
+        this.validator = new BackgroundValidator(cfg, modelValidator);
+        this.processors = BackgroundValidator.validateAndMapProcessors(cfg.processors, modelValidator);
+        if (mgr?.immediateProcessQueue && mgr.immediateProcessQueue()) {
+            Logger.info('Attaching to immediate processing queue');
+            mgr.immediateProcessQueue().subscribe(async (evt) => {
+                Logger.debug('Processing local background entry : %j', evt);
+                const rval = await this.processSingleBackgroundEntry(evt);
+                Logger.info('Processor returned %s', rval);
+            });
+        }
+    }
+    extractLabel(evt, context) {
+        let rval = null;
+        if (this.isBackgroundStartSnsEvent(evt)) {
+            rval = 'BG:START-EVT';
+        }
+        else if (this.isBackgroundImmediateFireEvent(evt)) {
+            const pEvt = this.parseImmediateFireBackgroundEntry(evt);
+            rval = 'BG:' + pEvt.type + ':' + pEvt.guid;
+        }
+        else {
+            rval = 'BG:UNKNOWN';
+        }
+        return rval;
+    }
+    handlesEvent(evt) {
+        return LambdaEventDetector.isValidSnsEvent(evt) && this.isBackgroundSNSEvent(evt);
+    }
+    isBackgroundSNSEvent(event) {
+        return this.isBackgroundStartSnsEvent(event) || this.isBackgroundImmediateFireEvent(event);
+    }
+    isBackgroundStartSnsEvent(event) {
+        let rval = false;
+        if (event) {
+            if (LambdaEventDetector.isSingleSnsEvent(event)) {
+                const cast = event;
+                rval = cast.Records[0].Sns.Message === EpsilonConstants.BACKGROUND_SNS_START_MARKER;
+            }
+        }
+        return rval;
+    }
+    isBackgroundImmediateFireEvent(event) {
+        let rval = false;
+        if (!!event) {
+            if (LambdaEventDetector.isSingleSnsEvent(event)) {
+                const cast = event;
+                const msg = cast.Records[0].Sns.Message;
+                if (!!StringRatchet.trimToNull(msg)) {
+                    const parsed = JSON.parse(msg);
+                    rval = !!parsed && parsed['type'] === EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG;
+                }
+            }
+        }
+        return rval;
+    }
+    parseImmediateFireBackgroundEntry(event) {
+        let rval = null;
+        try {
+            if (!!event) {
+                if (LambdaEventDetector.isSingleSnsEvent(event)) {
+                    const cast = event;
+                    const msg = cast.Records[0].Sns.Message;
+                    if (!!StringRatchet.trimToNull(msg)) {
+                        const parsed = JSON.parse(msg);
+                        if (!!parsed && parsed['type'] === EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG) {
+                            rval = parsed['backgroundEntry'];
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            Logger.error('Could not parse %j as an immediate run event : %s', event, err, err);
+        }
+        return rval;
+    }
+    async processEvent(event, context) {
+        let procd = null;
+        if (!this.isBackgroundStartSnsEvent(event)) {
+            const backgroundEntry = this.parseImmediateFireBackgroundEntry(event);
+            if (!!backgroundEntry) {
+                Logger.silly('Processing immediate fire event : %j', backgroundEntry);
+                const result = await this.processSingleBackgroundEntry(backgroundEntry);
+                procd = 1;
+            }
+            else {
+                Logger.warn('Tried to process non-background start / immediate event : %j returning false', event);
+            }
+        }
+        else {
+            Logger.info('Reading task from background queue');
+            procd = await this.takeAndProcessSingleBackgroundQueueEntry();
+            if (procd > 0) {
+                Logger.info('Processed %d elements from background queue, refiring', procd);
+                const refire = await this.mgr.fireStartProcessingRequest();
+                Logger.info('Refire returned %s', refire);
+            }
+            else {
+                Logger.info('No items processed - stopping');
+            }
+        }
+        const rval = {
+            statusCode: 200,
+            body: StringRatchet.safeString(procd),
+            isBase64Encoded: false,
+        };
+        return rval;
+    }
+    async takeAndProcessSingleBackgroundQueueEntry() {
+        let rval = null;
+        const entries = await this.mgr.takeEntryFromBackgroundQueue();
+        Logger.info('Found %d entries - processing', entries.length);
+        for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            const result = await this.processSingleBackgroundEntry(e);
+            rval += result ? 1 : 0;
+        }
+        Logger.debug('Returning %d', rval);
+        return rval;
+    }
+    async safeWriteToLogger(entry) {
+        if (this.cfg.transactionLogger) {
+            try {
+                await this.cfg.transactionLogger.logTransaction(entry);
+            }
+            catch (err) {
+                Logger.error('Failed to write to transaction logger : %j : %s', entry, err, err);
+            }
+        }
+        else {
+            Logger.silly('Skipping - no logger defined');
+        }
+    }
+    async conditionallyStartTransactionLog(e) {
+        if (!StringRatchet.trimToNull(e.guid)) {
+            Logger.warn('No guid found - creating');
+            e.guid = AbstractBackgroundManager.generateBackgroundGuid();
+            const log = {
+                request: e,
+                running: true,
+            };
+            await this.safeWriteToLogger(log);
+        }
+        Logger.debug('Starting transaction log');
+    }
+    async conditionallyCompleteTransactionLog(e, result, error, runtimeMS) {
+        Logger.debug('Completing transaction log');
+        const log = {
+            request: e,
+            result: result,
+            error: error ? ErrorRatchet.safeStringifyErr(error) : null,
+            running: false,
+            runtimeMS: runtimeMS,
+        };
+        await this.safeWriteToLogger(log);
+    }
+    async conditionallyRunErrorProcessor(e, error) {
+        try {
+            if (this.cfg.errorProcessor) {
+                Logger.info('Running error processor');
+                await this.cfg.errorProcessor.handleError(e, error);
+            }
+        }
+        catch (err) {
+            Logger.error('Background : BAD - Failed to run error processor : %s', err, err);
+        }
+    }
+    async fireListenerEvent(event) {
+        const listeners = this.cfg.executionListeners || [];
+        for (const listener of listeners) {
+            try {
+                await listener.onEvent(event);
+            }
+            catch (err) {
+                Logger.error('Failure triggering handler %s : %s', StringRatchet.trimToNull(listener?.label) || 'No-name', err);
+            }
+        }
+    }
+    async processSingleBackgroundEntry(e) {
+        ContextUtil.setOverrideTraceFromInternalBackgroundEntry(e);
+        Logger.info('Background Process Start: %j', e);
+        const sw = new StopWatch();
+        await this.conditionallyStartTransactionLog(e);
+        let rval = false;
+        try {
+            await this.fireListenerEvent({
+                type: BackgroundExecutionEventType.ProcessStarting,
+                processorType: e.type,
+                data: e.data,
+                guid: e.guid,
+            });
+            const processorInput = this.processors.get(e.type);
+            if (!processorInput) {
+                ErrorRatchet.throwFormattedErr('Found no processor for background entry : %j (returning false)', e);
+                await this.fireListenerEvent({
+                    type: BackgroundExecutionEventType.NoMatchProcessorName,
+                    processorType: e.type,
+                    data: e.data,
+                    guid: e.guid,
+                });
+            }
+            let dataValidationErrors = [];
+            if (StringRatchet.trimToNull(processorInput.dataSchemaName)) {
+                dataValidationErrors = this.modelValidator.validate(processorInput.dataSchemaName, e.data, false, false);
+            }
+            if (dataValidationErrors.length > 0) {
+                await this.fireListenerEvent({
+                    type: BackgroundExecutionEventType.DataValidationError,
+                    processorType: e.type,
+                    data: e.data,
+                    errors: dataValidationErrors,
+                    guid: e.guid,
+                });
+                ErrorRatchet.throwFormattedErr('Not processing, data failed validation; entry was %j : errors : %j', e, dataValidationErrors);
+            }
+            else {
+                let result = await processorInput.handleEvent(e.data, this.mgr);
+                result = result || 'SUCCESSFUL COMPLETION : NO RESULT RETURNED';
+                await this.conditionallyCompleteTransactionLog(e, result, null, sw.elapsedMS());
+                await this.fireListenerEvent({
+                    type: BackgroundExecutionEventType.ExecutionSuccessfullyComplete,
+                    processorType: e.type,
+                    data: result,
+                    guid: e.guid,
+                });
+                rval = true;
+            }
+        }
+        catch (err) {
+            Logger.error('Background Process Error: %j : %s', e, err, err);
+            await this.conditionallyRunErrorProcessor(e, err);
+            await this.conditionallyCompleteTransactionLog(e, null, err, sw.elapsedMS());
+            await this.fireListenerEvent({
+                type: BackgroundExecutionEventType.ExecutionFailedError,
+                processorType: e.type,
+                data: e.data,
+                errors: [ErrorRatchet.safeStringifyErr(err)],
+                guid: e.guid,
+            });
+        }
+        Logger.info('Background Process Stop: %j : %s', e, sw.dump());
+        return rval;
+    }
+    getConfig() {
+        const rval = Object.assign({}, this.cfg);
+        return rval;
+    }
+}