@platformatic/telemetry 2.12.0 → 2.14.0

package/eslint.config.js

@@ -1,3 +1,9 @@
 'use strict'
 
-module.exports = require('neostandard')({})
+const neostandard = require('neostandard')
+
+module.exports = neostandard(
+  {
+    ignores: ['**/.next', '**/dist', '**/tmp', 'test/fixtures/**'],
+  }
+)

package/index.js

@@ -1,9 +1,11 @@
 'use strict'
 
 const telemetry = require('./lib/telemetry')
+const { createTelemetryThreadInterceptorHooks } = require('./lib/thread-interceptor-hooks')
 const schema = require('./lib/schema')
 
 module.exports = {
   telemetry,
+  createTelemetryThreadInterceptorHooks,
   schema,
 }

package/lib/file-span-exporter.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const {
+  ExportResultCode,
+  hrTimeToMicroseconds,
+} = require('@opentelemetry/core')
+const path = require('node:path')
+const { appendFileSync } = require('node:fs')
+
+// Export spans to a file, mostly for testing purposes.
+class FileSpanExporter {
+  #path
+  constructor (opts) {
+    if (!opts.path) {
+      this.#path = path.resolve('spans.log')
+    } else {
+      this.#path = opts.path
+    }
+  }
+
+  export (spans, resultCallback) {
+    for (const span of spans) {
+      appendFileSync(this.#path, JSON.stringify(this.#exportInfo(span)) + '\n')
+    }
+    resultCallback(ExportResultCode.SUCCESS)
+  }
+
+  shutdown () {
+    return this.forceFlush()
+  }
+
+  forceFlush () {
+    return Promise.resolve()
+  }
+
+  #exportInfo (span) {
+    return {
+      traceId: span.spanContext().traceId,
+      parentId: span.parentSpanId,
+      traceState: span.spanContext().traceState?.serialize(),
+      name: span.name,
+      id: span.spanContext().spanId,
+      kind: span.kind,
+      timestamp: hrTimeToMicroseconds(span.startTime),
+      duration: hrTimeToMicroseconds(span.duration),
+      attributes: span.attributes,
+      status: span.status,
+      events: span.events,
+      links: span.links,
+      resource: span.resource,
+    }
+  }
+}
+
+module.exports = FileSpanExporter

package/lib/node-http-telemetry.js

@@ -1,9 +1,8 @@
 'use strict'
 const process = require('node:process')
 const opentelemetry = require('@opentelemetry/sdk-node')
-const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
 const { Resource } = require('@opentelemetry/resources')
-const setupTelemetry = require('./telemetry-config')
+const FileSpanExporter = require('./file-span-exporter')
 const { ATTR_SERVICE_NAME } = require('@opentelemetry/semantic-conventions')
 const { workerData } = require('node:worker_threads')
 const { resolve } = require('node:path')
@@ -12,11 +11,64 @@ const logger = require('abstract-logging')
 const { statSync, readFileSync } = require('node:fs') // We want to have all this synch
 const util = require('node:util')
 const debuglog = util.debuglog('@platformatic/telemetry')
