@platformatic/telemetry 3.4.1 → 3.5.0

package/lib/thread-interceptor-hooks.js

@@ -0,0 +1,137 @@
+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 tracer = trace.getTracer(moduleName, moduleVersion)
+
+export function createTelemetryThreadInterceptorHooks () {
+  const onServerRequest = (req, cb) => {
+    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 = trace.setSpan(activeContext, span)
+
+    context.with(ctx, cb)
+  }
+
+  const onServerResponse = (_req, _res) => {
+    const activeContext = context.active()
+    const span = trace.getSpan(activeContext)
+    if (span) {
+      span.end()
+    }
+  }
+
+  const onServerError = (_req, _res, error) => {
+    const activeContext = context.active()
+    const span = trace.getSpan(activeContext)
+    if (span) {
+      span.setAttributes(formatSpanAttributes.error(error))
+    }
+  }
+
+  const onClientRequest = (req, ctx) => {
+    const activeContext = 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 = trace.setSpan(activeContext, span)
+    propagation.inject(newCtx, headers, {
+      set (_carrier, key, value) {
+        headers[key] = value
+      }
+    })
+    req.headers = {
+      ...req.headers,
+      ...headers
+    }
+
+    ctx.span = span
+  }
+
+  const onClientResponseEnd = (_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
+      })
+
+      const httpCacheId = res.headers?.['x-plt-http-cache-id']
+      const isCacheHit = res.headers?.age !== undefined
+      if (httpCacheId) {
+        span.setAttributes({
+          'http.cache.id': httpCacheId,
+          'http.cache.hit': isCacheHit.toString()
+        })
+      }
+
+      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,
+    onClientResponseEnd,
+    onClientError
+  }
+}

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,37 +1,48 @@
 {
   "name": "@platformatic/telemetry",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "OpenTelemetry integration for Platformatic",
   "main": "index.js",
-  "author": "Marco Piraccini <marco.piraccini@gmail.com>",
+  "type": "module",
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "borp": "^0.17.0",
-    "fastify": "^5.0.0",
-    "express": "^4.19.2",
-    "neostandard": "^0.11.1",
-    "typescript": "^5.5.4"
+    "@databases/pg": "^5.5.0",
+    "@opentelemetry/instrumentation-express": "^0.52.0",
+    "@opentelemetry/instrumentation-pg": "^0.55.0",
+    "cleaner-spec-reporter": "^0.5.0",
+    "express": "^5.1.0",
+    "fastify": "^5.4.0",
+    "neostandard": "^0.12.2",
+    "protobufjs": "^7.5.3",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@fastify/swagger": "^9.0.0",
-    "@opentelemetry/api": "^1.8.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.50.0",
-    "@opentelemetry/core": "^1.22.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.53.0",
-    "@opentelemetry/exporter-zipkin": "^1.22.0",
-    "@opentelemetry/resources": "^1.22.0",
-    "@opentelemetry/sdk-node": "^0.53.0",
-    "@opentelemetry/sdk-trace-base": "^1.22.0",
-    "@opentelemetry/semantic-conventions": "^1.22.0",
-    "fast-uri": "^2.3.0",
-    "fastify-plugin": "^5.0.0"
+    "@fastify/swagger": "^9.5.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.0.1",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.203.0",
+    "@opentelemetry/exporter-zipkin": "^2.0.1",
+    "@opentelemetry/instrumentation": "^0.203.0",
+    "@opentelemetry/instrumentation-http": "^0.203.0",
+    "@opentelemetry/instrumentation-undici": "^0.14.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.1",
+    "@opentelemetry/semantic-conventions": "1.36.0",
+    "fast-uri": "^3.0.6",
+    "fastify-plugin": "^5.0.1",
+    "@platformatic/foundation": "3.5.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "test": "npm run lint && borp",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "lint": "eslint"
   }
 }

package/lib/node-http-telemetry.js

@@ -1,33 +0,0 @@
-'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 { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions')
-const setupTelemetry = require('./telemetry-config')
-
-const setupNodeHTTPTelemetry = (opts, logger) => {
-  const { serviceName } = opts
-  logger.info(`Setting up Node.js HTTP telemetry for service: ${serviceName}`)
-  // We setup the telemetry to init the spanProcessors, then we pass them to the SDK
-  const { spanProcessors } = setupTelemetry(opts, logger)
-  const sdk = new opentelemetry.NodeSDK({
-    spanProcessors, // https://github.com/open-telemetry/opentelemetry-js/issues/4881#issuecomment-2358059714
-    instrumentations: [
-      new HttpInstrumentation(),
-    ],
-    resource: new Resource({
-      [SemanticResourceAttributes.SERVICE_NAME]: serviceName
-    })
-  })
-  sdk.start()
-
-  // gracefully shut down the SDK on process exit
-  process.on('SIGTERM', () => {
-    sdk.shutdown()
-      .then(() => console.log('Tracing terminated'))
-      .catch((error) => console.log('Error terminating tracing', error))
-  })
-}
-
-module.exports = setupNodeHTTPTelemetry