@platformatic/telemetry 0.46.1 → 0.46.2

package/lib/telemetry.js

@@ -31,8 +31,9 @@ const { name: moduleName, version: moduleVersion } = require('../package.json')
 const extractPath = (request) => {
   // We must user RouterPath, because otherwise `/test/123` will be considered as
   // a different operation than `/test/321`. In case is not set (this should actually happen only for HTTP/404) we fallback to the path.
-  const { routerPath, url } = request
+  const { routeOptions, url } = request
   let path
+  const routerPath = routeOptions && routeOptions.url
   if (routerPath) {
     path = formatParamUrl(routerPath)
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/telemetry",
-  "version": "0.46.1",
+  "version": "0.46.2",
   "description": "OpenTelemetry integration for Platformatic",
   "main": "index.js",
   "author": "Marco Piraccini <marco.piraccini@gmail.com>",

package/test/client.test.js

@@ -1,283 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const fastify = require('fastify')
-const { SpanStatusCode, SpanKind } = require('@opentelemetry/api')
-const telemetryPlugin = require('../lib/telemetry')
-const { PlatformaticContext } = require('../lib/platformatic-context')
-const { fastifyTextMapGetter } = require('../lib/fastify-text-map')
-
-async function setupApp (pluginOpts, routeHandler, teardown) {
-  const app = fastify()
-  await app.register(telemetryPlugin, pluginOpts)
-  app.get('/test', routeHandler)
-  app.ready()
-  teardown(async () => {
-    await app.close()
-    const { exporters } = app.openTelemetry
-    exporters.forEach(exporter => {
-      if (exporter.constructor.name === 'InMemorySpanExporter') {
-        exporter.reset()
-      }
-    })
-  })
-  return app
-}
-
-test('should add the propagation headers correctly, new propagation started', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient } = app.openTelemetry
-
-  const url = 'http://localhost:3000/test'
-  const { span, telemetryHeaders } = startSpanClient(url, 'GET')
-
-  const spanId = span._spanContext.spanId
-  const traceId = span._spanContext.traceId
-  same(telemetryHeaders, {
-    traceparent: `00-${traceId}-${spanId}-01`
-  })
-})
-
-test('should add the propagation headers correctly, with propagation already started', async ({ equal, same, teardown }) => {
-  const traceId = '5e994e8fb53b27c91dcd2fec22771d15'
-  const spanId = '166f3ab30f21800b'
-  const traceparent = `00-${traceId}-${spanId}-01`
-
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient } = app.openTelemetry
-
-  const url = 'http://localhost:3000/test'
-  const incomingHeaders = {
-    host: 'test',
-    traceparent
-  }
-  const { propagator } = app.openTelemetry
-  const context = propagator.extract(new PlatformaticContext(), { headers: incomingHeaders }, fastifyTextMapGetter)
-
-  const { span, telemetryHeaders } = startSpanClient(url, 'GET', context)
-
-  const spanId2 = span._spanContext.spanId
-  const traceId2 = span._spanContext.traceId
-
-  // We preserved the tracedId
-  same(traceId, traceId2)
-  same(telemetryHeaders, {
-    traceparent: `00-${traceId}-${spanId2}-01`
-  })
-})
-
-test('should trace a client request', async ({ equal, same, teardown }) => {
-  let receivedHeaders = null
-  const handler = async (request, reply) => {
-    receivedHeaders = request.headers
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient, endSpanClient } = app.openTelemetry
-
-  const url = 'http://localhost:3000/test'
-
-  const { propagator } = app.openTelemetry
-  const context = propagator.extract(new PlatformaticContext(), { headers: {} }, fastifyTextMapGetter)
-
-  const { span, telemetryHeaders } = startSpanClient(url, 'GET', context)
-  const args = {
-    method: 'GET',
-    url: '/test',
-    headers: {
-      ...telemetryHeaders
-    }
-  }
-
-  const response = await app.inject(args)
-  endSpanClient(span, response)
-
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 2)
-  // We have two one for the client and one for the server
-  const spanServer = finishedSpans[0]
-  equal(spanServer.name, 'GET /test')
-  equal(spanServer.kind, SpanKind.SERVER)
-  equal(spanServer.status.code, SpanStatusCode.OK)
-  equal(spanServer.attributes['http.request.method'], 'GET')
-  equal(spanServer.attributes['url.path'], '/test')
-  equal(spanServer.attributes['http.response.status_code'], 200)
-
-  const spanClient = finishedSpans[1]
-  equal(spanClient.name, 'GET http://localhost:3000/test')
-  equal(spanClient.kind, SpanKind.CLIENT)
-  equal(spanClient.status.code, SpanStatusCode.OK)
-  equal(spanClient.attributes['url.full'], 'http://localhost:3000/test')
-  equal(spanClient.attributes['http.response.status_code'], 200)
-  equal(spanClient.attributes['server.port'], 3000)
-  equal(spanClient.attributes['server.address'], 'localhost')
-  equal(spanClient.attributes['url.path'], '/test')
-
-  // The traceparent header is added to the request and propagated to the server
-  equal(receivedHeaders.traceparent, telemetryHeaders.traceparent)
-})
-
-test('should trace a client request failing', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient, endSpanClient } = app.openTelemetry
-
-  const { propagator } = app.openTelemetry
-  const context = propagator.extract(new PlatformaticContext(), { headers: {} }, fastifyTextMapGetter)
-
-  const url = 'http://localhost:3000/test'
-  const { span, telemetryHeaders } = startSpanClient(url, 'GET', context)
-  const args = {
-    method: 'GET',
-    url: '/wrong',
-    headers: telemetryHeaders
-  }
-  const response = await app.inject(args)
-  endSpanClient(span, response)
-
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 2)
-  // We have two one for the client and one for the server
-  const spanServer = finishedSpans[0]
-  equal(spanServer.name, 'GET /wrong')
-  equal(spanServer.kind, SpanKind.SERVER)
-  equal(spanServer.status.code, SpanStatusCode.ERROR)
-  equal(spanServer.attributes['http.request.method'], 'GET')
-  equal(spanServer.attributes['url.path'], '/wrong')
-  equal(spanServer.attributes['http.response.status_code'], 404)
-
-  const spanClient = finishedSpans[1]
-  equal(spanClient.name, 'GET http://localhost:3000/test')
-  equal(spanClient.kind, SpanKind.CLIENT)
-  equal(spanClient.status.code, SpanStatusCode.ERROR)
-  equal(spanClient.attributes['url.full'], 'http://localhost:3000/test')
-  equal(spanClient.attributes['http.response.status_code'], 404)
-})
-
-test('should trace a client request failing (no HTTP error)', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient, endSpanClient, setErrorInSpanClient } = app.openTelemetry
-
-  const url = 'http://localhost:3000/test'
-  const { span } = startSpanClient(url, 'GET')
-  try {
-    throw new Error('KABOOM!!!')
-  } catch (err) {
-    setErrorInSpanClient(span, err)
-  } finally {
-    endSpanClient(span)
-  }
-
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 1)
-
-  const spanClient = finishedSpans[0]
-  equal(spanClient.name, 'GET http://localhost:3000/test')
-  equal(spanClient.status.code, SpanStatusCode.ERROR)
-  equal(spanClient.attributes['url.full'], 'http://localhost:3000/test')
-  equal(spanClient.attributes['error.name'], 'Error')
-  equal(spanClient.attributes['error.message'], 'KABOOM!!!')
-  equal(spanClient.attributes['error.stack'].includes('Error: KABOOM!!!'), true)
-})
-
-test('should not add the query in span name', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient } = app.openTelemetry
-
-  const url = 'http://localhost:3000/test?foo=bar'
-  const { span } = startSpanClient(url, 'GET')
-  same(span.name, 'GET http://localhost:3000/test')
-})
-
-test('should ignore the skipped operations', async ({ equal, same, ok, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    skip: [
-      {
-        path: '/skipme',
-        method: 'POST'
-      }
-    ],
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const { startSpanClient } = app.openTelemetry
-
-  const url = 'http://localhost:3000/skipme'
-  const ret = startSpanClient(url, 'POST')
-  // no spam should be created
-  ok(!ret)
-})

package/test/multispan-processor.test.js

@@ -1,81 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { MultiSpanProcessor } = require('../lib/multispan-processor')
-
-test('should add multiple processors', async ({ equal, same, teardown }) => {
-  const mockSpanProcessor = {
-    onStart: () => {},
-    onEnd: () => {},
-    shutdown: async () => {},
-    forceFlush: async () => {}
-  }
-  const processor = new MultiSpanProcessor()
-  equal(processor._spanProcessors.length, 0)
-
-  {
-    const processor = new MultiSpanProcessor([mockSpanProcessor, mockSpanProcessor])
-    equal(processor._spanProcessors.length, 2)
-  }
-})
-
-test('should call onStart on every processor', async ({ equal, same, teardown }) => {
-  let called1 = false
-  let called2 = false
-  const mockSpanProcessor1 = {
-    onStart: () => { called1 = true }
-  }
-  const mockSpanProcessor2 = {
-    called: false,
-    onStart: () => { called2 = true }
-  }
-  const processor = new MultiSpanProcessor([mockSpanProcessor1, mockSpanProcessor2])
-  processor.onStart()
-  equal(called1, true)
-  equal(called2, true)
-})
-
-test('should call onEnd on every processor', async ({ equal, same, teardown }) => {
-  let called1 = false
-  let called2 = false
-  const mockSpanProcessor1 = {
-    onEnd: () => { called1 = true }
-  }
-  const mockSpanProcessor2 = {
-    onEnd: () => { called2 = true }
-  }
-  const processor = new MultiSpanProcessor([mockSpanProcessor1, mockSpanProcessor2])
-  processor.onEnd()
-  equal(called1, true)
-  equal(called2, true)
-})
-
-test('should call shutdown on every processor', async ({ equal, same, teardown }) => {
-  let called1 = false
-  let called2 = false
-  const mockSpanProcessor1 = {
-    shutdown: async () => { called1 = true }
-  }
-  const mockSpanProcessor2 = {
-    shutdown: async () => { called2 = true }
-  }
-  const processor = new MultiSpanProcessor([mockSpanProcessor1, mockSpanProcessor2])
-  await processor.shutdown()
-  equal(called1, true)
-  equal(called2, true)
-})
-
-test('should call forceFlush on every processor', async ({ equal, same, teardown }) => {
-  let called1 = false
-  let called2 = false
-  const mockSpanProcessor1 = {
-    forceFlush: async () => { called1 = true }
-  }
-  const mockSpanProcessor2 = {
-    forceFlush: async () => { called2 = true }
-  }
-  const processor = new MultiSpanProcessor([mockSpanProcessor1, mockSpanProcessor2])
-  await processor.forceFlush()
-  equal(called1, true)
-  equal(called2, true)
-})

package/test/platformatic-trace-provider.test.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const { PlatformaticTracerProvider } = require('../lib/platformatic-trace-provider')
-
-test('should propagate forceFlush to all registered processors ', async ({ equal, same, teardown }) => {
-  let called1 = false
-  let called2 = false
-  const mockSpanProcessor1 = {
-    forceFlush: async () => { called1 = true }
-  }
-  const mockSpanProcessor2 = {
-    forceFlush: async () => { called2 = true }
-  }
-  const provider = new PlatformaticTracerProvider()
-  equal(provider._registeredSpanProcessors.length, 0)
-
-  provider.addSpanProcessor(mockSpanProcessor1)
-  provider.addSpanProcessor(mockSpanProcessor2)
-
-  equal(provider._registeredSpanProcessors.length, 2)
-  await provider.forceFlush()
-  equal(called1, true)
-  equal(called2, true)
-})
-
-test('should propagate shutdown to the active span processor, which should propagate to all the processors ', async ({ equal, same, teardown }) => {
-  let called1 = false
-  let called2 = false
-  const mockSpanProcessor1 = {
-    shutdown: async () => { called1 = true }
-  }
-  const mockSpanProcessor2 = {
-    shutdown: async () => { called2 = true }
-  }
-  const provider = new PlatformaticTracerProvider()
-  equal(provider._registeredSpanProcessors.length, 0)
-
-  provider.addSpanProcessor(mockSpanProcessor1)
-  provider.addSpanProcessor(mockSpanProcessor2)
-
-  equal(provider._registeredSpanProcessors.length, 2)
-  await provider.shutdown()
-  equal(called1, true)
-  equal(called2, true)
-})

package/test/telemetry.test.js

@@ -1,383 +0,0 @@
-'use strict'
-
-const { test } = require('tap')
-const fastify = require('fastify')
-const { SpanStatusCode, SpanKind } = require('@opentelemetry/api')
-const telemetryPlugin = require('../lib/telemetry')
-
-async function setupApp (pluginOpts, routeHandler, teardown) {
-  const app = fastify()
-  await app.register(telemetryPlugin, pluginOpts)
-  app.get('/test', routeHandler)
-  app.get('/test/:id', routeHandler)
-  app.ready()
-  teardown(async () => {
-    await app.close()
-    const { exporters } = app.openTelemetry
-    exporters.forEach(exporter => {
-      if (exporter.constructor.name === 'InMemorySpanExporter') {
-        exporter.reset()
-      }
-    })
-  })
-  return app
-}
-
-const injectArgs = {
-  method: 'GET',
-  url: '/test',
-  headers: {
-    host: 'test'
-  }
-}
-
-test('should trace a request not failing', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 1)
-  const span = finishedSpans[0]
-  equal(span.kind, SpanKind.SERVER)
-  equal(span.name, 'GET /test')
-  equal(span.status.code, SpanStatusCode.OK)
-  equal(span.attributes['http.request.method'], 'GET')
-  equal(span.attributes['url.path'], '/test')
-  equal(span.attributes['http.response.status_code'], 200)
-  equal(span.attributes['url.scheme'], 'http')
-  equal(span.attributes['server.address'], 'test')
-  const resource = span.resource
-  same(resource.attributes['service.name'], 'test-service')
-  same(resource.attributes['service.version'], '1.0.0')
-})
-
-test('should not put query in `url.path', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const injectArgs = {
-    method: 'GET',
-    url: '/test?foo=bar',
-    headers: {
-      host: 'test'
-    }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 1)
-  const span = finishedSpans[0]
-  equal(span.kind, SpanKind.SERVER)
-  equal(span.name, 'GET /test')
-  equal(span.status.code, SpanStatusCode.OK)
-  equal(span.attributes['http.request.method'], 'GET')
-  equal(span.attributes['url.path'], '/test')
-  equal(span.attributes['http.response.status_code'], 200)
-  equal(span.attributes['url.scheme'], 'http')
-  equal(span.attributes['server.address'], 'test')
-  const resource = span.resource
-  same(resource.attributes['service.name'], 'test-service')
-  same(resource.attributes['service.version'], '1.0.0')
-})
-
-test('request should add attribute to a span', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    request.span.setAttribute('foo', 'bar')
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 1)
-  const span = finishedSpans[0]
-  equal(span.name, 'GET /test')
-  equal(span.status.code, SpanStatusCode.OK)
-  equal(span.attributes['http.request.method'], 'GET')
-  equal(span.attributes['url.path'], '/test')
-  equal(span.attributes['http.response.status_code'], 200)
-  // This is the attribute we added
-  equal(span.attributes.foo, 'bar')
-  const resource = span.resource
-  same(resource.attributes['service.name'], 'test-service')
-  same(resource.attributes['service.version'], '1.0.0')
-})
-
-test('should be able to set the W3C trace context', async ({ equal, same, teardown, ok }) => {
-  const handler = async (request, reply) => {
-    const context = request.openTelemetry().span.context
-    const newContext = context.setValue('foo', 'bar')
-    request.openTelemetry().span.context = newContext
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const response = await app.inject(injectArgs)
-  // see: https://www.w3.org/TR/trace-context/#design-overview
-  ok(response.headers.traceparent)
-})
-
-test('should trace a request that fails', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    throw new Error('booooom!!!')
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 1)
-  const span = finishedSpans[0]
-  equal(span.name, 'GET /test')
-  equal(span.status.code, SpanStatusCode.ERROR)
-  equal(span.attributes['http.request.method'], 'GET')
-  equal(span.attributes['url.path'], '/test')
-  equal(span.attributes['http.response.status_code'], 500)
-  equal(span.attributes['error.message'], 'booooom!!!')
-  const resource = span.resource
-  same(resource.attributes['service.name'], 'test-service')
-  same(resource.attributes['service.version'], '1.0.0')
-})
-
-test('if no exporter is configured, should default to console', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return {}
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0'
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  same(exporter.constructor.name, 'ConsoleSpanExporter')
-})
-
-test('should configure OTLP correctly', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return {}
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'otlp',
-      options: {
-        url: 'http://localhost:4317'
-      }
-    }
-  }, handler, teardown)
-
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  same(exporter.constructor.name, 'OTLPTraceExporter')
-  same(exporter.url, 'http://localhost:4317')
-})
-
-test('should configure Zipkin correctly', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return {}
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'zipkin',
-      options: {
-        url: 'http://localhost:9876'
-      }
-    }
-  }, handler, teardown)
-
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  same(exporter.constructor.name, 'ZipkinExporter')
-  same(exporter._urlStr, 'http://localhost:9876')
-})
-
-test('wrong exporter is configured, should default to console', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return {}
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'wrong-exporter'
-    }
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  same(exporter.constructor.name, 'ConsoleSpanExporter')
-})
-
-test('should not trace if the operation is skipped', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    skip: [{
-      path: '/documentation/json',
-      method: 'GET'
-    }],
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  const injectArgs = {
-    method: 'GET',
-    url: '/documentation/json',
-    headers: {
-      host: 'test'
-    }
-  }
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 0)
-})
-
-test('should not put the URL param in path', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return { foo: 'bar' }
-  }
-
-  const injectArgs = {
-    method: 'GET',
-    url: '/test/123',
-    headers: {
-      host: 'test'
-    }
-  }
-
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: {
-      type: 'memory'
-    }
-  }, handler, teardown)
-
-  await app.inject(injectArgs)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  const finishedSpans = exporter.getFinishedSpans()
-  equal(finishedSpans.length, 1)
-  const span = finishedSpans[0]
-  equal(span.kind, SpanKind.SERVER)
-  equal(span.name, 'GET /test/{id}')
-  equal(span.status.code, SpanStatusCode.OK)
-  equal(span.attributes['http.request.method'], 'GET')
-  equal(span.attributes['url.path'], '/test/{id}')
-  equal(span.attributes['http.response.status_code'], 200)
-  equal(span.attributes['url.scheme'], 'http')
-  equal(span.attributes['server.address'], 'test')
-  const resource = span.resource
-  same(resource.attributes['service.name'], 'test-service')
-  same(resource.attributes['service.version'], '1.0.0')
-})
-
-test('should configure an exporter as an array', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return {}
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: [{
-      type: 'otlp',
-      options: {
-        url: 'http://localhost:4317'
-      }
-    }]
-  }, handler, teardown)
-  const { exporters } = app.openTelemetry
-  const exporter = exporters[0]
-  same(exporter.constructor.name, 'OTLPTraceExporter')
-  same(exporter.url, 'http://localhost:4317')
-})
-
-test('should use multiple exporters and sent traces to all the exporters', async ({ equal, same, teardown }) => {
-  const handler = async (request, reply) => {
-    return {}
-  }
-  const app = await setupApp({
-    serviceName: 'test-service',
-    version: '1.0.0',
-    exporter: [{
-      type: 'memory'
-    }, {
-      type: 'memory'
-    }]
-  }, handler, teardown)
-  const { exporters } = app.openTelemetry
-
-  await app.inject(injectArgs)
-
-  const finishedSpans0 = exporters[0].getFinishedSpans()
-  equal(finishedSpans0.length, 1)
-  const span0 = finishedSpans0[0]
-  equal(span0.name, 'GET /test')
-  equal(span0.status.code, SpanStatusCode.OK)
-
-  const finishedSpans1 = exporters[1].getFinishedSpans()
-  equal(finishedSpans1.length, 1)
-  const span1 = finishedSpans1[0]
-  equal(span1.name, 'GET /test')
-  equal(span1.status.code, SpanStatusCode.OK)
-})