@platformatic/telemetry 3.0.0-alpha.4 → 3.0.0-alpha.6

package/eslint.config.js

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

package/index.js

@@ -1,11 +1,3 @@
-'use strict'
-
-const telemetry = require('./lib/telemetry')
-const { createTelemetryThreadInterceptorHooks } = require('./lib/thread-interceptor-hooks')
-const schema = require('./lib/schema')
-
-module.exports = {
-  telemetry,
-  createTelemetryThreadInterceptorHooks,
-  schema,
-}
+export * as schema from './lib/schema.js'
+export * as telemetry from './lib/telemetry.js'
+export { createTelemetryThreadInterceptorHooks } from './lib/thread-interceptor-hooks.js'

package/lib/fastify-text-map.js

@@ -1,22 +1,15 @@
-'use strict'
-
-const fastifyTextMapGetter = {
+export const fastifyTextMapGetter = {
   get (request, key) {
     return request.headers[key]
   },
   /* istanbul ignore next */
   keys (request) {
     return Object.keys(request.headers)
-  },
+  }
 }
 
-const fastifyTextMapSetter = {
+export const fastifyTextMapSetter = {
   set (reply, key, value) {
     reply.headers({ [key]: value })
-  },
-}
-
-module.exports = {
-  fastifyTextMapGetter,
-  fastifyTextMapSetter,
+  }
 }

package/lib/file-span-exporter.js

@@ -1,12 +1,10 @@
-'use strict'
-
-const { ExportResultCode, hrTimeToMicroseconds } = require('@opentelemetry/core')
-const { resolve: resolvePath } = require('node:path')
-const { appendFileSync } = require('node:fs')
-const { workerData } = require('node:worker_threads')
+import { ExportResultCode, hrTimeToMicroseconds } from '@opentelemetry/core'
+import { appendFileSync } from 'node:fs'
+import { resolve as resolvePath } from 'node:path'
+import { workerData } from 'node:worker_threads'
 
 // Export spans to a file, mostly for testing purposes.
