@chainlink/external-adapter-framework 0.0.12 → 0.0.14

package/src/index.ts

@@ -1,149 +0,0 @@
-import fastify, { FastifyInstance } from 'fastify'
-import { Server } from 'http'
-import { AddressInfo } from 'net'
-import { join } from 'path'
-import { Adapter, InitializedAdapter, initializeAdapter, AdapterDependencies } from './adapter'
-import { callBackgroundExecutes } from './background-executor'
-import { buildCacheMiddleware } from './cache'
-import { AdapterConfig, buildAdapterConfig } from './config'
-import { buildMetricsMiddleware, setupMetricsServer } from './metrics'
-import { buildTransportHandler } from './transports'
-import { AdapterRouteGeneric, loggingContextMiddleware, makeLogger } from './util'
-import { loadTestPayload } from './util/test-payload-loader'
-import { errorCatchingMiddleware, validatorMiddleware } from './validation'
-
-const logger = 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
- */
-export const expose = async (
-  adapter: Adapter,
-  dependencies?: Partial<AdapterDependencies>,
-): Promise<Server | undefined> => {
-  const config = buildAdapterConfig({
-    overrides: adapter.envDefaultOverrides,
-    customSettings: adapter.customSettings,
-  })
-  // Initialize adapter (create dependencies, inject them, build endpoint map, etc.)
-  const initializedAdapter = await initializeAdapter(adapter, config, dependencies)
-
-  let server: Server | undefined = undefined
-
-  if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
-    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() as AddressInfo).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')
-    callBackgroundExecutes(initializedAdapter, server)
-  } else {
-    logger.info(
-      'Background executor is disabled; this instance will not perform async background executes.',
-    )
-  }
-
-  return server
-}
-
-async function buildRestApi(config: AdapterConfig, initializedAdapter: InitializedAdapter) {
-  const app = fastify()
-
-  // Add healthcheck endpoint before middlewares to bypass them
-  app.get(join(config.BASE_URL, 'health'), (req, res) => {
-    res.status(200).send({ message: 'OK', version: VERSION })
-  })
-
-  // Use global error handling
-  app.setErrorHandler(errorCatchingMiddleware)
-
-  const transportHandler = await buildTransportHandler(initializedAdapter)
-
-  app.register(async (router) => {
-    // Set up "middlewares" (hooks in fastify)
-    router.addHook<AdapterRouteGeneric>('preHandler', validatorMiddleware(initializedAdapter))
-    router.addHook<AdapterRouteGeneric>('preHandler', buildCacheMiddleware(initializedAdapter))
-    if (config['CORRELATION_ID_ENABLED']) {
-      router.addHook<AdapterRouteGeneric>('onRequest', loggingContextMiddleware)
-    }
-
-    router.route<AdapterRouteGeneric>({
-      url: config.BASE_URL,
-      method: 'POST',
-      handler: transportHandler,
-    })
-
-    if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
-      router.addHook<AdapterRouteGeneric>('onResponse', buildMetricsMiddleware)
-    }
-  })
-
-  // Add smoke endpoint after middleware which are needed for tests
-  buildSmokeEndpoint(app, config)
-  return app
-}
-
-/**
- * Adds the /smoke endpoint to the API for smoke testing the adapter
- *
- * @param app - the Fastify instance
- * @param config - the initialized adapter config
- */
-function buildSmokeEndpoint(app: FastifyInstance, config: AdapterConfig) {
-  const testPayload = loadTestPayload(config.SMOKE_TEST_PAYLOAD_FILE_NAME)
-  app.get(join(config.BASE_URL, 'smoke'), async (_, res) => {
-    if (testPayload.isDefault) {
-      return res.status(200).send('OK')
-    }
-
-    const errors = []
-    for (const index in testPayload.requests) {
-      try {
-        const request = { id: index, data: testPayload.requests[index] }
-        // Use Fastify's app inject to pass smoke requests internally
-        const response = await app.inject({
-          method: 'POST',
-          url: '/',
-          payload: request,
-        })
-        const parsedResponse = JSON.parse(response.body)
-        // Throw error if not 2xx status code
-        if (parsedResponse.statusCode < 200 || parsedResponse.statusCode > 299) {
-          throw Error('Smoke test request failed')
-        }
-      } catch (e: unknown) {
-        errors.push(e)
-      }
-    }
-    if (errors.length > 0) {
-      return res.status(500).send(errors)
-    }
-    return res.status(200).send('OK')
-  })
-}

