dd-trace 5.65.0 → 5.67.0

package/packages/dd-trace/src/guardrails/telemetry.js

@@ -47,7 +47,7 @@ function shouldSend (point) {
   return true
 }
 
-function sendTelemetry (name, tags) {
+function sendTelemetry (name, tags, resultMetadata) {
   var points = name
   if (typeof name === 'string') {
     points = [{ name: name, tags: tags || [] }]
@@ -62,32 +62,31 @@ function sendTelemetry (name, tags) {
   if (points.length === 0) {
     return
   }
+
+  // Update metadata with provided result metadata
+  var currentMetadata = {}
+  for (var key in metadata) {
+    currentMetadata[key] = metadata[key]
+  }
+  if (resultMetadata) {
+    for (var resultKey in resultMetadata) {
+      currentMetadata[resultKey] = resultMetadata[resultKey]
+    }
+  }
+
   var proc = spawn(process.env.DD_TELEMETRY_FORWARDER_PATH, ['library_entrypoint'], {
     stdio: 'pipe'
   })
   proc.on('error', function () {
     log.error('Failed to spawn telemetry forwarder')
-    metadata.result = 'error'
-    metadata.result_class = 'internal_error'
-    metadata.result_reason = 'Failed to spawn telemetry forwarder'
   })
   proc.on('exit', function (code) {
-    if (code === 0) {
-      metadata.result = 'success'
-      metadata.result_class = 'success'
-      metadata.result_reason = 'Successfully configured ddtrace package'
-    } else {
+    if (code !== 0) {
       log.error('Telemetry forwarder exited with code', code)
-      metadata.result = 'error'
-      metadata.result_class = 'internal_error'
-      metadata.result_reason = 'Telemetry forwarder exited with code ' + code
     }
   })
   proc.stdin.on('error', function () {
     log.error('Failed to write telemetry data to telemetry forwarder')
-    metadata.result = 'error'
-    metadata.result_class = 'internal_error'
-    metadata.result_reason = 'Failed to write telemetry data to telemetry forwarder'
   })
-  proc.stdin.end(JSON.stringify({ metadata: metadata, points: points }))
+  proc.stdin.end(JSON.stringify({ metadata: currentMetadata, points: points }))
 }

package/packages/dd-trace/src/llmobs/index.js

@@ -16,6 +16,7 @@ const spanProcessCh = channel('dd-trace:span:process')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
 const flushCh = channel('llmobs:writers:flush')
 const injectCh = channel('dd-trace:span:inject')
+const registerUserSpanProcessorCh = channel('llmobs:register-processor')
 
 const LLMObsEvalMetricsWriter = require('./writers/evaluations')
 const LLMObsTagger = require('./tagger')
@@ -56,6 +57,7 @@ function enable (config) {
 
   evalMetricAppendCh.subscribe(handleEvalMetricAppend)
   flushCh.subscribe(handleFlush)
+  registerUserSpanProcessorCh.subscribe(handleRegisterProcessor)
 
   // span processing
   spanProcessor = new LLMObsSpanProcessor(config)
@@ -86,6 +88,7 @@ function disable () {
   if (flushCh.hasSubscribers) flushCh.unsubscribe(handleFlush)
   if (spanProcessCh.hasSubscribers) spanProcessCh.unsubscribe(handleSpanProcess)
   if (injectCh.hasSubscribers) injectCh.unsubscribe(handleLLMObsParentIdInjection)
+  if (registerUserSpanProcessorCh.hasSubscribers) registerUserSpanProcessorCh.unsubscribe(handleRegisterProcessor)
 
   spanWriter?.destroy()
   evalWriter?.destroy()
@@ -126,6 +129,10 @@ function handleFlush () {
   telemetry.recordUserFlush(err)
 }
 
+function handleRegisterProcessor (userSpanProcessor) {
+  spanProcessor.setUserSpanProcessor(userSpanProcessor)
+}
+
 function handleSpanProcess (data) {
   spanProcessor.process(data)
 }

package/packages/dd-trace/src/llmobs/sdk.js

@@ -23,9 +23,16 @@ const LLMObsTagger = require('./tagger')
 const { channel } = require('dc-polyfill')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
 const flushCh = channel('llmobs:writers:flush')
+const registerUserSpanProcessorCh = channel('llmobs:register-processor')
 const NoopLLMObs = require('./noop')
 
 class LLMObs extends NoopLLMObs {
+  /**
+   * flag representing if a user span processor has been registered
+   * @type {boolean}
+   */
+  #hasUserSpanProcessor = false
+
   constructor (tracer, llmobsModule, config) {
     super(tracer)
 
@@ -309,6 +316,27 @@ class LLMObs extends NoopLLMObs {
     }
   }
 
+  registerProcessor (processor) {
+    if (!this.enabled) return
+
+    if (this.#hasUserSpanProcessor) {
+      throw new Error(
+        '[LLMObs] Only one user span processor can be registered. ' +
+        'To register a new processor, deregister the existing processor first using `llmobs.deregisterProcessor()`.'
+      )
+    }
+
+    this.#hasUserSpanProcessor = true
+    registerUserSpanProcessorCh.publish(processor)
+  }
+
+  deregisterProcessor () {
+    if (!this.enabled) return
+
+    this.#hasUserSpanProcessor = false
+    registerUserSpanProcessorCh.publish(null)
+  }
+
   submitEvaluation (llmobsSpanContext, options = {}) {
     if (!this.enabled) return
 

package/packages/dd-trace/src/llmobs/span_processor.js

@@ -34,25 +34,55 @@ const LLMObsTagger = require('./tagger')
 const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 
+const util = require('node:util')
+
+class LLMObservabilitySpan {
+  constructor () {
+    this.input = []
+    this.output = []
+
+    this._tags = {}
+  }
+
+  getTag (key) {
+    return this._tags[key]
+  }
+}
+
 class LLMObsSpanProcessor {
+  /** @type {import('../config')} */
+  #config
+
+  /** @type {((span: LLMObservabilitySpan) => LLMObservabilitySpan | null) | null} */
+  #userSpanProcessor
+
+  /** @type {import('./writers/spans')} */
+  #writer
+
   constructor (config) {
-    this._config = config
+    this.#config = config
+  }
+
+  setUserSpanProcessor (userSpanProcessor) {
+    this.#userSpanProcessor = userSpanProcessor
   }
 
   setWriter (writer) {
-    this._writer = writer
+    this.#writer = writer
   }
 
   // TODO: instead of relying on the tagger's weakmap registry, can we use some namespaced storage correlation?
   process ({ span }) {
-    if (!this._config.llmobs.enabled) return
+    if (!this.#config.llmobs.enabled) return
     // if the span is not in our private tagger map, it is not an llmobs span
     if (!LLMObsTagger.tagMap.has(span)) return
 
     try {
       const formattedEvent = this.format(span)
       telemetry.incrementLLMObsSpanFinishedCount(span)
-      this._writer.append(formattedEvent)
+      if (formattedEvent == null) return
+
+      this.#writer.append(formattedEvent)
     } catch (e) {
       // this should be a rare case
       // we protect against unserializable properties in the format function, and in
@@ -65,6 +95,9 @@ class LLMObsSpanProcessor {
   }
 
   format (span) {
+    const llmObsSpan = new LLMObservabilitySpan()
+    let inputType, outputType
+
     const spanTags = span.context()._tags
     const mlObsTags = LLMObsTagger.tagMap.get(span)
 
@@ -78,26 +111,29 @@ class LLMObsSpanProcessor {
       meta.model_name = mlObsTags[MODEL_NAME] || 'custom'
       meta.model_provider = (mlObsTags[MODEL_PROVIDER] || 'custom').toLowerCase()
     }
+
     if (mlObsTags[METADATA]) {
-      this._addObject(mlObsTags[METADATA], meta.metadata = {})
+      this.#addObject(mlObsTags[METADATA], meta.metadata = {})
     }
+
     if (spanKind === 'llm' && mlObsTags[INPUT_MESSAGES]) {
-      input.messages = mlObsTags[INPUT_MESSAGES]
-    }
-    if (mlObsTags[INPUT_VALUE]) {
-      input.value = mlObsTags[INPUT_VALUE]
-    }
-    if (spanKind === 'llm' && mlObsTags[OUTPUT_MESSAGES]) {
-      output.messages = mlObsTags[OUTPUT_MESSAGES]
-    }
-    if (spanKind === 'embedding' && mlObsTags[INPUT_DOCUMENTS]) {
+      llmObsSpan.input = mlObsTags[INPUT_MESSAGES]
+      inputType = 'messages'
+    } else if (spanKind === 'embedding' && mlObsTags[INPUT_DOCUMENTS]) {
       input.documents = mlObsTags[INPUT_DOCUMENTS]
+    } else if (mlObsTags[INPUT_VALUE]) {
+      llmObsSpan.input = [{ role: '', content: mlObsTags[INPUT_VALUE] }]
+      inputType = 'value'
     }
-    if (mlObsTags[OUTPUT_VALUE]) {
-      output.value = mlObsTags[OUTPUT_VALUE]
-    }
-    if (spanKind === 'retrieval' && mlObsTags[OUTPUT_DOCUMENTS]) {
+
+    if (spanKind === 'llm' && mlObsTags[OUTPUT_MESSAGES]) {
+      llmObsSpan.output = mlObsTags[OUTPUT_MESSAGES]
+      outputType = 'messages'
+    } else if (spanKind === 'retrieval' && mlObsTags[OUTPUT_DOCUMENTS]) {
       output.documents = mlObsTags[OUTPUT_DOCUMENTS]
+    } else if (mlObsTags[OUTPUT_VALUE]) {
+      llmObsSpan.output = [{ role: '', content: mlObsTags[OUTPUT_VALUE] }]
+      outputType = 'value'
     }
 
     const error = spanTags.error || spanTags[ERROR_TYPE]
@@ -107,9 +143,6 @@ class LLMObsSpanProcessor {
       meta[ERROR_STACK] = spanTags[ERROR_STACK] || error.stack
     }
 
-    if (input) meta.input = input
-    if (output) meta.output = output
-
     const metrics = mlObsTags[METRICS] || {}
 
     const mlApp = mlObsTags[ML_APP]
@@ -118,12 +151,37 @@ class LLMObsSpanProcessor {
 
     const name = mlObsTags[NAME] || span._name
 
+    const tags = this.#getTags(span, mlApp, sessionId, error)
+    llmObsSpan._tags = tags
+
+    const processedSpan = this.#runProcessor(llmObsSpan)
+    if (processedSpan === null) return null
+
+    if (processedSpan.input) {
+      if (inputType === 'messages') {
+        input.messages = processedSpan.input
+      } else if (inputType === 'value') {
+        input.value = processedSpan.input[0].content
+      }
+    }
+
+    if (processedSpan.output) {
+      if (outputType === 'messages') {
+        output.messages = processedSpan.output
+      } else if (outputType === 'value') {
+        output.value = processedSpan.output[0].content
+      }
+    }
+
+    if (input) meta.input = input
+    if (output) meta.output = output
+
     const llmObsSpanEvent = {
       trace_id: span.context().toTraceId(true),
       span_id: span.context().toSpanId(),
       parent_id: parentId,
       name,
-      tags: this._processTags(span, mlApp, sessionId, error),
+      tags: this.#objectTagsToStringArrayTags(tags),
       start_ns: Math.round(span._startTime * 1e6),
       duration: Math.round(span._duration * 1e6),
       status: error ? 'error' : 'ok',
@@ -144,7 +202,7 @@ class LLMObsSpanProcessor {
   // However, we want to protect against circular references or BigInts (unserializable)
   // This function can be reused for other fields if needed
   // Messages, Documents, and Metrics are safeguarded in `llmobs/tagger.js`
-  _addObject (obj, carrier) {
+  #addObject (obj, carrier) {
     const seenObjects = new WeakSet()
     seenObjects.add(obj) // capture root object
 
@@ -176,12 +234,12 @@ class LLMObsSpanProcessor {
     add(obj, carrier)
   }
 
-  _processTags (span, mlApp, sessionId, error) {
+  #getTags (span, mlApp, sessionId, error) {
     let tags = {
-      ...this._config.parsedDdTags,
-      version: this._config.version,
-      env: this._config.env,
-      service: this._config.service,
+      ...this.#config.parsedDdTags,
+      version: this.#config.version,
+      env: this.#config.env,
+      service: this.#config.service,
       source: 'integration',
       ml_app: mlApp,
       'ddtrace.version': tracerVersion,
@@ -191,13 +249,51 @@ class LLMObsSpanProcessor {
 
     const errType = span.context()._tags[ERROR_TYPE] || error?.name
     if (errType) tags.error_type = errType
+
     if (sessionId) tags.session_id = sessionId
+
     const integration = LLMObsTagger.tagMap.get(span)?.[INTEGRATION]
     if (integration) tags.integration = integration
+
     const existingTags = LLMObsTagger.tagMap.get(span)?.[TAGS] || {}
     if (existingTags) tags = { ...tags, ...existingTags }
+
+    return tags
+  }
+
+  #objectTagsToStringArrayTags (tags) {
     return Object.entries(tags).map(([key, value]) => `${key}:${value ?? ''}`)
   }
+
+  /**
+   * Runs the user span processor, emitting telemetry and adding some guardrails against invalid return types
+   * @param {LLMObservabilitySpan} span
+   * @returns {LLMObservabilitySpan | null}
+   */
+  #runProcessor (span) {
+    const processor = this.#userSpanProcessor
+    if (!processor) return span
+
+    let error = false
+
+    try {
+      const processedLLMObsSpan = processor(span)
+      if (processedLLMObsSpan === null) return null
+
+      if (!(processedLLMObsSpan instanceof LLMObservabilitySpan)) {
+        error = true
+        logger.warn('User span processor must return an instance of an LLMObservabilitySpan or null, dropping span.')
+        return null
+      }
+
+      return processedLLMObsSpan
+    } catch (e) {
+      logger.error(`[LLMObs] Error in LLMObs span processor (${util.inspect(processor)}): ${util.inspect(e)}`)
+      error = true
+    } finally {
+      telemetry.recordLLMObsUserProcessorCalled(error)
+    }
+  }
 }
 
 module.exports = LLMObsSpanProcessor

package/packages/dd-trace/src/llmobs/tagger.js

@@ -65,7 +65,8 @@ class LLMObsTagger {
       mlApp ||
       registry.get(parent)?.[ML_APP] ||
       span.context()._trace.tags[PROPAGATED_ML_APP_KEY] ||
-      this._config.llmobs.mlApp
+      this._config.llmobs.mlApp ||
+      this._config.service // this should always have a default
 
     if (!spanMlApp) {
       throw new Error(

package/packages/dd-trace/src/llmobs/telemetry.js

@@ -154,6 +154,11 @@ function recordSubmitEvaluation (options, err, value = 1) {
   llmobsMetrics.count('evals_submitted', tags).inc(value)
 }
 
+function recordLLMObsUserProcessorCalled (error, value = 1) {
+  const tags = { error: error ? 1 : 0 }
+  llmobsMetrics.count('user_processor_called', tags).inc(value)
+}
+
 module.exports = {
   recordLLMObsEnabled,
   incrementLLMObsSpanStartCount,
@@ -164,5 +169,6 @@ module.exports = {
   recordLLMObsAnnotate,
   recordUserFlush,
   recordExportSpan,
-  recordSubmitEvaluation
+  recordSubmitEvaluation,
+  recordLLMObsUserProcessorCalled
 }

package/packages/dd-trace/src/log/writer.js

@@ -71,7 +71,7 @@ function setStackTraceLimitFunction (fn) {
 function onError (err) {
   const { formatted, cause } = getErrorLog(err)
 
-  // calling twice logger.error() because Error cause is only available in nodejs v16.9.0
+  // calling twice logger.error() because Error cause is only available in Node.js v16.9.0
   // TODO: replace it with Error(message, { cause }) when cause has broad support
   if (formatted) {
     withNoop(() => {

package/packages/dd-trace/src/plugin_manager.js

@@ -145,7 +145,10 @@ module.exports = class PluginManager {
       ciVisAgentlessLogSubmissionEnabled,
       isTestDynamicInstrumentationEnabled,
       isServiceUserProvided,
-      middlewareTracingEnabled
+      middlewareTracingEnabled,
+      traceWebsocketMessagesEnabled,
+      traceWebsocketMessagesInheritSampling,
+      traceWebsocketMessagesSeparateTraces
     } = this._tracerConfig
 
     const sharedConfig = {
@@ -160,7 +163,10 @@ module.exports = class PluginManager {
       ciVisibilityTestSessionName,
       ciVisAgentlessLogSubmissionEnabled,
       isTestDynamicInstrumentationEnabled,
-      isServiceUserProvided
+      isServiceUserProvided,
+      traceWebsocketMessagesEnabled,
+      traceWebsocketMessagesInheritSampling,
+      traceWebsocketMessagesSeparateTraces
     }
 
     if (logInjection !== undefined) {

package/packages/dd-trace/src/plugins/index.js

@@ -102,5 +102,6 @@ module.exports = {
   get sharedb () { return require('../../../datadog-plugin-sharedb/src') },
   get tedious () { return require('../../../datadog-plugin-tedious/src') },
   get undici () { return require('../../../datadog-plugin-undici/src') },
-  get winston () { return require('../../../datadog-plugin-winston/src') }
+  get winston () { return require('../../../datadog-plugin-winston/src') },
+  get ws () { return require('../../../datadog-plugin-ws/src') }
 }

package/packages/dd-trace/src/plugins/util/ip_extractor.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const { BlockList } = require('net')
 const net = require('net')
 
 const FORWARED_HEADER_NAME = 'forwarded'
@@ -32,7 +31,7 @@ const privateCIDRs = [
   'fd00::/8'
 ]
 
-const privateIPMatcher = new BlockList()
+const privateIPMatcher = new net.BlockList()
 
 for (const cidr of privateCIDRs) {
   const [address, prefix] = cidr.split('/')
@@ -45,7 +44,11 @@ function extractIp (config, req) {
   if (config.clientIpHeader) {
     if (!headers) return
 
-    const ip = findFirstIp(headers[config.clientIpHeader])
+    const ipHeaderName = config.clientIpHeader
+    const header = headers[ipHeaderName]
+    if (typeof header !== 'string') return
+
+    const ip = findFirstIp(header, ipHeaderName === FORWARED_HEADER_NAME)
     return ip.public || ip.private
   }
 
@@ -53,12 +56,14 @@ function extractIp (config, req) {
   if (headers) {
     for (const ipHeaderName of ipHeaderList) {
       const header = headers[ipHeaderName]
-      const firstIp = ipHeaderName === FORWARED_HEADER_NAME ? findFirstIpForwardedFormat(header) : findFirstIp(header)
+      if (typeof header !== 'string') continue
+
+      const ip = findFirstIp(header, ipHeaderName === FORWARED_HEADER_NAME)
 
-      if (firstIp.public) {
-        return firstIp.public
-      } else if (!firstPrivateIp && firstIp.private) {
-        firstPrivateIp = firstIp.private
+      if (ip.public) {
+        return ip.public
+      } else if (!firstPrivateIp && ip.private) {
+        firstPrivateIp = ip.private
       }
     }
   }
@@ -66,25 +71,39 @@ function extractIp (config, req) {
   return firstPrivateIp || req.socket?.remoteAddress
 }
 
-function isPublicIp (ip, type) {
-  return !privateIPMatcher.check(ip, type === 6 ? 'ipv6' : 'ipv4')
-}
-
-function findFirstIp (str) {
+function findFirstIp (str, isForwardedHeader) {
   const result = {}
   if (!str) return result
 
   const splitted = str.split(',')
 
-  for (const part of splitted) {
-    const chunk = part.trim()
+  for (let chunk of splitted) {
+    if (isForwardedHeader) {
+      // find "for" directive
+      const forDirective = chunk.split(';').find(subchunk => subchunk.trim().toLowerCase().startsWith('for='))
+
+      // if found remove the "for=" prefix
+      // else keep going as is
+      if (forDirective) {
+        chunk = forDirective.slice(4)
+      }
+    }
+
+    chunk = chunk.trim()
+
+    // trim potential double quotes
+    if (chunk.startsWith('"') && chunk.endsWith('"')) {
+      chunk = chunk.slice(1, -1).trim()
+    }
 
-    // TODO: strip port and interface data ?
+    // TODO: when min node support is v24 we can instead use net.SocketAddress.parse()
+    chunk = cleanIp(chunk)
+    if (!chunk) continue
 
     const type = net.isIP(chunk)
     if (!type) continue
 
-    if (isPublicIp(chunk, type)) {
+    if (!privateIPMatcher.check(chunk, type === 6 ? 'ipv6' : 'ipv4')) {
       // it's public, return it immediately
       result.public = chunk
       return result
@@ -97,37 +116,21 @@ function findFirstIp (str) {
   return result
 }
 
-const forwardedForRegexp = /for="?\[?(([0-9]+\.)+[0-9]+|[0-9a-f:]*:[0-9a-f]*)/i
-const forwardedByRegexp = /by="?\[?(([0-9]+\.)+[0-9]+|[0-9a-f:]*:[0-9a-f]*)/i
-const forwardedRegexps = [forwardedForRegexp, forwardedByRegexp]
-
-function findFirstIpForwardedFormat (str) {
-  const result = {}
-  if (!str) return result
-
-  const splitted = str.split(',')
-
-  for (const part of splitted) {
-    const chunk = part.trim()
-
-    for (const regex of forwardedRegexps) {
-      const ip = regex.exec(chunk)?.[1]
-
-      const type = net.isIP(ip)
-      if (!type) continue
-
-      if (isPublicIp(ip, type)) {
-        // it's public, return it immediately
-        result.public = ip
-        return result
-      }
+function cleanIp (input) {
+  const colonIndex = input.indexOf(':')
+  if (colonIndex !== -1 && input.includes('.')) {
+    // treat it as ipv4 with port
+    return input.slice(0, colonIndex).trim()
+  }
 
-      // it's private, only save the first one found
-      if (!result.private) result.private = ip
-    }
+  const closingBracketIndex = input.indexOf(']')
+  if (closingBracketIndex !== -1 && input.startsWith('[')) {
+    // treat as ipv6 with brackets
+    return input.slice(1, closingBracketIndex).trim()
   }
 
-  return result
+  // no need to clean it
+  return input
 }
 
 module.exports = {

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -13,6 +13,7 @@ const {
   getThreadLabels,
   encodeProfileAsync
 } = require('./shared')
+const TRACE_ENDPOINT_LABEL = 'trace endpoint'
 
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
 
@@ -251,7 +252,12 @@ class NativeWallProfiler {
       this._enter()
       this._lastSampleCount = 0
     }
-    const profile = this._pprof.time.stop(restart, this._generateLabels)
+
+    // Mark thread labels and trace endpoint label as good deduplication candidates
+    const lowCardinalityLabels = Object.keys(getThreadLabels())
+    lowCardinalityLabels.push(TRACE_ENDPOINT_LABEL)
+
+    const profile = this._pprof.time.stop(restart, this._generateLabels, lowCardinalityLabels)
 
     if (restart) {
       const v8BugDetected = this._pprof.time.v8ProfilerStuckEventLoopDetected()
@@ -312,10 +318,10 @@ class NativeWallProfiler {
       labels[LOCAL_ROOT_SPAN_ID_LABEL] = rootSpanId
     }
     if (webTags !== undefined && Object.keys(webTags).length !== 0) {
-      labels['trace endpoint'] = endpointNameFromTags(webTags)
+      labels[TRACE_ENDPOINT_LABEL] = endpointNameFromTags(webTags)
     } else if (endpoint) {
       // fallback to endpoint computed when sample was taken
-      labels['trace endpoint'] = endpoint
+      labels[TRACE_ENDPOINT_LABEL] = endpoint
     }
 
     return labels

package/packages/dd-trace/src/service-naming/schemas/v0/index.js

@@ -6,5 +6,6 @@ const storage = require('./storage')
 const graphql = require('./graphql')
 const web = require('./web')
 const serverless = require('./serverless')
+const websocket = require('./websocket')
 
-module.exports = new SchemaDefinition({ messaging, storage, web, graphql, serverless })
+module.exports = new SchemaDefinition({ messaging, storage, web, graphql, serverless, websocket })

package/packages/dd-trace/src/service-naming/schemas/v0/websocket.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const websocket = {
+  request: {
+    ws: {
+      opName: () => 'web.request',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    }
+  },
+  producer: {
+    ws: {
+      opName: () => 'websocket.send',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    }
+  },
+  consumer: {
+    ws: {
+      opName: () => 'websocket.receive',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    }
+  },
+  close: {
+    ws: {
+      opName: () => 'websocket.close',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    }
+  }
+}
+
+module.exports = websocket

package/packages/dd-trace/src/service-naming/schemas/v1/index.js

@@ -6,5 +6,6 @@ const storage = require('./storage')
 const graphql = require('./graphql')
 const web = require('./web')
 const serverless = require('./serverless')
+const websocket = require('./websocket')
 
-module.exports = new SchemaDefinition({ messaging, storage, web, graphql, serverless })
+module.exports = new SchemaDefinition({ messaging, storage, web, graphql, serverless, websocket })