@chainlink/external-adapter-framework 0.0.6 → 0.0.7

package/dist/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = void 0;
+const fastify_1 = __importDefault(require("fastify"));
+const path_1 = require("path");
+const adapter_1 = require("./adapter");
+const background_executor_1 = require("./background-executor");
+const cache_1 = require("./cache");
+const config_1 = require("./config");
+const metrics_1 = require("./metrics");
+const transports_1 = require("./transports");
+const util_1 = require("./util");
+const validation_1 = require("./validation");
+const logger = (0, util_1.makeLogger)('Main');
+const VERSION = process.env['npm_package_version'];
+/**
+ * Main function for the framework.
+ * Initializes config and dependencies, uses those to initialize Transports, and starts listening for requests.
+ *
+ * @param adapter - an object describing an External Adapter
+ * @param dependencies - an optional object with adapter dependencies to inject
+ * @returns a Promise that resolves to the http.Server listening for connections
+ */
+const expose = async (adapter, dependencies) => {
+    const config = (0, config_1.buildAdapterConfig)({
+        overrides: adapter.envDefaultOverrides,
+        customSettings: adapter.customSettings,
+    });
+    // Initialize adapter (create dependencies, inject them, build endpoint map, etc.)
+    const initializedAdapter = await (0, adapter_1.initializeAdapter)(adapter, config, dependencies);
+    let server = undefined;
+    if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
+        (0, metrics_1.setupMetricsServer)(adapter.name, config);
+    }
+    if (config.EA_MODE === 'reader' || config.EA_MODE === 'reader-writer') {
+        // Main REST API server to handle incoming requests
+        const app = await buildRestApi(config, initializedAdapter);
+        // Start listening for incoming requests
+        try {
+            await app.listen(config.EA_PORT, config.EA_HOST);
+        }
+        catch (err) {
+            logger.fatal(`There was an error when starting the EA server: ${err}`);
+            process.exit();
+        }
+        logger.info(`Listening on port ${app.server.address().port}`);
+        server = app.server;
+    }
+    else {
+        logger.info('REST API is disabled; this instance will not process incoming requests.');
+    }
+    if (config.EA_MODE === 'writer' || config.EA_MODE === 'reader-writer') {
+        // Start background loop that will take care of calling any async Transports
+        logger.info('Starting background execution loop');
+        (0, background_executor_1.callBackgroundExecutes)(initializedAdapter, server);
+    }
+    else {
+        logger.info('Background executor is disabled; this instance will not perform async background executes.');
+    }
+    return server;
+};
+exports.expose = expose;
+async function buildRestApi(config, initializedAdapter) {
+    const app = (0, fastify_1.default)();
+    // Add healthcheck endpoint before middlewares to bypass them
+    app.get((0, path_1.join)(config.BASE_URL, 'health'), (req, res) => {
+        res.status(200).send({ message: 'OK', version: VERSION });
+    });
+    // Use global error handling
+    app.setErrorHandler(validation_1.errorCatchingMiddleware);
+    const transportHandler = await (0, transports_1.buildTransportHandler)(initializedAdapter);
+    app.register(async (router) => {
+        // Set up "middlewares" (hooks in fastify)
+        router.addHook('preHandler', (0, validation_1.validatorMiddleware)(initializedAdapter));
+        router.addHook('preHandler', (0, cache_1.buildCacheMiddleware)(initializedAdapter));
+        if (config['CORRELATION_ID_ENABLED']) {
+            router.addHook('onRequest', util_1.loggingContextMiddleware);
+        }
+        router.route({
+            url: config.BASE_URL,
+            method: 'POST',
+            handler: transportHandler,
+        }); // Pass config maybe? cleaner that multiple instances / dependencies
+    });
+    return app;
+}

