dd-trace 3.25.0 → 3.26.0

package/packages/dd-trace/src/datastreams/pathway.js

@@ -0,0 +1,58 @@
+// encoding used here is sha256
+// other languages use FNV1
+// this inconsistency is ok because hashes do not need to be consistent across services
+const crypto = require('crypto')
+const { encodeVarint, decodeVarint } = require('./encoding')
+const LRUCache = require('lru-cache')
+
+const options = { max: 500 }
+const cache = new LRUCache(options)
+
+function shaHash (checkpointString) {
+  const hash = crypto.createHash('md5').update(checkpointString).digest('hex').slice(0, 16)
+  return Buffer.from(hash, 'hex')
+}
+
+function computeHash (service, env, edgeTags, parentHash) {
+  const key = `${service}${env}` + edgeTags.join('') + parentHash.toString()
+  if (cache.get(key)) {
+    return cache.get(key)
+  }
+  const currentHash = shaHash(`${service}${env}` + edgeTags.join(''))
+  const buf = Buffer.concat([ currentHash, parentHash ], 16)
+  const val = shaHash(buf.toString())
+  cache.set(key, val)
+  return val
+}
+
+function encodePathwayContext (dataStreamsContext) {
+  return Buffer.concat([
+    dataStreamsContext.hash,
+    Buffer.from(encodeVarint(Math.round(dataStreamsContext.pathwayStartNs / 1e6))),
+    Buffer.from(encodeVarint(Math.round(dataStreamsContext.edgeStartNs / 1e6)))
+  ], 20)
+}
+
+function decodePathwayContext (pathwayContext) {
+  if (pathwayContext == null || pathwayContext.length < 8) {
+    return null
+  }
+  // hash and parent hash are in LE
+  const pathwayHash = pathwayContext.subarray(0, 8)
+  const encodedTimestamps = pathwayContext.subarray(8)
+  const [pathwayStartMs, encodedTimeSincePrev] = decodeVarint(encodedTimestamps)
+  if (pathwayStartMs === undefined) {
+    return null
+  }
+  const [edgeStartMs] = decodeVarint(encodedTimeSincePrev)
+  if (edgeStartMs === undefined) {
+    return null
+  }
+  return { hash: pathwayHash, pathwayStartNs: pathwayStartMs * 1e6, edgeStartNs: edgeStartMs * 1e6 }
+}
+
+module.exports = {
+  computePathwayHash: computeHash,
+  encodePathwayContext,
+  decodePathwayContext
+}

package/packages/dd-trace/src/datastreams/processor.js

