@depup/dd-trace 5.90.0-depup.0

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -0,0 +1,156 @@
+'use strict'
+
+const id = require('../../id')
+const log = require('../../log')
+const { getValueFromEnvSources } = require('../../config/helper')
+const {
+  incrementCountMetric,
+  distributionMetric,
+  TELEMETRY_GIT_REQUESTS_SETTINGS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS_MS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS_ERRORS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
+} = require('../telemetry')
+const { writeSettingsToCache } = require('../test-optimization-cache')
+const request = require('./request')
+
+const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
+const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
+
+function getLibraryConfiguration ({
+  url,
+  isEvpProxy,
+  evpProxyPrefix,
+  env,
+  service,
+  repositoryUrl,
+  sha,
+  osVersion,
+  osPlatform,
+  osArchitecture,
+  runtimeName,
+  runtimeVersion,
+  branch,
+  testLevel = 'suite',
+  custom,
+  tag,
+}, done) {
+  const options = {
+    path: '/api/v2/libraries/tests/services/setting',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    url,
+    timeout: 20_000,
+  }
+
+  if (isEvpProxy) {
+    options.path = `${evpProxyPrefix}/api/v2/libraries/tests/services/setting`
+    options.headers['X-Datadog-EVP-Subdomain'] = 'api'
+  } else {
+    const apiKey = getValueFromEnvSources('DD_API_KEY')
+    if (!apiKey) {
+      return done(new Error('Request to settings endpoint was not done because Datadog API key is not defined.'))
+    }
+    options.headers['dd-api-key'] = apiKey
+  }
+
+  const data = JSON.stringify({
+    data: {
+      id: id().toString(10),
+      type: 'ci_app_test_service_libraries_settings',
+      attributes: {
+        test_level: testLevel,
+        configurations: {
+          'os.platform': osPlatform,
+          'os.version': osVersion,
+          'os.architecture': osArchitecture,
+          'runtime.name': runtimeName,
+          'runtime.version': runtimeVersion,
+          custom,
+        },
+        service,
+        env,
+        repository_url: repositoryUrl,
+        sha,
+        branch: branch || tag,
+      },
+    },
+  })
+
+  incrementCountMetric(TELEMETRY_GIT_REQUESTS_SETTINGS)
+
+  const startTime = Date.now()
+  request(data, options, (err, res, statusCode) => {
+    distributionMetric(TELEMETRY_GIT_REQUESTS_SETTINGS_MS, {}, Date.now() - startTime)
+    if (err) {
+      incrementCountMetric(TELEMETRY_GIT_REQUESTS_SETTINGS_ERRORS, { statusCode })
+      done(err)
+    } else {
+      try {
+        const {
+          data: {
+            attributes: {
+              code_coverage: isCodeCoverageEnabled,
+              tests_skipping: isSuitesSkippingEnabled,
+              itr_enabled: isItrEnabled,
+              require_git: requireGit,
+              early_flake_detection: earlyFlakeDetectionConfig,
+              flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
+              di_enabled: isDiEnabled,
+              known_tests_enabled: isKnownTestsEnabled,
+              test_management: testManagementConfig,
+              impacted_tests_enabled: isImpactedTestsEnabled,
+              coverage_report_upload_enabled: isCoverageReportUploadEnabled,
+            },
+          },
+        } = JSON.parse(res)
+
+        const settings = {
+          isCodeCoverageEnabled,
+          isSuitesSkippingEnabled,
+          isItrEnabled,
+          requireGit,
+          isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
+          earlyFlakeDetectionNumRetries:
+            earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+          earlyFlakeDetectionSlowTestRetries:
+            earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
+          earlyFlakeDetectionFaultyThreshold:
+            earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+          isFlakyTestRetriesEnabled,
+          isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
+          isKnownTestsEnabled,
+          isTestManagementEnabled: (testManagementConfig?.enabled ?? false),
+          testManagementAttemptToFixRetries:
+            testManagementConfig?.attempt_to_fix_retries,
+          isImpactedTestsEnabled,
+          isCoverageReportUploadEnabled: isCoverageReportUploadEnabled ?? false,
+        }
+
+        log.debug('Remote settings: %j', settings)
+
+        if (getValueFromEnvSources('DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE')) {
+          settings.isCodeCoverageEnabled = true
+          log.debug('Dangerously set code coverage to true')
+        }
+        if (getValueFromEnvSources('DD_CIVISIBILITY_DANGEROUSLY_FORCE_TEST_SKIPPING')) {
+          settings.isSuitesSkippingEnabled = true
+          log.debug('Dangerously set test skipping to true')
+        }
+
+        incrementCountMetric(TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE, settings)
+
+        writeSettingsToCache(settings)
+
+        done(null, settings)
+      } catch (err) {
+        done(err)
+      }
+    }
+  })
+}
+
+module.exports = { getLibraryConfiguration }