-class FileSpanExporter {
+export class FileSpanExporter {
   #path
   constructor (opts) {
     this.#path = resolvePath(workerData?.dirname ?? process.cwd(), opts.path ?? 'spans.log')
@@ -51,5 +49,3 @@ class FileSpanExporter {
     }
   }
 }
-
-module.exports = FileSpanExporter

package/lib/import-or-local.js

@@ -1,10 +1,8 @@
-'use strict'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
 
-const { pathToFileURL } = require('node:url')
-const { createRequire } = require('node:module')
-const { join } = require('node:path')
-
-async function importOrLocal ({ projectDir, pkg }) {
+export async function importOrLocal ({ projectDir, pkg }) {
   try {
     return import(pkg)
   } catch (err) {
@@ -14,5 +12,3 @@ async function importOrLocal ({ projectDir, pkg }) {
     return import(pathToFileURL(fileToImport))
   }
 }
-
-module.exports = importOrLocal

package/lib/multispan-processor.js

@@ -1,8 +1,6 @@
-'use strict'
-
 // This implements the SpanProcessor interface:
 // https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-sdk-trace-base/src/SpanProcessor.ts
-class MultiSpanProcessor {
+export class MultiSpanProcessor {
   constructor (_spanProcessors = []) {
     this._spanProcessors = _spanProcessors
   }
@@ -35,5 +33,3 @@ class MultiSpanProcessor {
     return Promise.all(promises)
   }
 }
-
-module.exports = { MultiSpanProcessor }

package/lib/node-telemetry.js

@@ -1,40 +1,37 @@
-'use strict'
-
-const process = require('node:process')
-const { resourceFromAttributes } = require('@opentelemetry/resources')
-const { AsyncLocalStorage } = require('node:async_hooks')
-const opentelemetry = require('@opentelemetry/sdk-node')
-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')
-const { tmpdir } = require('node:os')
-const { abstractLogger } = require('@platformatic/foundation')
-const { statSync, readFileSync } = require('node:fs') // We want to have all this synch
-const util = require('node:util')
-const { getInstrumentations } = require('./pluggable-instrumentations')
-
-const debuglog = util.debuglog('@platformatic/telemetry')
-const {
-  ConsoleSpanExporter,
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'
+import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici'
+import { resourceFromAttributes } from '@opentelemetry/resources'
+import * as opentelemetry from '@opentelemetry/sdk-node'
+import {
   BatchSpanProcessor,
-  SimpleSpanProcessor,
+  ConsoleSpanExporter,
   InMemorySpanExporter,
-} = require('@opentelemetry/sdk-trace-base')
+  SimpleSpanProcessor
+} from '@opentelemetry/sdk-trace-base'
+import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions'
+import { abstractLogger } from '@platformatic/foundation'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { readFileSync, statSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import util from 'node:util'
+import { workerData } from 'node:worker_threads'
+import { FileSpanExporter } from './file-span-exporter.js'
+import { getInstrumentations } from './pluggable-instrumentations.js'
 
-const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
-const {
-  UndiciInstrumentation,
-} = require('@opentelemetry/instrumentation-undici')
+const debuglog = util.debuglog('@platformatic/telemetry')
+const require = createRequire(import.meta.url)
 
 // 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 = async (opts, serviceDir) => {
-  const { serviceName, instrumentations = [] } = opts
-  const additionalInstrumentations = await getInstrumentations(instrumentations, serviceDir)
+const setupNodeHTTPTelemetry = async (opts, applicationDir) => {
+  const { applicationName, instrumentations = [] } = opts
+  const additionalInstrumentations = await getInstrumentations(instrumentations, applicationDir)
 
   let exporter = opts.exporter
   if (!exporter) {
@@ -46,15 +43,13 @@ const setupNodeHTTPTelemetry = async (opts, serviceDir) => {
   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 }
+    const exporterOptions = { ...exporter.options, applicationName }
 
     let exporterObj
     if (exporter.type === 'console') {
       exporterObj = new ConsoleSpanExporter(exporterOptions)
     } else if (exporter.type === 'otlp') {
-      const {
-        OTLPTraceExporter,
-      } = require('@opentelemetry/exporter-trace-otlp-proto')
+      const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-proto')
       exporterObj = new OTLPTraceExporter(exporterOptions)
     } else if (exporter.type === 'zipkin') {
       const { ZipkinExporter } = require('@opentelemetry/exporter-zipkin')
@@ -64,9 +59,7 @@ const setupNodeHTTPTelemetry = async (opts, serviceDir) => {
     } else if (exporter.type === 'file') {
       exporterObj = new FileSpanExporter(exporterOptions)
     } else {
-      abstractLogger.warn(
-        `Unknown exporter type: ${exporter.type}, defaulting to console.`
-      )
+      abstractLogger.warn(`Unknown exporter type: ${exporter.type}, defaulting to console.`)
       exporterObj = new ConsoleSpanExporter(exporterOptions)
     }
 
@@ -89,7 +82,7 @@ const setupNodeHTTPTelemetry = async (opts, serviceDir) => {
     spanProcessors, // https://github.com/open-telemetry/opentelemetry-js/issues/4881#issuecomment-2358059714
     instrumentations: [
       new UndiciInstrumentation({
-        responseHook: (span) => {
+        responseHook: span => {
           const store = clientSpansAls.getStore()
           if (store) {
             store.span = span
@@ -100,19 +93,20 @@ const setupNodeHTTPTelemetry = async (opts, serviceDir) => {
       ...additionalInstrumentations
     ],
     resource: resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: serviceName
+      [ATTR_SERVICE_NAME]: applicationName
     })
   })
   sdk.start()
 
   process.on('SIGTERM', () => {
-    sdk.shutdown()
+    sdk
+      .shutdown()
       .then(() => debuglog('Tracing terminated'))
-      .catch((error) => debuglog('Error terminating tracing', error))
+      .catch(error => debuglog('Error terminating tracing', error))
   })
 }
 
-const main = async () => {
+async function main () {
   let data = null
   const useWorkerData = !!workerData
 
@@ -132,11 +126,11 @@ const main = async () => {
 
   if (data) {
     debuglog('Setting up telemetry %o', data)
-    const serviceDir = data.serviceConfig?.path
-    const telemetryConfig = useWorkerData ? data?.serviceConfig?.telemetry : data?.telemetryConfig
+    const applicationDir = data.applicationConfig?.path
+    const telemetryConfig = useWorkerData ? data?.applicationConfig?.telemetry : data?.telemetryConfig
     if (telemetryConfig) {
       debuglog('telemetryConfig %o', telemetryConfig)
-      setupNodeHTTPTelemetry(telemetryConfig, serviceDir)
+      setupNodeHTTPTelemetry(telemetryConfig, applicationDir)
     }
   }
 }

package/lib/platformatic-context.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const { createContextKey } = require('@opentelemetry/api')
+import { createContextKey } from '@opentelemetry/api'
 
 // Unfortunately, these kesy are not exported by the OpenTelemetry API :()
 // And we HAVE to use these keys because are used by the propagators
@@ -9,13 +7,13 @@ const SPAN_KEY = createContextKey('OpenTelemetry Context Key SPAN')
 // This is basicaklly the same as https://github.com/open-telemetry/opentelemetry-js/blob/main/api/src/context/context.ts#L85
 // (so just a wrapper around a Map)
 // Note that mutating the context is not allowed by the OpenTelemetry spec.
-class PlatformaticContext {
+export class PlatformaticContext {
   _currentContext
 
   constructor (parentContext) {
     this._currentContext = parentContext ? new Map(parentContext) : new Map()
 
-    this.getValue = (key) => this._currentContext.get(key)
+    this.getValue = key => this._currentContext.get(key)
 
     // Must create and return a new context
     this.setValue = (key, value) => {
@@ -26,16 +24,14 @@ class PlatformaticContext {
 
     // Must return a new context
     /* istanbul ignore next */
-    this.deleteValue = (key) => {
+    this.deleteValue = key => {
       const context = new PlatformaticContext(this._currentContext)
       context._currentContext.delete(key)
       return context
     }
 
-    this.setSpan = (span) => {
+    this.setSpan = span => {
       return this.setValue(SPAN_KEY, span)
     }
   }
 }
-
-module.exports = { PlatformaticContext }

package/lib/platformatic-trace-provider.js

@@ -1,13 +1,14 @@
-'use strict'
+import { CompositePropagator, merge, W3CTraceContextPropagator } from '@opentelemetry/core'
+import { emptyResource } from '@opentelemetry/resources'
+import { AlwaysOnSampler } from '@opentelemetry/sdk-trace-base'
+import { createRequire } from 'node:module'
+import { MultiSpanProcessor } from './multispan-processor.js'
 
-const { emptyResource } = require('@opentelemetry/resources')
-const { merge, CompositePropagator, W3CTraceContextPropagator } = require('@opentelemetry/core')
-const { AlwaysOnSampler } = require('@opentelemetry/sdk-trace-base')
+const require = createRequire(import.meta.url)
 // We need to import the Tracer to write our own TracerProvider that does NOT extend the OpenTelemetry one.
 const { Tracer } = require('@opentelemetry/sdk-trace-base/build/src/Tracer')
-const { MultiSpanProcessor } = require('./multispan-processor')
 
-class PlatformaticTracerProvider {
+export class PlatformaticTracerProvider {
   activeSpanProcessor = null
   _registeredSpanProcessors = []
   // This MUST be called `resource`, see: https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-sdk-trace-base/src/Tracer.ts#L57
@@ -18,13 +19,13 @@ class PlatformaticTracerProvider {
     const mergedConfig = merge(
       {},
       {
-        sampler: new AlwaysOnSampler(),
+        sampler: new AlwaysOnSampler()
       },
       config
     )
     this.resource = mergedConfig.resource ?? emptyResource
     this._config = Object.assign({}, mergedConfig, {
-      resource: this.resource,
+      resource: this.resource
     })
   }
 
@@ -39,9 +40,7 @@ class PlatformaticTracerProvider {
     } else {
       this._registeredSpanProcessors.push(spanProcessor)
     }
-    this.activeSpanProcessor = new MultiSpanProcessor(
-      this._registeredSpanProcessors
-    )
+    this.activeSpanProcessor = new MultiSpanProcessor(this._registeredSpanProcessors)
   }
 
   getActiveSpanProcessor () {
@@ -51,8 +50,8 @@ class PlatformaticTracerProvider {
   getPropagator () {
     return new CompositePropagator({
       propagators: [
-        new W3CTraceContextPropagator(), // see: https://www.w3.org/TR/trace-context/
-      ],
+        new W3CTraceContextPropagator() // see: https://www.w3.org/TR/trace-context/
+      ]
     })
   }
 
@@ -65,5 +64,3 @@ class PlatformaticTracerProvider {
     return this.activeSpanProcessor.shutdown()
   }
 }
-
-module.exports = { PlatformaticTracerProvider }

package/lib/pluggable-instrumentations.js

@@ -1,41 +1,42 @@
-'use strict'
-
-const importOrLocal = require('./import-or-local')
+import { importOrLocal } from './import-or-local.js'
 
 // These are already set automatically by the runtime, so we throw
 // if set again.
-const defaultInstrumentations = [
-  '@opentelemetry/instrumentation-http',
-  '@opentelemetry/instrumentation-undici'
-]
+const defaultInstrumentations = ['@opentelemetry/instrumentation-http', '@opentelemetry/instrumentation-undici']
 
-const getInstrumentationInstance = async (instrumentationConfig, serviceDir) => {
+async function getInstrumentationInstance (instrumentationConfig, applicationDir) {
   if (typeof instrumentationConfig === 'string') {
     instrumentationConfig = { package: instrumentationConfig, exportName: 'default', options: {} }
   }
   const { package: packageName, exportName = 'default', options = {} } = instrumentationConfig
 
   if (defaultInstrumentations.includes(packageName)) {
-    throw new Error(`Instrumentation package ${packageName} is already included by default, please remove it from your config.`)
+    throw new Error(
+      `Instrumentation package ${packageName} is already included by default, please remove it from your config.`
+    )
   }
 
   let mod
   try {
-    mod = await importOrLocal({ pkg: packageName, projectDir: serviceDir })
+    mod = await importOrLocal({ pkg: packageName, projectDir: applicationDir })
   } catch (err) {
-    throw new Error(`Instrumentation package not found: ${instrumentationConfig.package}, please add it to your dependencies.`)
+    throw new Error(
+      `Instrumentation package not found: ${instrumentationConfig.package}, please add it to your dependencies.`
+    )
   }
 
   let Instrumenter = mod[exportName]
   if (!Instrumenter || typeof Instrumenter !== 'function') {
     // Check for for an export that ends with 'Instrumentation'. We need to do that because unfortunately
     // each instrumenttions has different named export. But all of them ends with 'Instrumentation'.
-    const possibleExports = Object.keys(mod).filter((key) => key.endsWith('Instrumentation'))
+    const possibleExports = Object.keys(mod).filter(key => key.endsWith('Instrumentation'))
     if (possibleExports.length === 0) {
       throw new Error(`Instrumentation export not found: ${exportName} in ${packageName}. Please specify in config`)
     }
     if (possibleExports.length > 1) {
-      throw new Error(`Multiple Instrumentation exports found: ${possibleExports} in ${packageName}. Please specify in config`)
+      throw new Error(
+        `Multiple Instrumentation exports found: ${possibleExports} in ${packageName}. Please specify in config`
+      )
     }
     Instrumenter = mod[possibleExports[0]]
   }
@@ -51,15 +52,11 @@ const getInstrumentationInstance = async (instrumentationConfig, serviceDir) =>
 //          "exportName": "RedisInstrumentation",
 //          "options": { "foo": "bar" }
 //       }
-const getInstrumentations = async (configs = [], serviceDir) => {
+export async function getInstrumentations (configs = [], applicationDir) {
   const instrumentations = []
   for (const instrumentationConfig of configs) {
-    const instance = await getInstrumentationInstance(instrumentationConfig, serviceDir)
+    const instance = await getInstrumentationInstance(instrumentationConfig, applicationDir)
     instrumentations.push(instance)
   }
   return instrumentations
 }
-
-module.exports = {
-  getInstrumentations,
-}

package/lib/schema.js

@@ -1,4 +1,3 @@
-'use strict'
+import { schemaComponents } from '@platformatic/foundation'
 
-const { schemaComponents } = require('@platformatic/foundation')
-module.exports = schemaComponents.telemetry
+export default schemaComponents.telemetry

package/lib/telemetry-config.js

@@ -1,27 +1,21 @@
-'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,
+import { formatParamUrl } from '@fastify/swagger'
+import { SpanKind, SpanStatusCode } from '@opentelemetry/api'
+import { resourceFromAttributes } from '@opentelemetry/resources'
+import {
   BatchSpanProcessor,
-  SimpleSpanProcessor,
+  ConsoleSpanExporter,
   InMemorySpanExporter,
-} = require('@opentelemetry/sdk-trace-base')
-
-const FileSpanExporter = require('./file-span-exporter')
-
-const { resourceFromAttributes } = require('@opentelemetry/resources')
-const { PlatformaticTracerProvider } = require('./platformatic-trace-provider')
-
-const { name: moduleName, version: moduleVersion } = require('../package.json')
+  SimpleSpanProcessor
+} from '@opentelemetry/sdk-trace-base'
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions'
+import fastUri from 'fast-uri'
+import { createRequire } from 'node:module'
+import { fastifyTextMapGetter, fastifyTextMapSetter } from './fastify-text-map.js'
+import { FileSpanExporter } from './file-span-exporter.js'
+import { PlatformaticContext } from './platformatic-context.js'
+import { PlatformaticTracerProvider } from './platformatic-trace-provider.js'
+
+import { name as moduleName, version as moduleVersion } from './version.js'
 
 // Platformatic telemetry plugin.
 // Supported Exporters:
@@ -30,7 +24,7 @@ const { name: moduleName, version: moduleVersion } = require('../package.json')
 // - zipkin (https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-exporter-zipkin/README.md)
 // - memory: for testing
 
-function formatSpanName (request, route) {
+export function formatSpanName (request, route) {
   if (route) {
     route = formatParamUrl(route)
   }
@@ -39,7 +33,7 @@ function formatSpanName (request, route) {
   return `${method} ${route ?? url}`
 }
 
-const formatSpanAttributes = {
+export const formatSpanAttributes = {
   request (request, route) {
     const { hostname, method, url, protocol = 'http' } = request
     // Inspired by: https://github.com/fastify/fastify-url-data/blob/master/plugin.js#L11
@@ -52,7 +46,7 @@ const formatSpanAttributes = {
       'http.request.method': method,
       'url.full': fullUrl,
       'url.path': urlData.path,
-      'url.scheme': protocol,
+      'url.scheme': protocol
     }
 
     if (route) {
@@ -71,20 +65,20 @@ const formatSpanAttributes = {
   },
   reply (reply) {
     return {
-      'http.response.status_code': reply.statusCode,
+      'http.response.status_code': reply.statusCode
     }
   },
   error (error) {
     return {
       'error.name': error.name,
       'error.message': error.message,
-      'error.stack': error.stack,
+      'error.stack': error.stack
     }
-  },
+  }
 }
 
 const initTelemetry = (opts, logger) => {
-  const { serviceName, version } = opts
+  const { applicationName, version } = opts
   let exporter = opts.exporter
   if (!exporter) {
     logger.warn('No exporter configured, defaulting to console.')
@@ -94,31 +88,30 @@ const initTelemetry = (opts, logger) => {
   const exporters = Array.isArray(exporter) ? exporter : [exporter]
 
   logger.debug(
-    `Setting up platformatic telemetry for service: ${serviceName}${version ? ' version: ' + version : ''} with exporter of type ${exporter.type}`
+    `Setting up platformatic telemetry for application: ${applicationName}${version ? ' version: ' + version : ''} with exporter of type ${exporter.type}`
   )
 
   const provider = new PlatformaticTracerProvider({
     resource: resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: serviceName,
-      [ATTR_SERVICE_VERSION]: version,
-    }),
+      [ATTR_SERVICE_NAME]: applicationName,
+      [ATTR_SERVICE_VERSION]: version
+    })
   })
 
   const exporterObjs = []
   const spanProcessors = []
+  const require = createRequire(import.meta.url)
   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 }
+    const exporterOptions = { ...exporter.options, applicationName }
 
     let exporterObj
     if (exporter.type === 'console') {
       exporterObj = new ConsoleSpanExporter(exporterOptions)
     } else if (exporter.type === 'otlp') {
       // We require here because this require (and only the require!) creates some issue with c8 on some mjs tests on other modules. Since we need an assignemet here, we don't use a switch.
-      const {
-        OTLPTraceExporter,
-      } = require('@opentelemetry/exporter-trace-otlp-proto')
+      const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-proto')
       exporterObj = new OTLPTraceExporter(exporterOptions)
     } else if (exporter.type === 'zipkin') {
       const { ZipkinExporter } = require('@opentelemetry/exporter-zipkin')
@@ -128,9 +121,7 @@ const initTelemetry = (opts, logger) => {
     } else if (exporter.type === 'file') {
       exporterObj = new FileSpanExporter(exporterOptions)
     } else {
-      logger.warn(
-        `Unknown exporter type: ${exporter.type}, defaulting to console.`
-      )
+      logger.warn(`Unknown exporter type: ${exporter.type}, defaulting to console.`)
       exporterObj = new ConsoleSpanExporter(exporterOptions)
     }
 
@@ -153,30 +144,23 @@ const initTelemetry = (opts, logger) => {
   return { tracer, exporters: exporterObjs, propagator, provider, spanProcessors }
 }
 
-function setupTelemetry (opts, logger) {
+export function setupTelemetry (opts, logger) {
   const openTelemetryAPIs = initTelemetry(opts, logger)
   const { tracer, propagator, provider } = openTelemetryAPIs
   const skipOperations =
-    opts?.skip?.map((skip) => {
+    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'
-      )
+      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
-    )
+    let context = propagator.extract(new PlatformaticContext(), request, fastifyTextMapGetter)
 
     const route = request.routeOptions?.url ?? null
     const span = tracer.startSpan(formatSpanName(request, route), {}, context)
@@ -210,13 +194,13 @@ function setupTelemetry (opts, logger) {
   }
 
   //* Client APIs
-  const getSpanPropagationHeaders = (span) => {
+  const getSpanPropagationHeaders = span => {
     const context = span.context
     const headers = {}
     propagator.inject(context, headers, {
       set (_carrier, key, value) {
         headers[key] = value
-      },
+      }
     })
     return headers
   }
@@ -231,10 +215,7 @@ function setupTelemetry (opts, logger) {
     const urlObj = fastUri.parse(url)
 
     if (skipOperations.includes(`${method}${urlObj.path}`)) {
-      logger.debug(
-        { operation: `${method}${urlObj.path}` },
-        'Skipping telemetry'
-      )
+      logger.debug({ operation: `${method}${urlObj.path}` }, 'Skipping telemetry')
       return
     }
 
@@ -258,7 +239,7 @@ function setupTelemetry (opts, logger) {
           'http.request.method': method,
           'url.full': url,
           'url.path': urlObj.path,
-          'url.scheme': urlObj.scheme,
+          'url.scheme': urlObj.scheme
         }
       : {}
     span.setAttributes(attributes)
@@ -282,7 +263,7 @@ function setupTelemetry (opts, logger) {
         spanStatus.code = SpanStatusCode.ERROR
       }
       span.setAttributes({
-        'http.response.status_code': response.statusCode,
+        'http.response.status_code': response.statusCode
       })
 
       const httpCacheId = response.headers?.['x-plt-http-cache-id']
@@ -298,7 +279,7 @@ function setupTelemetry (opts, logger) {
     } else {
       span.setStatus({
         code: SpanStatusCode.ERROR,
-        message: 'No response received',
+        message: 'No response received'
       })
     }
     span.end()
@@ -330,7 +311,7 @@ function setupTelemetry (opts, logger) {
     if (error) {
       span.setStatus({
         code: SpanStatusCode.ERROR,
-        message: error.message,
+        message: error.message
       })
     } else {
       const spanStatus = { code: SpanStatusCode.OK }
@@ -358,12 +339,6 @@ function setupTelemetry (opts, logger) {
     startSpan,
     endSpan,
     shutdown,
-    openTelemetryAPIs,
+    openTelemetryAPIs
   }
 }
-
-module.exports = {
-  setupTelemetry,
-  formatSpanName,
-  formatSpanAttributes
-}

package/lib/telemetry.js

@@ -1,8 +1,6 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-const { SpanKind } = require('@opentelemetry/api')
-const { setupTelemetry } = require('./telemetry-config')
+import { SpanKind } from '@opentelemetry/api'
+import fp from 'fastify-plugin'
+import { setupTelemetry } from './telemetry-config.js'
 
 // Telemetry fastify plugin
 async function telemetry (app, opts) {
@@ -36,8 +34,8 @@ async function telemetry (app, opts) {
     startSpan,
     endSpan,
     shutdown,
-    SpanKind,
+    SpanKind
   })
 }
 
-module.exports = fp(telemetry)
+export default fp(telemetry)

package/lib/thread-interceptor-hooks.js

@@ -1,45 +1,46 @@
-'use strict'
+import { context, propagation, SpanKind, SpanStatusCode, trace } from '@opentelemetry/api'
+import fastUri from 'fast-uri'
+import { formatSpanAttributes, formatSpanName } from './telemetry-config.js'
+import { name as moduleName, version as moduleVersion } from './version.js'
 
-const { SpanStatusCode, SpanKind } = require('@opentelemetry/api')
-const { formatSpanName, formatSpanAttributes } = require('./telemetry-config')
-const api = require('@opentelemetry/api')
-const fastUri = require('fast-uri')
-const packageJson = require('../package.json')
+const tracer = trace.getTracer(moduleName, moduleVersion)
 
-const tracer = api.trace.getTracer(packageJson.name, packageJson.version)
-
-const createTelemetryThreadInterceptorHooks = () => {
+export function createTelemetryThreadInterceptorHooks () {
   const onServerRequest = (req, cb) => {
-    const activeContext = api.propagation.extract(api.context.active(), req.headers)
+    const activeContext = propagation.extract(context.active(), req.headers)
 
     const route = req.routeOptions?.url ?? null
-    const span = tracer.startSpan(formatSpanName(req, route), {
-      attributes: formatSpanAttributes.request(req, route),
-      kind: SpanKind.SERVER
-    }, activeContext)
-    const ctx = api.trace.setSpan(activeContext, span)
+    const span = tracer.startSpan(
+      formatSpanName(req, route),
+      {
+        attributes: formatSpanAttributes.request(req, route),
+        kind: SpanKind.SERVER
+      },
+      activeContext
+    )
+    const ctx = trace.setSpan(activeContext, span)
 
-    api.context.with(ctx, cb)
+    context.with(ctx, cb)
   }
 
   const onServerResponse = (_req, _res) => {
-    const activeContext = api.context.active()
-    const span = api.trace.getSpan(activeContext)
+    const activeContext = context.active()
+    const span = trace.getSpan(activeContext)
     if (span) {
       span.end()
     }
   }
 
   const onServerError = (_req, _res, error) => {
-    const activeContext = api.context.active()
-    const span = api.trace.getSpan(activeContext)
+    const activeContext = context.active()
+    const span = trace.getSpan(activeContext)
     if (span) {
       span.setAttributes(formatSpanAttributes.error(error))
     }
   }
 
   const onClientRequest = (req, ctx) => {
-    const activeContext = api.context.active()
+    const activeContext = context.active()
 
     const { origin, method = '', path } = req
     const targetUrl = `${origin}${path}`
@@ -51,26 +52,30 @@ const createTelemetryThreadInterceptorHooks = () => {
     } 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,
+    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
       },
-      kind: SpanKind.CLIENT
-    }, activeContext)
+      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, {
+    const newCtx = trace.setSpan(activeContext, span)
+    propagation.inject(newCtx, headers, {
       set (_carrier, key, value) {
         headers[key] = value
-      },
+      }
     })
     req.headers = {
       ...req.headers,
@@ -91,7 +96,7 @@ const createTelemetryThreadInterceptorHooks = () => {
         spanStatus.code = SpanStatusCode.ERROR
       }
       span.setAttributes({
-        'http.response.status_code': res.statusCode,
+        'http.response.status_code': res.statusCode
       })
 
       const httpCacheId = res.headers?.['x-plt-http-cache-id']
@@ -107,7 +112,7 @@ const createTelemetryThreadInterceptorHooks = () => {
     } else {
       span.setStatus({
         code: SpanStatusCode.ERROR,
-        message: 'No response received',
+        message: 'No response received'
       })
     }
     span.end()
@@ -130,7 +135,3 @@ const createTelemetryThreadInterceptorHooks = () => {
     onClientError
   }
 }
-
-module.exports = {
-  createTelemetryThreadInterceptorHooks
-}

package/lib/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf-8'))
+
+export const name = packageJson.name
+export const version = packageJson.version

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@platformatic/telemetry",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.6",
   "description": "OpenTelemetry integration for Platformatic",
   "main": "index.js",
+  "type": "module",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "repository": {
     "type": "git",
@@ -13,7 +14,7 @@
     "@databases/pg": "^5.5.0",
     "@opentelemetry/instrumentation-express": "^0.52.0",
     "@opentelemetry/instrumentation-pg": "^0.55.0",
-    "borp": "^0.20.1",
+    "cleaner-spec-reporter": "^0.5.0",
     "express": "^5.1.0",
     "fastify": "^5.4.0",
     "neostandard": "^0.12.2",
@@ -35,13 +36,13 @@
     "@opentelemetry/semantic-conventions": "1.36.0",
     "fast-uri": "^3.0.6",
     "fastify-plugin": "^5.0.1",
-    "@platformatic/foundation": "3.0.0-alpha.4"
+    "@platformatic/foundation": "3.0.0-alpha.6"
   },
   "engines": {
     "node": ">=22.18.0"
   },
   "scripts": {
-    "test": "npm run lint && borp --timeout=120000 --concurrency=1",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "lint": "eslint"
   }
 }