dd-trace 3.13.2 → 3.14.0

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

@@ -6,16 +6,8 @@ const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const {
   TEST_STATUS,
   finishAllTraceSpans,
-  getTestParentSpan,
-  getTestSessionCommonTags,
   getTestSuitePath,
-  TEST_SESSION_ID,
-  TEST_COMMAND,
-  TEST_SUITE_ID,
-  getTestSuiteCommonTags,
-  getTestModuleCommonTags,
-  TEST_MODULE_ID,
-  TEST_BUNDLE
+  getTestSuiteCommonTags
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT } = require('../../dd-trace/src/constants')
@@ -30,32 +22,6 @@ class PlaywrightPlugin extends CiPlugin {
 
     this._testSuites = new Map()
 
-    this.addSub('ci:playwright:session:start', ({ command, frameworkVersion, rootDir }) => {
-      const childOf = getTestParentSpan(this.tracer)
-      this.command = command
-      this.frameworkVersion = frameworkVersion
-      this.rootDir = rootDir
-
-      const testSessionSpanMetadata = getTestSessionCommonTags(command, frameworkVersion)
-      this.testSessionSpan = this.tracer.startSpan('playwright.test_session', {
-        childOf,
-        tags: {
-          [COMPONENT]: this.constructor.name,
-          ...this.testEnvironmentMetadata,
-          ...testSessionSpanMetadata
-        }
-      })
-      const testModuleSpanMetadata = getTestModuleCommonTags(command, frameworkVersion)
-      this.testModuleSpan = this.tracer.startSpan('playwright.test_module', {
-        childOf: this.testSessionSpan,
-        tags: {
-          [COMPONENT]: this.constructor.name,
-          ...this.testEnvironmentMetadata,
-          ...testModuleSpanMetadata
-        }
-      })
-    })
-
     this.addSub('ci:playwright:session:finish', ({ status, onDone }) => {
       this.testModuleSpan.setTag(TEST_STATUS, status)
       this.testSessionSpan.setTag(TEST_STATUS, status)
@@ -138,33 +104,8 @@ class PlaywrightPlugin extends CiPlugin {
   }
 
   startTestSpan (testName, testSuite) {
-    const childOf = getTestParentSpan(this.tracer)
-    // This is a hack to get good time resolution on test events, while keeping
-    // the test event as the root span of its trace.
-    childOf._trace.startTime = this.testSessionSpan.context()._trace.startTime
-    childOf._trace.ticks = this.testSessionSpan.context()._trace.ticks
-
-    const testSuiteTags = {}
     const testSuiteSpan = this._testSuites.get(testSuite)
-    if (testSuiteSpan) {
-      const testSuiteId = testSuiteSpan.context().toSpanId()
-      testSuiteTags[TEST_SUITE_ID] = testSuiteId
-    }
-
-    if (this.testSessionSpan) {
-      const testSessionId = this.testSessionSpan.context().toTraceId()
-      testSuiteTags[TEST_SESSION_ID] = testSessionId
-      testSuiteTags[TEST_COMMAND] = this.command
-    }
-
-    if (this.testModuleSpan) {
-      const testModuleId = this.testModuleSpan.context().toSpanId()
-      testSuiteTags[TEST_MODULE_ID] = testModuleId
-      testSuiteTags[TEST_COMMAND] = this.command
-      testSuiteTags[TEST_BUNDLE] = this.command
-    }
-
-    return super.startTestSpan(testName, testSuite, testSuiteTags, childOf)
+    return super.startTestSpan(testName, testSuite, testSuiteSpan)
   }
 }
 

package/packages/datadog-shimmer/src/shimmer.js

@@ -10,7 +10,11 @@ function copyProperties (original, wrapped) {
   const keys = Reflect.ownKeys(props)
 
   for (const key of keys) {
-    Object.defineProperty(wrapped, key, props[key])
+    try {
+      Object.defineProperty(wrapped, key, props[key])
+    } catch (e) {
+      // TODO: figure out how to handle this without a try/catch
+    }
   }
 }
 
@@ -33,28 +37,41 @@ function wrapFn (original, delegate) {
 
 function wrapMethod (target, name, wrapper) {
   assertMethod(target, name)
-  assertNotClass(target[name]) // TODO: support constructors of native classes
   assertFunction(wrapper)
 
   const original = target[name]
   const wrapped = wrapper(original)
   const descriptor = Object.getOwnPropertyDescriptor(target, name)
 
+  const attributes = {
+    configurable: true,
+    ...descriptor
+  }
+
+  copyProperties(original, wrapped)
+
   if (descriptor) {
     unwrappers.set(wrapped, () => Object.defineProperty(target, name, descriptor))
+
+    if (descriptor.get || descriptor.set) {
+      attributes.get = () => wrapped
+    } else {
+      attributes.value = wrapped
+    }
+
+    // TODO: create a single object for multiple wrapped methods
+    if (descriptor.configurable === false) {
+      return Object.create(target, {
+        [name]: attributes
+      })
+    }
   } else { // no descriptor means original was on the prototype
     unwrappers.set(wrapped, () => delete target[name])
+    attributes.value = wrapped
+    attributes.writable = true
   }
 
-  Object.defineProperty(target, name, {
-    configurable: true,
-    writable: true,
-    enumerable: false,
-    ...descriptor,
-    value: wrapped
-  })
-
-  copyProperties(original, wrapped)
+  Object.defineProperty(target, name, attributes)
 
   return target
 }

package/packages/dd-trace/src/appsec/reporter.js

@@ -86,28 +86,28 @@ function formatHeaderName (name) {
 
 function reportMetrics (metrics, store) {
   const req = store && store.get('req')
-  const topSpan = web.root(req)
-  if (!topSpan) return false
+  const rootSpan = web.root(req)
+  if (!rootSpan) return false
 
   if (metrics.duration) {
-    topSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
+    rootSpan.setTag('_dd.appsec.waf.duration', metrics.duration)
   }
 
   if (metrics.durationExt) {
-    topSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
+    rootSpan.setTag('_dd.appsec.waf.duration_ext', metrics.durationExt)
   }
 
   if (metrics.rulesVersion) {
-    topSpan.setTag('_dd.appsec.event_rules.version', metrics.rulesVersion)
+    rootSpan.setTag('_dd.appsec.event_rules.version', metrics.rulesVersion)
   }
 }
 
 function reportAttack (attackData, store) {
   const req = store && store.get('req')
-  const topSpan = web.root(req)
-  if (!topSpan) return false
+  const rootSpan = web.root(req)
+  if (!rootSpan) return false
 
-  const currentTags = topSpan.context()._tags
+  const currentTags = rootSpan.context()._tags
 
   const newTags = {
     'appsec.event': 'true'
@@ -146,20 +146,20 @@ function reportAttack (attackData, store) {
     newTags['network.client.ip'] = resolvedRequest.remote_ip
   }
 
-  topSpan.addTags(newTags)
+  rootSpan.addTags(newTags)
 }
 
 function finishRequest (req, context) {
-  const topSpan = web.root(req)
-  if (!topSpan) return false
+  const rootSpan = web.root(req)
+  if (!rootSpan) return false
 
   if (metricsQueue.size) {
-    topSpan.addTags(Object.fromEntries(metricsQueue))
+    rootSpan.addTags(Object.fromEntries(metricsQueue))
 
     metricsQueue.clear()
   }
 
-  if (!context || !topSpan.context()._tags['appsec.event']) return false
+  if (!context || !rootSpan.context()._tags['appsec.event']) return false
 
   const resolvedResponse = resolveHTTPResponse(context)
 
@@ -169,7 +169,7 @@ function finishRequest (req, context) {
     newTags['http.endpoint'] = resolvedResponse.endpoint
   }
 
-  topSpan.addTags(newTags)
+  rootSpan.addTags(newTags)
 }
 
 function setRateLimit (rateLimit) {

package/packages/dd-trace/src/ci-visibility/exporters/agent-proxy/index.js

@@ -20,8 +20,7 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
       prioritySampler,
       lookup,
       protocolVersion,
-      headers,
-      isGitUploadEnabled
+      headers
     } = config
 
     this.getAgentInfo((err, agentInfo) => {
@@ -38,9 +37,6 @@ class AgentProxyCiVisibilityExporter extends CiVisibilityExporter {
           url: this._url,
           evpProxyPrefix: AGENT_EVP_PROXY_PATH
         })
-        if (isGitUploadEnabled) {
-          this.sendGitMetadata({ url: this._url, isEvpProxy: true })
-        }
       } else {
         this._writer = new AgentWriter({
           url: this._url,

package/packages/dd-trace/src/ci-visibility/exporters/agentless/index.js

@@ -9,7 +9,7 @@ const log = require('../../../log')
 class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
   constructor (config) {
     super(config)
-    const { tags, site, url, isGitUploadEnabled } = config
+    const { tags, site, url } = config
     // we don't need to request /info because we are using agentless by configuration
     this._isInitialized = true
     this._resolveCanUseCiVisProtocol(true)
@@ -21,10 +21,6 @@ class AgentlessCiVisibilityExporter extends CiVisibilityExporter {
     this._coverageWriter = new CoverageWriter({ url: this._coverageUrl })
 
     this._apiUrl = url || new URL(`https://api.${site}`)
-
-    if (isGitUploadEnabled) {
-      this.sendGitMetadata({ url: this._getApiUrl() })
-    }
   }
 
   setUrl (url, coverageUrl = url, apiUrl = url) {

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -14,6 +14,9 @@ function getIsTestSessionTrace (trace) {
   )
 }
 
+const GIT_UPLOAD_TIMEOUT = 60000 // 60 seconds
+const CAN_USE_CI_VIS_PROTOCOL_TIMEOUT = GIT_UPLOAD_TIMEOUT
+
 class CiVisibilityExporter extends AgentInfoExporter {
   constructor (config) {
     super(config)
@@ -24,14 +27,24 @@ class CiVisibilityExporter extends AgentInfoExporter {
     // AKA CI Vis Protocol
     this._canUseCiVisProtocol = false
 
-    // TODO: add timeout to reject this promise
+    const gitUploadTimeoutId = setTimeout(() => {
+      this._resolveGit(new Error('Timeout while uploading git metadata'))
+    }, GIT_UPLOAD_TIMEOUT).unref()
+
+    const canUseCiVisProtocolTimeoutId = setTimeout(() => {
+      this._resolveCanUseCiVisProtocol(false)
+    }, CAN_USE_CI_VIS_PROTOCOL_TIMEOUT).unref()
+
     this._gitUploadPromise = new Promise(resolve => {
-      this._resolveGit = resolve
+      this._resolveGit = (err) => {
+        clearTimeout(gitUploadTimeoutId)
+        resolve(err)
+      }
     })
 
-    // TODO: add timeout to reject this promise
     this._canUseCiVisProtocolPromise = new Promise(resolve => {
       this._resolveCanUseCiVisProtocol = (canUseCiVisProtocol) => {
+        clearTimeout(canUseCiVisProtocolTimeoutId)
         this._canUseCiVisProtocol = canUseCiVisProtocol
         resolve(canUseCiVisProtocol)
       }
@@ -93,6 +106,7 @@ class CiVisibilityExporter extends AgentInfoExporter {
    * CI Visibility Protocol, hence the this._canUseCiVisProtocol promise.
    */
   getItrConfiguration (testConfiguration, callback) {
+    this.sendGitMetadata()
     if (!this.shouldRequestItrConfiguration()) {
       return callback(null, {})
     }
@@ -118,14 +132,22 @@ class CiVisibilityExporter extends AgentInfoExporter {
     })
   }
 
-  sendGitMetadata ({ url, isEvpProxy }) {
-    sendGitMetadataRequest(url, isEvpProxy, (err) => {
-      if (err) {
-        log.error(`Error uploading git metadata: ${err.message}`)
-      } else {
-        log.debug('Successfully uploaded git metadata')
+  sendGitMetadata () {
+    if (!this._config.isGitUploadEnabled) {
+      return
+    }
+    this._canUseCiVisProtocolPromise.then((canUseCiVisProtocol) => {
+      if (!canUseCiVisProtocol) {
+        return
       }
-      this._resolveGit(err)
+      sendGitMetadataRequest(this._getApiUrl(), !!this._isUsingEvpProxy, (err) => {
+        if (err) {
+          log.error(`Error uploading git metadata: ${err.message}`)
+        } else {
+          log.debug('Successfully uploaded git metadata')
+        }
+        this._resolveGit(err)
+      })
     })
   }
 

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-skippable-suites.js

@@ -19,7 +19,7 @@ function getSkippableSuites ({
     headers: {
       'Content-Type': 'application/json'
     },
-    timeout: 15000,
+    timeout: 20000,
     url
   }
 

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

@@ -54,6 +54,32 @@ function remapify (input, mappings) {
   return output
 }
 
+function propagationStyle (key, option, defaultValue) {
+  // Extract by key if in object-form value
+  if (typeof option === 'object' && !Array.isArray(option)) {
+    option = option[key]
+  }
+
+  // Should be an array at this point
+  if (Array.isArray(option)) return option.map(v => v.toLowerCase())
+
+  // If it's not an array but not undefined there's something wrong with the input
+  if (typeof option !== 'undefined') {
+    log.warn('Unexpected input for config.tracePropagationStyle')
+  }
+
+  // Otherwise, fallback to env var parsing
+  const envKey = `DD_TRACE_PROPAGATION_STYLE_${key.toUpperCase()}`
+  const envVar = coalesce(process.env[envKey], process.env.DD_TRACE_PROPAGATION_STYLE)
+  if (typeof envVar !== 'undefined') {
+    return envVar.split(',')
+      .filter(v => v !== '')
+      .map(v => v.trim().toLowerCase())
+  }
+
+  return defaultValue
+}
+
 class Config {
   constructor (options) {
     options = options || {}
@@ -195,15 +221,36 @@ class Config {
       process.env.DD_TRACE_CLIENT_IP_HEADER,
       null
     )
+    // TODO: Remove the experimental env vars as a major?
     const DD_TRACE_B3_ENABLED = coalesce(
       options.experimental && options.experimental.b3,
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
       false
     )
-    const DD_TRACE_TRACEPARENT_ENABLED = coalesce(
-      options.experimental && options.experimental.traceparent,
-      process.env.DD_TRACE_EXPERIMENTAL_TRACEPARENT_ENABLED,
-      false
+    const defaultPropagationStyle = ['tracecontext', 'datadog']
+    if (isTrue(DD_TRACE_B3_ENABLED)) {
+      defaultPropagationStyle.push('b3')
+      defaultPropagationStyle.push('b3 single header')
+    }
+    if (process.env.DD_TRACE_PROPAGATION_STYLE && (
+      process.env.DD_TRACE_PROPAGATION_STYLE_INJECT ||
+      process.env.DD_TRACE_PROPAGATION_STYLE_EXTRACT
+    )) {
+      log.warn(
+        'Use either the DD_TRACE_PROPAGATION_STYLE environment variable or separate ' +
+        'DD_TRACE_PROPAGATION_STYLE_INJECT and DD_TRACE_PROPAGATION_STYLE_EXTRACT ' +
+        'environment variables'
+      )
+    }
+    const DD_TRACE_PROPAGATION_STYLE_INJECT = propagationStyle(
+      'inject',
+      options.tracePropagationStyle,
+      defaultPropagationStyle
+    )
+    const DD_TRACE_PROPAGATION_STYLE_EXTRACT = propagationStyle(
+      'extract',
+      options.tracePropagationStyle,
+      defaultPropagationStyle
     )
     const DD_TRACE_RUNTIME_ID_ENABLED = coalesce(
       options.experimental && options.experimental.runtimeId,
@@ -389,9 +436,11 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       port: String(coalesce(dogstatsd.port, process.env.DD_DOGSTATSD_PORT, 8125))
     }
     this.runtimeMetrics = isTrue(DD_RUNTIME_METRICS_ENABLED)
+    this.tracePropagationStyle = {
+      inject: DD_TRACE_PROPAGATION_STYLE_INJECT,
+      extract: DD_TRACE_PROPAGATION_STYLE_EXTRACT
+    }
     this.experimental = {
-      b3: isTrue(DD_TRACE_B3_ENABLED),
-      traceparent: isTrue(DD_TRACE_TRACEPARENT_ENABLED),
       runtimeId: isTrue(DD_TRACE_RUNTIME_ID_ENABLED),
       exporter: DD_TRACE_EXPORTER,
       enableGetRumData: isTrue(DD_TRACE_GET_RUM_DATA_ENABLED)

package/packages/dd-trace/src/encode/0.4.js

@@ -14,7 +14,7 @@ float64Array[0] = -1
 const bigEndian = uInt8Float64Array[7] === 0
 
 function formatSpan (span) {
-  return normalizeSpan(truncateSpan(span))
+  return normalizeSpan(truncateSpan(span, false))
 }
 
 class AgentEncoder {

package/packages/dd-trace/src/encode/0.5.js

@@ -7,7 +7,7 @@ const ARRAY_OF_TWO = 0x92
 const ARRAY_OF_TWELVE = 0x9c
 
 function formatSpan (span) {
-  return normalizeSpan(truncateSpan(span))
+  return normalizeSpan(truncateSpan(span, false))
 }
 
 class AgentEncoder extends BaseEncoder {

package/packages/dd-trace/src/encode/tags-processors.js

@@ -38,11 +38,12 @@ function truncateToLength (value, maxLength) {
   return value
 }
 
-function truncateSpan (span) {
+// normally the agent truncates the resource and parses it in certain scenarios (e.g. SQL Queries)
+function truncateSpan (span, shouldTruncateResourceName = true) {
   return fromEntries(Object.entries(span).map(([key, value]) => {
     switch (key) {
       case 'resource':
-        return ['resource', truncateToLength(value, MAX_RESOURCE_NAME_LENGTH)]
+        return ['resource', shouldTruncateResourceName ? truncateToLength(value, MAX_RESOURCE_NAME_LENGTH) : value]
       case 'meta':
         return ['meta', fromEntries(Object.entries(value).map(([metaKey, metaValue]) =>
           [truncateToLength(metaKey, MAX_META_KEY_LENGTH), truncateToLength(metaValue, MAX_META_VALUE_LENGTH)]