package/packages/dd-trace/src/ci-visibility/requests/request.js

@@ -0,0 +1,236 @@
+'use strict'
+
+const http = require('http')
+const https = require('https')
+const zlib = require('zlib')
+
+const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
+const { httpAgent, httpsAgent } = require('../../exporters/common/agents')
+const { urlToHttpOptions } = require('../../exporters/common/url-to-http-options-polyfill')
+
+const RATE_LIMIT_MAX_WAIT_MS = 30_000
+const RETRY_BASE_MS = 5000
+const RETRY_JITTER_MS = 2500
+
+/**
+ * Calculates retry delay with jitter to prevent thundering herd.
+ * Delay is RETRY_BASE_MS + random(0, RETRY_JITTER_MS) (e.g. 5–7.5 seconds).
+ *
+ * @returns {number} Delay in milliseconds
+ */
+function getRetryDelay () {
+  return RETRY_BASE_MS + (Math.random() * RETRY_JITTER_MS)
+}
+
+/**
+ * Determines if a network error is retriable (transient failures only).
+ * ECONNREFUSED is retried because it can be transient (service starting up,
+ * restarts, rolling deploys, k8s pod/readiness transitions). ENOTFOUND is
+ * excluded as it indicates DNS failure or wrong host and is usually not transient.
+ *
+ * @param {Error} err - The error to check
+ * @returns {boolean}
+ */
+function isRetriableNetworkError (err) {
+  if (!err.code) return false
+  return err.code === 'ECONNREFUSED' ||
+    err.code === 'ECONNRESET' ||
+    err.code === 'ETIMEDOUT' ||
+    err.code === 'EPIPE'
+}
+
+function parseUrl (urlObjOrString) {
+  if (urlObjOrString !== null && typeof urlObjOrString === 'object') {
+    return urlToHttpOptions(urlObjOrString)
+  }
+
+  const url = urlToHttpOptions(new URL(urlObjOrString))
+
+  if (url.protocol === 'unix:' && url.hostname === '.') {
+    const udsPath = urlObjOrString.slice(5)
+    url.path = udsPath
+    url.pathname = udsPath
+  }
+
+  return url
+}
+
+/**
+ * Simplified HTTP request for test optimization (library config). Uses common HTTP agents.
+ * Retries: 429 (with X-ratelimit-reset, max 30s wait),
+ * >=500 and transient network errors (5–7.5s delay with jitter). Max one retry.
+ * Destroys connections on errors to prevent reuse of bad connections. Preserves
+ * original status code across retries for telemetry.
+ *
+ * @param {string} data - Request body (e.g. JSON string)
+ * @param {object} options - { url, path?, method?, headers?, timeout? } (may be mutated)
+ * @param {Function} callback - (err, res, statusCode) => void
+ */
+function request (data, options, callback) {
+  const headers = options.headers ? { ...options.headers } : {}
+  headers['Content-Length'] = Buffer.byteLength(data, 'utf8')
+
+  const opts = { ...options, method: 'POST', headers }
+
+  if (opts.url) {
+    const url = parseUrl(opts.url)
+    if (url.protocol === 'unix:') {
+      opts.socketPath = url.pathname
+    } else {
+      opts.path = opts.path ?? url.path
+      opts.protocol = url.protocol
+      opts.hostname = url.hostname
+      opts.port = url.port
+    }
+  }
+
+  const timeout = opts.timeout || 2000
+  const isSecure = opts.protocol === 'https:'
+  const client = isSecure ? https : http
+
+  if (!opts.socketPath) {
+    opts.agent = isSecure ? httpsAgent : httpAgent
+  }
+
+  let hasRetried = false
+  let firstStatusCode = null
+
+  const makeRequest = () => {
+    storage('legacy').run({ noop: true }, () => {
+      const req = client.request(opts, (res) => {
+        // Capture non-2xx status code as soon as we see it so telemetry preserves it if the retry
+        // fails with a network error (no HTTP response) before 'end' fires
+        if (res.statusCode >= 400 && firstStatusCode === null) {
+          firstStatusCode = res.statusCode
+        }
+
+        const chunks = []
+
+        res.setTimeout(timeout)
+
+        res.on('data', chunk => {
+          chunks.push(chunk)
+        })
+
+        res.once('end', () => {
+          const buffer = Buffer.concat(chunks)
+
+          if (res.statusCode >= 200 && res.statusCode <= 299) {
+            const isGzip = res.headers['content-encoding'] === 'gzip'
+            if (isGzip) {
+              zlib.gunzip(buffer, (err, result) => {
+                if (err) {
+                  log.error('Could not gunzip response: %s', err.message)
+                  callback(null, '', res.statusCode)
+                } else {
+                  callback(null, result.toString(), res.statusCode)
+                }
+              })
+            } else {
+              callback(null, buffer.toString(), res.statusCode)
+            }
+            return
+          }
+
+          if (res.statusCode === 429 && !hasRetried) {
+            const resetHeader = res.headers['x-ratelimit-reset']
+            const resetTs = (resetHeader === null || resetHeader === undefined)
+              ? Number.NaN
+              : Number.parseInt(resetHeader, 10)
+            const waitMs = Number.isFinite(resetTs) ? Math.max(0, resetTs * 1000 - Date.now()) : Number.NaN
+
+            if (Number.isFinite(waitMs) && waitMs <= RATE_LIMIT_MAX_WAIT_MS) {
+              hasRetried = true
+              setTimeout(makeRequest, waitMs)
+              return
+            }
+
+            if (!Number.isFinite(waitMs) || waitMs > RATE_LIMIT_MAX_WAIT_MS) {
+              log.debug('Rate limited (429): drop payload (wait %sms > %sms or invalid header)',
+                Number.isFinite(waitMs) ? waitMs : 'N/A', RATE_LIMIT_MAX_WAIT_MS)
+            }
+          } else if (res.statusCode >= 500 && !hasRetried) {
+            try {
+              if (req.socket) req.socket.destroy()
+            } catch {
+              // ignore
+            }
+            hasRetried = true
+            setTimeout(makeRequest, getRetryDelay())
+            return
+          }
+
+          const error = buildError(res, buffer, opts)
+          // Use original status code if this is a failed retry
+          callback(error, null, firstStatusCode === null ? res.statusCode : firstStatusCode)
+        })
+      })
+
+      req.once('error', err => {
+        try {
+          if (req.socket) req.socket.destroy()
+        } catch {
+          // ignore
+        }
+
+        // Retry on retriable network errors
+        if (!hasRetried && isRetriableNetworkError(err)) {
+          hasRetried = true
+          setTimeout(makeRequest, getRetryDelay())
+          return
+        }
+
+        // Pass original status code (if any) for accurate telemetry
+        callback(err, null, firstStatusCode)
+      })
+
+      req.setTimeout(timeout, () => {
+        try {
+          if (typeof req.abort === 'function') {
+            req.abort()
+          } else {
+            req.destroy()
+          }
+        } catch {
+          // ignore
+        }
+      })
+
+      req.write(data, 'utf8')
+      req.end()
+    })
+  }
+
+  makeRequest()
+}
+
+/**
+ * @param {object} res - IncomingMessage
+ * @param {Buffer} buffer - Response body
+ * @param {object} options - Request options
+ * @returns {Error}
+ */
+function buildError (res, buffer, options) {
+  let errorMessage = ''
+  try {
+    const fullUrl = new URL(
+      options.path,
+      options.url || options.hostname || `http://localhost:${options.port}`
+    ).href
+    errorMessage = `Error from ${fullUrl}: ${res.statusCode} ${http.STATUS_CODES[res.statusCode]}.`
+  } catch {
+    // ignore
+  }
+
+  const responseData = buffer.toString()
+  if (responseData) {
+    errorMessage += ` Response from the endpoint: "${responseData}"`
+  }
+
+  const error = new log.NoTransmitError(errorMessage)
+  error.status = res.statusCode
+  return error
+}
+
+module.exports = request

