@chainlink/external-adapter-framework 0.0.7 → 0.0.10

package/examples/ncfx/websocket.d.ts

@@ -0,0 +1,36 @@
+import { AdapterEndpoint } from '../../adapter';
+import { WebSocketTransport } from '../../transports/websocket';
+import { InputParameters } from '../../validation';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+export declare const inputParameters: InputParameters;
+interface ProviderMessage {
+    timestamp: string;
+    currencyPair: string;
+    bid: number;
+    offer: number;
+    mid: number;
+    changes: [
+        {
+            period: string;
+            change: number;
+            percentage: number;
+        }
+    ];
+}
+export declare const websocketTransport: WebSocketTransport<AdapterRequestParams, ProviderMessage[], {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;
+export declare const webSocketEndpoint: AdapterEndpoint;
+export {};

package/index.d.ts

@@ -0,0 +1,12 @@
+import { Server } from 'http';
+import { Adapter } from './adapter';
+import { AdapterDependencies } from './transports';
+/**
+ * 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
+ */
+export declare const expose: (adapter: Adapter, dependencies?: Partial<AdapterDependencies>) => Promise<Server | undefined>;

package/{dist/index.js → index.js}

@@ -84,6 +84,9 @@ async function buildRestApi(config, initializedAdapter) {
             method: 'POST',
             handler: transportHandler,
         }); // Pass config maybe? cleaner that multiple instances / dependencies
+        if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
+            router.addHook('onResponse', metrics_1.buildMetricsMiddleware);
+        }
     });
     return app;
 }

package/metrics/constants.d.ts

@@ -0,0 +1,16 @@
+export declare enum HttpRequestType {
+    CACHE_HIT = "cacheHit",
+    DATA_PROVIDER_HIT = "dataProviderHit",
+    ADAPTER_ERROR = "adapterError",
+    INPUT_ERROR = "inputError",
+    RATE_LIMIT_ERROR = "rateLimitError",
+    DP_ERROR = "dataProviderError",
+    TIMEOUT_ERROR = "timeoutError",
+    CONNECTION_ERROR = "connectionError",
+    CUSTOM_ERROR = "customError"
+}
+/**
+ * Maxiumum number of characters that a feedId can contain.
+ */
+export declare const MAX_FEED_ID_LENGTH = 300;
+export declare const requestDurationBuckets: number[];

package/{dist/src/metrics → metrics}/constants.js

@@ -12,7 +12,7 @@ var HttpRequestType;
     // BACKOFF_ERROR = 'backoffError',
     HttpRequestType["DP_ERROR"] = "dataProviderError";
     HttpRequestType["TIMEOUT_ERROR"] = "timeoutError";
-    // CONNECTION_ERROR = 'connectionError',
+    HttpRequestType["CONNECTION_ERROR"] = "connectionError";
     // RES_EMPTY_ERROR = 'responseEmptyError',
     // RES_INVALID_ERROR = 'responseInvalidError',
     HttpRequestType["CUSTOM_ERROR"] = "customError";

package/metrics/index.d.ts

@@ -0,0 +1,15 @@
+import * as client from 'prom-client';
+import { AdapterRequest } from '../util';
+import { AdapterConfig } from '../config';
+import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
+export declare function setupMetricsServer(name: string, config: AdapterConfig): void;
+export declare const setupMetrics: (name: string, config: AdapterConfig) => void;
+/**
+ * Builds metrics middleware that records end to end EA response times
+ * and count of requests
+ *
+ * @returns the cache middleware function
+ */
+export declare const buildMetricsMiddleware: (req: AdapterRequest, res: FastifyReply, done: HookHandlerDoneFunction) => void;
+export declare const httpRequestsTotal: client.Counter<"type" | "method" | "feed_id" | "status_code" | "provider_status_code" | "retry" | "is_cache_warming">;
+export declare const httpRequestDurationSeconds: client.Histogram<string>;

package/{dist/metrics → metrics}/index.js