package/dist/metrics/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDurationBuckets = exports.MAX_FEED_ID_LENGTH = exports.HttpRequestType = void 0;
+var HttpRequestType;
+(function (HttpRequestType) {
+    HttpRequestType["CACHE_HIT"] = "cacheHit";
+    HttpRequestType["DATA_PROVIDER_HIT"] = "dataProviderHit";
+    HttpRequestType["ADAPTER_ERROR"] = "adapterError";
+    HttpRequestType["INPUT_ERROR"] = "inputError";
+    HttpRequestType["RATE_LIMIT_ERROR"] = "rateLimitError";
+    // BURST_LIMIT_ERROR = 'burstLimitError',
+    // BACKOFF_ERROR = 'backoffError',
+    HttpRequestType["DP_ERROR"] = "dataProviderError";
+    HttpRequestType["TIMEOUT_ERROR"] = "timeoutError";
+    // CONNECTION_ERROR = 'connectionError',
+    // RES_EMPTY_ERROR = 'responseEmptyError',
+    // RES_INVALID_ERROR = 'responseInvalidError',
+    HttpRequestType["CUSTOM_ERROR"] = "customError";
+})(HttpRequestType = exports.HttpRequestType || (exports.HttpRequestType = {}));
+/**
+ * Maxiumum number of characters that a feedId can contain.
+ */
+exports.MAX_FEED_ID_LENGTH = 300;
+// We should tune these as we collect data, this is the default bucket distribution that prom comes with
+exports.requestDurationBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];

package/dist/metrics/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequestDurationSeconds = exports.httpRequestsTotal = exports.setupMetrics = exports.setupMetricsServer = void 0;
+const client = __importStar(require("prom-client"));
+const constants_1 = require("./constants");
+const util_1 = require("../util");
+const fastify_1 = __importDefault(require("fastify"));
+const path_1 = require("path");
+const logger = (0, util_1.makeLogger)('Metrics');
+function setupMetricsServer(name, config) {
+    const metricsApp = (0, fastify_1.default)({
+        logger: false,
+    });
+    const metricsPort = config.METRICS_PORT;
+    const endpoint = config.METRICS_USE_BASE_URL ? (0, path_1.join)(config.BASE_URL, 'metrics') : '/metrics';
+    const eaHost = config.EA_HOST;
+    (0, exports.setupMetrics)(name, config);
+    metricsApp.get(endpoint, async (_, res) => {
+        res.type('txt');
+        res.send(await client.register.metrics());
+    });
+    metricsApp.listen(metricsPort, eaHost, () => logger.info(`Monitoring listening on port ${metricsPort}!`));
+}
+exports.setupMetricsServer = setupMetricsServer;
+const setupMetrics = (name, config) => {
+    client.collectDefaultMetrics();
+    client.register.setDefaultLabels({
+        app_name: config.METRICS_NAME || name || 'N/A',
+        app_version: config['npm_package_version'],
+    });
+};
+exports.setupMetrics = setupMetrics;
+exports.httpRequestsTotal = new client.Counter({
+    name: 'http_requests_total',
+    help: 'The number of http requests this external adapter has serviced for its entire uptime',
+    labelNames: [
+        'method',
+        'status_code',
+        'retry',
+        'type',
+        'is_cache_warming',
+        'feed_id',
+        'provider_status_code',
+    ],
+});
+exports.httpRequestDurationSeconds = new client.Histogram({
+    name: 'http_request_duration_seconds',
+    help: 'A histogram bucket of the distribution of http request durations',
+    buckets: constants_1.requestDurationBuckets,
+});

package/dist/metrics/util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetricsMeta = void 0;
+const cache_1 = require("../cache");
+const getMetricsMeta = (endpoint, data) => {
+    const feedId = (0, cache_1.calculateFeedId)(endpoint, data);
+    return { feedId };
+};
+exports.getMetricsMeta = getMetricsMeta;

package/dist/rate-limiting/factory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiterFactory = void 0;
+const _1 = require(".");
+const util_1 = require("../util");
+const logger = (0, util_1.makeLogger)('RateLimiterFactory');
+class RateLimiterFactory {
+    static buildRateLimiter(tiers, selectedTier, strategy = _1.RateLimitingStrategy.NOP_RATE_LIMITER) {
+        const RateLimiterCtor = _1.RateLimiterMap[strategy];
+        let tier;
+        if (tiers) {
+            // Check that if the tiers object is defined, it has values
+            if (Object.values(tiers).length === 0) {
+                throw new Error(`The tiers object is defined, but has no entries`);
+            }
+            // Check that the tier set in the AdapterConfig is a valid one
+            if (selectedTier && !tiers[selectedTier]) {
+                const validTiersString = Object.keys(tiers)
+                    .map((t) => `"${t}"`)
+                    .join(', ');
+                throw new Error(`The selected rate limit tier "${selectedTier}" is not valid (can be one of ${validTiersString})`);
+            }
+            // If no selected tier is present, use the first one
+            // TODO: Add logic to select lowest throughput one?
+            tier = selectedTier ? tiers[selectedTier] : Object.values(tiers)[0];
+        }
+        const rateLimiter = new RateLimiterCtor();
+        rateLimiter.initialize(tier);
+        logger.info(`Initialized rate limiter using "${strategy}" strategy.`);
+        return rateLimiter;
+    }
+}
+exports.RateLimiterFactory = RateLimiterFactory;

