@chainlink/external-adapter-framework 0.0.15 → 0.0.16

package/test/metrics/metrics.test.ts

@@ -1,267 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios, { AxiosRequestConfig, AxiosResponse } from 'axios'
-import { AddressInfo } from 'net'
-import nock from 'nock'
-import { expose } from '../../src'
-import { Adapter, AdapterEndpoint } from '../../src/adapter'
-import { EmptySettings } from '../../src/config'
-import { RestTransport } from '../../src/transports'
-import { AdapterRequest, AdapterResponse } from '../../src/util'
-import { parsePromMetrics } from './helper'
-
-const test = untypedTest as TestFn<{
-  serverAddress: string
-}>
-
-const URL = 'http://test-url.com'
-
-interface AdapterRequestParams {
-  from: string
-  to: string
-}
-
-interface ProviderRequestBody {
-  base: string
-  quote: string
-}
-
-interface ProviderResponseBody {
-  price: number
-}
-
-const endpoint = '/price'
-
-const createAdapterEndpoint = (): AdapterEndpoint => {
-  const restEndpointTransport = new RestTransport<
-    AdapterRequestParams,
-    ProviderRequestBody,
-    ProviderResponseBody,
-    EmptySettings
-  >({
-    prepareRequest: (
-      req: AdapterRequest<AdapterRequestParams>,
-    ): AxiosRequestConfig<ProviderRequestBody> => {
-      return {
-        baseURL: URL,
-        url: endpoint,
-        method: 'GET',
-        params: {
-          base: req.requestContext.data.from,
-          quote: req.requestContext.data.to,
-        },
-      }
-    },
-    parseResponse: (
-      req: AdapterRequest<AdapterRequestParams>,
-      res: AxiosResponse<ProviderResponseBody>,
-    ): AdapterResponse<ProviderResponseBody> => {
-      return {
-        data: res.data,
-        statusCode: 200,
-        result: res.data.price,
-      }
-    },
-    options: {
-      coalescing: true,
-    },
-  })
-
-  return {
-    name: 'test',
-    inputParameters: {
-      from: {
-        type: 'string',
-        required: true,
-      },
-      to: {
-        type: 'string',
-        required: true,
-      },
-    },
-    transport: restEndpointTransport,
-  }
-}
-
-const from = 'ETH'
-const to = 'USD'
-const price = 1234
-
-test.before(async (t) => {
-  process.env['METRICS_ENABLED'] = 'true'
-  process.env['METRICS_PORT'] = '9090'
-  process.env['npm_package_version'] = '1'
-  const adapter: Adapter = {
-    name: 'test',
-    defaultEndpoint: 'test',
-    endpoints: [createAdapterEndpoint()],
-  }
-  const server = await expose(adapter)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
-})
-
-test.serial('Test http requests total metrics (data provider hit)', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  nock(URL)
-    .get(endpoint)
-    .query({
-      base: from,
-      quote: to,
-    })
-    .reply(200, {
-      price,
-    })
-
-  await axios.post(t.context.serverAddress, {
-    data: {
-      from,
-      to,
-    },
-  })
-
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{method="POST",feed_id="|from:eth|to:usd",status_code="200",type="dataProviderHit",provider_status_code="200",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`http_requests_total${expectedLabel}`), 1)
-})
-
-test.serial('Test http request duration metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel = '{app_name="test",app_version="undefined"}'
-  const responseTime = metricsMap.get(`http_request_duration_seconds_sum${expectedLabel}`)
-  if (responseTime !== undefined) {
-    t.is(typeof responseTime === 'number', true)
-    t.is(responseTime > 0, true)
-  } else {
-    t.fail('Response time did not record')
-  }
-})
-
-test.serial('Test data provider requests metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{provider_status_code="200",method="GET",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`data_provider_requests${expectedLabel}`), 1)
-})
-
-test.serial('Test data provider request duration metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel = '{app_name="test",app_version="undefined"}'
-  const responseTime = metricsMap.get(`data_provider_request_duration_seconds_sum${expectedLabel}`)
-  if (responseTime !== undefined) {
-    t.is(typeof responseTime === 'number', true)
-    t.is(responseTime > 0, true)
-  } else {
-    t.fail('Response time did not record')
-  }
-})
-
-test.serial('Test cache set count metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{participant_id="test-|from:eth|to:usd",feed_id="|from:eth|to:usd",cache_type="local",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`cache_data_set_count${expectedLabel}`), 1)
-})
-
-test.serial('Test cache max age metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{participant_id="test-|from:eth|to:usd",feed_id="|from:eth|to:usd",cache_type="local",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`cache_data_max_age${expectedLabel}`), 90000)
-})
-
-test.serial('Test cache set staleness metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{participant_id="test-|from:eth|to:usd",feed_id="|from:eth|to:usd",cache_type="local",app_name="test",app_version="undefined"}'
-  const staleness = metricsMap.get(`cache_data_staleness_seconds${expectedLabel}`)
-  if (staleness !== undefined) {
-    t.is(typeof staleness === 'number', true)
-    t.is(staleness === 0, true)
-  } else {
-    t.fail('Staleness was not retrieved')
-  }
-})
-
-test.serial('Test credit spent metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{feed_id="|from:eth|to:usd",participant_id="test-|from:eth|to:usd",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`rate_limit_credits_spent_total${expectedLabel}`), 1)
-})
-
-test.serial('Test http requests total metrics (cache hit)', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  nock(URL)
-    .get(endpoint)
-    .query({
-      base: from,
-      quote: to,
-    })
-    .reply(200, {
-      price,
-    })
-
-  await axios.post(t.context.serverAddress, {
-    data: {
-      from,
-      to,
-    },
-  })
-
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{method="POST",feed_id="|from:eth|to:usd",status_code="200",type="cacheHit",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`http_requests_total${expectedLabel}`), 1)
-})
-
-test.serial('Test cache get count metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{participant_id="test-|from:eth|to:usd",feed_id="|from:eth|to:usd",cache_type="local",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`cache_data_get_count${expectedLabel}`), 1)
-})
-
-test.serial('Test cache get value metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{participant_id="test-|from:eth|to:usd",feed_id="|from:eth|to:usd",cache_type="local",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`cache_data_get_values${expectedLabel}`), 1234)
-})
-
-test.serial('Test cache get staleness metrics', async (t) => {
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{participant_id="test-|from:eth|to:usd",feed_id="|from:eth|to:usd",cache_type="local",app_name="test",app_version="undefined"}'
-  const staleness = metricsMap.get(`cache_data_staleness_seconds${expectedLabel}`)
-  if (staleness !== undefined) {
-    t.is(typeof staleness === 'number', true)
-    t.is(staleness > 0, true)
-  } else {
-    t.fail('Staleness was not retrieved')
-  }
-})