@@ -0,0 +1,194 @@
+const os = require('os')
+const pkg = require('../../../../package.json')
+// Message pack int encoding is done in big endian, but data streams uses little endian
+const Uint64 = require('int64-buffer').Uint64BE
+
+const { LogCollapsingLowestDenseDDSketch } = require('@datadog/sketches-js')
+
+const { DataStreamsWriter } = require('./writer')
+const { computePathwayHash } = require('./pathway')
+const ENTRY_PARENT_HASH = Buffer.from('0000000000000000', 'hex')
+
+const HIGH_ACCURACY_DISTRIBUTION = 0.0075
+
+class StatsPoint {
+  constructor (hash, parentHash, edgeTags) {
+    this.hash = new Uint64(hash)
+    this.parentHash = new Uint64(parentHash)
+    this.edgeTags = edgeTags
+    this.edgeLatency = new LogCollapsingLowestDenseDDSketch(HIGH_ACCURACY_DISTRIBUTION)
+    this.pathwayLatency = new LogCollapsingLowestDenseDDSketch(HIGH_ACCURACY_DISTRIBUTION)
+  }
+
+  addLatencies (checkpoint) {
+    const edgeLatencySec = checkpoint.edgeLatencyNs / 1e9
+    const pathwayLatencySec = checkpoint.pathwayLatencyNs / 1e9
+    this.edgeLatency.accept(edgeLatencySec)
+    this.pathwayLatency.accept(pathwayLatencySec)
+  }
+
+  encode () {
+    return {
+      Hash: this.hash,
+      ParentHash: this.parentHash,
+      EdgeTags: this.edgeTags,
+      EdgeLatency: this.edgeLatency.toProto(),
+      PathwayLatency: this.pathwayLatency.toProto()
+    }
+  }
+}
+
+class StatsBucket extends Map {
+  forCheckpoint (checkpoint) {
+    const key = checkpoint.hash
+    if (!this.has(key)) {
+      this.set(key, new StatsPoint(checkpoint.hash, checkpoint.parentHash, checkpoint.edgeTags)) // StatsPoint
+    }
+
+    return this.get(key)
+  }
+}
+
+class TimeBuckets extends Map {
+  forTime (time) {
+    if (!this.has(time)) {
+      this.set(time, new StatsBucket())
+    }
+
+    return this.get(time)
+  }
+}
+
+class DataStreamsProcessor {
+  constructor ({
+    dsmEnabled,
+    hostname,
+    port,
+    url,
+    env,
+    tags
+  } = {}) {
+    this.writer = new DataStreamsWriter({
+      hostname,
+      port,
+      url
+    })
+    this.bucketSizeNs = 1e10
+    this.buckets = new TimeBuckets()
+    this.hostname = os.hostname()
+    this.enabled = dsmEnabled
+    this.env = env
+    this.tags = tags || {}
+    this.service = this.tags.service || 'unnamed-nodejs-service'
+    this.sequence = 0
+
+    if (this.enabled) {
+      this.timer = setInterval(this.onInterval.bind(this), 10000)
+      this.timer.unref()
+    }
+  }
+
+  onInterval () {
+    const serialized = this._serializeBuckets()
+    if (!serialized) return
+    const payload = {
+      Env: this.env,
+      Service: this.service,
+      Stats: serialized,
+      TracerVersion: pkg.version,
+      Lang: 'javascript'
+    }
+    this.writer.flush(payload)
+  }
+
+  recordCheckpoint (checkpoint) {
+    if (!this.enabled) return
+    const bucketTime = Math.round(checkpoint.currentTimestamp - (checkpoint.currentTimestamp % this.bucketSizeNs))
+    this.buckets.forTime(bucketTime)
+      .forCheckpoint(checkpoint)
+      .addLatencies(checkpoint)
+  }
+
+  setCheckpoint (edgeTags, ctx = null) {
+    if (!this.enabled) return null
+    const nowNs = Date.now() * 1e6
+    const direction = edgeTags.find(t => t.startsWith('direction:'))
+    let pathwayStartNs = nowNs
+    let edgeStartNs = nowNs
+    let parentHash = ENTRY_PARENT_HASH
+    let closestOppositeDirectionHash = ENTRY_PARENT_HASH
+    let closestOppositeDirectionEdgeStart = nowNs
+    if (ctx != null) {
+      pathwayStartNs = ctx.pathwayStartNs
+      edgeStartNs = ctx.edgeStartNs
+      parentHash = ctx.hash
+      closestOppositeDirectionHash = ctx.closestOppositeDirectionHash || ENTRY_PARENT_HASH
+      closestOppositeDirectionEdgeStart = ctx.closestOppositeDirectionEdgeStart || nowNs
+      if (direction === ctx.previousDirection) {
+        parentHash = ctx.closestOppositeDirectionHash
+        if (parentHash === ENTRY_PARENT_HASH) {
+          // if the closest hash from opposite direction is the entry hash, that means
+          // we produce in a loop, without consuming
+          // in that case, we don't want the pathway to be longer and longer, but we want to restart a new pathway.
+          edgeStartNs = nowNs
+          pathwayStartNs = nowNs
+        } else {
+          edgeStartNs = ctx.closestOppositeDirectionEdgeStart
+        }
+      } else {
+        closestOppositeDirectionHash = parentHash
+        closestOppositeDirectionEdgeStart = edgeStartNs
+      }
+    }
+    const hash = computePathwayHash(this.service, this.env, edgeTags, parentHash)
+    const edgeLatencyNs = nowNs - edgeStartNs
+    const pathwayLatencyNs = nowNs - pathwayStartNs
+    const checkpoint = {
+      currentTimestamp: nowNs,
+      parentHash: parentHash,
+      hash: hash,
+      edgeTags: edgeTags,
+      edgeLatencyNs: edgeLatencyNs,
+      pathwayLatencyNs: pathwayLatencyNs
+    }
+    this.recordCheckpoint(checkpoint)
+    return {
+      hash: hash,
+      edgeStartNs: edgeStartNs,
+      pathwayStartNs: pathwayStartNs,
+      previousDirection: direction,
+      closestOppositeDirectionHash: closestOppositeDirectionHash,
+      closestOppositeDirectionEdgeStart: closestOppositeDirectionEdgeStart
+    }
+  }
+
+  _serializeBuckets () {
+    const serializedBuckets = []
+
+    for (const [ timeNs, bucket ] of this.buckets.entries()) {
+      const points = []
+
+      for (const stats of bucket.values()) {
+        points.push(stats.encode())
+      }
+
+      serializedBuckets.push({
+        Start: new Uint64(timeNs),
+        Duration: new Uint64(this.bucketSizeNs),
+        Stats: points
+      })
+    }
+
+    this.buckets.clear()
+
+    return serializedBuckets
+  }
+}
+
+module.exports = {
+  DataStreamsProcessor: DataStreamsProcessor,
+  StatsPoint: StatsPoint,
+  StatsBucket: StatsBucket,
+  TimeBuckets,
+  ENTRY_PARENT_HASH
+}

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