@@ -26,12 +26,13 @@ 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;
+exports.httpRequestDurationSeconds = exports.httpRequestsTotal = exports.buildMetricsMiddleware = 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 error_1 = require("../validation/error");
 const logger = (0, util_1.makeLogger)('Metrics');
 function setupMetricsServer(name, config) {
     const metricsApp = (0, fastify_1.default)({
@@ -56,6 +57,52 @@ const setupMetrics = (name, config) => {
     });
 };
 exports.setupMetrics = setupMetrics;
+/**
+ * Builds metrics middleware that records end to end EA response times
+ * and count of requests
+ *
+ * @returns the cache middleware function
+ */
+const buildMetricsMiddleware = (req, res, done) => {
+    const feedId = req.requestContext.meta?.metrics?.feedId || 'N/A';
+    const labels = buildHttpRequestMetricsLabel(feedId, req.requestContext.meta?.error, req.requestContext.meta?.metrics?.cacheHit);
+    // Record number of requests sent to EA
+    exports.httpRequestsTotal.labels(labels).inc();
+    // Record response time of request through entire EA
+    exports.httpRequestDurationSeconds.observe(res.getResponseTime());
+    logger.debug(`Response time for ${feedId}: ${res.getResponseTime()}ms`);
+    done();
+};
+exports.buildMetricsMiddleware = buildMetricsMiddleware;
+const buildHttpRequestMetricsLabel = (feedId, error, cacheHit) => {
+    const labels = {};
+    labels.method = 'POST';
+    labels.feed_id = feedId;
+    if (error instanceof error_1.AdapterError) {
+        // If error present and an instace of AdapterError, build label from error info
+        labels.type = error?.metricsLabel || constants_1.HttpRequestType.ADAPTER_ERROR;
+        labels.status_code = error?.statusCode;
+        labels.provider_status_code = error?.providerStatusCode;
+    }
+    else if (error instanceof Error) {
+        // If error present and not instance of generic Error, unexpected failure occurred
+        // TODO: Build label with 500 error and withold dp status? Status sent as 200 in error handler
+        labels.type = constants_1.HttpRequestType.ADAPTER_ERROR;
+        labels.status_code = 500;
+    }
+    else {
+        // If no error present, request went as expected
+        labels.status_code = 200;
+        if (cacheHit) {
+            labels.type = constants_1.HttpRequestType.CACHE_HIT;
+        }
+        else {
+            labels.type = constants_1.HttpRequestType.DATA_PROVIDER_HIT;
+            labels.provider_status_code = 200;
+        }
+    }
+    return labels;
+};
 exports.httpRequestsTotal = new client.Counter({
     name: 'http_requests_total',
     help: 'The number of http requests this external adapter has serviced for its entire uptime',

package/metrics/util.d.ts

@@ -0,0 +1,3 @@
+import { AdapterMetricsMeta, AdapterRequestData } from '../util';
+import { AdapterEndpoint } from '../adapter';
+export declare const getMetricsMeta: (endpoint: AdapterEndpoint, data: AdapterRequestData) => AdapterMetricsMeta;

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.7",
+  "version": "0.0.10",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
     "axios": "^0.27.2",
@@ -66,8 +65,5 @@
     "environmentVariables": {
       "METRICS_ENABLED": "false"
     }
-  },
-  "files": [
-    "dist/**"
-  ]
+  }
 }

package/rate-limiting/background/fixed-frequency.d.ts

@@ -0,0 +1,10 @@
+import { AdapterRateLimitTier, BackgroundExecuteRateLimiter } from '..';
+import { AdapterEndpoint } from '../../adapter';
+export declare const DEFAULT_SHARED_MS_BETWEEN_REQUESTS = 5000;
+export declare class FixedFrequencyRateLimiter implements BackgroundExecuteRateLimiter {
+    msBetweenRequestsMap: {
+        [endpointName: string]: number;
+    };
+    initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier): this;
+    msUntilNextExecution(endpointName: string): number;
+}

package/rate-limiting/index.d.ts

@@ -0,0 +1,54 @@
+import { AdapterEndpoint } from '../adapter';
+export * from './request/simple-counting';
+export * from './background/fixed-frequency';
+export interface AdapterRateLimitTier {
+    rateLimit1s?: number;
+    rateLimit1m?: number;
+    rateLimit1h?: number;
+    note?: string;
+}
+/**
+ * Common interface for all RateLimiter classes to implement
+ */
+export interface RateLimiter {
+    /**
+     * Method to ensure all RateLimiters can be initialized in the same manner.
+     *
+     * @param limits - settings for how much throughput to allow for the Adapter
+     * @param endpoints - list of adapter endpoints
+     */
+    initialize(endpoints: AdapterEndpoint[], limits: AdapterRateLimitTier): this;
+}
+/**
+ * RequestRateLimiters perform checks agains imminent outbound requests for any transport.
+ */
+export interface RequestRateLimiter extends RateLimiter {
+    /**
+     * This method will check using whatever strategy is implemented to determine if
+     * this request can be processed. If so, it returns true; if not, returns false.
+     */
+    isUnderLimits(): boolean;
+}
+/**
+ * BackgroundExecuteFrequencyRateLimiters will implement custom logic to calculate
+ * the period of time to wait between background executions for a transport.
+ */
+export interface BackgroundExecuteRateLimiter extends RateLimiter {
+    msUntilNextExecution(endpointName: string): number;
+}
+/**
+ * This method will convert all possible settings for a rate limit tier and
+ * convert them all to requests per second, returning the lowest one
+ *
+ * @param limits - the rate limit tier set for the adapter
+ * @returns the most restrictive of the set options, in requests per second
+ */
+export declare const consolidateTierLimits: (limits?: AdapterRateLimitTier) => number;
+/**
+ * Validates rate limiting tiers specified for the adapter, and returns the one to use.
+ *
+ * @param tiers - the adapter config listing the different available API tiers
+ * @param selectedTier - chosen API tier from settings, if present
+ * @returns the specified API tier, or a default one if none are specified
+ */
+export declare const getRateLimitingTier: (tiers?: Record<string, AdapterRateLimitTier>, selectedTier?: string) => AdapterRateLimitTier | undefined;