package/dist/rate-limiting/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiterMap = exports.RateLimitingStrategy = void 0;
+const nop_limiter_1 = require("./nop-limiter");
+const simple_counting_1 = require("./simple-counting");
+__exportStar(require("./simple-counting"), exports);
+__exportStar(require("./factory"), exports);
+/**
+ * Enum to easily specify rate limiting strategy in the Adapter config
+ */
+var RateLimitingStrategy;
+(function (RateLimitingStrategy) {
+    RateLimitingStrategy["SIMPLE_COUNTING_LIMITER"] = "SIMPLE_COUNTING_LIMITER";
+    RateLimitingStrategy["NOP_RATE_LIMITER"] = "NOP_RATE_LIMITER";
+})(RateLimitingStrategy = exports.RateLimitingStrategy || (exports.RateLimitingStrategy = {}));
+/**
+ * Record to map a limiting strategy to the implementing class
+ */
+exports.RateLimiterMap = {
+    [RateLimitingStrategy.SIMPLE_COUNTING_LIMITER]: simple_counting_1.SimpleCountingRateLimiter,
+    [RateLimitingStrategy.NOP_RATE_LIMITER]: nop_limiter_1.NopRateLimiter,
+};

package/dist/rate-limiting/metrics.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimitCreditsSpentTotal = void 0;
+const client = __importStar(require("prom-client"));
+exports.rateLimitCreditsSpentTotal = new client.Counter({
+    name: 'rate_limit_credits_spent_total',
+    help: 'The number of data provider credits the adapter is consuming',
+    labelNames: ['participant_id', 'feed_id', 'experimental'],
+});

package/dist/rate-limiting/nop-limiter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NopRateLimiter = void 0;
+/**
+ * Default rate limiter that will basically do nothing, always allow requests through
+ */
+class NopRateLimiter {
+    initialize() {
+        return;
+    }
+    isUnderLimits() {
+        return true;
+    }
+}
+exports.NopRateLimiter = NopRateLimiter;

package/dist/rate-limiting/simple-counting.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCountingRateLimiter = void 0;
+const util_1 = require("../util");
+const logger = (0, util_1.makeLogger)('SimpleCountingRateLimiter');
+/**
+ * This rate limiter is the simplest stateful option.
+ * On startup, it'll compare the different thresholds for each tier, calculate them all
+ * in the finest window we'll use (seconds), and use the most restrictive one.
+ * This is so if the EA were to restart, we don't need to worry about persisting state
+ * for things like daily quotas. The downside is that this does not work well for bursty
+ * loads or spikes, in cases where e.g. the per second limit is high but daily quotas low.
+ */
+class SimpleCountingRateLimiter {
+    constructor() {
+        this.latestSecondInterval = 0;
+        this.requestsThisSecond = 0;
+        this.latestMinuteInterval = 0;
+        this.requestsThisMinute = 0;
+    }
+    initialize(limits) {
+        // Translate the hourly limit into reqs per minute
+        const perHourLimit = (limits?.rateLimit1h || Infinity) / 60;
+        this.perMinuteLimit = Math.min(limits?.rateLimit1m || Infinity, perHourLimit);
+        this.perSecondLimit = limits?.rateLimit1s || Infinity;
+        logger.debug(`Using rate limiting settings: perMinute = ${this.perMinuteLimit} | perSecond: = ${this.perSecondLimit}`);
+    }
+    isUnderLimits() {
+        // If the limit is set to infinity, there was no tier limit specified
+        if (this.perSecondLimit === Infinity && this.perMinuteLimit === Infinity) {
+            return true;
+        }
+        const now = Date.now();
+        const nearestSecondInterval = Math.floor(now / 1000);
+        const nearestMinuteInterval = Math.floor(now / (1000 * 60));
+        // This should always run to completion, even if it doesn't look atomic; therefore the
+        // Ops should be "thread safe". Thank JS and its infinite single threaded dumbness.
+        if (nearestSecondInterval !== this.latestSecondInterval) {
+            logger.trace(`Clearing latest second interval, # of requests logged was: ${this.requestsThisSecond} `);
+            this.latestSecondInterval = nearestSecondInterval;
+            this.requestsThisSecond = 0;
+        }
+        if (nearestMinuteInterval !== this.latestMinuteInterval) {
+            logger.trace(`Clearing latest second minute, # of requests logged was: ${this.requestsThisMinute} `);
+            this.latestMinuteInterval = nearestMinuteInterval;
+            this.requestsThisMinute = 0;
+        }
+        if (this.requestsThisSecond < this.perSecondLimit &&
+            this.requestsThisMinute < this.perMinuteLimit) {
+            logger.trace('Request under limits, counting +1');
+            this.requestsThisSecond++;
+            this.requestsThisMinute++;
+            return true;
+        }
+        else {
+            logger.trace('Requests seen this interval are above limits');
+            return false;
+        }
+    }
+}
+exports.SimpleCountingRateLimiter = SimpleCountingRateLimiter;

