@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,157 @@
+'use strict'
+
+const log = require('../../log')
+const tags = require('../../../../../ext/tags')
+
+const RESOURCE_NAME = tags.RESOURCE_NAME
+const SPAN_TYPE = tags.SPAN_TYPE
+const SPAN_KIND = tags.SPAN_KIND
+const HTTP_URL = tags.HTTP_URL
+const HTTP_METHOD = tags.HTTP_METHOD
+const HTTP_ROUTE = tags.HTTP_ROUTE
+
+const PROXY_HEADER_SYSTEM = 'x-dd-proxy'
+const PROXY_HEADER_START_TIME_MS = 'x-dd-proxy-request-time-ms'
+const PROXY_HEADER_PATH = 'x-dd-proxy-path'
+const PROXY_HEADER_HTTPMETHOD = 'x-dd-proxy-httpmethod'
+const PROXY_HEADER_DOMAIN = 'x-dd-proxy-domain-name'
+const PROXY_HEADER_STAGE = 'x-dd-proxy-stage'
+const PROXY_HEADER_REGION = 'x-dd-proxy-region'
+const PROXY_HEADER_RESOURCE_PATH = 'x-dd-proxy-resource-path'
+const PROXY_HEADER_ACCOUNT_ID = 'x-dd-proxy-account-id'
+const PROXY_HEADER_API_ID = 'x-dd-proxy-api-id'
+const PROXY_HEADER_AWS_USER = 'x-dd-proxy-user'
+
+const supportedProxies = {
+  'aws-apigateway': {
+    spanName: 'aws.apigateway',
+    component: 'aws-apigateway',
+  },
+  'aws-httpapi': {
+    spanName: 'aws.httpapi',
+    component: 'aws-httpapi',
+  },
+  'azure-apim': {
+    spanName: 'azure.apim',
+    component: 'azure-apim',
+  },
+}
+
+function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, config, startSpanHelper) {
+  if (!headers) {
+    return null
+  }
+
+  if (!tracer._config?.inferredProxyServicesEnabled) {
+    return null
+  }
+
+  const proxyContext = extractInferredProxyContext(headers)
+
+  if (!proxyContext) {
+    return null
+  }
+
+  const proxySpanInfo = supportedProxies[proxyContext.proxySystemName]
+
+  log.debug('Successfully extracted inferred span info %s for proxy:', proxyContext, proxyContext.proxySystemName)
+
+  const span = startSpanHelper(tracer, proxySpanInfo.spanName, {
+    childOf,
+    type: 'web',
+    startTime: proxyContext.requestTime,
+    integrationName: proxySpanInfo.component,
+    meta: {
+      service: proxyContext.domainName || tracer._config.service,
+      component: proxySpanInfo.component,
+      [SPAN_TYPE]: 'web',
+      [SPAN_KIND]: 'server',
+      [HTTP_METHOD]: proxyContext.method,
+      [HTTP_URL]: 'https://' + proxyContext.domainName + proxyContext.path,
+      stage: proxyContext.stage,
+      region: proxyContext.region,
+      ...(proxyContext.resourcePath && { [HTTP_ROUTE]: proxyContext.resourcePath }),
+      ...(proxyContext.accountId && { account_id: proxyContext.accountId }),
+      ...(proxyContext.apiId && { apiid: proxyContext.apiId }),
+      ...(proxyContext.region && { region: proxyContext.region }),
+      ...(proxyContext.awsUser && { aws_user: proxyContext.awsUser }),
+    },
+  }, traceCtx, config)
+
+  reqCtx.inferredProxySpan = span
+  childOf = span
+
+  log.debug('Successfully created inferred proxy span.')
+
+  setInferredProxySpanTags(span, proxyContext)
+
+  return childOf
+}
+
+function setInferredProxySpanTags (span, proxyContext) {
+  const resourcePath = proxyContext.resourcePath || proxyContext.path
+  span.setTag(RESOURCE_NAME, `${proxyContext.method} ${resourcePath}`)
+  span.setTag('_dd.inferred_span', 1)
+
+  // Set dd_resource_key as API Gateway ARN if we have the required components
+  if (proxyContext.apiId && proxyContext.region) {
+    const partition = 'aws'
+    // API Gateway v1 (REST): arn:{partition}:apigateway:{region}::/restapis/{api-id}
+    // API Gateway v2 (HTTP): arn:{partition}:apigateway:{region}::/apis/{api-id}
+    const apiType = proxyContext.proxySystemName === 'aws-httpapi' ? 'apis' : 'restapis'
+    span.setTag(
+      'dd_resource_key',
+      `arn:${partition}:apigateway:${proxyContext.region}::/${apiType}/${proxyContext.apiId}`
+    )
+  }
+
+  return span
+}
+
+function extractInferredProxyContext (headers) {
+  if (!(PROXY_HEADER_START_TIME_MS in headers)) {
+    return null
+  }
+
+  if (!(PROXY_HEADER_SYSTEM in headers && headers[PROXY_HEADER_SYSTEM] in supportedProxies)) {
+    log.debug('Received headers to create inferred proxy span but headers include an unsupported proxy type', headers)
+    return null
+  }
+
+  return {
+    requestTime: headers[PROXY_HEADER_START_TIME_MS]
+      ? Number.parseInt(headers[PROXY_HEADER_START_TIME_MS], 10)
+      : null,
+    method: headers[PROXY_HEADER_HTTPMETHOD],
+    path: headers[PROXY_HEADER_PATH],
+    stage: headers[PROXY_HEADER_STAGE],
+    domainName: headers[PROXY_HEADER_DOMAIN],
+    proxySystemName: headers[PROXY_HEADER_SYSTEM],
+    region: headers[PROXY_HEADER_REGION],
+    resourcePath: headers[PROXY_HEADER_RESOURCE_PATH],
+    accountId: headers[PROXY_HEADER_ACCOUNT_ID],
+    apiId: headers[PROXY_HEADER_API_ID],
+    awsUser: headers[PROXY_HEADER_AWS_USER],
+  }
+}
+
+function finishInferredProxySpan (context) {
+  const { req } = context
+
+  if (!context.inferredProxySpan) return
+
+  if (context.inferredProxySpanFinished && !req.stream) return
+
+  // context.config.hooks.request(context.inferredProxySpan, req, res) # TODO: Do we need this??
+
+  // Only close the inferred span if one was created
+  if (context.inferredProxySpan) {
+    context.inferredProxySpan.finish()
+    context.inferredProxySpanFinished = true
+  }
+}
+
+module.exports = {
+  createInferredProxySpan,
+  finishInferredProxySpan,
+}

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