package/rate-limiting/metrics.d.ts

@@ -0,0 +1,3 @@
+import * as client from 'prom-client';
+export declare const retrieveCost: <ProviderResponseBody>(data: ProviderResponseBody) => number;
+export declare const rateLimitCreditsSpentTotal: client.Counter<"feed_id" | "participant_id">;

package/{dist/src/rate-limiting → rate-limiting}/metrics.js

@@ -23,10 +23,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rateLimitCreditsSpentTotal = void 0;
+exports.rateLimitCreditsSpentTotal = exports.retrieveCost = void 0;
 const client = __importStar(require("prom-client"));
+// Retrieve cost field from response if exists
+// If not return default cost of 1
+const retrieveCost = (data) => {
+    const cost = data['cost'];
+    if (typeof cost === 'number' || typeof cost === 'string') {
+        return Number(cost);
+    }
+    else {
+        return 1;
+    }
+};
+exports.retrieveCost = retrieveCost;
 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'],
+    labelNames: ['participant_id', 'feed_id'],
 });

package/rate-limiting/request/simple-counting.d.ts

@@ -0,0 +1,20 @@
+import { AdapterRateLimitTier, RateLimiter } from '..';
+import { AdapterEndpoint } from '../../adapter';
+/**
+ * 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.
+ */
+export declare class SimpleCountingRateLimiter implements RateLimiter {
+    latestSecondInterval: number;
+    requestsThisSecond: number;
+    latestMinuteInterval: number;
+    requestsThisMinute: number;
+    perSecondLimit: number;
+    perMinuteLimit: number;
+    initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier): this;
+    isUnderLimits(): boolean;
+}

package/test.d.ts

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

package/transports/batch-warming.d.ts

@@ -0,0 +1,34 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Cache } from '../cache';
+import { AdapterConfig, SettingsMap } from '../config';
+import { BackgroundExecuteRateLimiter } from '../rate-limiting';
+import { ExpiringSortedSet } from '../util';
+import { AdapterRequest, ProviderResult } from '../util/request';
+import { AdapterContext, AdapterDependencies, Transport } from './';
+/**
+ * Transport implementation that takes incoming batches requests and keeps a warm cache of values.
+ * Within the setup function, adapter params are added to an set that also keeps track and expires values.
+ * In the background execute, the list of non-expired items in the set is fetched.
+ * Then, the list is passed through the `prepareRequest` function, that returns an AxiosRequestConfig.
+ * The Data Provider response is, they are passed through the `parseResponse` function to create a [[CacheEntry]] list.
+ * Finally, the items in that [[CacheEntry]] list are set in the Cache so the Adapter can fetch values from there.
+ *
+ * @typeParam AdapterParams - interface for the adapter request body
+ * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
+ * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
+ */
+export declare class BatchWarmingTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
+    private config;
+    cache: Cache;
+    rateLimiter: BackgroundExecuteRateLimiter;
+    expiringSortedSet: ExpiringSortedSet<AdapterParams>;
+    WARMER_ACTIVE: boolean;
+    constructor(config: {
+        prepareRequest: (params: AdapterParams[], context: AdapterContext<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody>;
+        parseResponse: (res: AxiosResponse<ProviderResponseBody>, context: AdapterContext<CustomSettings>) => ProviderResult<AdapterParams>[];
+    });
+    initialize(dependencies: AdapterDependencies): Promise<void>;
+    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
+    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<void>;
+    backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number>;
+}

package/{dist/src/transports → transports}/batch-warming.js

