dd-trace 3.3.1 → 3.12.1

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

@@ -1,9 +1,9 @@
 
 const fs = require('fs')
-const https = require('https')
 const path = require('path')
 
 const FormData = require('../../../exporters/common/form-data')
+const request = require('../../../exporters/common/request')
 
 const log = require('../../../log')
 const {
@@ -18,7 +18,7 @@ const isValidSha = (sha) => /[0-9a-f]{40}/.test(sha)
 function sanitizeCommits (commits) {
   return commits.map(({ id: commitSha, type }) => {
     if (type !== 'commit') {
-      throw new Error('Invalid commit response')
+      throw new Error('Invalid commit type response')
     }
     const sanitizedCommit = commitSha.replace(/[^0-9a-f]+/g, '')
     if (sanitizedCommit !== commitSha || !isValidSha(sanitizedCommit)) {
@@ -35,9 +35,7 @@ function getCommonRequestOptions (url) {
       'dd-api-key': process.env.DATADOG_API_KEY || process.env.DD_API_KEY
     },
     timeout: 15000,
-    protocol: url.protocol,
-    hostname: url.hostname,
-    port: url.port
+    url
   }
 }
 
@@ -46,7 +44,7 @@ function getCommonRequestOptions (url) {
  * The response are the commits for which the backend already has information
  * This response is used to know which commits can be ignored from there on
  */
-function getCommitsToExclude ({ url, repositoryUrl }, callback) {
+function getCommitsToExclude ({ url, isEvpProxy, repositoryUrl }, callback) {
   const latestCommits = getLatestCommits()
   const [headCommit] = latestCommits
 
@@ -61,6 +59,12 @@ function getCommitsToExclude ({ url, repositoryUrl }, callback) {
     path: '/api/v2/git/repository/search_commits'
   }
 
+  if (isEvpProxy) {
+    options.path = '/evp_proxy/v2/api/v2/git/repository/search_commits'
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    delete options.headers['dd-api-key']
+  }
+
   const localCommitData = JSON.stringify({
     meta: {
       repository_url: repositoryUrl
@@ -71,39 +75,25 @@ function getCommitsToExclude ({ url, repositoryUrl }, callback) {
     }))
   })
 
-  const request = https.request(options, (res) => {
-    let responseData = ''
-
-    res.on('data', chunk => { responseData += chunk })
-    res.on('end', () => {
-      if (res.statusCode === 200) {
-        let commitsToExclude
-        try {
-          commitsToExclude = sanitizeCommits(JSON.parse(responseData).data)
-        } catch (e) {
-          callback(new Error(`Can't parse response: ${e.message}`))
-          return
-        }
-        callback(null, commitsToExclude, headCommit)
-      } else {
-        const error = new Error(`Error getting commits: ${res.statusCode} ${res.statusMessage}`)
-        callback(error)
-      }
-    })
+  request(localCommitData, options, (err, response) => {
+    if (err) {
+      const error = new Error(`Error fetching commits to exclude: ${err.message}`)
+      return callback(error)
+    }
+    let commitsToExclude
+    try {
+      commitsToExclude = sanitizeCommits(JSON.parse(response).data)
+    } catch (e) {
+      return callback(new Error(`Can't parse commits to exclude response: ${e.message}`))
+    }
+    callback(null, commitsToExclude, headCommit)
   })
-
-  request.write(localCommitData)
-  request.on('error', callback)
-
-  request.end()
-
-  return request
 }
 
 /**
  * This function uploads a git packfile
  */
-function uploadPackFile ({ url, packFileToUpload, repositoryUrl, headCommit }, callback) {
+function uploadPackFile ({ url, isEvpProxy, packFileToUpload, repositoryUrl, headCommit }, callback) {
   const form = new FormData()
 
   const pushedSha = JSON.stringify({
@@ -127,7 +117,7 @@ function uploadPackFile ({ url, packFileToUpload, repositoryUrl, headCommit }, c
       contentType: 'application/octet-stream'
     })
   } catch (e) {
-    callback(new Error(`Error reading packfile: ${packFileToUpload}`))
+    callback(new Error(`Could not read "${packFileToUpload}"`))
     return
   }
 
@@ -142,60 +132,58 @@ function uploadPackFile ({ url, packFileToUpload, repositoryUrl, headCommit }, c
     }
   }
 
-  const req = https.request(options, res => {
-    res.on('data', () => {})
-    res.on('end', () => {
-      if (res.statusCode === 204) {
-        callback(null)
-      } else {
-        const error = new Error(`Error uploading packfiles: ${res.statusCode} ${res.statusMessage}`)
-        error.status = res.statusCode
-
-        callback(error)
-      }
-    })
-  })
+  if (isEvpProxy) {
+    options.path = '/evp_proxy/v2/api/v2/git/repository/packfile'
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    delete options.headers['dd-api-key']
+  }
 
-  req.on('error', err => {
-    callback(err)
+  request(form, options, (err, _, statusCode) => {
+    if (err) {
+      const error = new Error(`Could not upload packfiles: status code ${statusCode}: ${err.message}`)
+      return callback(error)
+    }
+    callback(null)
   })
-  form.pipe(req)
 }
 
 /**
  * This function uploads git metadata to CI Visibility's backend.
 */
-function sendGitMetadata (site, callback) {
-  const url = new URL(`https://api.${site}`)
-
+function sendGitMetadata (url, isEvpProxy, callback) {
   const repositoryUrl = getRepositoryUrl()
 
-  getCommitsToExclude({ url, repositoryUrl }, (err, commitsToExclude, headCommit) => {
+  if (!repositoryUrl) {
+    return callback(new Error('Repository URL is empty'))
+  }
+
+  getCommitsToExclude({ url, repositoryUrl, isEvpProxy }, (err, commitsToExclude, headCommit) => {
     if (err) {
-      callback(err)
-      return
+      return callback(err)
     }
     const commitsToUpload = getCommitsToUpload(commitsToExclude)
 
     if (!commitsToUpload.length) {
       log.debug('No commits to upload')
-      callback(null)
-      return
+      return callback(null)
     }
-
     const packFilesToUpload = generatePackFilesForCommits(commitsToUpload)
 
+    if (!packFilesToUpload.length) {
+      return callback(new Error('Failed to generate packfiles'))
+    }
+
     let packFileIndex = 0
     // This uploads packfiles sequentially
     const uploadPackFileCallback = (err) => {
       if (err || packFileIndex === packFilesToUpload.length) {
-        callback(err)
-        return
+        return callback(err)
       }
       return uploadPackFile(
         {
           packFileToUpload: packFilesToUpload[packFileIndex++],
           url,
+          isEvpProxy,
           repositoryUrl,
           headCommit
         },
@@ -205,8 +193,9 @@ function sendGitMetadata (site, callback) {
 
     uploadPackFile(
       {
-        url,
         packFileToUpload: packFilesToUpload[packFileIndex++],
+        url,
+        isEvpProxy,
         repositoryUrl,
         headCommit
       },

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-itr-configuration.js

@@ -0,0 +1,89 @@
+const request = require('../../exporters/common/request')
+const id = require('../../id')
+
+function getItrConfiguration ({
+  url,
+  isEvpProxy,
+  env,
+  service,
+  repositoryUrl,
+  sha,
+  osVersion,
+  osPlatform,
+  osArchitecture,
+  runtimeName,
+  runtimeVersion,
+  branch
+}, done) {
+  const options = {
+    path: '/api/v2/libraries/tests/services/setting',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    url
+  }
+
+  if (isEvpProxy) {
+    options.path = '/evp_proxy/v2/api/v2/libraries/tests/services/setting'
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.headers['X-Datadog-NeedsAppKey'] = 'true'
+  } else {
+    const apiKey = process.env.DATADOG_API_KEY || process.env.DD_API_KEY
+    const appKey = process.env.DATADOG_APP_KEY ||
+      process.env.DD_APP_KEY ||
+      process.env.DATADOG_APPLICATION_KEY ||
+      process.env.DD_APPLICATION_KEY
+
+    if (!apiKey || !appKey) {
+      return done(new Error('App key or API key undefined'))
+    }
+    options.headers['dd-api-key'] = apiKey
+    options.headers['dd-application-key'] = appKey
+  }
+
+  const data = JSON.stringify({
+    data: {
+      id: id().toString(10),
+      type: 'ci_app_test_service_libraries_settings',
+      attributes: {
+        test_level: 'suite',
+        configurations: {
+          'os.platform': osPlatform,
+          'os.version': osVersion,
+          'os.architecture': osArchitecture,
+          'runtime.name': runtimeName,
+          'runtime.version': runtimeVersion
+        },
+        service,
+        env,
+        repository_url: repositoryUrl,
+        sha,
+        branch
+      }
+    }
+  })
+
+  request(data, options, (err, res) => {
+    if (err) {
+      done(err)
+    } else {
+      try {
+        const {
+          data: {
+            attributes: {
+              code_coverage: isCodeCoverageEnabled,
+              tests_skipping: isSuitesSkippingEnabled
+            }
+          }
+        } = JSON.parse(res)
+
+        done(null, { isCodeCoverageEnabled, isSuitesSkippingEnabled })
+      } catch (err) {
+        done(err)
+      }
+    }
+  })
+}
+
+module.exports = { getItrConfiguration }

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

@@ -0,0 +1,82 @@
+const request = require('../../exporters/common/request')
+
+function getSkippableSuites ({
+  url,
+  isEvpProxy,
+  env,
+  service,
+  repositoryUrl,
+  sha,
+  osVersion,
+  osPlatform,
+  osArchitecture,
+  runtimeName,
+  runtimeVersion
+}, done) {
+  const options = {
+    path: '/api/v2/ci/tests/skippable',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    timeout: 15000,
+    url
+  }
+
+  if (isEvpProxy) {
+    options.path = '/evp_proxy/v2/api/v2/ci/tests/skippable'
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+    options.headers['X-Datadog-NeedsAppKey'] = 'true'
+  } else {
+    const apiKey = process.env.DATADOG_API_KEY || process.env.DD_API_KEY
+    const appKey = process.env.DATADOG_APP_KEY ||
+      process.env.DD_APP_KEY ||
+      process.env.DATADOG_APPLICATION_KEY ||
+      process.env.DD_APPLICATION_KEY
+
+    if (!apiKey || !appKey) {
+      return done(new Error('App key or API key undefined'))
+    }
+    options.headers['dd-api-key'] = apiKey
+    options.headers['dd-application-key'] = appKey
+  }
+
+  const data = JSON.stringify({
+    data: {
+      type: 'test_params',
+      attributes: {
+        test_level: 'suite',
+        configurations: {
+          'os.platform': osPlatform,
+          'os.version': osVersion,
+          'os.architecture': osArchitecture,
+          'runtime.name': runtimeName,
+          'runtime.version': runtimeVersion
+        },
+        service,
+        env,
+        repository_url: repositoryUrl,
+        sha
+      }
+    }
+  })
+
+  request(data, options, (err, res) => {
+    if (err) {
+      done(err)
+    } else {
+      let skippableSuites = []
+      try {
+        skippableSuites = JSON.parse(res)
+          .data
+          .filter(({ type }) => type === 'suite')
+          .map(({ attributes: { suite } }) => suite)
+        done(null, skippableSuites)
+      } catch (err) {
+        done(err)
+      }
+    }
+  })
+}
+
+module.exports = { getSkippableSuites }

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

@@ -3,12 +3,13 @@
 const fs = require('fs')
 const os = require('os')
 const URL = require('url').URL
-const path = require('path')
+const log = require('./log')
 const pkg = require('./pkg')
 const coalesce = require('koalas')
 const tagger = require('./tagger')
 const { isTrue, isFalse } = require('./util')
 const uuid = require('crypto-randomuuid')
+const path = require('path')
 
 const fromEntries = Object.fromEntries || (entries =>
   entries.reduce((obj, [k, v]) => Object.assign(obj, { [k]: v }), {}))
@@ -16,6 +17,25 @@ const fromEntries = Object.fromEntries || (entries =>
 // eslint-disable-next-line max-len
 const qsRegex = '(?:p(?:ass)?w(?:or)?d|pass(?:_?phrase)?|secret|(?:api_?|private_?|public_?|access_?|secret_?)key(?:_?id)?|token|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)(?:(?:\\s|%20)*(?:=|%3D)[^&]+|(?:"|%22)(?:\\s|%20)*(?::|%3A)(?:\\s|%20)*(?:"|%22)(?:%2[^2]|%[^2]|[^"%])+(?:"|%22))|bearer(?:\\s|%20)+[a-z0-9\\._\\-]+|token(?::|%3A)[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|ey[I-L](?:[\\w=-]|%3D)+\\.ey[I-L](?:[\\w=-]|%3D)+(?:\\.(?:[\\w.+\\/=-]|%3D|%2F|%2B)+)?|[\\-]{5}BEGIN(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY[\\-]{5}[^\\-]+[\\-]{5}END(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY|ssh-rsa(?:\\s|%20)*(?:[a-z0-9\\/\\.+]|%2F|%5C|%2B){100,}'
 
+function maybeFile (filepath) {
+  if (!filepath) return
+  try {
+    return fs.readFileSync(filepath, 'utf8')
+  } catch (e) {
+    return undefined
+  }
+}
+
+function maybePath (filepath) {
+  if (!filepath) return
+  try {
+    fs.openSync(filepath, 'r')
+    return filepath
+  } catch (e) {
+    return undefined
+  }
+}
+
 function safeJsonParse (input) {
   try {
     return JSON.parse(input)
@@ -38,6 +58,21 @@ class Config {
   constructor (options) {
     options = options || {}
 
+    // Configure the logger first so it can be used to warn about other configs
+    this.debug = isTrue(coalesce(
+      process.env.DD_TRACE_DEBUG,
+      false
+    ))
+    this.logger = options.logger
+    this.logLevel = coalesce(
+      options.logLevel,
+      process.env.DD_TRACE_LOG_LEVEL,
+      'debug'
+    )
+
+    log.use(this.logger)
+    log.toggle(this.debug, this.logLevel, this)
+
     this.tags = {}
 
     tagger.add(this.tags, process.env.DD_TAGS)
@@ -70,6 +105,11 @@ class Config {
       process.env.DD_RUNTIME_METRICS_ENABLED,
       false
     )
+    const DD_DBM_PROPAGATION_MODE = coalesce(
+      options.dbmPropagationMode,
+      process.env.DD_DBM_PROPAGATION_MODE,
+      'disabled'
+    )
     const DD_AGENT_HOST = coalesce(
       options.hostname,
       process.env.DD_AGENT_HOST,
@@ -87,6 +127,10 @@ class Config {
       process.env.DD_TRACE_URL,
       null
     )
+    const DD_IS_CIVISIBILITY = coalesce(
+      options.isCiVisibility,
+      false
+    )
     const DD_CIVISIBILITY_AGENTLESS_URL = process.env.DD_CIVISIBILITY_AGENTLESS_URL
 
     const DD_CIVISIBILITY_ITR_ENABLED = coalesce(
@@ -101,7 +145,12 @@ class Config {
       process.env.AWS_LAMBDA_FUNCTION_NAME ||
       pkg.name ||
       'node'
-    const DD_SERVICE_MAPPING = process.env.DD_SERVICE_MAPPING || ''
+    const DD_SERVICE_MAPPING = coalesce(
+      options.serviceMapping,
+      process.env.DD_SERVICE_MAPPING ? fromEntries(
+        process.env.DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
+      ) : {}
+    )
     const DD_ENV = coalesce(
       options.env,
       process.env.DD_ENV,
@@ -122,10 +171,6 @@ class Config {
       process.env.DD_TRACE_TELEMETRY_ENABLED,
       !process.env.AWS_LAMBDA_FUNCTION_NAME
     )
-    const DD_TRACE_DEBUG = coalesce(
-      process.env.DD_TRACE_DEBUG,
-      false
-    )
     const DD_TRACE_AGENT_PROTOCOL_VERSION = coalesce(
       options.protocolVersion,
       process.env.DD_TRACE_AGENT_PROTOCOL_VERSION,
@@ -140,10 +185,6 @@ class Config {
       process.env.DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
       qsRegex
     )
-    const DD_TRACE_CLIENT_IP_HEADER_DISABLED = coalesce(
-      process.env.DD_TRACE_CLIENT_IP_HEADER_DISABLED,
-      false
-    )
     const DD_TRACE_CLIENT_IP_HEADER = coalesce(
       process.env.DD_TRACE_CLIENT_IP_HEADER,
       null
@@ -184,20 +225,24 @@ class Config {
       false
     )
 
-    let appsec = options.appsec || (options.experimental && options.experimental.appsec)
+    let appsec = options.appsec != null ? options.appsec : options.experimental && options.experimental.appsec
+
+    if (typeof appsec === 'boolean') {
+      appsec = {
+        enabled: appsec
+      }
+    } else if (appsec == null) {
+      appsec = {}
+    }
 
     const DD_APPSEC_ENABLED = coalesce(
-      appsec && (appsec === true || appsec.enabled === true), // TODO: remove when enabled by default
-      process.env.DD_APPSEC_ENABLED,
-      false
+      appsec.enabled,
+      process.env.DD_APPSEC_ENABLED && isTrue(process.env.DD_APPSEC_ENABLED)
     )
 
-    appsec = appsec || {}
-
     const DD_APPSEC_RULES = coalesce(
       appsec.rules,
-      process.env.DD_APPSEC_RULES,
-      path.join(__dirname, 'appsec', 'recommended.json')
+      process.env.DD_APPSEC_RULES
     )
     const DD_APPSEC_TRACE_RATE_LIMIT = coalesce(
       parseInt(appsec.rateLimit),
@@ -223,6 +268,29 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
 \\s+[a-z0-9\\._\\-]+|token:[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|ey[I-L][\\w=-]+\\.ey[I-L][\\w=-]+(?:\\.[\\w.+\\/=-]+)?\
 |[\\-]{5}BEGIN[a-z\\s]+PRIVATE\\sKEY[\\-]{5}[^\\-]+[\\-]{5}END[a-z\\s]+PRIVATE\\sKEY|ssh-rsa\\s*[a-z0-9\\/\\.+]{100,}`
     )
+    const DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML = coalesce(
+      maybePath(appsec.blockedTemplateHtml),
+      maybePath(process.env.DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML),
+      path.join(__dirname, 'appsec', 'templates', 'blocked.html')
+    )
+    const DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON = coalesce(
+      maybePath(appsec.blockedTemplateJson),
+      maybePath(process.env.DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON),
+      path.join(__dirname, 'appsec', 'templates', 'blocked.json')
+    )
+
+    const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
+
+    const remoteConfigOptions = options.remoteConfig || {}
+    const DD_REMOTE_CONFIGURATION_ENABLED = coalesce(
+      process.env.DD_REMOTE_CONFIGURATION_ENABLED && isTrue(process.env.DD_REMOTE_CONFIGURATION_ENABLED),
+      !inAWSLambda
+    )
+    const DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS = coalesce(
+      parseInt(remoteConfigOptions.pollInterval),
+      parseInt(process.env.DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS),
+      5 // seconds
+    )
 
     const iastOptions = options.experimental && options.experimental.iast
     const DD_IAST_ENABLED = coalesce(
@@ -267,18 +335,32 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
         ingestion.sampleRate
       ),
       rateLimit: coalesce(options.rateLimit, process.env.DD_TRACE_RATE_LIMIT, ingestion.rateLimit),
-      rules: coalesce(options.samplingRules, safeJsonParse(process.env.DD_TRACE_SAMPLING_RULES), []).map(rule => {
+      rules: coalesce(
+        options.samplingRules,
+        safeJsonParse(process.env.DD_TRACE_SAMPLING_RULES),
+        []
+      ).map(rule => {
         return remapify(rule, {
           sample_rate: 'sampleRate'
         })
+      }),
+      spanSamplingRules: coalesce(
+        options.spanSamplingRules,
+        safeJsonParse(maybeFile(process.env.DD_SPAN_SAMPLING_RULES_FILE)),
+        safeJsonParse(process.env.DD_SPAN_SAMPLING_RULES),
+        []
+      ).map(rule => {
+        return remapify(rule, {
+          sample_rate: 'sampleRate',
+          max_per_second: 'maxPerSecond'
+        })
       })
     }
 
-    const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
     const defaultFlushInterval = inAWSLambda ? 0 : 2000
 
     this.tracing = !isFalse(DD_TRACING_ENABLED)
-    this.debug = isTrue(DD_TRACE_DEBUG)
+    this.dbmPropagationMode = DD_DBM_PROPAGATION_MODE
     this.logInjection = isTrue(DD_LOGS_INJECTION)
     this.env = DD_ENV
     this.url = DD_CIVISIBILITY_AGENTLESS_URL ? new URL(DD_CIVISIBILITY_AGENTLESS_URL)
@@ -290,14 +372,10 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this.sampleRate = coalesce(Math.min(Math.max(sampler.sampleRate, 0), 1), 1)
     this.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
-    this.clientIpHeaderDisabled = isTrue(DD_TRACE_CLIENT_IP_HEADER_DISABLED)
     this.clientIpHeader = DD_TRACE_CLIENT_IP_HEADER
-    this.logger = options.logger
     this.plugins = !!coalesce(options.plugins, true)
     this.service = DD_SERVICE
-    this.serviceMapping = DD_SERVICE_MAPPING.length ? fromEntries(
-      DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
-    ) : {}
+    this.serviceMapping = DD_SERVICE_MAPPING
     this.version = DD_VERSION
     this.dogstatsd = {
       hostname: coalesce(dogstatsd.hostname, process.env.DD_DOGSTATSD_HOSTNAME, this.hostname),
@@ -314,11 +392,6 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.sampler = sampler
     this.reportHostname = isTrue(coalesce(options.reportHostname, process.env.DD_TRACE_REPORT_HOSTNAME, false))
     this.scope = process.env.DD_TRACE_SCOPE
-    this.logLevel = coalesce(
-      options.logLevel,
-      process.env.DD_TRACE_LOG_LEVEL,
-      'debug'
-    )
     this.profiling = {
       enabled: isTrue(DD_PROFILING_ENABLED),
       sourceMap: !isFalse(DD_PROFILING_SOURCE_MAP),
@@ -331,12 +404,18 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.protocolVersion = DD_TRACE_AGENT_PROTOCOL_VERSION
     this.tagsHeaderMaxLength = parseInt(DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH)
     this.appsec = {
-      enabled: isTrue(DD_APPSEC_ENABLED),
+      enabled: DD_APPSEC_ENABLED,
       rules: DD_APPSEC_RULES,
       rateLimit: DD_APPSEC_TRACE_RATE_LIMIT,
       wafTimeout: DD_APPSEC_WAF_TIMEOUT,
       obfuscatorKeyRegex: DD_APPSEC_OBFUSCATION_PARAMETER_KEY_REGEXP,
-      obfuscatorValueRegex: DD_APPSEC_OBFUSCATION_PARAMETER_VALUE_REGEXP
+      obfuscatorValueRegex: DD_APPSEC_OBFUSCATION_PARAMETER_VALUE_REGEXP,
+      blockedTemplateHtml: DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML,
+      blockedTemplateJson: DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON
+    }
+    this.remoteConfig = {
+      enabled: DD_REMOTE_CONFIGURATION_ENABLED,
+      pollInterval: DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS
     }
     this.iast = {
       enabled: isTrue(DD_IAST_ENABLED),
@@ -344,8 +423,13 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       maxConcurrentRequests: DD_IAST_MAX_CONCURRENT_REQUESTS,
       maxContextOperations: DD_IAST_MAX_CONTEXT_OPERATIONS
     }
-    this.isGitUploadEnabled = isTrue(DD_CIVISIBILITY_GIT_UPLOAD_ENABLED)
-    this.isIntelligentTestRunnerEnabled = isTrue(DD_CIVISIBILITY_ITR_ENABLED)
+
+    this.isCiVisibility = isTrue(DD_IS_CIVISIBILITY)
+
+    this.isIntelligentTestRunnerEnabled = this.isCiVisibility && isTrue(DD_CIVISIBILITY_ITR_ENABLED)
+    this.isGitUploadEnabled = this.isCiVisibility &&
+      (this.isIntelligentTestRunnerEnabled || isTrue(DD_CIVISIBILITY_GIT_UPLOAD_ENABLED))
+
     this.stats = {
       enabled: isTrue(DD_TRACE_STATS_COMPUTATION_ENABLED)
     }

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

@@ -15,6 +15,14 @@ module.exports = {
   SAMPLING_MECHANISM_MANUAL: 4,
   SAMPLING_MECHANISM_APPSEC: 5,
   SAMPLING_MECHANISM_SPAN: 8,
+  SPAN_SAMPLING_MECHANISM: '_dd.span_sampling.mechanism',
+  SPAN_SAMPLING_RULE_RATE: '_dd.span_sampling.rule_rate',
+  SPAN_SAMPLING_MAX_PER_SECOND: '_dd.span_sampling.max_per_second',
   DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
-  DECISION_MAKER_KEY: '_dd.p.dm'
+  DECISION_MAKER_KEY: '_dd.p.dm',
+  PROCESS_ID: 'process_id',
+  ERROR_TYPE: 'error.type',
+  ERROR_MESSAGE: 'error.message',
+  ERROR_STACK: 'error.stack',
+  COMPONENT: 'component'
 }