@@ -0,0 +1,139 @@
+'use strict'
+
+const net = require('net')
+
+const FORWARED_HEADER_NAME = 'forwarded'
+
+const ipHeaderList = [
+  'x-forwarded-for',
+  'x-real-ip',
+  'true-client-ip',
+  'x-client-ip',
+  FORWARED_HEADER_NAME,
+  'forwarded-for',
+  'x-cluster-client-ip',
+  'fastly-client-ip',
+  'cf-connecting-ip',
+  'cf-connecting-ipv6',
+]
+
+const privateCIDRs = [
+  '127.0.0.0/8',
+  '10.0.0.0/8',
+  '172.16.0.0/12',
+  '192.168.0.0/16',
+  '169.254.0.0/16',
+  '100.65.0.0/10',
+  '::1/128',
+  'fec0::/10',
+  'fe80::/10',
+  'fc00::/7',
+  'fd00::/8',
+]
+
+const privateIPMatcher = new net.BlockList()
+
+for (const cidr of privateCIDRs) {
+  const [address, prefix] = cidr.split('/')
+
+  privateIPMatcher.addSubnet(address, Number.parseInt(prefix), net.isIPv6(address) ? 'ipv6' : 'ipv4')
+}
+
+function extractIp (config, req) {
+  const headers = req.headers
+  if (config.clientIpHeader) {
+    if (!headers) return
+
+    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
+  }
+
+  let firstPrivateIp
+  if (headers) {
+    for (const ipHeaderName of ipHeaderList) {
+      const header = headers[ipHeaderName]
+      if (typeof header !== 'string') continue
+
+      const ip = findFirstIp(header, ipHeaderName === FORWARED_HEADER_NAME)
+
+      if (ip.public) {
+        return ip.public
+      } else if (!firstPrivateIp && ip.private) {
+        firstPrivateIp = ip.private
+      }
+    }
+  }
+
+  return firstPrivateIp || req.socket?.remoteAddress
+}
+
+function findFirstIp (str, isForwardedHeader) {
+  const result = {}
+  if (!str) return result
+
+  const splitted = str.split(',')
+
+  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: 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 (!privateIPMatcher.check(chunk, type === 6 ? 'ipv6' : 'ipv4')) {
+      // it's public, return it immediately
+      result.public = chunk
+      return result
+    }
+
+    // it's private, only save the first one found
+    if (!result.private) result.private = chunk
+  }
+
+  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()
+  }
+
+  const closingBracketIndex = input.indexOf(']')
+  if (closingBracketIndex !== -1 && input.startsWith('[')) {
+    // treat as ipv6 with brackets
+    return input.slice(1, closingBracketIndex).trim()
+  }
+
+  // no need to clean it
+  return input
+}
+
+module.exports = {
+  extractIp,
+  ipHeaderList,
+}

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