@@ -0,0 +1,66 @@
+const pkg = require('../../../../package.json')
+const log = require('../log')
+const request = require('../exporters/common/request')
+const { URL, format } = require('url')
+const msgpack = require('msgpack-lite')
+const zlib = require('zlib')
+const codec = msgpack.createCodec({ int64: true })
+
+function makeRequest (data, url, cb) {
+  const options = {
+    path: '/v0.1/pipeline_stats',
+    method: 'POST',
+    headers: {
+      'Datadog-Meta-Lang': 'javascript',
+      'Datadog-Meta-Tracer-Version': pkg.version,
+      'Content-Type': 'application/msgpack',
+      'Content-Encoding': 'gzip'
+    }
+  }
+
+  options.protocol = url.protocol
+  options.hostname = url.hostname
+  options.port = url.port
+
+  log.debug(() => `Request to the intake: ${JSON.stringify(options)}`)
+
+  request(data, options, (err, res) => {
+    cb(err, res)
+  })
+}
+
+class DataStreamsWriter {
+  constructor (config) {
+    const { hostname = '127.0.0.1', port = 8126, url } = config
+    this._url = url || new URL(format({
+      protocol: 'http:',
+      hostname: hostname || 'localhost',
+      port
+    }))
+  }
+
+  flush (payload) {
+    if (!request.writable) {
+      log.debug(() => `Maximum number of active requests reached. Payload discarded: ${JSON.stringify(payload)}`)
+      return
+    }
+    const encodedPayload = msgpack.encode(payload, { codec })
+
+    zlib.gzip(encodedPayload, { level: 1 }, (err, compressedData) => {
+      if (err) {
+        log.error(err)
+        return
+      }
+      makeRequest(compressedData, this._url, (err, res) => {
+        log.debug(`Response from the agent: ${res}`)
+        if (err) {
+          log.error(err)
+        }
+      })
+    })
+  }
+}
+
+module.exports = {
+  DataStreamsWriter
+}

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

@@ -133,7 +133,9 @@ module.exports = class PluginManager {
       serviceMapping,
       queryStringObfuscation,
       site,
-      url
+      url,
+      dbmPropagationMode,
+      dsmEnabled
     } = this._tracerConfig
 
     const sharedConfig = {}
@@ -146,6 +148,9 @@ module.exports = class PluginManager {
       sharedConfig.queryStringObfuscation = queryStringObfuscation
     }
 
+    sharedConfig.dbmPropagationMode = dbmPropagationMode
+    sharedConfig.dsmEnabled = dsmEnabled
+
     if (serviceMapping && serviceMapping[name]) {
       sharedConfig.service = serviceMapping[name]
     }

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

