@chainlink/external-adapter-framework 0.0.15 → 0.0.17

package/adapter.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapter = exports.AdapterEndpoint = void 0;
+const cache_1 = require("./cache");
+const config_1 = require("./config");
+const rate_limiting_1 = require("./rate-limiting");
+const util_1 = require("./util");
+const logger = (0, util_1.makeLogger)('Adapter');
+class AdapterEndpoint {
+    constructor(params) {
+        this.name = params.name;
+        this.aliases = params.aliases;
+        this.transport = params.transport;
+        this.inputParameters = params.inputParameters;
+        this.rateLimiting = params.rateLimiting;
+    }
+}
+exports.AdapterEndpoint = AdapterEndpoint;
+class Adapter {
+    constructor(params) {
+        // After initialization
+        this.initialized = false;
+        /** Object containing alias translations for all endpoints */
+        this.endpointsMap = {};
+        // Copy over params
+        this.name = params.name;
+        this.defaultEndpoint = params.defaultEndpoint?.toLowerCase();
+        this.endpoints = params.endpoints;
+        this.envDefaultOverrides = params.envDefaultOverrides;
+        this.customSettings = params.customSettings;
+        this.rateLimiting = params.rateLimiting;
+        this.overrides = params.overrides;
+        this.config = (0, config_1.buildAdapterConfig)({
+            overrides: this.envDefaultOverrides,
+            customSettings: this.customSettings,
+        });
+        this.normalizeEndpointNames();
+        this.calculateRateLimitAllocations();
+    }
+    /**
+     * 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).
+     */
+    async initialize(dependencies) {
+        if (this.initialized) {
+            throw new Error('This adapter has already been initialized!');
+        }
+        this.dependencies = this.initializeDependencies(dependencies);
+        for (const endpoint of this.endpoints) {
+            // Add aliases to map to use in validation
+            const aliases = [endpoint.name, ...(endpoint.aliases || [])];
+            for (const alias of aliases) {
+                if (this.endpointsMap[alias]) {
+                    throw new Error(`Duplicate endpoint / alias: "${alias}"`);
+                }
+                this.endpointsMap[alias] = endpoint;
+            }
+            logger.debug(`Initializing transport for endpoint "${endpoint.name}"...`);
+            await endpoint.transport.initialize(this.dependencies, this.config);
+        }
+        logger.debug('Adapter initialization complete.');
+        this.initialized = true;
+    }
+    /**
+     * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
+     * i.e. makes them lowercase for now
+     */
+    normalizeEndpointNames() {
+        for (const endpoint of this.endpoints) {
+            endpoint.name = endpoint.name.toLowerCase();
+            endpoint.aliases = endpoint.aliases?.map((a) => a.toLowerCase());
+        }
+    }
+    /**
+     * 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.
+     *
+     */
+    calculateRateLimitAllocations() {
+        const numberOfEndpoints = this.endpoints.length;
+        const endpointsWithExplicitAllocations = this.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 this.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 inputDependencies - a partial obj of initialized dependencies to override the created ones
+     * @returns a set of AdapterDependencies all initialized
+     */
+    initializeDependencies(inputDependencies) {
+        const dependencies = inputDependencies || {};
+        if (!dependencies.cache) {
+            dependencies.cache = cache_1.CacheFactory.buildCache(this.config);
+        }
+        const rateLimitingTier = (0, rate_limiting_1.getRateLimitingTier)(this.config, this.rateLimiting?.tiers);
+        if (!dependencies.requestRateLimiter) {
+            dependencies.requestRateLimiter = new rate_limiting_1.SimpleCountingRateLimiter().initialize(this.endpoints, rateLimitingTier);
+        }
+        if (!dependencies.backgroundExecuteRateLimiter) {
+            dependencies.backgroundExecuteRateLimiter = new rate_limiting_1.FixedFrequencyRateLimiter().initialize(this.endpoints, rateLimitingTier);
+        }
+        if (!dependencies.subscriptionSetFactory) {
+            dependencies.subscriptionSetFactory = new util_1.SubscriptionSetFactory(this.config);
+        }
+        return dependencies;
+    }
+}
+exports.Adapter = Adapter;

package/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/cache/factory.js

@@ -0,0 +1,58 @@
+"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,
+                password: config.CACHE_REDIS_PASSWORD,
+                path: config.CACHE_REDIS_PATH,
+                timeout: config.CACHE_REDIS_TIMEOUT,
+            });
+            redis.on('connect', () => {
+                cacheMetrics.redisConnectionsOpen.inc();
+            });
+            return new redis_1.RedisCache(redis);
+        }
+    }
+}
+exports.CacheFactory = CacheFactory;