package/dist/src/adapter.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeAdapter = exports.initializeDependencies = void 0;
+const factory_1 = require("./cache/factory");
+const rate_limiting_1 = require("./rate-limiting");
+const util_1 = require("./util");
+const logger = (0, util_1.makeLogger)('Adapter');
+/**
+ * This function will take an adapter structure and go through each endpoint, calculating
+ * each one's allocation of the total rate limits that are set for the adapter as a whole.
+ *
+ * @param adapter - the adapter to initialize rate limiting for
+ */
+const calculateRateLimitAllocations = (adapter) => {
+    const numberOfEndpoints = adapter.endpoints.length;
+    const endpointsWithExplicitAllocations = adapter.endpoints.filter((e) => e.rateLimiting);
+    const totalExplicitAllocation = endpointsWithExplicitAllocations
+        .map((e) => e.rateLimiting?.allocationPercentage || 0)
+        .reduce((sum, next) => sum + next, 0);
+    if (totalExplicitAllocation > 100) {
+        throw new Error('The total allocation set for all endpoints summed cannot exceed 100%');
+    }
+    if (totalExplicitAllocation === 100 &&
+        numberOfEndpoints - endpointsWithExplicitAllocations.length > 0) {
+        throw new Error('The explicit allocation is at 100% but there are endpoints with implicit allocation');
+    }
+    const implicitAllocation = 100 - totalExplicitAllocation;
+    logger.debug('Adapter rate limit allocations:');
+    for (const endpoint of adapter.endpoints) {
+        if (!endpoint.rateLimiting) {
+            endpoint.rateLimiting = {
+                allocationPercentage: implicitAllocation / (numberOfEndpoints - endpointsWithExplicitAllocations.length),
+            };
+        }
+        logger.debug(`Endpoint [${endpoint.name}] - ${endpoint.rateLimiting?.allocationPercentage}%`);
+    }
+};
+/**
+ * This function will process dependencies for an adapter, such as caches or rate limiters,
+ * in order to inject them into transports and other relevant places later in the lifecycle.
+ *
+ * @param config - the configuration for this adapter
+ * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
+ * @param rateLimitingConfig - details from the adapter regarding rate limiting
+ * @returns a set of AdapterDependencies all initialized
+ */
+const initializeDependencies = (adapter, config, inputDependencies) => {
+    const dependencies = inputDependencies || {};
+    if (!dependencies.cache) {
+        dependencies.cache = factory_1.CacheFactory.buildCache(config);
+    }
+    // In the future we might want something more complex, but for now it's better to simplify
+    // and just use the same rate limiting for everything. Once we have a more complex use case we
+    // can think of ways to make this more configurable.
+    const rateLimitingTier = (0, rate_limiting_1.getRateLimitingTier)(adapter.rateLimiting?.tiers, config.RATE_LIMIT_API_TIER);
+    if (!dependencies.requestRateLimiter) {
+        dependencies.requestRateLimiter = new rate_limiting_1.SimpleCountingRateLimiter().initialize(adapter.endpoints, rateLimitingTier);
+    }
+    if (!dependencies.backgroundExecuteRateLimiter) {
+        dependencies.backgroundExecuteRateLimiter = new rate_limiting_1.FixedFrequencyRateLimiter().initialize(adapter.endpoints, rateLimitingTier);
+    }
+    return dependencies;
+};
+exports.initializeDependencies = initializeDependencies;
+/**
+ * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
+ * i.e. makes them lowercase for now
+ * @param adapter - an instance of an Adapter
+ */
+const normalizeEndpointNames = (adapter) => {
+    // Make endpoints case insensitive, including default
+    adapter.defaultEndpoint = adapter.defaultEndpoint?.toLowerCase();
+    for (const endpoint of adapter.endpoints) {
+        endpoint.name = endpoint.name.toLowerCase();
+        endpoint.aliases = endpoint.aliases?.map((a) => a.toLowerCase());
+    }
+};
+/**
+ * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
+ * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
+ *
+ * @param adapter - an instance of an Adapter
+ * @param dependencies - dependencies that the adapter will need at initialization
+ * @param config - configuration variables already processed and validated
+ * @returns - the adapter with all transports initialized and aliases map built
+ */
+const initializeAdapter = async (adapter, config, dependencies) => {
+    normalizeEndpointNames(adapter);
+    calculateRateLimitAllocations(adapter);
+    const initializedDependencies = (0, exports.initializeDependencies)(adapter, config, dependencies);
+    const endpointsMap = {};
+    for (const endpoint of adapter.endpoints) {
+        // Add aliases to map to use in validation
+        const aliases = [endpoint.name, ...(endpoint.aliases || [])];
+        for (const alias of aliases) {
+            if (endpointsMap[alias]) {
+                throw new Error(`Duplicate endpoint / alias: "${alias}"`);
+            }
+            endpointsMap[alias] = endpoint;
+        }
+        logger.debug(`Initializing transport for endpoint "${endpoint.name}"...`);
+        await endpoint.transport.initialize(initializedDependencies);
+    }
+    logger.debug('Adapter initialization complete.');
+    return {
+        ...adapter,
+        endpointsMap,
+        dependencies: initializedDependencies,
+        config,
+    };
+};
+exports.initializeAdapter = initializeAdapter;