@@ -0,0 +1,54 @@
+'use strict'
+
+const Sampler = require('../../sampler')
+
+const RE_NEWLINE = /\n/g
+const RE_TAB = /\t/g
+
+function normalize (text, limit = 128) {
+  if (typeof text !== 'string' || text.length === 0) return
+
+  if (text.length > limit) {
+    return text.slice(0, limit) + '...'
+  }
+
+  text = text
+    .replaceAll(RE_NEWLINE, String.raw`\n`)
+    .replaceAll(RE_TAB, String.raw`\t`)
+
+  // In case the replace above matched, more characters were added that must now be considered.
+  if (text.length > limit) {
+    return text.slice(0, limit) + '...'
+  }
+
+  return text
+}
+
+/**
+ * Determines whether a prompt completion should be sampled based on the configured sampling rate.
+ *
+ * @param {Sampler} sampler
+ * @param {import('index').Span|import('index').SpanContext} span
+ * @returns {boolean} `true` if the prompt completion should be sampled, otherwise `false`.
+ */
+function isPromptCompletionSampled (sampler, span) {
+  return sampler.isSampled(span)
+}
+
+module.exports = function makeUtilities (integrationName, tracerConfig) {
+  const integrationConfig = tracerConfig[integrationName] || {}
+  const { spanCharLimit, spanPromptCompletionSampleRate } = integrationConfig
+
+  const sampler = new Sampler(spanPromptCompletionSampleRate ?? 1)
+
+  return {
+    normalize: str => normalize(str, spanCharLimit),
+    /**
+     * Determines whether a prompt completion should be sampled based on the configured sampling rate.
+     *
+     * @param {import('index').Span|import('index').SpanContext} span
+     * @returns {boolean} `true` if the prompt completion should be sampled, otherwise `false`.
+     */
+    isPromptCompletionSampled: (span) => isPromptCompletionSampled(sampler, span),
+  }
+}

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