package/test/metrics/redis-metrics.test.ts

@@ -1,113 +0,0 @@
-import untypedTest, { TestFn } from 'ava'
-import axios from 'axios'
-import Redis from 'ioredis'
-import { AddressInfo } from 'ws'
-import { expose } from '../../src'
-import { Adapter, AdapterDependencies, AdapterEndpoint } from '../../src/adapter'
-import { Cache, LocalCache, RedisCache } from '../../src/cache'
-import { SettingsMap } from '../../src/config'
-import { Transport } from '../../src/transports'
-import { BasicCacheSetterTransport } from '../cache/helper'
-import { NopTransport } from '../util'
-import { parsePromMetrics } from './helper'
-
-export const test = untypedTest as TestFn<{
-  serverAddress: string
-  cache: Cache
-  adapterEndpoint: AdapterEndpoint
-}>
-
-class RedisMock {
-  store = new LocalCache<string>()
-
-  get(key: string) {
-    return this.store.get(key)
-  }
-
-  del(key: string) {
-    return this.store.delete(key)
-  }
-
-  set(key: string, value: string, px: 'PX', ttl: number) {
-    return this.store.set(key, value, ttl)
-  }
-
-  multi() {
-    return new CommandChainMock(this)
-  }
-}
-
-class CommandChainMock {
-  promises: Promise<unknown>[] = []
-  constructor(private redisMock: RedisMock) {}
-
-  set(key: string, value: string, px: 'PX', ttl: number) {
-    this.promises.push(this.redisMock.set(key, value, px, ttl))
-    return this
-  }
-
-  exec() {
-    return Promise.all(this.promises)
-  }
-}
-
-test.before(async (t) => {
-  process.env['METRICS_ENABLED'] = 'true'
-  process.env['METRICS_PORT'] = '9091'
-  const adapter: Adapter = {
-    name: 'test',
-    defaultEndpoint: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {
-          base: {
-            type: 'string',
-            required: true,
-          },
-          factor: {
-            type: 'number',
-            required: true,
-          },
-        },
-        transport: new BasicCacheSetterTransport() as Transport<unknown, unknown, SettingsMap>,
-      },
-      {
-        name: 'nowork',
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-    ],
-    envDefaultOverrides: {
-      CACHE_POLLING_SLEEP_MS: 10,
-      CACHE_POLLING_MAX_RETRIES: 3,
-    },
-  }
-
-  const cache = new RedisCache(new RedisMock() as unknown as Redis) // Fake redis
-  const dependencies: Partial<AdapterDependencies> = {
-    cache,
-  }
-
-  t.context.cache = cache
-  const server = await expose(adapter, dependencies)
-  if (!server) {
-    throw 'Server did not start'
-  }
-  t.context.serverAddress = `http://localhost:${(server.address() as AddressInfo).port}`
-})
-
-test.serial('Test redis sent command metric', async (t) => {
-  const data = {
-    base: 'eth',
-    factor: 123,
-  }
-
-  await axios.post(t.context.serverAddress, { data })
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  const response = await axios.get(metricsAddress)
-  const metricsMap = parsePromMetrics(response.data)
-  const expectedLabel =
-    '{status="SUCCESS",function_name="exec",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`redis_commands_sent_count${expectedLabel}`), 1)
-})

