@chainlink/external-adapter-framework 0.0.14 → 0.0.15

package/test/metrics/metrics.test.ts

@@ -0,0 +1,267 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,193 @@
+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)
+})