@@ -0,0 +1,244 @@
+'use strict'
+
+const { relative, sep, join } = require('path')
+
+const cwd = process.cwd()
+
+const NODE_MODULES_PATTERN_MIDDLE = `${sep}node_modules${sep}`
+const NODE_MODULES_PATTERN_START = `node_modules${sep}`
+
+/**
+ * We detect if we're running inside the dd-trace-js repo by checking if the
+ * current file path ends with the expected path structure from the repo root.
+ * This is needed for local and CI where dd-trace-js is not in node_modules.
+ * In production, these frames are already filtered by isNodeModulesFrame.
+ */
+const SHOULD_FILTER_DD_TRACE_INSTRUMENTAION = __filename.endsWith(
+  join(sep, 'dd-trace-js', 'packages', 'dd-trace', 'src', 'plugins', 'util', 'stacktrace.js')
+)
+
+module.exports = {
+  getCallSites,
+  parseUserLandFrames,
+}
+
+// From https://github.com/felixge/node-stack-trace/blob/ba06dcdb50d465cd440d84a563836e293b360427/index.js#L1
+function getCallSites (constructorOpt) {
+  const oldLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = Infinity
+
+  const dummy = {}
+
+  const v8Handler = Error.prepareStackTrace
+  Error.prepareStackTrace = function (_, v8StackTrace) {
+    return v8StackTrace
+  }
+  Error.captureStackTrace(dummy, constructorOpt)
+
+  const v8StackTrace = dummy.stack
+  Error.prepareStackTrace = v8Handler
+  Error.stackTraceLimit = oldLimit
+
+  return v8StackTrace
+}
+
+/**
+ * Get stack trace of user-land frames.
+ *
+ * @param {string} stack - The stack trace to parse
+ * @param {number} [limit=Infinity] - The maximum number of frames to return
+ * @returns {StackFrame[]} - A list of stack frames from user-land code
+ */
+function parseUserLandFrames (stack, limit = Infinity) {
+  let index = stack.indexOf('\n    at ')
+  const frames = []
+
+  while (index !== -1 && frames.length !== limit) {
+    const nextIndex = stack.indexOf('\n', index + 1)
+    const frame = parseLine(stack, index, nextIndex === -1 ? stack.length : nextIndex)
+    if (frame !== undefined) frames.push(frame)
+    index = nextIndex
+  }
+
+  return frames
+}
+
+/**
+ * Parses a line of the stack trace and returns the parsed frame if it is a user-land frame.
+ * Returns `undefined` otherwise.
+ *
+ * @param {string} stack - The stack trace in which the line is located.
+ * @param {number} start - The start index of the line to parse within the stack trace.
+ * @param {number} end - The end index of the line to parse within the stack trace.
+ * @returns {StackFrame|undefined} The parsed frame if it is a user frame, `undefined` otherwise.
+ *
+ * @typedef {object} StackFrame
+ * @property {string} fileName - The file name of the frame.
+ * @property {string} lineNumber - The line number of the frame.
+ * @property {string} columnNumber - The column number of the frame.
+ * @property {string} [functionName] - The function name of the frame.
+ * @property {string} [methodName] - The method name of the frame.
+ * @property {string} [typeName] - The type name of the frame.
+ */
+function parseLine (stack, start, end) {
+  let index
+  if (stack[end - 1] === ')') {
+    index = end - 2 // skip the last closing parenthesis
+    const code = stack.charCodeAt(index)
+    if (code < 0x30 || code > 0x39) return // not a digit
+  } else {
+    index = end - 1
+  }
+
+  start += 8 // skip the `\n    at ` prefix
+  if (stack.startsWith('new ', start)) start += 4 // skip `new `
+  else if (stack.startsWith('async ', start)) start += 6 // skip `async `
+
+  let fileName, lineNumber, columnNumber
+  const result = parseLocation(stack, start, index)
+  if (result === undefined) return
+  [fileName, lineNumber, columnNumber, index] = result
+
+  if (isNodeModulesFrame(fileName)) return
+  if (SHOULD_FILTER_DD_TRACE_INSTRUMENTAION && isDDInstrumentationFile(fileName)) return
+
+  // parse method name
+  let methodName, functionName
+  if (stack[index] === ']') {
+    methodName = ''
+    index-- // skip the closing square bracket
+    for (; index >= start; index--) {
+      const char = stack[index]
+      if (char === ' ' && stack.slice(index - 4, index) === ' [as') {
+        // The space after `[as` in `[as Foo]`
+        index -= 4 // skip ` [as`
+        break
+      } else if (char === '[') {
+        // This isn't a method name after all, but probably a symbol
+        functionName = `${stack.slice(start, index)}[${methodName}]`
+        methodName = undefined
+        break
+      }
+      methodName = char + methodName
+    }
+    index-- // skip the opening square bracket
+  }
+
+  // parse function and type name
+  functionName ??= start <= index ? stack.slice(start, index + 1) : undefined
+  let typeName
+  if (functionName !== undefined && functionName[0] !== '[') {
+    const periodIndex = functionName.indexOf('.')
+    if (periodIndex !== -1) {
+      typeName = functionName.slice(0, periodIndex)
+      functionName = functionName.slice(periodIndex + 1)
+    }
+  }
+
+  return {
+    lineNumber,
+    columnNumber,
+    fileName,
+    methodName,
+    functionName,
+    typeName,
+  }
+}
+
+// TODO: Technically, the algorithm below could be simplified to not use the relative path, but be simply:
+//
+//     return filename.includes(NODE_MODULES_PATTERN_MIDDLE))
+//
+// However, if the user happens to be running this within a directory where `node_modules` is one of the parent
+// directories, it will be flagged as a false positive.
+function isNodeModulesFrame (fileName) {
+  // Quick check first - if it doesn't contain node_modules, it's not a node_modules frame
+  if (!fileName.includes(NODE_MODULES_PATTERN_MIDDLE)) {
+    return false
+  }
+
+  // More expensive relative path calculation only when necessary
+  const actualPath = fileName.startsWith('file:') ? fileName.slice(7) : fileName
+  const relativePath = relative(cwd, actualPath)
+
+  return relativePath.startsWith(NODE_MODULES_PATTERN_START) || relativePath.includes(NODE_MODULES_PATTERN_MIDDLE)
+}
+
+function isDDInstrumentationFile (fileName) {
+  return fileName.includes(`packages${sep}datadog-instrumentations${sep}src`)
+}
+
+/**
+ * A stack trace location can be in one of the following formats:
+ *
+ * 1. `myscript.js:10:3`
+ * 2. `(myscript.js:10:3`
+ * 3. `(eval at Foo.a (myscript.js:10:3)`
+ * 4. `(eval at Foo.a (myscript.js:10:3), <anonymous>:1:1`
+ * 5. `(eval at Foo.a (eval at Bar.z (myscript.js:10:3)`
+ * 6. `(eval at Foo.a (eval at Bar.z (myscript.js:10:3), <anonymous>:1:1`
+ *
+ * Notice how the optional closing parenthesis is not included in the location string at this point. It has been
+ * skipped to save time.
+ *
+ * This function extracts the `myscript.js:10:3` part, passes it, returns the file name, line number, and column
+ * number and sets the `index` to the start of the whole location string.
+ *
+ * @returns {[string, string, string, number]|undefined}
+ */
+function parseLocation (stack, start, index) {
+  // parse column number
+  let columnNumber = ''
+  for (; index >= start; index--) {
+    const code = stack.charCodeAt(index)
+    if (code === 0x29) { // closing parenthesis
+      // e.g. `eval at Foo.a (eval at Bar.z (myscript.js:10:3))`
+      continue
+    }
+    if (code < 0x30 || code > 0x39) break // not a digit
+    columnNumber = stack[index] + columnNumber
+  }
+
+  index-- // skip colon
+
+  // parse line number
+  let lineNumber = ''
+  for (; index >= start; index--) {
+    const code = stack.charCodeAt(index)
+    if (code < 0x30 || code > 0x39) break // not a digit
+    lineNumber = stack[index] + lineNumber
+  }
+
+  index-- // skip colon
+
+  // parse file name
+  let nestedParenthesis = 1 // 1 instead of 0 because the trailing parenthesis wasn't seen by this function
+  let fileName = ''
+  for (; index >= start; index--) {
+    const char = stack[index]
+    if (char === ')') {
+      nestedParenthesis++
+    } else if (char === '(' && --nestedParenthesis === 0) {
+      index -= 2 // skip the opening parenthesis and the whitespace before it
+      break
+    } else if (nestedParenthesis === 1 && char === ':' && stack.slice(index - 4, index) === 'node') {
+      return // e.g. `node:vm:137:12` is not considered a user frame
+    }
+    fileName = char + fileName
+  }
+
+  if (fileName.startsWith('eval at ')) {
+    // The location we parsed was not the actual location, but the location inside the eval. Let's parse the nested
+    // location, which will be the location of the eval.
+    const result = parseLocation(fileName, 0, fileName.lastIndexOf(',') - 2)
+    if (result === undefined) return
+    [fileName, lineNumber, columnNumber] = result // ignore returned index, as we need to retain the original one
+  }
+
+  return [
+    fileName,
+    lineNumber,
+    columnNumber,
+    index, // return the index, so the caller knows how far we got
+  ]
+}

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

