dd-trace 4.28.0 → 4.29.0

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

@@ -1,156 +1,5 @@
-const {
-  TEST_STATUS,
-  TEST_IS_RUM_ACTIVE,
-  TEST_CODE_OWNERS,
-  getTestEnvironmentMetadata,
-  CI_APP_ORIGIN,
-  getTestParentSpan,
-  getCodeOwnersFileEntries,
-  getCodeOwnersForFilename,
-  getTestCommonTags,
-  getTestSessionCommonTags,
-  getTestModuleCommonTags,
-  getTestSuiteCommonTags,
-  TEST_SUITE_ID,
-  TEST_MODULE_ID,
-  TEST_SESSION_ID,
-  TEST_COMMAND,
-  TEST_MODULE,
-  TEST_SOURCE_START,
-  finishAllTraceSpans,
-  getCoveredFilenamesFromCoverage,
-  getTestSuitePath,
-  addIntelligentTestRunnerSpanTags,
-  TEST_SKIPPED_BY_ITR,
-  TEST_ITR_UNSKIPPABLE,
-  TEST_ITR_FORCED_RUN,
-  ITR_CORRELATION_ID,
-  TEST_SOURCE_FILE
-} = require('../../dd-trace/src/plugins/util/test')
-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 { appClosing: appClosingTelemetry } = require('../../dd-trace/src/telemetry')
-const {
-  GIT_REPOSITORY_URL,
-  GIT_COMMIT_SHA,
-  GIT_BRANCH,
-  CI_PROVIDER_NAME,
-  CI_WORKSPACE_PATH
-} = 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'
-
-const CYPRESS_STATUS_TO_TEST_STATUS = {
-  passed: 'pass',
-  failed: 'fail',
-  pending: 'skip',
-  skipped: 'skip'
-}
-
-function getTestSpanMetadata (tracer, testName, testSuite, cypressConfig) {
-  const childOf = getTestParentSpan(tracer)
-
-  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version, TEST_FRAMEWORK_NAME)
-
-  return {
-    childOf,
-    ...commonTags
-  }
-}
-
-function getCypressVersion (details) {
-  if (details && details.cypressVersion) {
-    return details.cypressVersion
-  }
-  if (details && details.config && details.config.version) {
-    return details.config.version
-  }
-  return ''
-}
-
-function getRootDir (details) {
-  if (details && details.config) {
-    return details.config.projectRoot || details.config.repoRoot || process.cwd()
-  }
-  return process.cwd()
-}
-
-function getCypressCommand (details) {
-  if (!details) {
-    return TEST_FRAMEWORK_NAME
-  }
-  return `${TEST_FRAMEWORK_NAME} ${details.specPattern || ''}`
-}
-
-function getSessionStatus (summary) {
-  if (summary.totalFailed !== undefined && summary.totalFailed > 0) {
-    return 'fail'
-  }
-  if (summary.totalSkipped !== undefined && summary.totalSkipped === summary.totalTests) {
-    return 'skip'
-  }
-  return 'pass'
-}
-
-function getSuiteStatus (suiteStats) {
-  if (suiteStats.failures !== undefined && suiteStats.failures > 0) {
-    return 'fail'
-  }
-  if (suiteStats.tests !== undefined &&
-    (suiteStats.tests === suiteStats.pending || suiteStats.tests === suiteStats.skipped)) {
-    return 'skip'
-  }
-  return 'pass'
-}
-
-function getLibraryConfiguration (tracer, testConfiguration) {
-  return new Promise(resolve => {
-    if (!tracer._tracer._exporter?.getLibraryConfiguration) {
-      return resolve({ err: new Error('CI Visibility was not initialized correctly') })
-    }
-
-    tracer._tracer._exporter.getLibraryConfiguration(testConfiguration, (err, libraryConfig) => {
-      resolve({ err, libraryConfig })
-    })
-  })
-}
-
-function getSkippableTests (isSuitesSkippingEnabled, tracer, testConfiguration) {
-  if (!isSuitesSkippingEnabled) {
-    return Promise.resolve({ skippableTests: [] })
-  }
-  return new Promise(resolve => {
-    if (!tracer._tracer._exporter?.getLibraryConfiguration) {
-      return resolve({ err: new Error('CI Visibility was not initialized correctly') })
-    }
-    tracer._tracer._exporter.getSkippableSuites(testConfiguration, (err, skippableTests, correlationId) => {
-      resolve({
-        err,
-        skippableTests,
-        correlationId
-      })
-    })
-  })
-}
+const cypressPlugin = require('./cypress-plugin')
 
 const noopTask = {
   'dd:testSuiteStart': () => {
@@ -168,8 +17,6 @@ const noopTask = {
 }
 
 module.exports = (on, config) => {
-  let isTestsSkipped = false
-  const skippedTests = []
   const tracer = require('../../dd-trace')
 
   // The tracer was not init correctly for whatever reason (such as invalid DD_SITE)
@@ -178,400 +25,10 @@ module.exports = (on, config) => {
     return on('task', noopTask)
   }
 
-  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,
-    [CI_PROVIDER_NAME]: ciProviderName,
-    [CI_WORKSPACE_PATH]: repositoryRoot
-  } = testEnvironmentMetadata
-
-  const isUnsupportedCIProvider = !ciProviderName
-
-  const finishedTestsByFile = {}
-
-  const testConfiguration = {
-    repositoryUrl,
-    sha,
-    osVersion,
-    osPlatform,
-    osArchitecture,
-    runtimeName,
-    runtimeVersion,
-    branch,
-    testLevel: 'test'
-  }
-
-  const codeOwnersEntries = getCodeOwnersFileEntries(repositoryRoot)
-
-  let activeSpan = null
-  let testSessionSpan = null
-  let testModuleSpan = null
-  let testSuiteSpan = null
-  let command = null
-  let frameworkVersion
-  let rootDir
-  let isSuitesSkippingEnabled = false
-  let isCodeCoverageEnabled = false
-  let testsToSkip = []
-  let itrCorrelationId = ''
-  const unskippableSuites = []
-  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,
-      [TEST_COMMAND]: command,
-      [TEST_MODULE]: TEST_FRAMEWORK_NAME
-    }
-    if (testSuiteSpan) {
-      testSuiteTags[TEST_SUITE_ID] = testSuiteSpan.context().toSpanId()
-    }
-    if (testSessionSpan && testModuleSpan) {
-      testSuiteTags[TEST_SESSION_ID] = testSessionSpan.context().toTraceId()
-      testSuiteTags[TEST_MODULE_ID] = testModuleSpan.context().toSpanId()
-      // If testSuiteSpan couldn't be created, we'll use the testModuleSpan as the parent
-      if (!testSuiteSpan) {
-        testSuiteTags[TEST_SUITE_ID] = testModuleSpan.context().toSpanId()
-      }
-    }
-
-    const {
-      childOf,
-      resource,
-      ...testSpanMetadata
-    } = getTestSpanMetadata(tracer, testName, testSuite, config)
-
-    const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
-
-    if (codeOwners) {
-      testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
-    }
-
-    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: {
-        [COMPONENT]: TEST_FRAMEWORK_NAME,
-        [ORIGIN_KEY]: CI_APP_ORIGIN,
-        ...testSpanMetadata,
-        ...testEnvironmentMetadata,
-        ...testSuiteTags
-      }
-    })
-  }
-
-  function getTestSuiteSpan (suite) {
-    const testSuiteSpanMetadata = getTestSuiteCommonTags(command, frameworkVersion, suite, TEST_FRAMEWORK_NAME)
-    ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
-    return tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_suite`, {
-      childOf: testModuleSpan,
-      tags: {
-        [COMPONENT]: TEST_FRAMEWORK_NAME,
-        ...testEnvironmentMetadata,
-        ...testSuiteSpanMetadata
-      }
-    })
-  }
-
-  on('before:run', (details) => {
-    return getLibraryConfiguration(tracer, testConfiguration).then(({ err, libraryConfig }) => {
-      if (err) {
-        log.error(err)
-      } else {
-        isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
-        isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
-      }
-
-      return getSkippableTests(isSuitesSkippingEnabled, tracer, testConfiguration)
-        .then(({ err, skippableTests, correlationId }) => {
-          if (err) {
-            log.error(err)
-          } else {
-            testsToSkip = skippableTests || []
-            itrCorrelationId = correlationId
-          }
-
-          // `details.specs` are test files
-          details.specs.forEach(({ absolute, relative }) => {
-            const isUnskippableSuite = isMarkedAsUnskippable({ path: absolute })
-            if (isUnskippableSuite) {
-              unskippableSuites.push(relative)
-            }
-          })
-
-          const childOf = getTestParentSpan(tracer)
-          rootDir = getRootDir(details)
-
-          command = getCypressCommand(details)
-          frameworkVersion = getCypressVersion(details)
-
-          const testSessionSpanMetadata = getTestSessionCommonTags(command, frameworkVersion, TEST_FRAMEWORK_NAME)
-          const testModuleSpanMetadata = getTestModuleCommonTags(command, frameworkVersion, TEST_FRAMEWORK_NAME)
-
-          testSessionSpan = tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_session`, {
-            childOf,
-            tags: {
-              [COMPONENT]: TEST_FRAMEWORK_NAME,
-              ...testEnvironmentMetadata,
-              ...testSessionSpanMetadata
-            }
-          })
-          ciVisEvent(TELEMETRY_EVENT_CREATED, 'session')
-
-          testModuleSpan = tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_module`, {
-            childOf: testSessionSpan,
-            tags: {
-              [COMPONENT]: TEST_FRAMEWORK_NAME,
-              ...testEnvironmentMetadata,
-              ...testModuleSpanMetadata
-            }
-          })
-          ciVisEvent(TELEMETRY_EVENT_CREATED, 'module')
-
-          return details
-        })
-    })
-  })
-  on('after:spec', (spec, { tests, stats }) => {
-    const cypressTests = tests || []
-    const finishedTests = finishedTestsByFile[spec.relative] || []
-
-    if (!testSuiteSpan) {
-      // dd:testSuiteStart hasn't been triggered for whatever reason
-      // We will create the test suite span on the spot if that's the case
-      log.warn('There was an error creating the test suite event.')
-      testSuiteSpan = getTestSuiteSpan(spec.relative)
-    }
-
-    // Get tests that didn't go through `dd:afterEach`
-    // and create a skipped test span for each of them
-    cypressTests.filter(({ title }) => {
-      const cypressTestName = title.join(' ')
-      const isTestFinished = finishedTests.find(({ testName }) => cypressTestName === testName)
-
-      return !isTestFinished
-    }).forEach(({ title }) => {
-      const cypressTestName = title.join(' ')
-      const isSkippedByItr = testsToSkip.find(test =>
-        cypressTestName === test.name && spec.relative === test.suite
-      )
-      const skippedTestSpan = getTestSpan(cypressTestName, spec.relative)
-      if (spec.absolute && repositoryRoot) {
-        skippedTestSpan.setTag(TEST_SOURCE_FILE, getTestSuitePath(spec.absolute, repositoryRoot))
-      } else {
-        skippedTestSpan.setTag(TEST_SOURCE_FILE, spec.relative)
-      }
-      skippedTestSpan.setTag(TEST_STATUS, 'skip')
-      if (isSkippedByItr) {
-        skippedTestSpan.setTag(TEST_SKIPPED_BY_ITR, 'true')
-      }
-      if (itrCorrelationId) {
-        skippedTestSpan.setTag(ITR_CORRELATION_ID, itrCorrelationId)
-      }
-      skippedTestSpan.finish()
-    })
-
-    // Make sure that reported test statuses are the same as Cypress reports.
-    // This is not always the case, such as when an `after` hook fails:
-    // Cypress will report the last run test as failed, but we don't know that yet at `dd:afterEach`
-    let latestError
-    finishedTests.forEach((finishedTest) => {
-      const cypressTest = cypressTests.find(test => test.title.join(' ') === finishedTest.testName)
-      if (!cypressTest) {
-        return
-      }
-      if (cypressTest.displayError) {
-        latestError = new Error(cypressTest.displayError)
-      }
-      const cypressTestStatus = CYPRESS_STATUS_TO_TEST_STATUS[cypressTest.state]
-      // update test status
-      if (cypressTestStatus !== finishedTest.testStatus) {
-        finishedTest.testSpan.setTag(TEST_STATUS, cypressTestStatus)
-        finishedTest.testSpan.setTag('error', latestError)
-      }
-      if (itrCorrelationId) {
-        finishedTest.testSpan.setTag(ITR_CORRELATION_ID, itrCorrelationId)
-      }
-      if (spec.absolute && repositoryRoot) {
-        finishedTest.testSpan.setTag(TEST_SOURCE_FILE, getTestSuitePath(spec.absolute, repositoryRoot))
-      } else {
-        finishedTest.testSpan.setTag(TEST_SOURCE_FILE, spec.relative)
-      }
-      finishedTest.testSpan.finish(finishedTest.finishTime)
-    })
-
-    if (testSuiteSpan) {
-      const status = getSuiteStatus(stats)
-      testSuiteSpan.setTag(TEST_STATUS, status)
-
-      if (latestError) {
-        testSuiteSpan.setTag('error', latestError)
-      }
-      testSuiteSpan.finish()
-      testSuiteSpan = null
-      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
-    }
-  })
-
-  on('after:run', (suiteStats) => {
-    if (testSessionSpan && testModuleSpan) {
-      const testStatus = getSessionStatus(suiteStats)
-      testModuleSpan.setTag(TEST_STATUS, testStatus)
-      testSessionSpan.setTag(TEST_STATUS, testStatus)
-
-      addIntelligentTestRunnerSpanTags(
-        testSessionSpan,
-        testModuleSpan,
-        {
-          isSuitesSkipped: isTestsSkipped,
-          isSuitesSkippingEnabled,
-          isCodeCoverageEnabled,
-          skippingType: 'test',
-          skippingCount: skippedTests.length,
-          hasForcedToRunSuites,
-          hasUnskippableSuites
-        }
-      )
-
-      testModuleSpan.finish()
-      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
-      testSessionSpan.finish()
-      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
-
-      finishAllTraceSpans(testSessionSpan)
-    }
-
-    return new Promise(resolve => {
-      const exporter = tracer._tracer._exporter
-      if (!exporter) {
-        return resolve(null)
-      }
-      if (exporter.flush) {
-        exporter.flush(() => {
-          appClosingTelemetry()
-          resolve(null)
-        })
-      } else if (exporter._writer) {
-        exporter._writer.flush(() => {
-          appClosingTelemetry()
-          resolve(null)
-        })
-      }
-    })
-  })
-  on('task', {
-    'dd:testSuiteStart': (suite) => {
-      if (testSuiteSpan) {
-        return null
-      }
-      testSuiteSpan = getTestSuiteSpan(suite)
-      return null
-    },
-    'dd:beforeEach': (test) => {
-      const { testName, testSuite } = test
-      const shouldSkip = !!testsToSkip.find(test => {
-        return testName === test.name && testSuite === test.suite
-      })
-      const isUnskippable = unskippableSuites.includes(testSuite)
-      const isForcedToRun = shouldSkip && isUnskippable
-
-      // skip test
-      if (shouldSkip && !isUnskippable) {
-        skippedTests.push(test)
-        isTestsSkipped = true
-        return { shouldSkip: true }
-      }
-
-      if (!activeSpan) {
-        activeSpan = getTestSpan(testName, testSuite, isUnskippable, isForcedToRun)
-      }
-
-      return activeSpan ? { traceId: activeSpan.context().toTraceId() } : {}
-    },
-    'dd:afterEach': ({ test, coverage }) => {
-      const { state, error, isRUMActive, testSourceLine, testSuite, testName } = test
-      if (activeSpan) {
-        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,
-            suiteId: _spanId,
-            testId: activeSpan.context()._spanId,
-            files: relativeCoverageFiles
-          }
-          tracer._tracer._exporter.exportCoverage(formattedCoverage)
-        }
-        const testStatus = CYPRESS_STATUS_TO_TEST_STATUS[state]
-        activeSpan.setTag(TEST_STATUS, testStatus)
+  cypressPlugin.init(tracer, config)
 
-        if (error) {
-          activeSpan.setTag('error', error)
-        }
-        if (isRUMActive) {
-          activeSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
-        }
-        if (testSourceLine) {
-          activeSpan.setTag(TEST_SOURCE_START, testSourceLine)
-        }
-        const finishedTest = {
-          testName,
-          testStatus,
-          finishTime: activeSpan._getTime(), // we store the finish time here
-          testSpan: activeSpan
-        }
-        if (finishedTestsByFile[testSuite]) {
-          finishedTestsByFile[testSuite].push(finishedTest)
-        } else {
-          finishedTestsByFile[testSuite] = [finishedTest]
-        }
-        // test spans are finished at after:spec
-      }
-      activeSpan = null
-      ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test')
-      return null
-    },
-    'dd:addTags': (tags) => {
-      if (activeSpan) {
-        activeSpan.addTags(tags)
-      }
-      return null
-    }
-  })
+  on('before:run', cypressPlugin.beforeRun.bind(cypressPlugin))
+  on('after:spec', cypressPlugin.afterSpec.bind(cypressPlugin))
+  on('after:run', cypressPlugin.afterRun.bind(cypressPlugin))
+  on('task', cypressPlugin.getTasks())
 }

package/packages/datadog-plugin-rhea/src/consumer.js

@@ -31,7 +31,10 @@ class RheaConsumerPlugin extends ConsumerPlugin {
       }
     })
 
-    if (this.config.dsmEnabled && msgObj.message) {
+    if (
+      this.config.dsmEnabled &&
+      msgObj?.message?.delivery_annotations?.[CONTEXT_PROPAGATION_KEY]
+    ) {
       const payloadSize = getAmqpMessageSize(
         { headers: msgObj.message.delivery_annotations, content: msgObj.message.body }
       )

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

@@ -209,10 +209,12 @@ class Config {
 
     const inServerlessEnvironment = inAWSLambda || isGCPFunction || isAzureFunctionConsumptionPlan
 
+    const isJestWorker = !!process.env.JEST_WORKER_ID
+
     const DD_INSTRUMENTATION_TELEMETRY_ENABLED = coalesce(
       process.env.DD_TRACE_TELEMETRY_ENABLED, // for backward compatibility
       process.env.DD_INSTRUMENTATION_TELEMETRY_ENABLED, // to comply with instrumentation telemetry specs
-      !inServerlessEnvironment
+      !(inServerlessEnvironment || isJestWorker)
     )
     const DD_TELEMETRY_HEARTBEAT_INTERVAL = process.env.DD_TELEMETRY_HEARTBEAT_INTERVAL
       ? Math.floor(parseFloat(process.env.DD_TELEMETRY_HEARTBEAT_INTERVAL) * 1000)
@@ -611,7 +613,6 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.peerServiceMapping = DD_TRACE_PEER_SERVICE_MAPPING
     this.lookup = options.lookup
     this.startupLogs = isTrue(DD_TRACE_STARTUP_LOGS)
-    // Disabled for CI Visibility's agentless
     this.telemetry = {
       enabled: isTrue(DD_INSTRUMENTATION_TELEMETRY_ENABLED),
       heartbeatInterval: DD_TELEMETRY_HEARTBEAT_INTERVAL,

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -173,7 +173,7 @@ class TextMapPropagator {
     ts.forVendor('dd', state => {
       state.set('s', priority)
       if (mechanism) {
-        state.set('t.dm', mechanism)
+        state.set('t.dm', `-${mechanism}`)
       }
 
       if (typeof origin === 'string') {

package/packages/dd-trace/src/opentracing/span.js

@@ -29,8 +29,8 @@ const OTEL_ENABLED = !!process.env.DD_TRACE_OTEL_ENABLED
 const ALLOWED = ['string', 'number', 'boolean']
 
 const integrationCounters = {
-  span_created: {},
-  span_finished: {}
+  spans_created: {},
+  spans_finished: {}
 }
 
 const finishCh = channel('dd-trace:span:finish')
@@ -72,7 +72,7 @@ class DatadogSpan {
     this._name = operationName
     this._integrationName = fields.integrationName || 'opentracing'
 
-    getIntegrationCounter('span_created', this._integrationName).inc()
+    getIntegrationCounter('spans_created', this._integrationName).inc()
 
     this._spanContext = this._createContext(parent, fields)
     this._spanContext._name = operationName
@@ -172,7 +172,7 @@ class DatadogSpan {
       }
     }
 
-    getIntegrationCounter('span_finished', this._integrationName).inc()
+    getIntegrationCounter('spans_finished', this._integrationName).inc()
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.decrement('runtime.node.spans.unfinished')