@platformatic/telemetry 0.34.1 → 0.35.0

package/lib/schema.js

@@ -12,6 +12,13 @@ const TelemetrySchema = {
       type: 'string',
       description: 'The version of the service (optional)'
     },
+    skip: {
+      type: 'array',
+      description: 'An array of paths to skip when creating spans. Useful for health checks and other endpoints that do not need to be traced.',
+      items: {
+        type: 'string'
+      }
+    },
     exporter: {
       type: 'object',
       properties: {

package/lib/telemetry.js

@@ -33,15 +33,16 @@ function formatSpanName (request) {
   return routerPath ? `${method} ${routerPath}` : method
 }
 
-const defaultFormatSpanAttributes = {
+const formatSpanAttributes = {
   request (request) {
     const { hostname, method, url, protocol } = request
-    const urlData = fastUri.parse(`${protocol}://${hostname})`)
+    // 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': url,
+      'url.path': urlData.path,
       'url.scheme': protocol
     }
   },
@@ -107,16 +108,17 @@ async function setupTelemetry (app, opts) {
   // const { serviceName, version } = opts
   const openTelemetryAPIs = setupProvider(app, opts)
   const { tracer, propagator, provider } = openTelemetryAPIs
-
-  const formatSpanAttributes = {
-    ...defaultFormatSpanAttributes,
-    ...(opts.formatSpanAttributes || {})
-  }
+  const skipOperations = opts.skip || []
 
   // expose the span as a request decorator
   app.decorateRequest('span')
 
   const startSpan = 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)
 
@@ -139,19 +141,23 @@ async function setupTelemetry (app, opts) {
   }
 
   const injectPropagationHeadersInReply = async (request, reply) => {
-    const context = request.span.context
-    propagator.inject(context, reply, fastifyTextMapSetter)
+    if (request.span) {
+      const context = request.span.context
+      propagator.inject(context, reply, fastifyTextMapSetter)
+    }
   }
 
   const endSpan = async (request, reply) => {
     const span = request.span
-    const spanStatus = { code: SpanStatusCode.OK }
-    if (reply.statusCode >= 400) {
-      spanStatus.code = SpanStatusCode.ERROR
+    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()
     }
-    span.setAttributes(formatSpanAttributes.reply(reply))
-    span.setStatus(spanStatus)
-    span.end()
   }
 
   app.addHook('onRequest', startSpan)
@@ -181,12 +187,20 @@ async function setupTelemetry (app, opts) {
   // - closing the span
   const startSpanClient = (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 || ''
-    const span = tracer.startSpan(`${method} ${url}`, {}, context)
+    const name = `${method} ${urlObj.scheme}://${urlObj.host}:${urlObj.port}${urlObj.path}`
+
+    const span = tracer.startSpan(name, {}, context)
     span.kind = SpanKind.CLIENT
 
-    const urlObj = fastUri.parse(url)
     /* istanbul ignore next */
     const attributes = url
       ? {

package/package.json

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

package/test/client.test.js

@@ -230,3 +230,43 @@ test('should trace a client request failing (no HTTP error)', async ({ equal, sa
   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: ['POST/skipme'],
+    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/telemetry.test.js

@@ -59,6 +59,45 @@ test('should trace a request not failing', async ({ equal, same, teardown }) =>
   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 { exporter } = app.openTelemetry
+  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')
@@ -209,3 +248,33 @@ test('wrong exporter is configured, should default to console', async ({ equal,
   const { exporter } = app.openTelemetry
   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: [
+      'GET/documentation/json'
+    ],
+    exporter: {
+      type: 'memory'
+    }
+  }, handler, teardown)
+
+  const injectArgs = {
+    method: 'GET',
+    url: '/documentation/json',
+    headers: {
+      host: 'test'
+    }
+  }
+
+  await app.inject(injectArgs)
+  const { exporter } = app.openTelemetry
+  const finishedSpans = exporter.getFinishedSpans()
+  equal(finishedSpans.length, 0)
+})