package/src/metrics/constants.ts

@@ -1,23 +0,0 @@
-export enum HttpRequestType {
-  CACHE_HIT = 'cacheHit',
-  DATA_PROVIDER_HIT = 'dataProviderHit',
-  ADAPTER_ERROR = 'adapterError',
-  INPUT_ERROR = 'inputError',
-  RATE_LIMIT_ERROR = 'rateLimitError',
-  // BURST_LIMIT_ERROR = 'burstLimitError',
-  // BACKOFF_ERROR = 'backoffError',
-  DP_ERROR = 'dataProviderError',
-  TIMEOUT_ERROR = 'timeoutError',
-  CONNECTION_ERROR = 'connectionError',
-  // RES_EMPTY_ERROR = 'responseEmptyError',
-  // RES_INVALID_ERROR = 'responseInvalidError',
-  CUSTOM_ERROR = 'customError',
-}
-
-/**
- * Maxiumum number of characters that a feedId can contain.
- */
-export const MAX_FEED_ID_LENGTH = 300
-
-// We should tune these as we collect data, this is the default bucket distribution that prom comes with
-export const requestDurationBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]

package/src/metrics/index.ts

@@ -1,115 +0,0 @@
-import * as client from 'prom-client'
-import { HttpRequestType, requestDurationBuckets } from './constants'
-import { AdapterRequest, makeLogger } from '../util'
-import { AdapterConfig } from '../config'
-import fastify, { FastifyReply, HookHandlerDoneFunction } from 'fastify'
-import { join } from 'path'
-import { AdapterError } from '../validation/error'
-
-const logger = makeLogger('Metrics')
-
-export function setupMetricsServer(name: string, config: AdapterConfig) {
-  const metricsApp = fastify({
-    logger: false,
-  })
-  const metricsPort = config.METRICS_PORT
-  const endpoint = config.METRICS_USE_BASE_URL ? join(config.BASE_URL, 'metrics') : '/metrics'
-  const eaHost = config.EA_HOST
-
-  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}!`),
-  )
-}
-
-export const setupMetrics = (name: string, config: AdapterConfig): void => {
-  client.collectDefaultMetrics()
-  client.register.setDefaultLabels({
-    app_name: config.METRICS_NAME || name || 'N/A',
-    app_version: config['npm_package_version'],
-  })
-}
-
-/**
- * Builds metrics middleware that records end to end EA response times
- * and count of requests
- *
- * @returns the cache middleware function
- */
-export const buildMetricsMiddleware = (
-  req: AdapterRequest,
-  res: FastifyReply,
-  done: HookHandlerDoneFunction,
-) => {
-  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
-  httpRequestsTotal.labels(labels).inc()
-
-  // Record response time of request through entire EA
-  httpRequestDurationSeconds.observe(res.getResponseTime())
-  logger.debug(`Response time for ${feedId}: ${res.getResponseTime()}ms`)
-  done()
-}
-
-const buildHttpRequestMetricsLabel = (
-  feedId: string,
-  error?: AdapterError | Error,
-  cacheHit?: boolean,
-): Parameters<typeof httpRequestsTotal.labels>[0] => {
-  const labels: Parameters<typeof httpRequestsTotal.labels>[0] = {}
-  labels.method = 'POST'
-  labels.feed_id = feedId
-  if (error instanceof AdapterError) {
-    // If error present and an instace of AdapterError, build label from error info
-    labels.type = error?.metricsLabel || 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
-    labels.type = HttpRequestType.ADAPTER_ERROR
-    labels.status_code = 500
-  } else {
-    // If no error present, request went as expected
-    labels.status_code = 200
-    if (cacheHit) {
-      labels.type = HttpRequestType.CACHE_HIT
-    } else {
-      labels.type = HttpRequestType.DATA_PROVIDER_HIT
-      labels.provider_status_code = 200
-    }
-  }
-
-  return labels
-}
-
-export const 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',
-  ] as const,
-})
-
-export const httpRequestDurationSeconds = new client.Histogram({
-  name: 'http_request_duration_seconds',
-  help: 'A histogram bucket of the distribution of http request durations',
-  buckets: requestDurationBuckets,
-})

package/src/metrics/util.ts

@@ -1,18 +0,0 @@
-import { AdapterMetricsMeta, AdapterRequestData } from '../util'
-import { AdapterEndpoint } from '../adapter'
-import { calculateFeedId } from '../cache'
-import { AdapterConfig } from '../config'
-
-export const getMetricsMeta = (
-  {
-    adapterEndpoint,
-    adapterConfig,
-  }: {
-    adapterEndpoint: AdapterEndpoint
-    adapterConfig: AdapterConfig
-  },
-  data: AdapterRequestData,
-): AdapterMetricsMeta => {
-  const feedId = calculateFeedId({ adapterEndpoint, adapterConfig }, data)
-  return { feedId }
-}

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

@@ -1,45 +0,0 @@
-import { AdapterRateLimitTier, BackgroundExecuteRateLimiter, consolidateTierLimits } from '..'
-import { AdapterEndpoint } from '../../adapter'
-import { makeLogger } from '../../util'
-
-const logger = makeLogger('FixedFrequencyRateLimiter')
-export const DEFAULT_SHARED_MS_BETWEEN_REQUESTS = 5000
-
-export class FixedFrequencyRateLimiter implements BackgroundExecuteRateLimiter {
-  msBetweenRequestsMap: {
-    [endpointName: string]: number // In ms
-  } = {}
-
-  initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier) {
-    // Translate the hourly limit into reqs per minute
-    let sharedMsBetweenRequests = 1000 / consolidateTierLimits(limits)
-
-    // If there is no limit set, we use some reasonable number
-    if (!limits?.rateLimit1h && !limits?.rateLimit1m && !limits?.rateLimit1s) {
-      // 5s period for all seems good
-      sharedMsBetweenRequests = DEFAULT_SHARED_MS_BETWEEN_REQUESTS
-    }
-
-    logger.debug('Using fixed frequency batch rate limiting')
-    for (const endpoint of endpoints) {
-      if (endpoint.rateLimiting?.allocationPercentage == null) {
-        throw new Error(`Allocation percentage for endpoint "${endpoint.name}" is null`)
-      }
-
-      this.msBetweenRequestsMap[endpoint.name] =
-        (sharedMsBetweenRequests / endpoint.rateLimiting?.allocationPercentage) * 100
-
-      logger.debug(
-        `Endpoint [${endpoint.name}]: ${
-          this.msBetweenRequestsMap[endpoint.name] / 1000
-        }s between requests`,
-      )
-    }
-
-    return this
-  }
-
-  msUntilNextExecution(endpointName: string): number {
-    return this.msBetweenRequestsMap[endpointName]
-  }
-}

package/src/rate-limiting/index.ts

@@ -1,100 +0,0 @@
-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 const consolidateTierLimits = (limits?: AdapterRateLimitTier) => {
-  const perHourLimit = (limits?.rateLimit1h || Infinity) / (60 * 60)
-  const perMinuteLimit = (limits?.rateLimit1m || Infinity) / 60
-  const perSecondLimit = limits?.rateLimit1s || Infinity
-  return Math.min(perHourLimit, perMinuteLimit, perSecondLimit)
-}
-
-/**
- * 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 const getRateLimitingTier = (
-  tiers?: Record<string, AdapterRateLimitTier>,
-  selectedTier?: string,
-): AdapterRateLimitTier | undefined => {
-  if (!tiers) {
-    return
-  }
-
-  // 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 (!selectedTier) {
-    // Sort the tiers by most to least restrictive
-    const sortedTiers = Object.values(tiers).sort(
-      (t1, t2) => consolidateTierLimits(t1) - consolidateTierLimits(t2),
-    )
-
-    return sortedTiers[0]
-  }
-
-  return tiers[selectedTier]
-}

package/src/rate-limiting/metrics.ts

@@ -1,18 +0,0 @@
-import * as client from 'prom-client'
-
-// Retrieve cost field from response if exists
-// If not return default cost of 1
-export const retrieveCost = <ProviderResponseBody>(data: ProviderResponseBody): number => {
-  const cost = (data as Record<string, unknown>)['cost']
-  if (typeof cost === 'number' || typeof cost === 'string') {
-    return Number(cost)
-  } else {
-    return 1
-  }
-}
-
-export const 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'] as const,
-})

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

@@ -1,76 +0,0 @@
-import { AdapterRateLimitTier, RateLimiter } from '..'
-import { AdapterEndpoint } from '../../adapter'
-import { makeLogger } from '../../util'
-
-const logger = 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.
- */
-export class SimpleCountingRateLimiter implements RateLimiter {
-  latestSecondInterval = 0
-  requestsThisSecond = 0
-  latestMinuteInterval = 0
-  requestsThisMinute = 0
-  perSecondLimit!: number
-  perMinuteLimit!: number
-
-  initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier) {
-    // 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}`,
-    )
-
-    return this
-  }
-
-  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
-    }
-  }
-}