package/packages/dd-trace/src/ci-visibility/requests/upload-coverage-report.js

@@ -0,0 +1,107 @@
+'use strict'
+
+const { readFileSync } = require('node:fs')
+const { gzipSync } = require('node:zlib')
+
+const FormData = require('../../exporters/common/form-data')
+const request = require('../../exporters/common/request')
+const log = require('../../log')
+const { getValueFromEnvSources } = require('../../config/helper')
+const {
+  incrementCountMetric,
+  distributionMetric,
+  TELEMETRY_COVERAGE_UPLOAD,
+  TELEMETRY_COVERAGE_UPLOAD_MS,
+  TELEMETRY_COVERAGE_UPLOAD_ERRORS,
+  TELEMETRY_COVERAGE_UPLOAD_BYTES,
+} = require('../telemetry')
+
+const UPLOAD_TIMEOUT_MS = 30_000
+
+/**
+ * Uploads a single coverage report to the Datadog CI intake.
+ * One file per request with field names 'coverage' and 'event'.
+ * @param {object} options - Upload options
+ * @param {string} options.filePath - Path to the coverage report file
+ * @param {string} options.format - Format of the coverage report (e.g., 'lcov', 'cobertura')
+ * @param {object} options.testEnvironmentMetadata - Test environment metadata containing git/CI tags
+ * @param {URL} options.url - The base URL for the coverage report upload
+ * @param {boolean} [options.isEvpProxy] - Whether to use EVP proxy for the upload
+ * @param {string} [options.evpProxyPrefix] - The EVP proxy prefix (e.g., '/evp_proxy/v4')
+ * @param {Function} callback - Callback function (err)
+ */
+function uploadCoverageReport (
+  { filePath, format, testEnvironmentMetadata, url, isEvpProxy, evpProxyPrefix },
+  callback
+) {
+  const apiKey = getValueFromEnvSources('DD_API_KEY')
+
+  if (!apiKey && !isEvpProxy) {
+    return callback(new Error('DD_API_KEY is required for coverage report upload'))
+  }
+
+  let compressedCoverage
+  try {
+    const coverageContent = readFileSync(filePath)
+    compressedCoverage = gzipSync(coverageContent)
+  } catch (err) {
+    return callback(new Error(`Failed to read coverage report at ${filePath}: ${err.message}`))
+  }
+
+  // Build the event payload with format, type, and all tags from test environment metadata
+  const eventPayload = {
+    type: 'coverage_report',
+    format,
+    ...testEnvironmentMetadata,
+  }
+
+  // Create multipart form
+  const form = new FormData()
+
+  form.append('coverage', compressedCoverage, {
+    filename: 'coverage.gz',
+    contentType: 'application/gzip',
+  })
+
+  form.append('event', JSON.stringify(eventPayload), {
+    filename: 'event.json',
+    contentType: 'application/json',
+  })
+
+  const options = {
+    method: 'POST',
+    headers: {
+      ...form.getHeaders(),
+    },
+    timeout: UPLOAD_TIMEOUT_MS,
+    url,
+  }
+
+  if (isEvpProxy) {
+    options.path = `${evpProxyPrefix}/api/v2/cicovreprt`
+    options.headers['X-Datadog-EVP-Subdomain'] = 'ci-intake'
+  } else {
+    options.path = '/api/v2/cicovreprt'
+    options.headers['dd-api-key'] = apiKey
+  }
+
+  log.debug('Uploading coverage report %s to %s%s', filePath, url, options.path)
+
+  incrementCountMetric(TELEMETRY_COVERAGE_UPLOAD)
+  distributionMetric(TELEMETRY_COVERAGE_UPLOAD_BYTES, {}, compressedCoverage.length)
+
+  const startTime = Date.now()
+
+  request(form, options, (err, res, statusCode) => {
+    distributionMetric(TELEMETRY_COVERAGE_UPLOAD_MS, {}, Date.now() - startTime)
+    if (err) {
+      incrementCountMetric(TELEMETRY_COVERAGE_UPLOAD_ERRORS, { statusCode })
+      log.error('Error uploading coverage report: %s', err.message)
+      return callback(err)
+    }
+    log.debug('Coverage report uploaded successfully (status: %d)', statusCode)
+    callback(null)
+  })
+}
+
+module.exports = { uploadCoverageReport }

