dd-trace 4.22.0 → 4.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.22.0",
+  "version": "4.23.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -79,7 +79,7 @@
     "crypto-randomuuid": "^1.0.0",
     "dc-polyfill": "^0.1.2",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "^1.4.2",
+    "import-in-the-middle": "^1.7.1",
     "int64-buffer": "^0.1.9",
     "ipaddr.js": "^2.1.0",
     "istanbul-lib-coverage": "3.2.0",

package/packages/datadog-instrumentations/src/child-process.js

@@ -9,11 +9,10 @@ const shimmer = require('../../datadog-shimmer')
 const childProcessChannel = channel('datadog:child_process:execution:start')
 const execMethods = ['exec', 'execFile', 'fork', 'spawn', 'execFileSync', 'execSync', 'spawnSync']
 const names = ['child_process', 'node:child_process']
-names.forEach(name => {
-  addHook({ name }, childProcess => {
-    shimmer.massWrap(childProcess, execMethods, wrapChildProcessMethod())
-    return childProcess
-  })
+
+addHook({ name: names }, childProcess => {
+  shimmer.massWrap(childProcess, execMethods, wrapChildProcessMethod())
+  return childProcess
 })
 
 function wrapChildProcessMethod () {

package/packages/datadog-instrumentations/src/couchbase.js

@@ -252,9 +252,10 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.
   return Cluster
 })
 
-// semver >=3.2.0
+// semver >=3.2.2
+// NOTE: <3.2.2 segfaults on cluster.close() https://issues.couchbase.com/browse/JSCBC-936
 
-addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }, collection => {
+addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }, collection => {
   const Collection = collection.Collection
 
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
@@ -264,7 +265,7 @@ addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }
   return collection
 })
 
-addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bucket => {
+addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {
   const Bucket = bucket.Bucket
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
     return function () {
@@ -278,7 +279,7 @@ addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bu
   return bucket
 })
 
-addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['3.2.0 - 3.2.1', '>=3.2.2'] }, (cluster) => {
+addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)

package/packages/datadog-instrumentations/src/crypto.js

@@ -11,8 +11,9 @@ const cryptoCipherCh = channel('datadog:crypto:cipher:start')
 
 const hashMethods = ['createHash', 'createHmac', 'createSign', 'createVerify', 'sign', 'verify']
 const cipherMethods = ['createCipheriv', 'createDecipheriv']
+const names = ['crypto', 'node:crypto']
 