@@ -1,9 +1,35 @@
 "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.BatchWarmingTransport = void 0;
 const util_1 = require("../util");
 const _1 = require("./");
 const util_2 = require("./util");
+const rateLimitMetrics = __importStar(require("../rate-limiting/metrics"));
+const cacheMetrics = __importStar(require("../cache/metrics"));
+const WARMUP_BATCH_REQUEST_ID = '9002';
 const logger = (0, util_1.makeLogger)('BatchWarmingTransport');
 /**
  * Transport implementation that takes incoming batches requests and keeps a warm cache of values.
@@ -21,6 +47,9 @@ class BatchWarmingTransport {
     constructor(config) {
         this.config = config;
         this.expiringSortedSet = new util_1.ExpiringSortedSet(); // TODO: Move to dependencies, inject
+        // Flag used to track whether the warmer has moved from having no entries to having some and vice versa
+        // Used for recording the cache warmer active metrics accurately
+        this.WARMER_ACTIVE = false;
     }
     async initialize(dependencies) {
         this.cache = dependencies.cache;
@@ -38,8 +67,18 @@ class BatchWarmingTransport {
         const entries = this.expiringSortedSet.getAll();
         if (!entries.length) {
             logger.debug('No entries in batch warming set, skipping');
+            if (this.WARMER_ACTIVE) {
+                // Decrement count when warmer changed from having entries to having none
+                cacheMetrics.cacheWarmerCount.labels({ isBatched: 'true' }).dec();
+                this.WARMER_ACTIVE = false;
+            }
             return this.rateLimiter.msUntilNextExecution(context.adapterEndpoint.name);
         }
+        else if (this.WARMER_ACTIVE === false) {
+            // Increment count when warmer changed from having no entries to having some
+            cacheMetrics.cacheWarmerCount.labels({ isBatched: 'true' }).inc();
+            this.WARMER_ACTIVE = true;
+        }
         const request = this.config.prepareRequest(entries, context);
         logger.trace('Sending request to data provider...');
         const providerResponse = await (0, util_2.axiosRequest)(request);
@@ -48,7 +87,14 @@ class BatchWarmingTransport {
         const adapterResponses = (0, _1.buildCacheEntriesFromResults)(results, context);
         logger.debug('Setting adapter responses in cache');
         await this.cache.setMany(adapterResponses, context.adapterConfig.CACHE_MAX_AGE);
-        // TODO: Record rate limit credit with cost, default 1
+        // Record cost of data provider call
+        const cost = rateLimitMetrics.retrieveCost(providerResponse.data);
+        rateLimitMetrics.rateLimitCreditsSpentTotal
+            .labels({
+            feed_id: 'N/A',
+            participant_id: WARMUP_BATCH_REQUEST_ID,
+        })
+            .inc(cost);
         return this.rateLimiter.msUntilNextExecution(context.adapterEndpoint.name);
     }
 }

package/transports/index.d.ts

@@ -0,0 +1,87 @@
+import { FastifyReply } from 'fastify';
+import { AdapterEndpoint, InitializedAdapter } from '../adapter';
+import { Cache, CacheEntry } from '../cache';
+import { AdapterConfig, CustomSettingsType, SettingsMap } from '../config';
+import { BackgroundExecuteRateLimiter, RequestRateLimiter } from '../rate-limiting';
+import { AdapterRequest, AdapterResponse, ProviderResult } from '../util/request';
+export * from './batch-warming';
+export * from './rest';
+export * from './websocket';
+/**
+ * Dependencies that will be injected into the Adapter on startup
+ */
+export interface AdapterDependencies {
+    cache: Cache;
+    requestRateLimiter: RequestRateLimiter;
+    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
+}
+/**
+ * Context that will be used on background executions of a Transport.
+ * For example, the endpointName used to log statements or generate Cache keys.
+ */
+export interface AdapterContext<CustomSettings extends CustomSettingsType<CustomSettings> = SettingsMap> {
+    adapterEndpoint: AdapterEndpoint;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}
+/**
+ * Generic interface for a Transport.
+ * A Transport defines the way in which an AdapterEndpoint will process incoming requests to
+ * fetch data from a Data Provider. The setup phase will take care of the former, while the
+ * backgroundExecute will be in charge of the latter.
+ * This separation gives us the ability of splitting these concerns, and optionally parallelizing
+ * the reading and writing of data to a centralized Cache.
+ *
+ * @typeParam Params - the structure of the AdapterRequest's body
+ * @typeParam Result - the structure of the AdapterResponse's body
+ */
+export interface Transport<Params, Result, CustomSettings extends SettingsMap> {
+    /**
+     * Initializes the transport in the Adapter context.
+     *
+     * @param dependencies - Adapter dependencies (e.g. cache instance)
+     * @returns an empty Promise
+     */
+    initialize: (dependencies: AdapterDependencies) => Promise<void>;
+    /**
+     * Checks if the Transport has already set up the incoming request.
+     * This will likely use the cacheKey generated in the provided request.
+     *
+     * @param req - the incoming AdapterRequest
+     * @returns a Promise that returns true if setup is in place
+     */
+    hasBeenSetUp: (req: AdapterRequest<Params>) => Promise<boolean>;
+    /**
+     * Sets up the incoming request within the Transport.
+     * In other words, it means that the Adapter has recognized this request, and will begin
+     * fetching the necessary data from a Data Provider.
+     *
+     * @param req - the incoming AdapterRequest
+     * @param config - common configuration for the Adapter as a whole
+     * @returns a Promise that _optionally_ returns an AdapterResponse, if the Transport has the capability of
+     *   immediately fetching data and returning it without the background process.
+     */
+    setup: (req: AdapterRequest<Params>, config: AdapterConfig<CustomSettings>) => Promise<AdapterResponse<Result> | void>;
+    /**
+     * If the Transport relies on an async mechanism, implementing this function will make it
+     * so the background task executor calls it on Adapter startup.
+     *
+     * @param context - background context for the execution (e.g. endpoint name)
+     */
+    backgroundExecute?: (context: AdapterContext<CustomSettings>) => Promise<number>;
+}
+/**
+ * Helper method to build cache entries to set after getting a bunch of responses from a DP.
+ *
+ * @param results - a list of results coming from a DataProvider
+ * @param context - context for the Adapter
+ * @returns a list of CacheEntries of AdapterResponses
+ */
+export declare const buildCacheEntriesFromResults: <Params, Context extends AdapterContext<any>>(results: ProviderResult<Params>[], context: Context) => CacheEntry<AdapterResponse<null>>[];
+/**
+ * Takes an Adapter, its configuration, and its dependencies, and it creates an express middleware
+ * that will pass along the AdapterRequest to the appropriate Transport (acc. to the endpoint in the req.)
+ *
+ * @param adapter - main adapter object, already initialized
+ * @returns the transport handler middleware function
+ */
+export declare const buildTransportHandler: (adapter: InitializedAdapter) => (req: AdapterRequest, reply: FastifyReply) => Promise<never>;