package/test/metrics/warmer-metrics.test.ts

@@ -1,193 +0,0 @@
-import FakeTimers from '@sinonjs/fake-timers'
-import untypedTest, { TestFn } from 'ava'
-import axios, { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import { AddressInfo } from 'net'
-import nock from 'nock'
-import { expose } from '../../src'
-import { Adapter } from '../../src/adapter'
-import { SettingsMap } from '../../src/config'
-import { DEFAULT_SHARED_MS_BETWEEN_REQUESTS } from '../../src/rate-limiting'
-import { BatchWarmingTransport } from '../../src/transports'
-import { ProviderResult } from '../../src/util'
-import { MockCache } from '../util'
-import { parsePromMetrics } from './helper'
-
-const test = untypedTest as TestFn<{
-  serverAddress: string
-  cache: MockCache
-}>
-
-const URL = 'http://test-url.com'
-const endpoint = '/price'
-
-interface AdapterRequestParams {
-  from: string
-  to: string
-}
-
-interface ProviderRequestBody {
-  pairs: Array<{
-    base: string
-    quote: string
-  }>
-}
-
-interface ProviderResponseBody {
-  prices: Array<{
-    pair: string
-    price: number
-  }>
-}
-const clock = FakeTimers.install({ shouldAdvanceTime: true, advanceTimeDelta: 100 })
-
-test.before(async (t) => {
-  nock.disableNetConnect()
-  nock.enableNetConnect('localhost')
-  process.env['METRICS_ENABLED'] = 'true'
-  process.env['METRICS_PORT'] = '9092'
-  // Disable retries to make the testing flow easier
-  process.env['CACHE_POLLING_MAX_RETRIES'] = '0'
-
-  const adapter: Adapter = {
-    name: 'test',
-    defaultEndpoint: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters,
-        transport: new MockBatchWarmingTransport(),
-      },
-    ],
-  }
-
-  // Create mocked cache so we can listen when values are set
-  // This is a more reliable method than expecting precise clock timings
-  const mockCache = new MockCache()
-
-  // Start the adapter
-  const server = await expose(adapter, {
-    cache: mockCache,
-  })
-  t.context.serverAddress = `http://localhost:${(server?.address() as AddressInfo)?.port}`
-  t.context.cache = mockCache
-})
-
-test.after(() => {
-  nock.restore()
-  clock.uninstall()
-})
-
-class MockBatchWarmingTransport extends BatchWarmingTransport<
-  AdapterRequestParams,
-  ProviderRequestBody,
-  ProviderResponseBody,
-  SettingsMap
-> {
-  constructor() {
-    super({
-      prepareRequest: (params: AdapterRequestParams[]): AxiosRequestConfig<ProviderRequestBody> => {
-        return {
-          baseURL: URL,
-          url: '/price',
-          method: 'POST',
-          data: {
-            pairs: params.map((p) => ({ base: p.from, quote: p.to })),
-          },
-        }
-      },
-      parseResponse: (
-        params: AdapterRequestParams[],
-        res: AxiosResponse<ProviderResponseBody>,
-      ): ProviderResult<AdapterRequestParams>[] => {
-        return res.data.prices.map((p) => {
-          const [from, to] = p.pair.split('/')
-          return {
-            params: { from, to },
-            value: p.price,
-          }
-        })
-      },
-    })
-  }
-}
-
-const from = 'ETH'
-const to = 'USD'
-const price = 1234
-
-nock(URL)
-  .post(endpoint, {
-    pairs: [
-      {
-        base: from,
-        quote: to,
-      },
-    ],
-  })
-  .reply(200, {
-    prices: [
-      {
-        pair: `${from}/${to}`,
-        price,
-      },
-    ],
-  })
-  .persist()
-
-const inputParameters = {
-  from: {
-    type: 'string',
-    required: true,
-  },
-  to: {
-    type: 'string',
-    required: true,
-  },
-} as const
-
-test.serial('Test cache warmer active metric', async (t) => {
-  const makeRequest = () =>
-    axios.post(t.context.serverAddress, {
-      data: {
-        from,
-        to,
-      },
-    })
-
-  // Expect the first response to time out
-  // The polling behavior is tested in the cache tests, so this is easier here.
-  // Start the request:
-  const errorPromise: Promise<AxiosError | undefined> = t.throwsAsync(makeRequest)
-  // Advance enough time for the initial request async flow
-  clock.tickAsync(10)
-  // Wait for the failed cache get -> instant 504
-  const error = await errorPromise
-  t.is(error?.response?.status, 504)
-
-  // Advance clock so that the batch warmer executes once again and wait for the cache to be set
-  const cacheValueSetPromise = t.context.cache.waitForNextSet()
-  await clock.tickAsync(DEFAULT_SHARED_MS_BETWEEN_REQUESTS + 10)
-  await cacheValueSetPromise
-
-  // Second request should find the response in the cache
-  let response = await makeRequest()
-
-  t.is(response.status, 200)
-  const metricsAddress = `http://localhost:${process.env['METRICS_PORT']}/metrics`
-  response = await axios.get(metricsAddress)
-  let metricsMap = parsePromMetrics(response.data)
-  let expectedLabel = '{isBatched="true",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`cache_warmer_get_count${expectedLabel}`), 1)
-
-  // Wait until the cache expires, and the subscription is out
-  await clock.tickAsync(90001)
-
-  // Now that the cache is out and the subscription no longer there, this should time out
-  const error2: AxiosError | undefined = await t.throwsAsync(makeRequest)
-  t.is(error2?.response?.status, 504)
-
-  response = await axios.get(metricsAddress)
-  metricsMap = parsePromMetrics(response.data)
-  expectedLabel = '{isBatched="true",app_name="test",app_version="undefined"}'
-  t.is(metricsMap.get(`cache_warmer_get_count${expectedLabel}`), 0)
-})