-addHook({ name: 'crypto' }, crypto => {
+addHook({ name: names }, crypto => {
   shimmer.massWrap(crypto, hashMethods, wrapCryptoMethod(cryptoHashCh))
   shimmer.massWrap(crypto, cipherMethods, wrapCryptoMethod(cryptoCipherCh))
   return crypto

package/packages/datadog-instrumentations/src/dns.js

@@ -18,8 +18,9 @@ const rrtypes = {
 }
 
 const rrtypeMap = new WeakMap()
+const names = ['dns', 'node:dns']
 
-addHook({ name: 'dns' }, dns => {
+addHook({ name: names }, dns => {
   dns.lookup = wrap('apm:dns:lookup', dns.lookup, 2)
   dns.lookupService = wrap('apm:dns:lookup_service', dns.lookupService, 3)
   dns.resolve = wrap('apm:dns:resolve', dns.resolve, 2)

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -31,7 +31,6 @@ module.exports = {
   'bunyan': () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
   'child_process': () => require('../child-process'),
-  'node:child_process': () => require('../child-process'),
   'connect': () => require('../connect'),
   'cookie': () => require('../cookie'),
   'cookie-parser': () => require('../cookie-parser'),
@@ -45,7 +44,6 @@ module.exports = {
   'fastify': () => require('../fastify'),
   'find-my-way': () => require('../find-my-way'),
   'fs': () => require('../fs'),
-  'node:fs': () => require('../fs'),
   'generic-pool': () => require('../generic-pool'),
   'graphql': () => require('../graphql'),
   'grpc': () => require('../grpc'),
@@ -79,6 +77,13 @@ module.exports = {
   'mysql2': () => require('../mysql2'),
   'net': () => require('../net'),
   'next': () => require('../next'),
+  'node:child_process': () => require('../child-process'),
+  'node:crypto': () => require('../crypto'),
+  'node:dns': () => require('../dns'),
+  'node:http': () => require('../http'),
+  'node:http2': () => require('../http2'),
+  'node:https': () => require('../http'),
+  'node:net': () => require('../net'),
   'oracledb': () => require('../oracledb'),
   'openai': () => require('../openai'),
   'paperplane': () => require('../paperplane'),

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -21,11 +21,16 @@ exports.channel = function (name) {
  * @param Function hook
  */
 exports.addHook = function addHook ({ name, versions, file }, hook) {
-  if (!instrumentations[name]) {
-    instrumentations[name] = []
+  if (typeof name === 'string') {
+    name = [name]
   }
 
-  instrumentations[name].push({ name, versions, file, hook })
+  for (const val of name) {
+    if (!instrumentations[val]) {
+      instrumentations[val] = []
+    }
+    instrumentations[val].push({ name: val, versions, file, hook })
+  }
 }
 
 // AsyncResource.bind exists and binds `this` properly only from 17.8.0 and up.

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -24,6 +24,7 @@ if (!disabledInstrumentations.has('fetch')) {
   require('../fetch')
 }
 
+const HOOK_SYMBOL = Symbol('hookExportsMap')
 // TODO: make this more efficient
 
 for (const packageName of names) {
@@ -42,14 +43,29 @@ for (const packageName of names) {
     for (const { name, file, versions, hook } of instrumentations[packageName]) {
       const fullFilename = filename(name, file)
 
+      // Create a WeakMap associated with the hook function so that patches on the same moduleExport only happens once
+      // for example by instrumenting both dns and node:dns double the spans would be created
+      // since they both patch the same moduleExport, this WeakMap is used to mitigate that
+      if (!hook[HOOK_SYMBOL]) {
+        hook[HOOK_SYMBOL] = new WeakMap()
+      }
+
       if (moduleName === fullFilename) {
         const version = moduleVersion || getVersion(moduleBaseDir)
 
         if (matchVersion(version, versions)) {
+          // Check if the hook already has a set moduleExport
+          if (hook[HOOK_SYMBOL].has(moduleExports)) {
+            return moduleExports
+          }
+
           try {
             loadChannel.publish({ name, version, file })
-
-            moduleExports = hook(moduleExports, version)
+            // Send the name and version of the module back to the callback because now addHook
+            // takes in an array of names so by passing the name the callback will know which module name is being used
+            moduleExports = hook(moduleExports, version, name)
+            // Set the moduleExports in the hooks weakmap
+            hook[HOOK_SYMBOL].set(moduleExports, name)
           } catch (e) {
             log.error(e)
           }

package/packages/datadog-instrumentations/src/http/client.js

@@ -14,9 +14,9 @@ const endChannel = channel('apm:http:client:request:end')
 const asyncStartChannel = channel('apm:http:client:request:asyncStart')
 const errorChannel = channel('apm:http:client:request:error')
 
-addHook({ name: 'https' }, hookFn)
+const names = ['http', 'https', 'node:http', 'node:https']
 
-addHook({ name: 'http' }, hookFn)
+addHook({ name: names }, hookFn)
 
 function hookFn (http) {
   patch(http, 'request')

package/packages/datadog-instrumentations/src/http/server.js

@@ -15,14 +15,17 @@ const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finis
 
 const requestFinishedSet = new WeakSet()
 
-addHook({ name: 'https' }, http => {
-  // http.ServerResponse not present on https
+const httpNames = ['http', 'node:http']
+const httpsNames = ['https', 'node:https']
+
+addHook({ name: httpNames }, http => {
+  shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
   return http
 })
 
-addHook({ name: 'http' }, http => {
-  shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
+addHook({ name: httpsNames }, http => {
+  // http.ServerResponse not present on https
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
   return http
 })

package/packages/datadog-instrumentations/src/http2/client.js

@@ -10,6 +10,8 @@ const asyncStartChannel = channel('apm:http2:client:request:asyncStart')
 const asyncEndChannel = channel('apm:http2:client:request:asyncEnd')
 const errorChannel = channel('apm:http2:client:request:error')
 
+const names = ['http2', 'node:http2']
+
 function createWrapEmit (ctx) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
@@ -66,7 +68,7 @@ function wrapConnect (connect) {
   }
 }
 
-addHook({ name: 'http2' }, http2 => {
+addHook({ name: names }, http2 => {
   shimmer.wrap(http2, 'connect', wrapConnect)
 
   return http2

package/packages/datadog-instrumentations/src/http2/server.js

@@ -14,7 +14,9 @@ const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
 const finishServerCh = channel('apm:http2:server:request:finish')
 
-addHook({ name: 'http2' }, http2 => {
+const names = ['http2', 'node:http2']
+
+addHook({ name: names }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
   return http2

package/packages/datadog-instrumentations/src/jest.js

@@ -403,7 +403,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
           const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
             .map(filename => getTestSuitePath(filename, environment.rootDir))
           asyncResource.runInAsyncScope(() => {
-            testSuiteCodeCoverageCh.publish([...coverageFiles, environment.testSuite])
+            testSuiteCodeCoverageCh.publish({ coverageFiles, testSuite: environment.testSuite })
           })
         }
         testSuiteFinishCh.publish({ status, errorMessage })

package/packages/datadog-instrumentations/src/net.js

@@ -17,8 +17,16 @@ const errorTCPCh = channel('apm:net:tcp:error')
 
 const connectionCh = channel(`apm:net:tcp:connection`)
 
-addHook({ name: 'net' }, net => {
-  require('dns')
+const names = ['net', 'node:net']
+
+addHook({ name: names }, (net, version, name) => {
+  // explicitly require dns so that net gets an instrumented instance
+  // so that we don't miss the dns calls
+  if (name === 'net') {
+    require('dns')
+  } else {
+    require('node:dns')
+  }
 
   shimmer.wrap(net.Socket.prototype, 'connect', connect => function () {
     if (!startICPCh.hasSubscribers || !startTCPCh.hasSubscribers) {

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

@@ -12,10 +12,21 @@ const {
   getTestSuiteCommonTags,
   addIntelligentTestRunnerSpanTags,
   TEST_ITR_UNSKIPPABLE,
-  TEST_ITR_FORCED_RUN
+  TEST_ITR_FORCED_RUN,
+  TEST_CODE_OWNERS
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
+const {
+  TELEMETRY_EVENT_CREATED,
+  TELEMETRY_EVENT_FINISHED,
+  TELEMETRY_CODE_COVERAGE_STARTED,
+  TELEMETRY_CODE_COVERAGE_FINISHED,
+  TELEMETRY_ITR_FORCED_TO_RUN,
+  TELEMETRY_CODE_COVERAGE_EMPTY,
+  TELEMETRY_ITR_UNSKIPPABLE,
+  TELEMETRY_CODE_COVERAGE_NUM_FILES
+} = require('../../dd-trace/src/ci-visibility/telemetry')
 
 class CucumberPlugin extends CiPlugin {
   static get id () {
@@ -54,7 +65,9 @@ class CucumberPlugin extends CiPlugin {
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
       finishAllTraceSpans(this.testSessionSpan)
 
       this.itrConfig = null
@@ -69,9 +82,11 @@ class CucumberPlugin extends CiPlugin {
         'cucumber'
       )
       if (isUnskippable) {
+        this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
       }
       if (isForcedToRun) {
+        this.telemetry.count(TELEMETRY_ITR_FORCED_TO_RUN, { testLevel: 'suite' })
         testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
       }
       this.testSuiteSpan = this.tracer.startSpan('cucumber.test_suite', {
@@ -82,20 +97,31 @@ class CucumberPlugin extends CiPlugin {
           ...testSuiteMetadata
         }
       })
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
+      if (this.itrConfig?.isCodeCoverageEnabled) {
+        this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_STARTED, 'suite', { library: 'istanbul' })
+      }
     })
 
     this.addSub('ci:cucumber:test-suite:finish', status => {
       this.testSuiteSpan.setTag(TEST_STATUS, status)
       this.testSuiteSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     })
 
     this.addSub('ci:cucumber:test-suite:code-coverage', ({ coverageFiles, suiteFile }) => {
-      if (!this.itrConfig || !this.itrConfig.isCodeCoverageEnabled) {
+      if (!this.itrConfig?.isCodeCoverageEnabled) {
         return
       }
+      if (!coverageFiles.length) {
+        this.telemetry.count(TELEMETRY_CODE_COVERAGE_EMPTY)
+      }
+
       const relativeCoverageFiles = [...coverageFiles, suiteFile]
         .map(filename => getTestSuitePath(filename, this.sourceRoot))
 
+      this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)
+
       const formattedCoverage = {
         sessionId: this.testSuiteSpan.context()._traceId,
         suiteId: this.testSuiteSpan.context()._spanId,
@@ -103,6 +129,7 @@ class CucumberPlugin extends CiPlugin {
       }
 
       this.tracer._exporter.exportCoverage(formattedCoverage)
+      this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: 'istanbul' })
     })
 
     this.addSub('ci:cucumber:test:start', ({ testName, fullTestSuite, testSourceLine }) => {
@@ -142,6 +169,11 @@ class CucumberPlugin extends CiPlugin {
       }
 
       span.finish()
+      this.telemetry.ciVisEvent(
+        TELEMETRY_EVENT_FINISHED,
+        'test',
+        { hasCodeOwners: !!span.context()._tags[TEST_CODE_OWNERS] }
+      )
       if (!isStep) {
         finishAllTraceSpans(span)
       }

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -29,6 +29,29 @@ const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
 const log = require('../../dd-trace/src/log')
 const NoopTracer = require('../../dd-trace/src/noop/tracer')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
+const {
+  TELEMETRY_EVENT_CREATED,
+  TELEMETRY_EVENT_FINISHED,
+  TELEMETRY_ITR_FORCED_TO_RUN,
+  TELEMETRY_CODE_COVERAGE_EMPTY,
+  TELEMETRY_ITR_UNSKIPPABLE,
+  TELEMETRY_CODE_COVERAGE_NUM_FILES,
+  incrementCountMetric,
+  distributionMetric
+} = require('../../dd-trace/src/ci-visibility/telemetry')
+const {
+  GIT_REPOSITORY_URL,
+  GIT_COMMIT_SHA,
+  GIT_BRANCH,
+  CI_PROVIDER_NAME
+} = require('../../dd-trace/src/plugins/util/tags')
+const {
+  OS_VERSION,
+  OS_PLATFORM,
+  OS_ARCHITECTURE,
+  RUNTIME_NAME,
+  RUNTIME_VERSION
+} = require('../../dd-trace/src/plugins/util/env')
 
 const TEST_FRAMEWORK_NAME = 'cypress'
 
@@ -152,16 +175,19 @@ module.exports = (on, config) => {
   const testEnvironmentMetadata = getTestEnvironmentMetadata(TEST_FRAMEWORK_NAME)
 
   const {
-    'git.repository_url': repositoryUrl,
-    'git.commit.sha': sha,
-    'os.version': osVersion,
-    'os.platform': osPlatform,
-    'os.architecture': osArchitecture,
-    'runtime.name': runtimeName,
-    'runtime.version': runtimeVersion,
-    'git.branch': branch
+    [GIT_REPOSITORY_URL]: repositoryUrl,
+    [GIT_COMMIT_SHA]: sha,
+    [OS_VERSION]: osVersion,
+    [OS_PLATFORM]: osPlatform,
+    [OS_ARCHITECTURE]: osArchitecture,
+    [RUNTIME_NAME]: runtimeName,
+    [RUNTIME_VERSION]: runtimeVersion,
+    [GIT_BRANCH]: branch,
+    [CI_PROVIDER_NAME]: ciProviderName
   } = testEnvironmentMetadata
 
+  const isUnsupportedCIProvider = !ciProviderName
+
   const finishedTestsByFile = {}
 
   const testConfiguration = {
@@ -192,6 +218,15 @@ module.exports = (on, config) => {
   let hasForcedToRunSuites = false
   let hasUnskippableSuites = false
 
+  function ciVisEvent (name, testLevel, tags = {}) {
+    incrementCountMetric(name, {
+      testLevel,
+      testFramework: 'cypress',
+      isUnsupportedCIProvider,
+      ...tags
+    })
+  }
+
   function getTestSpan (testName, testSuite, isUnskippable, isForcedToRun) {
     const testSuiteTags = {
       [TEST_COMMAND]: command,
@@ -220,14 +255,18 @@ module.exports = (on, config) => {
 
     if (isUnskippable) {
       hasUnskippableSuites = true
+      incrementCountMetric(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
       testSpanMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
     }
 
     if (isForcedToRun) {
       hasForcedToRunSuites = true
+      incrementCountMetric(TELEMETRY_ITR_FORCED_TO_RUN, { testLevel: 'suite' })
       testSpanMetadata[TEST_ITR_FORCED_RUN] = 'true'
     }
 
+    ciVisEvent(TELEMETRY_EVENT_CREATED, 'test', { hasCodeOwners: !!codeOwners })
+
     return tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test`, {
       childOf,
       tags: {
@@ -281,6 +320,8 @@ module.exports = (on, config) => {
             ...testSessionSpanMetadata
           }
         })
+        ciVisEvent(TELEMETRY_EVENT_CREATED, 'session')
+
         testModuleSpan = tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_module`, {
           childOf: testSessionSpan,
           tags: {
@@ -289,6 +330,8 @@ module.exports = (on, config) => {
             ...testModuleSpanMetadata
           }
         })
+        ciVisEvent(TELEMETRY_EVENT_CREATED, 'module')
+
         return details
       })
     })
@@ -347,6 +390,7 @@ module.exports = (on, config) => {
       }
       testSuiteSpan.finish()
       testSuiteSpan = null
+      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
     }
   })
 
@@ -371,7 +415,9 @@ module.exports = (on, config) => {
       )
 
       testModuleSpan.finish()
+      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       testSessionSpan.finish()
+      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
 
       finishAllTraceSpans(testSessionSpan)
     }
@@ -406,6 +452,7 @@ module.exports = (on, config) => {
           ...testSuiteSpanMetadata
         }
       })
+      ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
       return null
     },
     'dd:beforeEach': (test) => {
@@ -435,6 +482,10 @@ module.exports = (on, config) => {
         if (coverage && isCodeCoverageEnabled && tracer._tracer._exporter && tracer._tracer._exporter.exportCoverage) {
           const coverageFiles = getCoveredFilenamesFromCoverage(coverage)
           const relativeCoverageFiles = coverageFiles.map(file => getTestSuitePath(file, rootDir))
+          if (!relativeCoverageFiles.length) {
+            incrementCountMetric(TELEMETRY_CODE_COVERAGE_EMPTY)
+          }
+          distributionMetric(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)
           const { _traceId, _spanId } = testSuiteSpan.context()
           const formattedCoverage = {
             sessionId: _traceId,
@@ -470,6 +521,7 @@ module.exports = (on, config) => {
         // test spans are finished at after:spec
       }
       activeSpan = null
+      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test')
       return null
     },
     'dd:addTags': (tags) => {

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

@@ -12,10 +12,21 @@ const {
   TEST_FRAMEWORK_VERSION,
   TEST_SOURCE_START,
   TEST_ITR_UNSKIPPABLE,
-  TEST_ITR_FORCED_RUN
+  TEST_ITR_FORCED_RUN,
+  TEST_CODE_OWNERS
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
+const {
+  TELEMETRY_EVENT_CREATED,
+  TELEMETRY_EVENT_FINISHED,
+  TELEMETRY_CODE_COVERAGE_STARTED,
+  TELEMETRY_CODE_COVERAGE_FINISHED,
+  TELEMETRY_ITR_FORCED_TO_RUN,
+  TELEMETRY_CODE_COVERAGE_EMPTY,
+  TELEMETRY_ITR_UNSKIPPABLE,
+  TELEMETRY_CODE_COVERAGE_NUM_FILES
+} = require('../../dd-trace/src/ci-visibility/telemetry')
 
 const isJestWorker = !!process.env.JEST_WORKER_ID
 
@@ -81,7 +92,9 @@ class JestPlugin extends CiPlugin {
       )
 
       this.testModuleSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
       finishAllTraceSpans(this.testSessionSpan)
       this.tracer._exporter.flush()
     })
@@ -103,7 +116,8 @@ class JestPlugin extends CiPlugin {
         _ddTestCommand: testCommand,
         _ddTestModuleId: testModuleId,
         _ddForcedToRun,
-        _ddUnskippable
+        _ddUnskippable,
+        _ddTestCodeCoverageEnabled
       } = testEnvironmentOptions
 
       const testSessionSpanContext = this.tracer.extract('text_map', {
@@ -114,8 +128,10 @@ class JestPlugin extends CiPlugin {
       const testSuiteMetadata = getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, 'jest')
 
       if (_ddUnskippable) {
+        this.telemetry.count(TELEMETRY_ITR_UNSKIPPABLE, { testLevel: 'suite' })
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'
         if (_ddForcedToRun) {
+          this.telemetry.count(TELEMETRY_ITR_FORCED_TO_RUN, { testLevel: 'suite' })
           testSuiteMetadata[TEST_ITR_FORCED_RUN] = 'true'
         }
       }
@@ -128,6 +144,10 @@ class JestPlugin extends CiPlugin {
           ...testSuiteMetadata
         }
       })
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
+      if (_ddTestCodeCoverageEnabled) {
+        this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_STARTED, 'suite', { library: 'istanbul' })
+      }
     })
 
     this.addSub('ci:jest:worker-report:trace', traces => {
@@ -164,6 +184,7 @@ class JestPlugin extends CiPlugin {
         this.testSuiteSpan.setTag('error', new Error(errorMessage))
       }
       this.testSuiteSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       // Suites potentially run in a different process than the session,
       // so calling finishAllTraceSpans on the session span is not enough
       finishAllTraceSpans(this.testSuiteSpan)
@@ -180,14 +201,22 @@ class JestPlugin extends CiPlugin {
      * because this subscription happens in a different process from the one
      * fetching the ITR config.
      */
-    this.addSub('ci:jest:test-suite:code-coverage', (coverageFiles) => {
+    this.addSub('ci:jest:test-suite:code-coverage', ({ coverageFiles, testSuite }) => {
+      if (!coverageFiles.length) {
+        this.telemetry.count(TELEMETRY_CODE_COVERAGE_EMPTY)
+      }
+      const files = [...coverageFiles, testSuite]
+
       const { _traceId, _spanId } = this.testSuiteSpan.context()
       const formattedCoverage = {
         sessionId: _traceId,
         suiteId: _spanId,
-        files: coverageFiles
+        files
       }
+
       this.tracer._exporter.exportCoverage(formattedCoverage)
+      this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: 'istanbul' })
+      this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, files.length)
     })
 
     this.addSub('ci:jest:test:start', (test) => {
@@ -204,6 +233,11 @@ class JestPlugin extends CiPlugin {
         span.setTag(TEST_SOURCE_START, testStartLine)
       }
       span.finish()
+      this.telemetry.ciVisEvent(
+        TELEMETRY_EVENT_FINISHED,
+        'test',
+        { hasCodeOwners: !!span.context()._tags[TEST_CODE_OWNERS] }
+      )
       finishAllTraceSpans(span)
     })