package/cache/index.js

@@ -0,0 +1,173 @@
+"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 __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.buildCacheMiddleware = exports.pollResponseFromCache = exports.calculateKey = exports.calculateFeedId = exports.calculateCacheKey = void 0;
+const util_1 = require("../util");
+const cacheMetrics = __importStar(require("./metrics"));
+__exportStar(require("./local"), exports);
+__exportStar(require("./redis"), exports);
+__exportStar(require("./factory"), exports);
+const logger = (0, util_1.makeLogger)('Cache');
+// Uses calculateKey to generate a unique key from the endpoint name, data, and input parameters
+const calculateCacheKey = ({ adapterEndpoint, adapterConfig, }, data) => {
+    const paramNames = Object.keys(adapterEndpoint.inputParameters);
+    if (paramNames.length === 0) {
+        logger.trace(`Using default cache key ${adapterConfig.DEFAULT_CACHE_KEY}`);
+        return adapterConfig.DEFAULT_CACHE_KEY;
+    }
+    return `${adapterEndpoint.name}-${(0, exports.calculateKey)(data, paramNames, adapterConfig)}`;
+};
+exports.calculateCacheKey = calculateCacheKey;
+const calculateFeedId = ({ adapterEndpoint, adapterConfig, }, data) => {
+    const paramNames = Object.keys(adapterEndpoint.inputParameters);
+    if (paramNames.length === 0) {
+        logger.trace(`Cannot generate Feed ID without input parameters`);
+        return 'N/A';
+    }
+    return (0, exports.calculateKey)(data, paramNames, adapterConfig);
+};
+exports.calculateFeedId = calculateFeedId;
+/**
+ * Calculates a unique key from the provided data.
+ *
+ * @param data - the request data/body, i.e. the adapter input params
+ * @param paramNames - the keys from adapter endpoint input parameters
+ * @returns the calculated unique key
+ *
+ * @example
+ * ```
+ * calculateKey({ base: 'ETH', quote: 'BTC' }, ['base','quote'])
+ * // equals `|base:eth|quote:btc`
+ * ```
+ */
+const calculateKey = (data, paramNames, adapterConfig) => {
+    if (data && typeof data !== 'object') {
+        throw new Error('Data to calculate cache key should be an object');
+    }
+    const params = data;
+    let cacheKey = '';
+    for (const paramName of paramNames) {
+        // Ignore overrides param when generating cache keys
+        if (paramName === 'overrides') {
+            continue;
+        }
+        const param = params[paramName];
+        if (param === undefined) {
+            continue;
+        }
+        cacheKey += `|${paramName}:`;
+        switch (typeof param) {
+            case 'string':
+                cacheKey += param.toLowerCase();
+                break;
+            case 'number':
+            case 'boolean':
+                cacheKey += param.toString();
+                break;
+            case 'object':
+                // Force cache keys to only use performant properties of the input params.
+                // If the object were to be used, we'd have to sort its properties.
+                logger.debug(`Property "${paramName}" in request parameters is of type object, and won't be used in the cacheKey`);
+        }
+    }
+    if (cacheKey.length > adapterConfig.MAX_COMMON_KEY_SIZE) {
+        logger.warn(`Generated cache key for adapter request is bigger than the MAX_COMMON_KEY_SIZE and will be truncated`);
+        cacheKey = cacheKey.slice(0, adapterConfig.MAX_COMMON_KEY_SIZE);
+    }
+    logger.trace(`Generated cache key for request: "${cacheKey}"`);
+    return cacheKey;
+};
+exports.calculateKey = calculateKey;
+// Calculate the amount of time the non-expired entry has been in the cache
+const calculateStaleness = (expirationTimestamp, ttl) => {
+    if (expirationTimestamp) {
+        const createTimestamp = expirationTimestamp - ttl;
+        return (Date.now() - createTimestamp) / 1000;
+    }
+    else {
+        // If expirationTimestamp is not available, staleness cannot be calculated
+        // Defaults to ttl for metrics purposes
+        return ttl;
+    }
+};
+/**
+ * Polls the provided Cache for an AdapterResponse set in the provided key. If the maximum
+ * amount of retries is exceeded, it returns undefined instead.
+ *
+ * @param cache - a Cache instance
+ * @param key - the key generated from an AdapterRequest that corresponds to the desired AdapterResponse
+ * @param retry - current retry, only for internal use
+ * @returns the AdapterResponse if found, else undefined
+ */
+const pollResponseFromCache = async (cache, key, options, retry = 0) => {
+    if (retry > options.maxRetries) {
+        // Ideally this shouldn't happen often (p99 of reqs should be found in the cache)
+        logger.info('Exceeded max cache polling retries');
+        return undefined;
+    }
+    logger.trace('Getting response from cache...');
+    const response = await cache.get(key);
+    if (response) {
+        logger.trace('Got response from cache');
+        return response;
+    }
+    if (options.maxRetries === 0) {
+        logger.debug(`Response not found, retries disabled`);
+        return undefined;
+    }
+    logger.debug(`Response not found, sleeping ${options.sleep} milliseconds...`);
+    await (0, util_1.sleep)(options.sleep);
+    return (0, exports.pollResponseFromCache)(cache, key, options, retry + 1);
+};
+exports.pollResponseFromCache = pollResponseFromCache;
+/**
+ * Given a Cache instance in the adapter dependencies, builds a middleware function that will perform
+ * a get from said Cache and return that if found; otherwise it'll continue the middleware chain.
+ *
+ * @param adapter - an initialized adapter
+ * @returns the cache middleware function
+ */
+const buildCacheMiddleware = (adapter) => async (req, res) => {
+    const response = await adapter.dependencies.cache.get(req.requestContext.cacheKey);
+    if (response) {
+        logger.debug('Found response from cache, sending that');
+        if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+            const label = cacheMetrics.cacheMetricsLabel(req.requestContext.cacheKey, req.requestContext.meta?.metrics?.feedId || 'N/A', adapter.config.CACHE_TYPE);
+            // Record cache staleness and cache get count and value
+            const staleness = calculateStaleness(response.maxAge, adapter.config.CACHE_MAX_AGE);
+            cacheMetrics.cacheGet(label, response.result, staleness);
+            req.requestContext.meta = {
+                ...req.requestContext.meta,
+                metrics: { ...req.requestContext.meta?.metrics, cacheHit: true },
+            };
+        }
+        return res.send(response);
+    }
+    logger.debug('Did not find response in cache, moving to next middleware');
+};
+exports.buildCacheMiddleware = buildCacheMiddleware;