package/packages/dd-trace/src/ci-visibility/telemetry.js

@@ -0,0 +1,204 @@
+'use strict'
+
+const telemetryMetrics = require('../telemetry/metrics')
+
+const ciVisibilityMetrics = telemetryMetrics.manager.namespace('civisibility')
+
+const formattedTags = {
+  testLevel: 'event_type',
+  testFramework: 'test_framework',
+  errorType: 'error_type',
+  exitCode: 'exit_code',
+  isCodeCoverageEnabled: 'coverage_enabled',
+  isSuitesSkippingEnabled: 'itrskip_enabled',
+  hasCodeOwners: 'has_code_owners',
+  isUnsupportedCIProvider: 'is_unsupported_ci',
+  isNew: 'is_new',
+  isRum: 'is_rum',
+  browserDriver: 'browser_driver',
+  autoInjected: 'auto_injected',
+  isQuarantined: 'is_quarantined',
+  isDisabled: 'is_disabled',
+  isTestManagementEnabled: 'test_management_enabled',
+  isItrEnabled: 'itr_enabled',
+  isEarlyFlakeDetectionEnabled: 'early_flake_detection_enabled',
+  isFlakyTestRetriesEnabled: 'flaky_test_retries_enabled',
+  isKnownTestsEnabled: 'known_tests_enabled',
+  isImpactedTestsEnabled: 'impacted_tests_enabled',
+  hasFailedTestReplay: 'has_failed_test_replay',
+  isFailedTestReplayEnabled: 'is_failed_test_replay_enabled',
+  // isDiEnabled is specifically for the settings endpoint telemetry
+  isDiEnabled: 'failed_test_replay_enabled',
+  requireGit: 'require_git',
+  isModified: 'is_modified',
+  isRetry: 'is_retry',
+  retryReason: 'retry_reason',
+}
+
+// Transform tags dictionary to array of strings.
+// If tag value is true, then only tag key is added to the array.
+/**
+ * @param {Record<string, unknown>} tagsDictionary
+ * @returns {string[]}
+ */
+function formatMetricTags (tagsDictionary) {
+  return Object.keys(tagsDictionary).reduce((/** @type {string[]} */ acc, tagKey) => {
+    if (tagKey === 'statusCode') {
+      const statusCode = tagsDictionary[tagKey]
+      if (isStatusCode400(statusCode)) {
+        acc.push(`status_code:${statusCode}`)
+      }
+      acc.push(`error_type:${getErrorTypeFromStatusCode(statusCode)}`)
+      return acc
+    }
+    const formattedTagKey = /** @type {string} */(formattedTags[tagKey] || tagKey)
+    if (tagsDictionary[tagKey] === true) {
+      acc.push(formattedTagKey)
+    } else if (tagsDictionary[tagKey] !== undefined && tagsDictionary[tagKey] !== null) {
+      acc.push(`${formattedTagKey}:${tagsDictionary[tagKey]}`)
+    }
+    return acc
+  }, [])
+}
+
+function incrementCountMetric (name, tags = {}, value = 1) {
+  ciVisibilityMetrics.count(name, formatMetricTags(tags)).inc(value)
+}
+
+function distributionMetric (name, tags, measure) {
+  ciVisibilityMetrics.distribution(name, formatMetricTags(tags)).track(measure)
+}
+
+// CI Visibility telemetry events
+const TELEMETRY_TEST_SESSION = 'test_session'
+const TELEMETRY_EVENT_CREATED = 'event_created'
+const TELEMETRY_EVENT_FINISHED = 'event_finished'
+const TELEMETRY_CODE_COVERAGE_STARTED = 'code_coverage_started'
+const TELEMETRY_CODE_COVERAGE_FINISHED = 'code_coverage_finished'
+const TELEMETRY_ITR_SKIPPED = 'itr_skipped'
+const TELEMETRY_ITR_UNSKIPPABLE = 'itr_unskippable'
+const TELEMETRY_ITR_FORCED_TO_RUN = 'itr_forced_run'
+const TELEMETRY_CODE_COVERAGE_EMPTY = 'code_coverage.is_empty'
+const TELEMETRY_CODE_COVERAGE_NUM_FILES = 'code_coverage.files'
+const TELEMETRY_EVENTS_ENQUEUED_FOR_SERIALIZATION = 'events_enqueued_for_serialization'
+const TELEMETRY_ENDPOINT_PAYLOAD_SERIALIZATION_MS = 'endpoint_payload.events_serialization_ms'
+const TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS = 'endpoint_payload.requests'
+const TELEMETRY_ENDPOINT_PAYLOAD_BYTES = 'endpoint_payload.bytes'
+const TELEMETRY_ENDPOINT_PAYLOAD_EVENTS_COUNT = 'endpoint_payload.events_count'
+const TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS_MS = 'endpoint_payload.requests_ms'
+const TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS_ERRORS = 'endpoint_payload.requests_errors'
+const TELEMETRY_ENDPOINT_PAYLOAD_DROPPED = 'endpoint_payload.dropped'
+const TELEMETRY_GIT_COMMAND = 'git.command'
+const TELEMETRY_GIT_COMMAND_MS = 'git.command_ms'
+const TELEMETRY_GIT_COMMAND_ERRORS = 'git.command_errors'
+const TELEMETRY_GIT_REQUESTS_SEARCH_COMMITS = 'git_requests.search_commits'
+const TELEMETRY_GIT_REQUESTS_SEARCH_COMMITS_MS = 'git_requests.search_commits_ms'
+const TELEMETRY_GIT_REQUESTS_SEARCH_COMMITS_ERRORS = 'git_requests.search_commits_errors'
+const TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES = 'git_requests.objects_pack'
+const TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_MS = 'git_requests.objects_pack_ms'
+const TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_ERRORS = 'git_requests.objects_pack_errors'
+const TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_NUM = 'git_requests.objects_pack_files'
+const TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_BYTES = 'git_requests.objects_pack_bytes'
+const TELEMETRY_GIT_REQUESTS_SETTINGS = 'git_requests.settings'
+const TELEMETRY_GIT_REQUESTS_SETTINGS_MS = 'git_requests.settings_ms'
+const TELEMETRY_GIT_REQUESTS_SETTINGS_ERRORS = 'git_requests.settings_errors'
+const TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE = 'git_requests.settings_response'
+const TELEMETRY_GIT_SHA_MATCH = 'git.commit_sha_match'
+const TELEMETRY_GIT_COMMIT_SHA_DISCREPANCY = 'git.commit_sha_discrepancy'
+const TELEMETRY_ITR_SKIPPABLE_TESTS = 'itr_skippable_tests.request'
+const TELEMETRY_ITR_SKIPPABLE_TESTS_MS = 'itr_skippable_tests.request_ms'
+const TELEMETRY_ITR_SKIPPABLE_TESTS_ERRORS = 'itr_skippable_tests.request_errors'
+const TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_SUITES = 'itr_skippable_tests.response_suites'
+const TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS = 'itr_skippable_tests.response_tests'
+const TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES = 'itr_skippable_tests.response_bytes'
+// early flake detection
+const TELEMETRY_KNOWN_TESTS = 'early_flake_detection.request'
+const TELEMETRY_KNOWN_TESTS_MS = 'early_flake_detection.request_ms'
+const TELEMETRY_KNOWN_TESTS_ERRORS = 'early_flake_detection.request_errors'
+const TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS = 'early_flake_detection.response_tests'
+const TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES = 'early_flake_detection.response_bytes'
+// coverage upload
+const TELEMETRY_COVERAGE_UPLOAD = 'coverage_upload.request'
+const TELEMETRY_COVERAGE_UPLOAD_MS = 'coverage_upload.request_ms'
+const TELEMETRY_COVERAGE_UPLOAD_ERRORS = 'coverage_upload.request_errors'
+const TELEMETRY_COVERAGE_UPLOAD_BYTES = 'coverage_upload.request_bytes'
+// test management
+const TELEMETRY_TEST_MANAGEMENT_TESTS = 'test_management_tests.request'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_MS = 'test_management_tests.request_ms'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS = 'test_management_tests.request_errors'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS = 'test_management_tests.response_tests'
+const TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES = 'test_management_tests.response_bytes'
+
+function isStatusCode400 (statusCode) {
+  return statusCode >= 400 && statusCode < 500
+}
+
+function getErrorTypeFromStatusCode (statusCode) {
+  if (statusCode >= 400 && statusCode < 500) {
+    return 'status_code_4xx_response'
+  }
+  if (statusCode >= 500) {
+    return 'status_code_5xx_response'
+  }
+  return 'network'
+}
+
+module.exports = {
+  incrementCountMetric,
+  distributionMetric,
+  TELEMETRY_TEST_SESSION,
+  TELEMETRY_EVENT_CREATED,
+  TELEMETRY_EVENT_FINISHED,
+  TELEMETRY_CODE_COVERAGE_STARTED,
+  TELEMETRY_CODE_COVERAGE_FINISHED,
+  TELEMETRY_ITR_SKIPPED,
+  TELEMETRY_ITR_UNSKIPPABLE,
+  TELEMETRY_ITR_FORCED_TO_RUN,
+  TELEMETRY_CODE_COVERAGE_EMPTY,
+  TELEMETRY_CODE_COVERAGE_NUM_FILES,
+  TELEMETRY_EVENTS_ENQUEUED_FOR_SERIALIZATION,
+  TELEMETRY_ENDPOINT_PAYLOAD_SERIALIZATION_MS,
+  TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS,
+  TELEMETRY_ENDPOINT_PAYLOAD_BYTES,
+  TELEMETRY_ENDPOINT_PAYLOAD_EVENTS_COUNT,
+  TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS_MS,
+  TELEMETRY_ENDPOINT_PAYLOAD_REQUESTS_ERRORS,
+  TELEMETRY_ENDPOINT_PAYLOAD_DROPPED,
+  TELEMETRY_GIT_COMMAND,
+  TELEMETRY_GIT_COMMAND_MS,
+  TELEMETRY_GIT_COMMAND_ERRORS,
+  TELEMETRY_GIT_REQUESTS_SEARCH_COMMITS,
+  TELEMETRY_GIT_REQUESTS_SEARCH_COMMITS_MS,
+  TELEMETRY_GIT_REQUESTS_SEARCH_COMMITS_ERRORS,
+  TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_NUM,
+  TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_BYTES,
+  TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES,
+  TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_MS,
+  TELEMETRY_GIT_REQUESTS_OBJECT_PACKFILES_ERRORS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS_MS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS_ERRORS,
+  TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
+  TELEMETRY_GIT_SHA_MATCH,
+  TELEMETRY_GIT_COMMIT_SHA_DISCREPANCY,
+  TELEMETRY_ITR_SKIPPABLE_TESTS,
+  TELEMETRY_ITR_SKIPPABLE_TESTS_MS,
+  TELEMETRY_ITR_SKIPPABLE_TESTS_ERRORS,
+  TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_SUITES,
+  TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS,
+  TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES,
+  TELEMETRY_KNOWN_TESTS,
+  TELEMETRY_KNOWN_TESTS_MS,
+  TELEMETRY_KNOWN_TESTS_ERRORS,
+  TELEMETRY_KNOWN_TESTS_RESPONSE_TESTS,
+  TELEMETRY_KNOWN_TESTS_RESPONSE_BYTES,
+  TELEMETRY_COVERAGE_UPLOAD,
+  TELEMETRY_COVERAGE_UPLOAD_MS,
+  TELEMETRY_COVERAGE_UPLOAD_ERRORS,
+  TELEMETRY_COVERAGE_UPLOAD_BYTES,
+  TELEMETRY_TEST_MANAGEMENT_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_MS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_ERRORS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
+  TELEMETRY_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
+}