@platformatic/telemetry 2.35.1 → 2.36.2

package/lib/file-span-exporter.js

@@ -48,6 +48,7 @@ class FileSpanExporter {
       events: span.events,
       links: span.links,
       resource: span.resource,
+      instrumentationLibrary: span.instrumentationLibrary,
     }
   }
 }

package/lib/import-or-local.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { pathToFileURL } = require('node:url')
+const { createRequire } = require('node:module')
+const { join } = require('node:path')
+
+async function importOrLocal ({ projectDir, pkg }) {
+  try {
+    return import(pkg)
+  } catch (err) {
+    const pkgJsonPath = join(projectDir, 'package.json')
+    const _require = createRequire(pkgJsonPath)
+    const fileToImport = _require.resolve(pkg)
+    return import(pathToFileURL(fileToImport))
+  }
+}
+
+module.exports = importOrLocal

package/lib/node-telemetry.js

@@ -12,6 +12,8 @@ const { tmpdir } = require('node:os')
 const logger = require('abstract-logging')
 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,
@@ -31,8 +33,9 @@ const {
 // https://github.com/open-telemetry/opentelemetry-js/issues/5103
 process.env.OTEL_SEMCONV_STABILITY_OPT_IN = 'http/dup'
 
-const setupNodeHTTPTelemetry = (opts) => {
-  const { serviceName } = opts
+const setupNodeHTTPTelemetry = async (opts, serviceDir) => {
+  const { serviceName, instrumentations = [] } = opts
+  const additionalInstrumentations = await getInstrumentations(instrumentations, serviceDir)
 
   let exporter = opts.exporter
   if (!exporter) {
@@ -96,6 +99,7 @@ const setupNodeHTTPTelemetry = (opts) => {
       }),
       new HttpInstrumentation(),
       new PgInstrumentation(),
+      ...additionalInstrumentations
     ],
     resource: new Resource({
       [ATTR_SERVICE_NAME]: serviceName
@@ -110,28 +114,37 @@ const setupNodeHTTPTelemetry = (opts) => {
   })
 }
 
-let data = null
-const useWorkerData = !!workerData
+const main = async () => {
+  let data = null
+  const useWorkerData = !!workerData
 
-if (useWorkerData) {
-  data = workerData
-} else if (process.env.PLT_MANAGER_ID) {
-  try {
-    const dataPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${process.env.PLT_MANAGER_ID}.json`)
-    statSync(dataPath)
-    const jsonData = JSON.parse(readFileSync(dataPath, 'utf8'))
-    data = jsonData.data
-    debuglog(`Loaded data from ${dataPath}`)
-  } catch (e) {
-    debuglog('Error reading data from file %o', e)
+  if (useWorkerData) {
+    data = workerData
+  } else if (process.env.PLT_MANAGER_ID) {
+    try {
+      const dataPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${process.env.PLT_MANAGER_ID}.json`)
+      statSync(dataPath)
+      const jsonData = JSON.parse(readFileSync(dataPath, 'utf8'))
+      data = jsonData.data
+      debuglog(`Loaded data from ${dataPath}`)
+    } catch (e) {
+      debuglog('Error reading data from file %o', e)
+    }
   }
-}
 
-if (data) {
-  debuglog('Setting up telemetry %o', data)
-  const telemetryConfig = useWorkerData ? data?.serviceConfig?.telemetry : data?.telemetryConfig
-  if (telemetryConfig) {
-    debuglog('telemetryConfig %o', telemetryConfig)
-    setupNodeHTTPTelemetry(telemetryConfig)
+  if (data) {
+    debuglog('Setting up telemetry %o', data)
+    const serviceDir = data.serviceConfig?.path
+    const telemetryConfig = useWorkerData ? data?.serviceConfig?.telemetry : data?.telemetryConfig
+    if (telemetryConfig) {
+      debuglog('telemetryConfig %o', telemetryConfig)
+      setupNodeHTTPTelemetry(telemetryConfig, serviceDir)
+    }
   }
 }
+
+try {
+  main()
+} catch (e) {
+  debuglog('Error in main %o', e)
+}

package/lib/pluggable-instrumentations.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const importOrLocal = require('./import-or-local')
+
+// These are already set automatically by the runtime, so we throw
+// if set again.
+const defaultInstrumentations = [
+  '@opentelemetry/instrumentation-pg',
+  '@opentelemetry/instrumentation-http',
+  '@opentelemetry/instrumentation-undici'
+]
+
+const getInstrumentationInstance = async (instrumentationConfig, serviceDir) => {
+  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.`)
+  }
+
+  let mod
+  try {
+    mod = await importOrLocal({ pkg: packageName, projectDir: serviceDir })
+  } catch (err) {
+    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'))
+    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`)
+    }
+    Instrumenter = mod[possibleExports[0]]
+  }
+  const instance = new Instrumenter(options)
+  return instance
+}
+
+// Example of instrumentations config:
+// "instrumentations": [
+//       "@opentelemetry/instrumentation-express",
+//       {
+//          "package": "@opentelemetry/instrumentation-redisjs",
+//          "exportName": "RedisInstrumentation",
+//          "options": { "foo": "bar" }
+//       }
+const getInstrumentations = async (configs = [], serviceDir) => {
+  const instrumentations = []
+  for (const instrumentationConfig of configs) {
+    const instance = await getInstrumentationInstance(instrumentationConfig, serviceDir)
+    instrumentations.push(instance)
+  }
+  return instrumentations
+}
+
+module.exports = {
+  getInstrumentations,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/telemetry",
-  "version": "2.35.1",
+  "version": "2.36.2",
   "description": "OpenTelemetry integration for Platformatic",
   "main": "index.js",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
@@ -10,6 +10,8 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
+    "@databases/pg": "^5.5.0",
+    "@opentelemetry/instrumentation-express": "^0.47.0",
     "borp": "^0.19.0",
     "express": "^4.19.2",
     "fastify": "^5.0.0",
@@ -21,21 +23,23 @@
     "@fastify/swagger": "^9.0.0",
     "@opentelemetry/api": "^1.8.0",
     "@opentelemetry/core": "^1.22.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.56.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.57.0",
     "@opentelemetry/exporter-zipkin": "^1.22.0",
+    "@opentelemetry/instrumentation": "^0.57.0",
     "@opentelemetry/instrumentation-http": "^0.56.0",
     "@opentelemetry/instrumentation-pg": "^0.50.0",
     "@opentelemetry/instrumentation-undici": "^0.10.0",
     "@opentelemetry/resources": "^1.22.0",
-    "@opentelemetry/sdk-node": "^0.56.0",
+    "@opentelemetry/sdk-node": "^0.57.0",
     "@opentelemetry/sdk-trace-base": "^1.22.0",
     "@opentelemetry/semantic-conventions": "^1.27.0",
     "abstract-logging": "^2.0.1",
     "fast-uri": "^3.0.0",
-    "fastify-plugin": "^5.0.0"
+    "fastify-plugin": "^5.0.0",
+    "@platformatic/config": "2.36.2"
   },
   "scripts": {
-    "test": "npm run lint && borp --timeout=60000 --concurrency=1",
+    "test": "npm run lint && borp --timeout=120000 --concurrency=1",
     "lint": "eslint"
   }
 }