package/cache/local.js

@@ -0,0 +1,83 @@
+"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.LocalCache = void 0;
+const util_1 = require("../util");
+const cacheMetrics = __importStar(require("./metrics"));
+const logger = (0, util_1.makeLogger)('LocalCache');
+/**
+ * Local implementation of a Cache. It uses a simple js Object, storing entries with both
+ * a value and an expiration timestamp. Expired entries are deleted on reads (i.e. no background gc/upkeep).
+ *
+ * @typeParam T - the type for the entries' values
+ */
+class LocalCache {
+    constructor() {
+        this.store = {};
+    }
+    async get(key) {
+        logger.trace(`Getting key ${key}`);
+        const entry = this.store[key];
+        if (!entry) {
+            logger.debug(`No entry in local cache for key "${key}", returning undefined`);
+            return undefined;
+        }
+        const expired = entry.expirationTimestamp <= Date.now();
+        if (expired) {
+            logger.debug('Entry in local cache expired, deleting and returning undefined');
+            this.delete(key);
+            return undefined;
+        }
+        else {
+            logger.debug('Found valid entry in local cache, returning value');
+            return entry.value;
+        }
+    }
+    async delete(key) {
+        logger.trace(`Deleting key ${key}`);
+        delete this.store[key]; // Deletes are slower than ignoring or setting null, fyi
+    }
+    async set(key, value, ttl) {
+        logger.trace(`Setting key ${key} with ttl ${ttl}`);
+        this.store[key] = {
+            value,
+            expirationTimestamp: Date.now() + ttl,
+        };
+        // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
+        const feedId = value.meta?.metrics?.feedId;
+        if (feedId) {
+            // Record cache set count, max age, and staleness (set to 0 for cache set)
+            const label = cacheMetrics.cacheMetricsLabel(key, feedId, cacheMetrics.CacheTypes.Local);
+            cacheMetrics.cacheSet(label, ttl);
+        }
+    }
+    async setMany(entries, ttl) {
+        logger.trace(`Setting a bunch of keys with ttl ${ttl}`);
+        for (const { key, value } of entries) {
+            this.set(key, value, ttl);
+        }
+    }
+}
+exports.LocalCache = LocalCache;