@@ -4,6 +4,7 @@ const StoragePlugin = require('./storage')
 
 class DatabasePlugin extends StoragePlugin {
   static get operation () { return 'query' }
+  static get peerServicePrecursors () { return ['db.name'] }
 
   constructor (...args) {
     super(...args)
@@ -38,7 +39,7 @@ class DatabasePlugin extends StoragePlugin {
   }
 
   injectDbmQuery (query, serviceName, isPreparedStatement = false) {
-    const mode = this.config.dbmPropagationMode || this._tracerConfig.dbmPropagationMode
+    const mode = this.config.dbmPropagationMode
 
     if (mode === 'disabled') {
       return query

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

@@ -14,6 +14,7 @@ module.exports = {
   get '@node-redis/client' () { return require('../../../datadog-plugin-redis/src') },
   get '@opensearch-project/opensearch' () { return require('../../../datadog-plugin-opensearch/src') },
   get '@redis/client' () { return require('../../../datadog-plugin-redis/src') },
+  get '@smithy/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get 'amqp10' () { return require('../../../datadog-plugin-amqp10/src') },
   get 'amqplib' () { return require('../../../datadog-plugin-amqplib/src') },
   get 'aws-sdk' () { return require('../../../datadog-plugin-aws-sdk/src') },

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

@@ -35,7 +35,7 @@ class OutboundPlugin extends TracingPlugin {
      *   `_dd.peer.service.source`'s value is `peer.service`
      */
 
-    if (tags['peer.service']) {
+    if (tags['peer.service'] !== undefined) {
       return { [PEER_SERVICE_SOURCE_KEY]: 'peer.service' }
     }
 
@@ -43,6 +43,7 @@ class OutboundPlugin extends TracingPlugin {
       ...this.constructor.peerServicePrecursors,
       ...COMMON_PEER_SVC_SOURCE_TAGS
     ]
+
     for (const sourceTag of sourceTags) {
       if (tags[sourceTag]) {
         return {

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

@@ -33,6 +33,9 @@ class TracingPlugin extends Plugin {
   }
 
   serviceName (...serviceArgs) {
+    if (Nomenclature.shouldUseConsistentServiceNaming) {
+      return Nomenclature.shortCircuitServiceName(this.config, ...serviceArgs)
+    }
     const { type, id, kind } = this.constructor
     return Nomenclature.serviceName(type, kind, id, ...serviceArgs)
   }

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

@@ -35,9 +35,41 @@ function isShallowRepository () {
   return sanitizedExec('git', ['rev-parse', '--is-shallow-repository']) === 'true'
 }
 
+function getGitVersion () {
+  const gitVersionString = sanitizedExec('git', ['version'])
+  const gitVersionMatches = gitVersionString.match(/git version (\d+)\.(\d+)\.(\d+)/)
+  try {
+    return {
+      major: parseInt(gitVersionMatches[1]),
+      minor: parseInt(gitVersionMatches[2]),
+      patch: parseInt(gitVersionMatches[3])
+    }
+  } catch (e) {
+    return null
+  }
+}
+
 function unshallowRepository () {
-  sanitizedExec('git', ['config', 'remote.origin.partialclonefilter', '"blob:none"'])
-  sanitizedExec('git', ['fetch', '--shallow-since="1 month ago"', '--update-shallow', '--refetch'])
+  const gitVersion = getGitVersion()
+  if (!gitVersion) {
+    log.warn('Git version could not be extracted, so git unshallow will not proceed')
+    return
+  }
+  if (gitVersion.major < 2 || (gitVersion.major === 2 && gitVersion.minor < 27)) {
+    log.warn('Git version is <2.27, so git unshallow will not proceed')
+    return
+  }
+  const defaultRemoteName = sanitizedExec('git', ['config', '--default', 'origin', '--get', 'clone.defaultRemoteName'])
+  const revParseHead = sanitizedExec('git', ['rev-parse', 'HEAD'])
+  sanitizedExec('git', [
+    'fetch',
+    '--shallow-since="1 month ago"',
+    '--update-shallow',
+    '--filter=blob:none',
+    '--recurse-submodules=no',
+    defaultRemoteName,
+    revParseHead
+  ])
 }
 
 function getRepositoryUrl () {
@@ -56,7 +88,7 @@ function getLatestCommits () {
   }
 }
 
-function getCommitsToUpload (commitsToExclude) {
+function getCommitsToUpload (commitsToExclude, commitsToInclude) {
   const commitsToExcludeString = commitsToExclude.map(commit => `^${commit}`)
 
   try {
@@ -68,8 +100,8 @@ function getCommitsToUpload (commitsToExclude) {
         '--no-object-names',
         '--filter=blob:none',
         '--since="1 month ago"',
-        'HEAD',
-        ...commitsToExcludeString
+        ...commitsToExcludeString,
+        ...commitsToInclude
       ],
       { stdio: 'pipe', maxBuffer: GIT_REV_LIST_MAX_BUFFER })
       .toString()

package/packages/dd-trace/src/plugins/util/user-provided-git.js

@@ -13,6 +13,8 @@ const {
 } = require('./tags')
 
 const { normalizeRef } = require('./ci')
+const log = require('../../log')
+const { URL } = require('url')
 
 function removeEmptyValues (tags) {
   return Object.keys(tags).reduce((filteredTags, tag) => {
@@ -39,6 +41,37 @@ function filterSensitiveInfoFromRepository (repositoryUrl) {
   }
 }
 
+// The regex is extracted from
+// https://github.com/jonschlinkert/is-git-url/blob/396965ffabf2f46656c8af4c47bef1d69f09292e/index.js#L9C15-L9C87
+function validateGitRepositoryUrl (repoUrl) {
+  return /(?:git|ssh|https?|git@[-\w.]+):(\/\/)?(.*?)(\.git)(\/?|#[-\d\w._]+?)$/.test(repoUrl)
+}
+
+function validateGitCommitSha (gitCommitSha) {
+  const isValidSha1 = /^[0-9a-f]{40}$/.test(gitCommitSha)
+  const isValidSha256 = /^[0-9a-f]{64}$/.test(gitCommitSha)
+  return isValidSha1 || isValidSha256
+}
+
+function removeInvalidGitMetadata (metadata) {
+  return Object.keys(metadata).reduce((filteredTags, tag) => {
+    if (tag === GIT_REPOSITORY_URL) {
+      if (!validateGitRepositoryUrl(metadata[GIT_REPOSITORY_URL])) {
+        log.error('DD_GIT_REPOSITORY_URL must be a valid URL')
+        return filteredTags
+      }
+    }
+    if (tag === GIT_COMMIT_SHA) {
+      if (!validateGitCommitSha(metadata[GIT_COMMIT_SHA])) {
+        log.error('DD_GIT_COMMIT_SHA must be a full-length git SHA')
+        return filteredTags
+      }
+    }
+    filteredTags[tag] = metadata[tag]
+    return filteredTags
+  }, {})
+}
+
 function getUserProviderGitMetadata () {
   const {
     DD_GIT_COMMIT_SHA,
@@ -62,7 +95,7 @@ function getUserProviderGitMetadata () {
     tag = normalizeRef(DD_GIT_BRANCH)
   }
 
-  return removeEmptyValues({
+  const metadata = removeEmptyValues({
     [GIT_COMMIT_SHA]: DD_GIT_COMMIT_SHA,
     [GIT_BRANCH]: branch,
     [GIT_REPOSITORY_URL]: filterSensitiveInfoFromRepository(DD_GIT_REPOSITORY_URL),
@@ -75,6 +108,7 @@ function getUserProviderGitMetadata () {
     [GIT_COMMIT_AUTHOR_EMAIL]: DD_GIT_COMMIT_AUTHOR_EMAIL,
     [GIT_COMMIT_AUTHOR_DATE]: DD_GIT_COMMIT_AUTHOR_DATE
   })
+  return removeInvalidGitMetadata(metadata)
 }
 
-module.exports = { getUserProviderGitMetadata }
+module.exports = { getUserProviderGitMetadata, validateGitRepositoryUrl, validateGitCommitSha }

package/packages/dd-trace/src/profiling/config.js

@@ -12,7 +12,7 @@ const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
 const { oomExportStrategies, snapshotKinds } = require('./constants')
 const { tagger } = require('./tagger')
-const { isTrue } = require('../util')
+const { isFalse, isTrue } = require('../util')
 
 class Config {
   constructor (options = {}) {
@@ -32,6 +32,8 @@ class Config {
       DD_PROFILING_SOURCE_MAP,
       DD_PROFILING_UPLOAD_PERIOD,
       DD_PROFILING_PPROF_PREFIX,
+      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_WALLTIME_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
       DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
@@ -106,10 +108,9 @@ class Config {
       exportCommand
     }
 
-    const profilers = coalesce(options.profilers, DD_PROFILING_PROFILERS, [
-      new WallProfiler(this),
-      new SpaceProfiler(this)
-    ])
+    const profilers = options.profilers
+      ? options.profilers
+      : getProfilers({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS })
 
     this.profilers = ensureProfilers(profilers, this)
   }
@@ -117,6 +118,32 @@ class Config {
 
 module.exports = { Config }
 
+function getProfilers ({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS }) {
+  // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to wall + space
+  // Use a Set to avoid duplicates
+  const profilers = new Set(coalesce(DD_PROFILING_PROFILERS, 'wall,space').split(','))
+
+  // Add/remove wall depending on the value of DD_PROFILING_WALLTIME_ENABLED
+  if (DD_PROFILING_WALLTIME_ENABLED != null) {
+    if (isTrue(DD_PROFILING_WALLTIME_ENABLED)) {
+      profilers.add('wall')
+    } else if (isFalse(DD_PROFILING_WALLTIME_ENABLED)) {
+      profilers.delete('wall')
+    }
+  }
+
+  // Add/remove wall depending on the value of DD_PROFILING_HEAP_ENABLED
+  if (DD_PROFILING_HEAP_ENABLED != null) {
+    if (isTrue(DD_PROFILING_HEAP_ENABLED)) {
+      profilers.add('space')
+    } else if (isFalse(DD_PROFILING_HEAP_ENABLED)) {
+      profilers.delete('space')
+    }
+  }
+
+  return [...profilers]
+}
+
 function getExportStrategy (name, options) {
   const strategy = Object.values(oomExportStrategies).find(value => value === name)
   if (strategy === undefined) {

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

@@ -3,7 +3,7 @@ const { schemaDefinitions } = require('./schemas')
 class SchemaManager {
   constructor () {
     this.schemas = schemaDefinitions
-    this.config = { spanAttributeSchema: 'v0' }
+    this.config = { spanAttributeSchema: 'v0', traceRemoveIntegrationServiceNamesEnabled: false }
   }
 
   get schema () {
@@ -14,6 +14,10 @@ class SchemaManager {
     return this.config.spanAttributeSchema
   }
 
+  get shouldUseConsistentServiceNaming () {
+    return this.config.traceRemoveIntegrationServiceNamesEnabled && this.version === 'v0'
+  }
+
   opName (type, kind, plugin, ...opNameArgs) {
     return this.schema.getOpName(type, kind, plugin, ...opNameArgs)
   }
@@ -22,6 +26,14 @@ class SchemaManager {
     return this.schema.getServiceName(type, kind, plugin, this.config.service, ...serviceNameArgs)
   }
 
+  shortCircuitServiceName (pluginConfig, ...args) {
+    // We're short-circuiting, so we do not obey custom service functions
+    if (typeof pluginConfig.service === 'function') {
+      return this.config.service
+    }
+    return pluginConfig.service || this.config.service
+  }
+
   configure (config = {}) {
     this.config = config
   }

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

@@ -1,13 +1,22 @@
 const { identityService } = require('../util')
+const { DD_MAJOR } = require('../../../../../../version')
 
 const web = {
   client: {
+    grpc: {
+      opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.client',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.call',
       serviceName: identityService
     }
   },
   server: {
+    grpc: {
+      opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.server',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.action',
       serviceName: identityService

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

@@ -2,12 +2,20 @@ const { identityService } = require('../util')
 
 const web = {
   client: {
+    grpc: {
+      opName: () => 'grpc.client.request',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.client.request',
       serviceName: identityService
     }
   },
   server: {
+    grpc: {
+      opName: () => 'grpc.server.request',
+      serviceName: identityService
+    },
     moleculer: {
       opName: () => 'moleculer.server.request',
       serviceName: identityService