@@ -0,0 +1,81 @@
+'use strict'
+
+const GIT_COMMIT_SHA = 'git.commit.sha'
+const GIT_BRANCH = 'git.branch'
+const GIT_REPOSITORY_URL = 'git.repository_url'
+const GIT_TAG = 'git.tag'
+const GIT_COMMIT_MESSAGE = 'git.commit.message'
+const GIT_COMMIT_COMMITTER_DATE = 'git.commit.committer.date'
+const GIT_COMMIT_COMMITTER_EMAIL = 'git.commit.committer.email'
+const GIT_COMMIT_COMMITTER_NAME = 'git.commit.committer.name'
+const GIT_COMMIT_AUTHOR_DATE = 'git.commit.author.date'
+const GIT_COMMIT_AUTHOR_EMAIL = 'git.commit.author.email'
+const GIT_COMMIT_AUTHOR_NAME = 'git.commit.author.name'
+const GIT_COMMIT_HEAD_SHA = 'git.commit.head.sha'
+const GIT_COMMIT_HEAD_MESSAGE = 'git.commit.head.message'
+const GIT_COMMIT_HEAD_AUTHOR_DATE = 'git.commit.head.author.date'
+const GIT_COMMIT_HEAD_AUTHOR_EMAIL = 'git.commit.head.author.email'
+const GIT_COMMIT_HEAD_AUTHOR_NAME = 'git.commit.head.author.name'
+const GIT_COMMIT_HEAD_COMMITTER_DATE = 'git.commit.head.committer.date'
+const GIT_COMMIT_HEAD_COMMITTER_EMAIL = 'git.commit.head.committer.email'
+const GIT_COMMIT_HEAD_COMMITTER_NAME = 'git.commit.head.committer.name'
+
+const GIT_PULL_REQUEST_BASE_BRANCH_SHA = 'git.pull_request.base_branch_sha'
+const GIT_PULL_REQUEST_BASE_BRANCH_HEAD_SHA = 'git.pull_request.base_branch_head_sha'
+const GIT_PULL_REQUEST_BASE_BRANCH = 'git.pull_request.base_branch'
+
+const CI_PIPELINE_ID = 'ci.pipeline.id'
+const CI_PIPELINE_NAME = 'ci.pipeline.name'
+const CI_PIPELINE_NUMBER = 'ci.pipeline.number'
+const CI_PIPELINE_URL = 'ci.pipeline.url'
+const CI_PROVIDER_NAME = 'ci.provider.name'
+const CI_WORKSPACE_PATH = 'ci.workspace_path'
+const CI_JOB_URL = 'ci.job.url'
+const CI_JOB_NAME = 'ci.job.name'
+const CI_JOB_ID = 'ci.job.id'
+const CI_STAGE_NAME = 'ci.stage.name'
+const CI_NODE_NAME = 'ci.node.name'
+const CI_NODE_LABELS = 'ci.node.labels'
+
+const CI_ENV_VARS = '_dd.ci.env_vars'
+
+const PR_NUMBER = 'pr.number'
+
+module.exports = {
+  GIT_COMMIT_SHA,
+  GIT_BRANCH,
+  GIT_REPOSITORY_URL,
+  GIT_TAG,
+  GIT_COMMIT_MESSAGE,
+  GIT_COMMIT_COMMITTER_DATE,
+  GIT_COMMIT_COMMITTER_EMAIL,
+  GIT_COMMIT_COMMITTER_NAME,
+  GIT_COMMIT_AUTHOR_DATE,
+  GIT_COMMIT_AUTHOR_EMAIL,
+  GIT_COMMIT_AUTHOR_NAME,
+  GIT_COMMIT_HEAD_SHA,
+  GIT_COMMIT_HEAD_MESSAGE,
+  GIT_COMMIT_HEAD_AUTHOR_DATE,
+  GIT_COMMIT_HEAD_AUTHOR_EMAIL,
+  GIT_COMMIT_HEAD_AUTHOR_NAME,
+  GIT_COMMIT_HEAD_COMMITTER_DATE,
+  GIT_COMMIT_HEAD_COMMITTER_EMAIL,
+  GIT_COMMIT_HEAD_COMMITTER_NAME,
+  GIT_PULL_REQUEST_BASE_BRANCH_SHA,
+  GIT_PULL_REQUEST_BASE_BRANCH_HEAD_SHA,
+  GIT_PULL_REQUEST_BASE_BRANCH,
+  CI_PIPELINE_ID,
+  CI_PIPELINE_NAME,
+  CI_PIPELINE_NUMBER,
+  CI_PIPELINE_URL,
+  CI_PROVIDER_NAME,
+  CI_WORKSPACE_PATH,
+  CI_JOB_URL,
+  CI_JOB_NAME,
+  CI_JOB_ID,
+  CI_STAGE_NAME,
+  CI_ENV_VARS,
+  CI_NODE_NAME,
+  CI_NODE_LABELS,
+  PR_NUMBER,
+}