package/cache/metrics.js

@@ -0,0 +1,120 @@
+"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.cacheWarmerCount = exports.redisCommandsSentCount = exports.redisRetriesCount = exports.redisConnectionsOpen = exports.CMD_SENT_STATUS = exports.CacheTypes = exports.cacheMetricsLabel = exports.cacheSet = exports.cacheGet = void 0;
+const client = __importStar(require("prom-client"));
+const cacheGet = (label, value, staleness) => {
+    if (typeof value === 'number' || typeof value === 'string') {
+        const parsedValue = Number(value);
+        if (!Number.isNaN(parsedValue) && Number.isFinite(parsedValue)) {
+            cacheDataGetValues.labels(label).set(parsedValue);
+        }
+    }
+    cacheDataGetCount.labels(label).inc();
+    cacheDataStalenessSeconds.labels(label).set(staleness);
+};
+exports.cacheGet = cacheGet;
+const cacheSet = (label, maxAge) => {
+    cacheDataSetCount.labels(label).inc();
+    cacheDataMaxAge.labels(label).set(maxAge);
+    cacheDataStalenessSeconds.labels(label).set(0);
+};
+exports.cacheSet = cacheSet;
+const cacheMetricsLabel = (cacheKey, feedId, cacheType) => ({
+    participant_id: cacheKey,
+    feed_id: feedId,
+    cache_type: cacheType,
+});
+exports.cacheMetricsLabel = cacheMetricsLabel;
+var CacheTypes;
+(function (CacheTypes) {
+    CacheTypes["Redis"] = "redis";
+    CacheTypes["Local"] = "local";
+})(CacheTypes = exports.CacheTypes || (exports.CacheTypes = {}));
+var CMD_SENT_STATUS;
+(function (CMD_SENT_STATUS) {
+    CMD_SENT_STATUS["TIMEOUT"] = "TIMEOUT";
+    CMD_SENT_STATUS["FAIL"] = "FAIL";
+    CMD_SENT_STATUS["SUCCESS"] = "SUCCESS";
+})(CMD_SENT_STATUS = exports.CMD_SENT_STATUS || (exports.CMD_SENT_STATUS = {}));
+const baseLabels = [
+    'feed_id',
+    'participant_id',
+    'cache_type',
+    'is_from_ws',
+    'experimental',
+];
+// Skipping this metrics for v3
+// const cache_execution_duration_seconds = new client.Histogram({
+//   name: 'cache_execution_duration_seconds',
+//   help: 'A histogram bucket of the distribution of cache execution durations',
+//   labelNames: [...baseLabels, 'cache_hit'] as const,
+//   buckets: [0.01, 0.1, 1, 10],
+// })
+const cacheDataGetCount = new client.Counter({
+    name: 'cache_data_get_count',
+    help: 'A counter that increments every time a value is fetched from the cache',
+    labelNames: baseLabels,
+});
+const cacheDataGetValues = new client.Gauge({
+    name: 'cache_data_get_values',
+    help: 'A gauge keeping track of values being fetched from cache',
+    labelNames: baseLabels,
+});
+const cacheDataMaxAge = new client.Gauge({
+    name: 'cache_data_max_age',
+    help: 'A gauge tracking the max age of stored values in the cache',
+    labelNames: baseLabels,
+});
+const cacheDataSetCount = new client.Counter({
+    name: 'cache_data_set_count',
+    help: 'A counter that increments every time a value is set to the cache',
+    labelNames: [...baseLabels, 'status_code'],
+});
+const cacheDataStalenessSeconds = new client.Gauge({
+    name: 'cache_data_staleness_seconds',
+    help: 'Observes the staleness of the data returned',
+    labelNames: baseLabels,
+});
+// Redis Metrics
+exports.redisConnectionsOpen = new client.Counter({
+    name: 'redis_connections_open',
+    help: 'The number of redis connections that are open',
+});
+exports.redisRetriesCount = new client.Counter({
+    name: 'redis_retries_count',
+    help: 'The number of retries that have been made to establish a redis connection',
+});
+exports.redisCommandsSentCount = new client.Counter({
+    name: 'redis_commands_sent_count',
+    help: 'The number of redis commands sent',
+    labelNames: ['status', 'function_name'],
+});
+// Cache Warmer Metrics
+exports.cacheWarmerCount = new client.Gauge({
+    name: 'cache_warmer_get_count',
+    help: 'The number of cache warmers running',
+    labelNames: ['isBatched'],
+});