+const {
+  ConsoleSpanExporter,
+  BatchSpanProcessor,
+  SimpleSpanProcessor,
+  InMemorySpanExporter,
+} = require('@opentelemetry/sdk-trace-base')
+const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
+
+// See: https://www.npmjs.com/package/@opentelemetry/instrumentation-http
+// When this is fixed we should set this to 'http' and fixe the tests
+// https://github.com/open-telemetry/opentelemetry-js/issues/5103
+process.env.OTEL_SEMCONV_STABILITY_OPT_IN = 'http/dup'
 
 const setupNodeHTTPTelemetry = (opts) => {
   const { serviceName } = opts
-  debuglog(`Setting up Node.js Open Telemetry instrumentation for service: ${serviceName}`)
-  const { spanProcessors } = setupTelemetry(opts, logger)
+
+  let exporter = opts.exporter
+  if (!exporter) {
+    logger.warn('No exporter configured, defaulting to console.')
+    exporter = { type: 'console' }
+  }
+  const exporters = Array.isArray(exporter) ? exporter : [exporter]
+  const spanProcessors = []
+  for (const exporter of exporters) {
+    // Exporter config:
+    // https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_exporter_zipkin.ExporterConfig.html
+    const exporterOptions = { ...exporter.options, serviceName }
+
+    let exporterObj
+    if (exporter.type === 'console') {
+      exporterObj = new ConsoleSpanExporter(exporterOptions)
+    } else if (exporter.type === 'otlp') {
+      const {
+        OTLPTraceExporter,
+      } = require('@opentelemetry/exporter-trace-otlp-proto')
+      exporterObj = new OTLPTraceExporter(exporterOptions)
+    } else if (exporter.type === 'zipkin') {
+      const { ZipkinExporter } = require('@opentelemetry/exporter-zipkin')
+      exporterObj = new ZipkinExporter(exporterOptions)
+    } else if (exporter.type === 'memory') {
+      exporterObj = new InMemorySpanExporter()
+    } else if (exporter.type === 'file') {
+      exporterObj = new FileSpanExporter(exporterOptions)
+    } else {
+      logger.warn(
+        `Unknown exporter type: ${exporter.type}, defaulting to console.`
+      )
+      exporterObj = new ConsoleSpanExporter(exporterOptions)
+    }
+
+    // We use a SimpleSpanProcessor for the console/memory exporters and a BatchSpanProcessor for the others.
+    // (these are the ones used by tests)
+    const spanProcessor = ['memory', 'console', 'file'].includes(exporter.type)
+      ? new SimpleSpanProcessor(exporterObj)
+      : new BatchSpanProcessor(exporterObj)
+    spanProcessors.push(spanProcessor)
+  }
+
   const sdk = new opentelemetry.NodeSDK({
     spanProcessors, // https://github.com/open-telemetry/opentelemetry-js/issues/4881#issuecomment-2358059714
     instrumentations: [

package/lib/schema.js

@@ -5,7 +5,7 @@ const ExporterSchema = {
   properties: {
     type: {
       type: 'string',
-      enum: ['console', 'otlp', 'zipkin', 'memory'],
+      enum: ['console', 'otlp', 'zipkin', 'memory', 'file'],
       default: 'console',
     },
     options: {
@@ -20,6 +20,10 @@ const ExporterSchema = {
           type: 'object',
           description: 'Headers to send to the exporter. Not used for console or memory exporters.',
         },
+        path: {
+          type: 'string',
+          description: 'The path to write the traces to. Only for file exporter.'
+        }
       },
     },
     additionalProperties: false,

package/lib/telemetry-config.js

@@ -1,20 +1,90 @@
 'use strict'
 
+const { SpanStatusCode, SpanKind } = require('@opentelemetry/api')
+const { PlatformaticContext } = require('./platformatic-context')
+const {
+  fastifyTextMapGetter,
+  fastifyTextMapSetter,
+} = require('./fastify-text-map')
+const { formatParamUrl } = require('@fastify/swagger')
+const fastUri = require('fast-uri')
+const { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } = require('@opentelemetry/semantic-conventions')
 const {
   ConsoleSpanExporter,
   BatchSpanProcessor,
   SimpleSpanProcessor,
   InMemorySpanExporter,
 } = require('@opentelemetry/sdk-trace-base')
-const {
-  SemanticResourceAttributes,
-} = require('@opentelemetry/semantic-conventions')
+
+const FileSpanExporter = require('./file-span-exporter')
+
 const { Resource } = require('@opentelemetry/resources')
 const { PlatformaticTracerProvider } = require('./platformatic-trace-provider')
 
 const { name: moduleName, version: moduleVersion } = require('../package.json')
 
-const setupTelemetry = (opts, logger) => {
+// Platformatic telemetry plugin.
+// Supported Exporters:
+// - console
+// - otlp: (which also supports jaeger, see: https://opentelemetry.io/docs/instrumentation/js/exporters/#otlp-endpoint)
+// - zipkin (https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/README.md)
+// - memory: for testing
+
+// This has been partially copied and modified from @autotelic/opentelemetry: https://github.com/autotelic/fastify-opentelemetry/blob/main/index.js
+// , according with [MIT license](https://github.com/autotelic/fastify-opentelemetry/blob/main/LICENSE.md):
+// MIT License
+// Copyright (c) 2020 autotelic
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+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 { routeOptions, url } = request
+  let path
+  const routerPath = routeOptions && routeOptions.url
+  if (routerPath) {
+    path = formatParamUrl(routerPath)
+  } else {
+    path = url
+  }
+  return path
+}
+
+function formatSpanName (request, path) {
+  const { method } = request
+  /* istanbul ignore next */
+  return path ? `${method} ${path}` : method
+}
+
+const formatSpanAttributes = {
+  request (request, path) {
+    const { hostname, method, url, protocol = 'http' } = request
+    // Inspired by: https://github.com/fastify/fastify-url-data/blob/master/plugin.js#L11
+    const urlData = fastUri.parse(`${protocol}://${hostname}${url}`)
+    return {
+      'server.address': hostname,
+      'server.port': urlData.port,
+      'http.request.method': method,
+      'url.path': path,
+      'url.scheme': protocol,
+    }
+  },
+  reply (reply) {
+    return {
+      'http.response.status_code': reply.statusCode,
+    }
+  },
+  error (error) {
+    return {
+      'error.name': error.name,
+      'error.message': error.message,
+      'error.stack': error.stack,
+    }
+  },
+}
+
+const initTelemetry = (opts, logger) => {
   const { serviceName, version } = opts
   let exporter = opts.exporter
   if (!exporter) {
@@ -30,8 +100,8 @@ const setupTelemetry = (opts, logger) => {
 
   const provider = new PlatformaticTracerProvider({
     resource: new Resource({
-      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
-      [SemanticResourceAttributes.SERVICE_VERSION]: version,
+      [ATTR_SERVICE_NAME]: serviceName,
+      [ATTR_SERVICE_VERSION]: version,
     }),
   })
 
@@ -56,6 +126,8 @@ const setupTelemetry = (opts, logger) => {
       exporterObj = new ZipkinExporter(exporterOptions)
     } else if (exporter.type === 'memory') {
       exporterObj = new InMemorySpanExporter()
+    } else if (exporter.type === 'file') {
+      exporterObj = new FileSpanExporter(exporterOptions)
     } else {
       logger.warn(
         `Unknown exporter type: ${exporter.type}, defaulting to console.`
@@ -64,7 +136,8 @@ const setupTelemetry = (opts, logger) => {
     }
 
     // We use a SimpleSpanProcessor for the console/memory exporters and a BatchSpanProcessor for the others.
-    const spanProcessor = ['memory', 'console'].includes(exporter.type)
+    // (these are the ones used by tests)
+    const spanProcessor = ['memory', 'console', 'file'].includes(exporter.type)
       ? new SimpleSpanProcessor(exporterObj)
       : new BatchSpanProcessor(exporterObj)
     spanProcessors.push(spanProcessor)
@@ -78,4 +151,208 @@ const setupTelemetry = (opts, logger) => {
   return { tracer, exporters: exporterObjs, propagator, provider, spanProcessors }
 }
 
-module.exports = setupTelemetry
+function setupTelemetry (opts, logger) {
+  const openTelemetryAPIs = initTelemetry(opts, logger)
+  const { tracer, propagator, provider } = openTelemetryAPIs
+  const skipOperations =
+    opts?.skip?.map((skip) => {
+      const { method, path } = skip
+      return `${method}${path}`
+    }) || []
+
+  const startHTTPSpan = async (request, reply) => {
+    if (skipOperations.includes(`${request.method}${request.url}`)) {
+      request.log.debug(
+        { operation: `${request.method}${request.url}` },
+        'Skipping telemetry'
+      )
+      return
+    }
+
+    // We populate the context with the incoming request headers
+    let context = propagator.extract(
+      new PlatformaticContext(),
+      request,
+      fastifyTextMapGetter
+    )
+
+    const path = extractPath(request)
+    const span = tracer.startSpan(formatSpanName(request, path), {}, context)
+    span.kind = SpanKind.SERVER
+    // Next 2 lines are needed by W3CTraceContextPropagator
+    context = context.setSpan(span)
+    span.setAttributes(formatSpanAttributes.request(request, path))
+    span.context = context
+    // Inject the propagation headers
+    propagator.inject(context, reply, fastifyTextMapSetter)
+    request.span = span
+  }
+
+  const setErrorInSpan = async (request, _reply, error) => {
+    const span = request.span
+    span.setAttributes(formatSpanAttributes.error(error))
+  }
+
+  const endHTTPSpan = async (request, reply) => {
+    const span = request.span
+    if (span) {
+      propagator.inject(span.context, reply, fastifyTextMapSetter)
+      const spanStatus = { code: SpanStatusCode.OK }
+      if (reply.statusCode >= 400) {
+        spanStatus.code = SpanStatusCode.ERROR
+      }
+      span.setAttributes(formatSpanAttributes.reply(reply))
+      span.setStatus(spanStatus)
+      span.end()
+    }
+  }
+
+  //* Client APIs
+  const getSpanPropagationHeaders = (span) => {
+    const context = span.context
+    const headers = {}
+    propagator.inject(context, headers, {
+      set (_carrier, key, value) {
+        headers[key] = value
+      },
+    })
+    return headers
+  }
+
+  // If a context is passed, is used. Otherwise is a new one is created.
+  // Note that in this case we don't set the span in request, as this is a client call.
+  // So the client caller is responible of:
+  // - setting the propagatorHeaders in the client request
+  // - closing the span
+  const startHTTPSpanClient = (url, method, ctx) => {
+    let context = ctx || new PlatformaticContext()
+    const urlObj = fastUri.parse(url)
+
+    if (skipOperations.includes(`${method}${urlObj.path}`)) {
+      logger.debug(
+        { operation: `${method}${urlObj.path}` },
+        'Skipping telemetry'
+      )
+      return
+    }
+
+    /* istanbul ignore next */
+    method = method || ''
+    let name
+    if (urlObj.port) {
+      name = `${method} ${urlObj.scheme}://${urlObj.host}:${urlObj.port}${urlObj.path}`
+    } else {
+      name = `${method} ${urlObj.scheme}://${urlObj.host}${urlObj.path}`
+    }
+
+    const span = tracer.startSpan(name, {}, context)
+    span.kind = SpanKind.CLIENT
+
+    /* istanbul ignore next */
+    const attributes = url
+      ? {
+          'server.address': urlObj.host,
+          'server.port': urlObj.port,
+          'http.request.method': method,
+          'url.full': url,
+          'url.path': urlObj.path,
+          'url.scheme': urlObj.scheme,
+        }
+      : {}
+    span.setAttributes(attributes)
+
+    // Next 2 lines are needed by W3CTraceContextPropagator
+    context = context.setSpan(span)
+    span.context = context
+
+    const telemetryHeaders = getSpanPropagationHeaders(span)
+    return { span, telemetryHeaders }
+  }
+
+  const endHTTPSpanClient = (span, response) => {
+    /* istanbul ignore next */
+    if (!span) {
+      return
+    }
+    if (response) {
+      const spanStatus = { code: SpanStatusCode.OK }
+      if (response.statusCode >= 400) {
+        spanStatus.code = SpanStatusCode.ERROR
+      }
+      span.setAttributes({
+        'http.response.status_code': response.statusCode,
+      })
+      span.setStatus(spanStatus)
+    } else {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: 'No response received',
+      })
+    }
+    span.end()
+  }
+
+  const setErrorInSpanClient = (span, error) => {
+    /* istanbul ignore next */
+    if (!span) {
+      return
+    }
+    span.setAttributes(formatSpanAttributes.error(error))
+  }
+
+  // In the generic "startSpan" the attributes here are specified by the caller
+  const startSpan = (name, ctx, attributes = {}, kind = SpanKind.INTERNAL) => {
+    const context = ctx || new PlatformaticContext()
+    const span = tracer.startSpan(name, {}, context)
+    span.kind = kind
+    span.setAttributes(attributes)
+    span.context = context
+    return span
+  }
+
+  const endSpan = (span, error) => {
+    /* istanbul ignore next */
+    if (!span) {
+      return
+    }
+    if (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error.message,
+      })
+    } else {
+      const spanStatus = { code: SpanStatusCode.OK }
+      span.setStatus(spanStatus)
+    }
+    span.end()
+  }
+
+  // Unfortunately, this must be async, because of: https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_sdk_trace_base.SpanProcessor.html#shutdown
+  const shutdown = async () => {
+    try {
+      await provider.shutdown()
+    } catch (err) {
+      logger.error({ err }, 'Error shutting down telemetry provider')
+    }
+  }
+
+  return {
+    startHTTPSpan,
+    endHTTPSpan,
+    setErrorInSpan,
+    startHTTPSpanClient,
+    endHTTPSpanClient,
+    setErrorInSpanClient,
+    startSpan,
+    endSpan,
+    shutdown,
+    openTelemetryAPIs,
+  }
+}
+
+module.exports = {
+  setupTelemetry,
+  formatSpanName,
+  formatSpanAttributes,
+  extractPath
+}

package/lib/telemetry.js

@@ -1,271 +1,28 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const { SpanStatusCode, SpanKind } = require('@opentelemetry/api')
-const { PlatformaticContext } = require('./platformatic-context')
-const {
-  fastifyTextMapGetter,
-  fastifyTextMapSetter,
-} = require('./fastify-text-map')
-const setup = require('./telemetry-config')
-const { formatParamUrl } = require('@fastify/swagger')
-const fastUri = require('fast-uri')
-
-// Platformatic telemetry plugin.
-// Supported Exporters:
-// - console
-// - otlp: (which also supports jaeger, see: https://opentelemetry.io/docs/instrumentation/js/exporters/#otlp-endpoint)
-// - zipkin (https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/README.md)
-// - memory: for testing
-
-// This has been partially copied and modified from @autotelic/opentelemetry: https://github.com/autotelic/fastify-opentelemetry/blob/main/index.js
-// , according with [MIT license](https://github.com/autotelic/fastify-opentelemetry/blob/main/LICENSE.md):
-// MIT License
-// Copyright (c) 2020 autotelic
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-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 { routeOptions, url } = request
-  let path
-  const routerPath = routeOptions && routeOptions.url
-  if (routerPath) {
-    path = formatParamUrl(routerPath)
-  } else {
-    path = url
-  }
-  return path
-}
-
-function formatSpanName (request, path) {
-  const { method } = request
-  /* istanbul ignore next */
-  return path ? `${method} ${path}` : method
-}
-
-const formatSpanAttributes = {
-  request (request, path) {
-    const { hostname, method, url, protocol } = request
-    // Inspired by: https://github.com/fastify/fastify-url-data/blob/master/plugin.js#L11
-    const urlData = fastUri.parse(`${protocol}://${hostname}${url}`)
-    return {
-      'server.address': hostname,
-      'server.port': urlData.port,
-      'http.request.method': method,
-      'url.path': path,
-      'url.scheme': protocol,
-    }
-  },
-  reply (reply) {
-    return {
-      'http.response.status_code': reply.statusCode,
-    }
-  },
-  error (error) {
-    return {
-      'error.name': error.name,
-      'error.message': error.message,
-      'error.stack': error.stack,
-    }
-  },
-}
-
-async function setupTelemetry (app, opts) {
-  const openTelemetryAPIs = setup(opts, app.log)
-  const { tracer, propagator, provider } = openTelemetryAPIs
-  const skipOperations =
-    opts?.skip?.map((skip) => {
-      const { method, path } = skip
-      return `${method}${path}`
-    }) || []
-
-  // expose the span as a request decorator
-  app.decorateRequest('span')
-
-  const startHTTPSpan = async (request) => {
-    if (skipOperations.includes(`${request.method}${request.url}`)) {
-      request.log.debug(
-        { operation: `${request.method}${request.url}` },
-        'Skipping telemetry'
-      )
-      return
-    }
-
-    // We populate the context with the incoming request headers
-    let context = propagator.extract(
-      new PlatformaticContext(),
-      request,
-      fastifyTextMapGetter
-    )
-
-    const path = extractPath(request)
-    const span = tracer.startSpan(formatSpanName(request, path), {}, context)
-    span.kind = SpanKind.SERVER
-    // Next 2 lines are needed by W3CTraceContextPropagator
-    context = context.setSpan(span)
-    span.setAttributes(formatSpanAttributes.request(request, path))
-    span.context = context
-    request.span = span
-  }
-
-  const setErrorInSpan = async (request, _reply, error) => {
-    const span = request.span
-    span.setAttributes(formatSpanAttributes.error(error))
-  }
-
-  const injectPropagationHeadersInReply = async (request, reply) => {
-    if (request.span) {
-      const context = request.span.context
-      propagator.inject(context, reply, fastifyTextMapSetter)
-    }
-  }
-
-  const endHTTPSpan = async (request, reply) => {
-    const span = request.span
-    if (span) {
-      const spanStatus = { code: SpanStatusCode.OK }
-      if (reply.statusCode >= 400) {
-        spanStatus.code = SpanStatusCode.ERROR
-      }
-      span.setAttributes(formatSpanAttributes.reply(reply))
-      span.setStatus(spanStatus)
-      span.end()
-    }
-  }
+const { SpanKind } = require('@opentelemetry/api')
+const { setupTelemetry } = require('./telemetry-config')
+
+// Telemetry fastify plugin
+async function telemetry (app, opts) {
+  const {
+    startHTTPSpan,
+    endHTTPSpan,
+    setErrorInSpan,
+    startSpan,
+    endSpan,
+    startHTTPSpanClient,
+    endHTTPSpanClient,
+    setErrorInSpanClient,
+    shutdown,
+    openTelemetryAPIs
+  } = setupTelemetry(opts, app.log)
 
   app.addHook('onRequest', startHTTPSpan)
-  app.addHook('onSend', injectPropagationHeadersInReply)
   app.addHook('onResponse', endHTTPSpan)
   app.addHook('onError', setErrorInSpan)
-  app.addHook('onClose', async function () {
-    try {
-      await provider.shutdown()
-    } catch (err) {
-      app.log.error({ err }, 'Error shutting down telemetry provider')
-    }
-  })
-
-  //* Client APIs
-  const getSpanPropagationHeaders = (span) => {
-    const context = span.context
-    const headers = {}
-    propagator.inject(context, headers, {
-      set (_carrier, key, value) {
-        headers[key] = value
-      },
-    })
-    return headers
-  }
-
-  // If a context is passed, is used. Otherwise is a new one is created.
-  // Note that in this case we don't set the span in request, as this is a client call.
-  // So the client caller is responible of:
-  // - setting the propagatorHeaders in the client request
-  // - closing the span
-  const startHTTPSpanClient = (url, method, ctx) => {
-    let context = ctx || new PlatformaticContext()
-    const urlObj = fastUri.parse(url)
-
-    if (skipOperations.includes(`${method}${urlObj.path}`)) {
-      app.log.debug(
-        { operation: `${method}${urlObj.path}` },
-        'Skipping telemetry'
-      )
-      return
-    }
-
-    /* istanbul ignore next */
-    method = method || ''
-    let name
-    if (urlObj.port) {
-      name = `${method} ${urlObj.scheme}://${urlObj.host}:${urlObj.port}${urlObj.path}`
-    } else {
-      name = `${method} ${urlObj.scheme}://${urlObj.host}${urlObj.path}`
-    }
-
-    const span = tracer.startSpan(name, {}, context)
-    span.kind = SpanKind.CLIENT
-
-    /* istanbul ignore next */
-    const attributes = url
-      ? {
-          'server.address': urlObj.host,
-          'server.port': urlObj.port,
-          'http.request.method': method,
-          'url.full': url,
-          'url.path': urlObj.path,
-          'url.scheme': urlObj.scheme,
-        }
-      : {}
-    span.setAttributes(attributes)
-
-    // Next 2 lines are needed by W3CTraceContextPropagator
-    context = context.setSpan(span)
-    span.context = context
-
-    const telemetryHeaders = getSpanPropagationHeaders(span)
-    return { span, telemetryHeaders }
-  }
-
-  const endHTTPSpanClient = (span, response) => {
-    /* istanbul ignore next */
-    if (!span) {
-      return
-    }
-    if (response) {
-      const spanStatus = { code: SpanStatusCode.OK }
-      if (response.statusCode >= 400) {
-        spanStatus.code = SpanStatusCode.ERROR
-      }
-      span.setAttributes({
-        'http.response.status_code': response.statusCode,
-      })
-      span.setStatus(spanStatus)
-    } else {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: 'No response received',
-      })
-    }
-    span.end()
-  }
-
-  const setErrorInSpanClient = (span, error) => {
-    /* istanbul ignore next */
-    if (!span) {
-      return
-    }
-    span.setAttributes(formatSpanAttributes.error(error))
-  }
-
-  // In the generic "startSpan" the attributes here are specified by the caller
-  const startSpan = (name, ctx, attributes = {}, kind = SpanKind.INTERNAL) => {
-    const context = ctx || new PlatformaticContext()
-    const span = tracer.startSpan(name, {}, context)
-    span.kind = kind
-    span.setAttributes(attributes)
-    span.context = context
-    return span
-  }
-
-  const endSpan = (span, error) => {
-    /* istanbul ignore next */
-    if (!span) {
-      return
-    }
-    if (error) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error.message,
-      })
-    } else {
-      const spanStatus = { code: SpanStatusCode.OK }
-      span.setStatus(spanStatus)
-    }
-    span.end()
-  }
+  app.addHook('onClose', shutdown)
 
   app.decorate('openTelemetry', {
     ...openTelemetryAPIs,
@@ -274,8 +31,9 @@ async function setupTelemetry (app, opts) {
     setErrorInSpanClient,
     startSpan,
     endSpan,
+    shutdown,
     SpanKind,
   })
 }
 
-module.exports = fp(setupTelemetry)
+module.exports = fp(telemetry)

package/lib/thread-interceptor-hooks.js

@@ -0,0 +1,126 @@
+'use strict'
+
+const { SpanStatusCode, SpanKind } = require('@opentelemetry/api')
+const { formatSpanName, formatSpanAttributes, extractPath } = require('./telemetry-config')
+const api = require('@opentelemetry/api')
+const fastUri = require('fast-uri')
+const packageJson = require('../package.json')
+
+const tracer = api.trace.getTracer(packageJson.name, packageJson.version)
+
+const createTelemetryThreadInterceptorHooks = () => {
+  const onServerRequest = (req, cb) => {
+    const activeContext = api.propagation.extract(api.context.active(), req.headers)
+
+    const path = extractPath(req)
+    const span = tracer.startSpan(formatSpanName(req, path), {
+      attributes: formatSpanAttributes.request(req, path),
+      kind: SpanKind.SERVER
+    }, activeContext)
+    const ctx = api.trace.setSpan(activeContext, span)
+
+    api.context.with(ctx, cb)
+  }
+
+  const onServerResponse = (_req, _res) => {
+    const activeContext = api.context.active()
+    const span = api.trace.getSpan(activeContext)
+    if (span) {
+      span.end()
+    }
+  }
+
+  const onServerError = (_req, _res, error) => {
+    const activeContext = api.context.active()
+    const span = api.trace.getSpan(activeContext)
+    if (span) {
+      span.setAttributes(formatSpanAttributes.error(error))
+    }
+  }
+
+  const onClientRequest = (req, ctx) => {
+    const activeContext = api.context.active()
+
+    const { origin, method = '', path } = req
+    const targetUrl = `${origin}${path}`
+    const urlObj = fastUri.parse(targetUrl)
+
+    let name
+    if (urlObj.port) {
+      name = `${method} ${urlObj.scheme}://${urlObj.host}:${urlObj.port}${urlObj.path}`
+    } else {
+      name = `${method} ${urlObj.scheme}://${urlObj.host}${urlObj.path}`
+    }
+    const span = tracer.startSpan(name, {
+      attributes: {
+        'server.address': urlObj.host,
+        'server.port': urlObj.port,
+        'http.request.method': method,
+        'url.full': targetUrl,
+        'url.path': urlObj.path,
+        'url.scheme': urlObj.scheme,
+      },
+      kind: SpanKind.CLIENT
+    }, activeContext)
+
+    // Headers propagation
+    const headers = {}
+    // This line is important, otherwise it will use the old context
+    const newCtx = api.trace.setSpan(activeContext, span)
+    api.propagation.inject(newCtx, headers, {
+      set (_carrier, key, value) {
+        headers[key] = value
+      },
+    })
+    req.headers = {
+      ...req.headers,
+      ...headers
+    }
+
+    ctx.span = span
+  }
+
+  const onClientResponse = (_req, res, ctx) => {
+    const span = ctx.span ?? null
+    if (!span) {
+      return
+    }
+    if (res) {
+      const spanStatus = { code: SpanStatusCode.OK }
+      if (res.statusCode >= 400) {
+        spanStatus.code = SpanStatusCode.ERROR
+      }
+      span.setAttributes({
+        'http.response.status_code': res.statusCode,
+      })
+      span.setStatus(spanStatus)
+    } else {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: 'No response received',
+      })
+    }
+    span.end()
+  }
+
+  const onClientError = (_req, _res, ctx, error) => {
+    const span = ctx.span ?? null
+    if (!span) {
+      return
+    }
+    span.setAttributes(formatSpanAttributes.error(error))
+  }
+
+  return {
+    onServerRequest,
+    onServerResponse,
+    onServerError,
+    onClientRequest,
+    onClientResponse,
+    onClientError
+  }
+}
+
+module.exports = {
+  createTelemetryThreadInterceptorHooks
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/telemetry",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "OpenTelemetry integration for Platformatic",
   "main": "index.js",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
@@ -19,20 +19,20 @@
   "dependencies": {
     "@fastify/swagger": "^9.0.0",
     "@opentelemetry/api": "^1.8.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.52.0",
+    "@opentelemetry/instrumentation-http": "^0.54.2",
     "@opentelemetry/core": "^1.22.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.54.0",
     "@opentelemetry/exporter-zipkin": "^1.22.0",
     "@opentelemetry/resources": "^1.22.0",
     "@opentelemetry/sdk-node": "^0.54.0",
     "@opentelemetry/sdk-trace-base": "^1.22.0",
-    "@opentelemetry/semantic-conventions": "^1.22.0",
+    "@opentelemetry/semantic-conventions": "^1.27.0",
     "abstract-logging": "^2.0.1",
     "fast-uri": "^2.3.0",
     "fastify-plugin": "^5.0.0"
   },
   "scripts": {
-    "test": "npm run lint && borp",
+    "test": "npm run lint && borp --timeout=60000 --concurrency=1",
     "lint": "eslint"
   }
 }