package/src/test.ts

@@ -1,5 +0,0 @@
-import { expose } from '.'
-import { adapter } from './examples/bank-frick'
-
-// Start sample adapter
-expose(adapter)

package/src/transports/batch-warming.ts

@@ -1,122 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios'
-import { Cache } from '../cache'
-import { AdapterConfig, SettingsMap } from '../config'
-import { BackgroundExecuteRateLimiter } from '../rate-limiting'
-import { makeLogger, SubscriptionSet } from '../util'
-import { AdapterRequest, ProviderResult } from '../util/request'
-import { Transport, buildCacheEntriesFromResults } from './'
-import { axiosRequest } from './util'
-import * as rateLimitMetrics from '../rate-limiting/metrics'
-import * as cacheMetrics from '../cache/metrics'
-import { AdapterContext, AdapterDependencies } from '../adapter'
-
-const WARMUP_BATCH_REQUEST_ID = '9002'
-
-const logger = makeLogger('BatchWarmingTransport')
-
-/**
- * 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 class BatchWarmingTransport<
-  AdapterParams,
-  ProviderRequestBody,
-  ProviderResponseBody,
-  CustomSettings extends SettingsMap,
-> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings>
-{
-  cache!: Cache
-  rateLimiter!: BackgroundExecuteRateLimiter
-  subscriptionSet!: SubscriptionSet<AdapterParams>
-
-  // 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
-  WARMER_ACTIVE = false
-
-  constructor(
-    private config: {
-      prepareRequest: (
-        params: AdapterParams[],
-        context: AdapterContext<CustomSettings>,
-      ) => AxiosRequestConfig<ProviderRequestBody>
-      parseResponse: (
-        res: AxiosResponse<ProviderResponseBody>,
-        context: AdapterContext<CustomSettings>,
-      ) => ProviderResult<AdapterParams>[]
-    },
-  ) {}
-
-  async initialize(dependencies: AdapterDependencies): Promise<void> {
-    this.cache = dependencies.cache
-    this.rateLimiter = dependencies.backgroundExecuteRateLimiter
-    this.subscriptionSet = dependencies.subscriptionSetFactory.buildSet()
-  }
-
-  async hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean> {
-    return !!(await this.subscriptionSet.get(req.requestContext.cacheKey))
-  }
-
-  async setup(
-    req: AdapterRequest<AdapterParams>,
-    config: AdapterConfig<CustomSettings>,
-  ): Promise<void> {
-    logger.debug(
-      `Adding entry to batch warming set: [${req.requestContext.cacheKey}] = ${req.requestContext.data}`,
-    )
-    await this.subscriptionSet.add(
-      req.requestContext.cacheKey,
-      req.requestContext.data,
-      config.WARMUP_SUBSCRIPTION_TTL,
-    )
-  }
-
-  async backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number> {
-    logger.debug('Starting background execute')
-    const entries = await this.subscriptionSet.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 axiosRequest<ProviderRequestBody, ProviderResponseBody>(request)
-
-    logger.debug(`Got response from provider, parsing (raw body: ${providerResponse.data})`)
-    const results = this.config.parseResponse(providerResponse, context)
-    const adapterResponses = buildCacheEntriesFromResults(results, context)
-
-    logger.debug('Setting adapter responses in cache')
-    await this.cache.setMany(adapterResponses, context.adapterConfig.CACHE_MAX_AGE)
-
-    // 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)
-  }
-}