package/dist/src/background-executor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBackgroundExecutes = void 0;
+const util_1 = require("./util");
+const logger = (0, util_1.makeLogger)('BackgroundExecutor');
+/**
+ * Very simple background loop that will call the [[Transport.backgroundExecute]] functions in all Transports.
+ * It gets the time in ms to wait as the return value from those functions, and sleeps until next execution.
+ *
+ * @param adapter - an initialized External Adapter
+ * @param server - the http server to attach an on close listener to
+ */
+async function callBackgroundExecutes(adapter, server) {
+    // Set up variable to check later on to see if we need to stop this background "thread"
+    // If no server is provided, the listener won't be set and serverClosed will always be false
+    let serverClosed = false;
+    server?.on('close', () => {
+        serverClosed = true;
+    });
+    for (const endpoint of adapter.endpoints) {
+        const backgroundExecute = endpoint.transport.backgroundExecute?.bind(endpoint.transport);
+        if (!backgroundExecute) {
+            logger.debug(`Endpoint "${endpoint.name}" has no background execute, skipping...`);
+            continue;
+        }
+        const context = {
+            adapterEndpoint: endpoint,
+            adapterConfig: adapter.config,
+        };
+        const handler = async () => {
+            if (serverClosed) {
+                logger.info('Server closed, stopping recursive backgroundExecute handler chain');
+                return;
+            }
+            logger.debug(`Calling background execute for endpoint "${endpoint.name}"`);
+            const timeToWait = await backgroundExecute(context);
+            logger.debug(`Finished background execute for endpoint "${endpoint.name}", sleeping for ${timeToWait}ms`);
+            await (0, util_1.sleep)(timeToWait);
+            handler();
+        };
+        // Start recursive async calls
+        handler();
+    }
+}
+exports.callBackgroundExecutes = callBackgroundExecutes;

package/dist/src/cache/factory.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheFactory = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const util_1 = require("../util");
+const local_1 = require("./local");
+const cacheMetrics = __importStar(require("./metrics"));
+const redis_1 = require("./redis");
+const logger = (0, util_1.makeLogger)('CacheFactory');
+class CacheFactory {
+    static buildCache(config) {
+        logger.info(`Using "${config.CACHE_TYPE}" cache.`);
+        if (config.CACHE_TYPE === 'local') {
+            return new local_1.LocalCache();
+        }
+        else if (config.CACHE_TYPE === 'redis') {
+            const redis = new ioredis_1.default({
+                enableAutoPipelining: true,
+                host: config.CACHE_REDIS_HOST,
+                port: config.CACHE_REDIS_PORT,
+            });
+            redis.on('connect', () => {
+                cacheMetrics.redisConnectionsOpen.inc();
+            });
+            // TODO: Maybe track active redis connections instead of just total count of connections created
+            // Use a Gauge and track with a combo of connect/end events listeners
+            return new redis_1.RedisCache(redis);
+        }
+    }
+}
+exports.CacheFactory = CacheFactory;