package/{dist/src/transports → transports}/index.js

@@ -41,9 +41,11 @@ const buildCacheEntriesFromResults = (results, context) => results.map((r) => {
         context.adapterConfig.EXPERIMENTAL_METRICS_ENABLED) {
         const metrics = {
             maxAge: Date.now() + context.adapterConfig.CACHE_MAX_AGE,
-            metricsMeta: {
-                feedId: (0, cache_1.calculateFeedId)(context.adapterEndpoint, r.params),
-            },
+            meta: {
+                metrics: {
+                    feedId: (0, cache_1.calculateFeedId)(context.adapterEndpoint, r.params)
+                }
+            }
         };
         cacheEntry.value = { ...cacheEntry.value, ...metrics };
     }

package/transports/metrics.d.ts

@@ -0,0 +1,21 @@
+import * as client from 'prom-client';
+import { AdapterContext } from '.';
+export declare const dataProviderMetricsLabel: (providerStatusCode?: number, method?: string) => {
+    provider_status_code: number | undefined;
+    method: string;
+};
+export declare const dataProviderRequests: client.Counter<"method" | "provider_status_code">;
+export declare const dataProviderRequestDurationSeconds: client.Histogram<string>;
+export declare const connectionErrorLabels: (message: string) => {
+    message: string;
+};
+export declare const messageSubsLabels: (feed_id: string, cache_key: string) => {
+    feed_id: string;
+    subscription_key: string;
+};
+export declare const recordWsMessageMetrics: <AdapterParams>(context: AdapterContext, subscribes: AdapterParams[], unsubscrices: AdapterParams[]) => void;
+export declare const wsConnectionActive: client.Gauge<"url">;
+export declare const wsConnectionErrors: client.Counter<"message" | "url">;
+export declare const wsSubscriptionActive: client.Gauge<"feed_id" | "connection_url" | "subscription_key">;
+export declare const wsSubscriptionTotal: client.Counter<"feed_id" | "connection_url" | "subscription_key">;
+export declare const wsMessageTotal: client.Counter<"feed_id" | "subscription_key">;