@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-bunyan/src/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
+
+class BunyanPlugin extends LogPlugin {
+  static id = 'bunyan'
+}
+module.exports = BunyanPlugin

package/packages/datadog-plugin-cassandra-driver/src/index.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const CASSANDRA_CONTACT_POINTS_KEY = 'db.cassandra.contact.points'
+
+class CassandraDriverPlugin extends DatabasePlugin {
+  static id = 'cassandra-driver'
+  static system = 'cassandra'
+  static peerServicePrecursors = [CASSANDRA_CONTACT_POINTS_KEY]
+
+  bindStart (ctx) {
+    let { keyspace, query, contactPoints = {} } = ctx
+
+    if (Array.isArray(query)) {
+      query = combine(query)
+    }
+
+    this.startSpan(this.operationName(), {
+      service: this.serviceName({ pluginConfig: this.config, system: this.system }),
+      resource: trim(query, 5000),
+      type: 'cassandra',
+      kind: 'client',
+      meta: {
+        'db.type': 'cassandra',
+        'cassandra.query': query,
+        'cassandra.keyspace': keyspace,
+        [CASSANDRA_CONTACT_POINTS_KEY]: contactPoints.join(',') || null,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+function combine (queries) {
+  return queries
+    .map(query => (query.query || query).replace(/;?$/, ';'))
+    .join(' ')
+}
+
+function trim (str, size) {
+  if (!str || str.length <= size) return str
+
+  return `${str.slice(0, size - 3)}...`
+}
+
+module.exports = CassandraDriverPlugin

package/packages/datadog-plugin-child_process/src/index.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const scrubChildProcessCmd = require('./scrub-cmd-params')
+
+const MAX_ARG_SIZE = 4096 // 4kB
+
+function truncateCommand (cmdFields) {
+  let size = cmdFields[0].length
+  let truncated = false
+  for (let i = 1; i < cmdFields.length; i++) {
+    if (size >= MAX_ARG_SIZE) {
+      truncated = true
+      cmdFields[i] = ''
+      continue
+    }
+
+    const argLen = cmdFields[i].length
+    if (size < MAX_ARG_SIZE && size + argLen > MAX_ARG_SIZE) {
+      cmdFields[i] = cmdFields[i].slice(0, 2)
+      truncated = true
+    }
+
+    size += argLen
+  }
+
+  return truncated
+}
+
+class ChildProcessPlugin extends TracingPlugin {
+  static id = 'child_process'
+  static prefix = 'tracing:datadog:child_process:execution'
+
+  get tracer () {
+    return this._tracer
+  }
+
+  start (ctx) {
+    const { command, shell } = ctx
+
+    if (typeof command !== 'string') {
+      return
+    }
+
+    const cmdFields = scrubChildProcessCmd(command)
+    const truncated = truncateCommand(cmdFields)
+    const property = (shell === true) ? 'cmd.shell' : 'cmd.exec'
+
+    const meta = {
+      component: 'subprocess',
+      [property]: (shell === true) ? cmdFields.join(' ') : JSON.stringify(cmdFields),
+    }
+
+    if (truncated) {
+      meta['cmd.truncated'] = `${truncated}`
+    }
+
+    this.startSpan('command_execution', {
+      service: this.config.service || this._tracerConfig.service,
+      resource: (shell === true) ? 'sh' : cmdFields[0],
+      type: 'system',
+      meta,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    const { result, error } = ctx
+    let exitCode
+
+    if (result !== undefined) {
+      exitCode = result?.status || 0
+    } else if (error === undefined) {
+      // TracingChannels call start, end synchronously. Later when the promise is resolved then asyncStart asyncEnd.
+      // Therefore in the case of calling end with neither result nor error means that they will come in the asyncEnd.
+      return
+    } else {
+      exitCode = error?.status || error?.code || 0
+    }
+
+    const span = ctx.currentStore?.span || this.activeSpan
+
+    span?.setTag('cmd.exit_code', `${exitCode}`)
+    span?.finish()
+
+    return ctx.parentStore
+  }
+
+  error (ctx) {
+    const { error } = ctx
+
+    const span = ctx.currentStore?.span || this.activeSpan
+    this.addError(error, span)
+
+    return ctx.parentStore
+  }
+
+  asyncEnd (ctx) {
+    const { result } = ctx
+
+    const span = ctx.currentStore?.span || this.activeSpan
+
+    span?.setTag('cmd.exit_code', `${result}`)
+    span?.finish()
+
+    return ctx.parentStore
+  }
+}
+
+module.exports = ChildProcessPlugin

package/packages/datadog-plugin-child_process/src/scrub-cmd-params.js

@@ -0,0 +1,127 @@
+'use strict'
+
+const shellParser = require('../../../vendor/dist/shell-quote').parse
+
+const ALLOWED_ENV_VARIABLES = new Set(['LD_PRELOAD', 'LD_LIBRARY_PATH', 'PATH'])
+const PROCESS_DENYLIST = new Set(['md5'])
+
+const VARNAMES_REGEX = /\$([\w\d_]*)(?:[^\w\d_]|$)/gmi
+// eslint-disable-next-line @stylistic/max-len
+const PARAM_PATTERN = '^-{0,2}(?:p(?:ass(?:w(?:or)?d)?)?|address|api[-_]?key|e?mail|secret(?:[-_]?key)?|a(?:ccess|uth)[-_]?token|mysql_pwd|credentials|(?:stripe)?token)$'
+const regexParam = new RegExp(PARAM_PATTERN, 'i')
+const ENV_PATTERN = String.raw`^(\w+=\w+;)*\w+=\w+;?$`
+const envVarRegex = new RegExp(ENV_PATTERN)
+const REDACTED = '?'
+
+function extractVarNames (expression) {
+  const varNames = new Set()
+  let match
+
+  while ((match = VARNAMES_REGEX.exec(expression))) {
+    varNames.add(match[1])
+  }
+
+  const varNamesObject = {}
+  for (const varName of varNames.keys()) {
+    varNamesObject[varName] = `$${varName}`
+  }
+  return varNamesObject
+}
+
+function getTokensByExpression (expressionTokens) {
+  const expressionListTokens = []
+  let wipExpressionTokens = []
+  let isNewExpression = true
+
+  for (const token of expressionTokens) {
+    if (isNewExpression) {
+      expressionListTokens.push(wipExpressionTokens)
+      isNewExpression = false
+    }
+
+    wipExpressionTokens.push(token)
+
+    if (token.op) {
+      wipExpressionTokens = []
+      isNewExpression = true
+    }
+  }
+  return expressionListTokens
+}
+
+function scrubChildProcessCmd (expression) {
+  const varNames = extractVarNames(expression)
+  const expressionTokens = shellParser(expression, varNames)
+
+  const expressionListTokens = getTokensByExpression(expressionTokens)
+
+  const result = []
+  for (const expressionTokens of expressionListTokens) {
+    let foundBinary = false
+    for (let index = 0; index < expressionTokens.length; index++) {
+      const token = expressionTokens[index]
+
+      if (token === null) {
+        continue
+      } else if (typeof token === 'object') {
+        if (token.pattern) {
+          result.push(token.pattern)
+        } else if (token.op) {
+          result.push(token.op)
+        } else if (token.comment) {
+          result.push(`#${token.comment}`)
+        }
+      } else if (foundBinary) {
+        const paramKeyValue = token.split('=')
+        const paramKey = paramKeyValue[0]
+
+        if (regexParam.test(paramKey)) {
+          if (paramKeyValue.length === 1) {
+            expressionTokens[index + 1] = REDACTED
+            result.push(token)
+          } else {
+            result.push(`${paramKey}=${REDACTED}`)
+          }
+        } else {
+          result.push(token)
+        }
+      } else {
+        if (envVarRegex.test(token)) {
+          const envSplit = token.split('=')
+
+          if (ALLOWED_ENV_VARIABLES.has(envSplit[0])) {
+            result.push(token)
+          } else {
+            envSplit[1] = REDACTED
+
+            const newToken = envSplit.join('=')
+            expressionTokens[index] = newToken
+
+            result.push(newToken)
+          }
+        } else {
+          foundBinary = true
+          result.push(token)
+
+          if (PROCESS_DENYLIST.has(token)) {
+            for (index++; index < expressionTokens.length; index++) {
+              const token = expressionTokens[index]
+
+              if (token.op) {
+                result.push(token.op)
+              } else {
+                expressionTokens[index] = REDACTED
+                result.push(REDACTED)
+              }
+            }
+            break
+          }
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+module.exports = scrubChildProcessCmd

package/packages/datadog-plugin-confluentinc-kafka-javascript/src/batch-consumer.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const KafkajsBatchConsumerPlugin = require('../../datadog-plugin-kafkajs/src/batch-consumer')
+
+class ConfluentKafkaJsBatchConsumerPlugin extends KafkajsBatchConsumerPlugin {
+  static id = 'confluentinc-kafka-javascript'
+}
+
+module.exports = ConfluentKafkaJsBatchConsumerPlugin

package/packages/datadog-plugin-confluentinc-kafka-javascript/src/consumer.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const KafkajsConsumerPlugin = require('../../datadog-plugin-kafkajs/src/consumer')
+
+class ConfluentKafkaJsConsumerPlugin extends KafkajsConsumerPlugin {
+  static id = 'confluentinc-kafka-javascript'
+}
+
+module.exports = ConfluentKafkaJsConsumerPlugin

package/packages/datadog-plugin-confluentinc-kafka-javascript/src/index.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const KafkajsPlugin = require('../../datadog-plugin-kafkajs/src/index')
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+const BatchConsumerPlugin = require('./batch-consumer')
+
+class ConfluentKafkaJsPlugin extends KafkajsPlugin {
+  /**
+   * @override
+   */
+  static id = 'confluentinc-kafka-javascript'
+  /**
+   * @override
+   */
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+      batchConsumer: BatchConsumerPlugin,
+    }
+  }
+}
+
+module.exports = ConfluentKafkaJsPlugin

package/packages/datadog-plugin-confluentinc-kafka-javascript/src/producer.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const KafkajsProducerPlugin = require('../../datadog-plugin-kafkajs/src/producer')
+
+class ConfluentKafkaJsProducerPlugin extends KafkajsProducerPlugin {
+  static id = 'confluentinc-kafka-javascript'
+}
+
+module.exports = ConfluentKafkaJsProducerPlugin

package/packages/datadog-plugin-connect/src/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+
+class ConnectPlugin extends RouterPlugin {
+  static id = 'connect'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:connect:request:handle', ({ req }) => {
+      this.setFramework(req, 'connect', this.config)
+    })
+  }
+}
+
+module.exports = ConnectPlugin

package/packages/datadog-plugin-couchbase/src/index.js

@@ -0,0 +1,94 @@
+'use strict'
+
+const StoragePlugin = require('../../dd-trace/src/plugins/storage')
+const { storage } = require('../../datadog-core')
+
+class CouchBasePlugin extends StoragePlugin {
+  static id = 'couchbase'
+  static peerServicePrecursors = ['db.couchbase.seed.nodes']
+
+  addBinds (func, start) {
+    this.addBind(`apm:couchbase:${func}:start`, start)
+    this.addSub(`apm:couchbase:${func}:error`, ({ error }) => this.addError(error))
+    this.addSub(`apm:couchbase:${func}:finish`, ctx => this.finish(ctx))
+    this.addBind(`apm:couchbase:${func}:callback:start`, callbackStart)
+    this.addBind(`apm:couchbase:${func}:callback:finish`, callbackFinish)
+  }
+
+  startSpan (operation, customTags, { bucket, collection, seedNodes }, ctx) {
+    const tags = {
+      'db.type': 'couchbase',
+      component: 'couchbase',
+      'resource.name': `couchbase.${operation}`,
+      'span.kind': this.constructor.kind,
+      'db.couchbase.seed.nodes': seedNodes,
+    }
+
+    if (bucket) tags['couchbase.bucket.name'] = bucket.name
+    if (collection) tags['couchbase.collection.name'] = collection.name
+
+    for (const tag in customTags) {
+      tags[tag] = customTags[tag]
+    }
+
+    return super.startSpan(
+      this.operationName({ operation }),
+      {
+        service: this.serviceName({ pluginConfig: this.config }),
+        meta: tags,
+      },
+      ctx
+    )
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addBinds('query', (ctx) => {
+      const { resource, bucket, seedNodes } = ctx
+
+      this.startSpan(
+        'query',
+        {
+          'span.type': 'sql',
+          'resource.name': resource,
+          'span.kind': this.constructor.kind,
+        },
+        { bucket, seedNodes },
+        ctx
+      )
+
+      return ctx.currentStore
+    })
+    this.addBind('apm:couchbase:bucket:maybeInvoke:callback:start', callbackStart)
+    this.addBind('apm:couchbase:bucket:maybeInvoke:callback:finish', callbackFinish)
+    this.addBind('apm:couchbase:cluster:maybeInvoke:callback:start', callbackStart)
+    this.addBind('apm:couchbase:cluster:maybeInvoke:callback:finish', callbackFinish)
+
+    this._addCommandSubs('upsert')
+    this._addCommandSubs('insert')
+    this._addCommandSubs('replace')
+    this._addCommandSubs('append')
+    this._addCommandSubs('prepend')
+  }
+
+  _addCommandSubs (name) {
+    this.addBinds(name, (ctx) => {
+      const { bucket, collection, seedNodes } = ctx
+
+      this.startSpan(name, {}, { bucket, collection, seedNodes }, ctx)
+      return ctx.currentStore
+    })
+  }
+}
+
+function callbackStart (ctx) {
+  ctx.parentStore = storage('legacy').getStore()
+  return ctx.parentStore
+}
+
+function callbackFinish (ctx) {
+  return ctx.parentStore
+}
+
+module.exports = CouchBasePlugin