dd-trace 5.85.0 → 5.86.0

package/index.d.ts

@@ -295,7 +295,18 @@ interface Plugins {
 }
 
 declare namespace tracer {
-  export type SpanOptions = opentracing.SpanOptions;
+  export type SpanOptions = Omit<opentracing.SpanOptions, 'childOf'> & {
+  /**
+   * Set childOf to 'null' to create a root span without a parent, even when a parent span
+   * exists in the current async context. If 'undefined' the parent will be inferred from the
+   * existing async context.
+   */
+    childOf?: opentracing.Span | opentracing.SpanContext | null;
+    /**
+     * Optional name of the integration that crated this span.
+     */
+    integrationName?: string;
+  };
   export { Tracer };
 
   export interface TraceOptions extends Analyzable {
@@ -749,6 +760,14 @@ declare namespace tracer {
      */
     dbmPropagationMode?: 'disabled' | 'service' | 'full'
 
+    /**
+     * Whether to enable Data Streams Monitoring.
+     * Can also be enabled via the DD_DATA_STREAMS_ENABLED environment variable.
+     * When not provided, the value of DD_DATA_STREAMS_ENABLED is used.
+     * @default false
+     */
+    dsmEnabled?: boolean
+
     /**
      * Configuration of the AppSec protection. Can be a boolean as an alias to `appsec.enabled`.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.85.0",
+  "version": "5.86.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

package/packages/datadog-core/src/storage.js

@@ -59,28 +59,46 @@ class DatadogStorage extends AsyncLocalStorage {
       return stores.get(handle)
     }
   }
+}
+
+// To handle all versions always correct, feature detect AsyncContextFrame and
+// fallback to manual approach if not active. With ACF `run` delegates to
+// `enterWith`, without ACF `run` does not.
+const isACFActive = (() => {
+  let active = false
+  const als = new AsyncLocalStorage()
+  als.enterWith = () => { active = true }
+  als.run(1, () => {})
+  als.disable()
+  return active
+})()
+
+if (!isACFActive) {
+  const superGetStore = AsyncLocalStorage.prototype.getStore
+  const superEnterWith = AsyncLocalStorage.prototype.enterWith
 
   /**
-   * Here, we replicate the behavior of the original `run()` method. We ensure
-   * that our `enterWith()` is called internally, so that the handle to the
-   * store is set. As an optimization, we use super for getStore and enterWith
-   * when dealing with the parent store, so that we don't have to access the
-   * WeakMap.
+   * Override the `run` method to manually call `enterWith` and `getStore`
+   * when not using AsyncContextFrame.
+   *
+   * Without ACF, super.run() won't call this.enterWith(), so the WeakMap handle
+   * is never created and getStore() would fail.
+   *
    * @template R
-   * @template TArgs = unknown[]
+   * @template {unknown[]} TArgs
    * @param {Store<unknown>} store
-   * @param {() => R} fn
-   * @param {...TArgs} args
+   * @param {(...args: TArgs) => R} fn
+   * @param {TArgs} args
    * @returns {R}
    * @override
    */
-  run (store, fn, ...args) {
-    const prior = super.getStore()
+  DatadogStorage.prototype.run = function run (store, fn, ...args) {
+    const prior = superGetStore.call(this)
     this.enterWith(store)
     try {
       return Reflect.apply(fn, null, args)
     } finally {
-      super.enterWith(prior)
+      superEnterWith.call(this, prior)
     }
   }
 }
@@ -111,4 +129,4 @@ function storage (namespace) {
   return storages[namespace]
 }
 
-module.exports = { storage }
+module.exports = { storage, isACFActive }

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

@@ -7,6 +7,7 @@ const {
   getCoveredFilenamesFromCoverage,
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
+  JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
   getTestLineStart,
   getTestSuitePath,
   getTestParametersString,
@@ -16,6 +17,7 @@ const {
   isModifiedTest,
 } = require('../../dd-trace/src/plugins/util/test')
 const {
+  SEED_SUFFIX_RE,
   getFormattedJestTestParameters,
   getJestTestName,
   getJestSuitesToRun,
@@ -35,6 +37,7 @@ const testSuiteErrorCh = channel('ci:jest:test-suite:error')
 const workerReportTraceCh = channel('ci:jest:worker-report:trace')
 const workerReportCoverageCh = channel('ci:jest:worker-report:coverage')
 const workerReportLogsCh = channel('ci:jest:worker-report:logs')
+const workerReportTelemetryCh = channel('ci:jest:worker-report:telemetry')
 
 const testSuiteCodeCoverageCh = channel('ci:jest:test-suite:code-coverage')
 
@@ -55,6 +58,7 @@ const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 // Message sent by jest's main process to workers to run a test suite (=test file)
 // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/types.ts#L37
 const CHILD_MESSAGE_CALL = 1
+
 // Maximum time we'll wait for the tracer to flush
 const FLUSH_TIMEOUT = 10_000
 
@@ -515,6 +519,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
       }
       if (event.name === 'test_done') {
+        const originalError = event.test?.errors?.[0]
         let status = 'pass'
         if (event.test.errors && event.test.errors.length) {
           status = 'fail'
@@ -594,7 +599,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           const shouldSetProbe = this.isDiEnabled && willBeRetriedByFailedTestReplay && numTestExecutions === 1
           testErrCh.publish({
             ...ctx.currentStore,
-            error: formatJestError(event.test.errors[0]),
+            error: formatJestError(originalError),
             shouldSetProbe,
             promises,
             finalStatus,
@@ -954,7 +959,7 @@ function getCliWrapper (isNewJestVersion) {
             isTestManagementTestsEnabled = false
             testManagementTests = {}
           } else {
-            testManagementTests = receivedTestManagementTests
+            testManagementTests = receivedTestManagementTests || {}
           }
         } catch (err) {
           log.error('Jest test management tests error', err)
@@ -1012,33 +1017,39 @@ function getCliWrapper (isNewJestVersion) {
        * The rationale behind is the following: you may still be able to block your CI pipeline by gating
        * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
        */
+      let numEfdFailedTestsToIgnore = 0
       if (isEarlyFlakeDetectionEnabled) {
-        let numFailedTestsToIgnore = 0
         for (const testStatuses of newTestsTestStatuses.values()) {
           const { pass, fail } = getTestStats(testStatuses)
           if (pass > 0) { // as long as one passes, we'll consider the test passed
-            numFailedTestsToIgnore += fail
+            numEfdFailedTestsToIgnore += fail
           }
         }
         // If every test that failed was an EFD retry, we'll consider the suite passed
-        if (numFailedTestsToIgnore !== 0 && result.results.numFailedTests === numFailedTestsToIgnore) {
+        if (numEfdFailedTestsToIgnore !== 0 && result.results.numFailedTests === numEfdFailedTestsToIgnore) {
           result.results.success = true
         }
       }
 
+      let numFailedQuarantinedTests = 0
+      let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
       if (isTestManagementTestsEnabled) {
         const failedTests = result
           .results
           .testResults.flatMap(({ testResults, testFilePath: testSuiteAbsolutePath }) => (
             testResults.map(({ fullName: testName, status }) => (
-              { testName, testSuiteAbsolutePath, status }
+              {
+                // Strip @fast-check/jest seed suffix so the name matches what was reported via TEST_NAME
+                testName: testSuiteAbsolutePathsWithFastCheck.has(testSuiteAbsolutePath)
+                  ? testName.replace(SEED_SUFFIX_RE, '')
+                  : testName,
+                testSuiteAbsolutePath,
+                status,
+              }
             ))
           ))
           .filter(({ status }) => status === 'failed')
 
-        let numFailedQuarantinedTests = 0
-        let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
-
         for (const { testName, testSuiteAbsolutePath } of failedTests) {
           const testSuite = getTestSuitePath(testSuiteAbsolutePath, result.globalConfig.rootDir)
           const testManagementTest = testManagementTests
@@ -1069,6 +1080,16 @@ function getCliWrapper (isNewJestVersion) {
         }
       }
 
+      // Combined check: if all failed tests are accounted for by EFD (flaky retries) and/or quarantine,
+      // we should consider the suite passed even when neither check alone covers all failures.
+      if (!result.results.success && (isEarlyFlakeDetectionEnabled || isTestManagementTestsEnabled)) {
+        const totalIgnoredFailures =
+          numEfdFailedTestsToIgnore + numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
+        if (totalIgnoredFailures !== 0 && result.results.numFailedTests === totalIgnoredFailures) {
+          result.results.success = true
+        }
+      }
+
       // Determine session status after EFD and quarantine checks have potentially modified success
       let status, error
       if (result.results.success) {
@@ -1534,6 +1555,10 @@ function onMessageWrapper (onMessage) {
       workerReportLogsCh.publish(data)
       return
     }
+    if (code === JEST_WORKER_TELEMETRY_PAYLOAD_CODE) { // datadog telemetry payload
+      workerReportTelemetryCh.publish(data)
+      return
+    }
     return onMessage.apply(this, arguments)
   }
 }

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -165,6 +165,15 @@ function getOnEndHandler (isParallel) {
       this.failures -= numFailedQuarantinedTests + numFailedRetriedQuarantinedOrDisabledTests
     }
 
+    // Recompute status after EFD and quarantine adjustments have reduced failure counts
+    if (status === 'fail') {
+      if (this.stats) {
+        status = this.stats.failures === 0 ? 'pass' : 'fail'
+      } else {
+        status = this.failures === 0 ? 'pass' : 'fail'
+      }
+    }
+
     if (status === 'fail') {
       error = new Error(`Failed tests: ${this.failures}.`)
     }

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

@@ -4,45 +4,186 @@ const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const { channel, addHook } = require('./helpers/instrument')
 const prismaHelperInit = channel('apm:prisma:helper:init')
 
-const prismaHook = (runtime, versions, name, isIitm) => {
-  const originalGetPrismaClient = runtime.getPrismaClient
+/**
+ * @typedef {object} EnvValue
+ * @property {string|undefined} [value]
+ * @property {string|null|undefined} [fromEnvVar]
+ */
+
+/**
+ * @typedef {object} DatasourceConfig
+ * @property {string|EnvValue|undefined} [url]
+ */
+
+/**
+ * @typedef {object} PrismaRuntimeConfig
+ * @property {Record<string, DatasourceConfig>|undefined} [inlineDatasources]
+ * @property {Record<string, { url?: string }>|undefined} [overrideDatasources]
+ * @property {Record<string, { url?: string }>|undefined} [datasources]
+ * @property {string[]|undefined} [datasourceNames]
+ */
+
+/**
+ * @typedef {object} DbConfig
+ * @property {string|undefined} [user]
+ * @property {string|undefined} [password]
+ * @property {string|undefined} [host]
+ * @property {string|number|undefined} [port]
+ * @property {string|undefined} [database]
+ */
+
+/**
+ * @typedef {object} AdapterConfig
+ * @property {string|undefined} [connectionString]
+ * @property {string|undefined} [user]
+ * @property {string|undefined} [password]
+ * @property {string|undefined} [host]
+ * @property {string|number|undefined} [port]
+ * @property {string|undefined} [database]
+ */
+
+/**
+ * @typedef {object} Adapter
+ * @property {AdapterConfig|undefined} [config]
+ * @property {{ options?: AdapterConfig }|undefined} [externalPool]
+ */
+
+/**
+ * @typedef {object} PrismaClientConfig
+ * @property {string|undefined} [datasourceUrl]
+ * @property {Record<string, { url?: string }>|undefined} [datasources]
+ * @property {Adapter|undefined} [adapter]
+ */
+
+/**
+ * @typedef {object} PrismaHelperCtx
+ * @property {DbConfig} [dbConfig]
+ * @property {import('../../datadog-plugin-prisma/src/datadog-tracing-helper')} [helper]
+ */
+
+/**
+ * @param {string|EnvValue|undefined} envValue
+ * @returns {string|undefined}
+ */
+function resolveEnvValue (envValue) {
+  return typeof envValue === 'object' && envValue
+    ? (envValue.value || getEnvironmentVariable(envValue.fromEnvVar ?? ''))
+    : envValue
+}
+
+/**
+ * @param {PrismaRuntimeConfig|undefined} config
+ * @param {string} datasourceName
+ * @returns {string|undefined}
+ */
+function resolveDatasourceUrl (config, datasourceName) {
+  return resolveEnvValue(config?.inlineDatasources?.[datasourceName]?.url) ??
+    config?.overrideDatasources?.[datasourceName]?.url ??
+    config?.datasources?.[datasourceName]?.url ??
+    getEnvironmentVariable('DATABASE_URL')
+}
+
+/**
+ * @param {DbConfig} dbConfig
+ * @returns {DbConfig|undefined}
+ */
+function normalizeDbConfig (dbConfig) {
+  dbConfig.port = dbConfig.port == null ? undefined : String(dbConfig.port)
+  const hasValues = dbConfig.user || dbConfig.password || dbConfig.host || dbConfig.port || dbConfig.database
+  return hasValues ? dbConfig : undefined
+}
+
+/**
+ * @param {Adapter|undefined} adapter
+ * @returns {DbConfig|undefined}
+ */
+function resolveAdapterDbConfig (adapter) {
+  const adapterConfig = adapter?.config || adapter?.externalPool?.options
+  if (!adapterConfig) {
+    return
+  }
+
+  if (typeof adapterConfig === 'string') {
+    return parseDBString(adapterConfig)
+  }
+
+  const parsed = parseDBString(adapterConfig.connectionString)
+  if (parsed) {
+    return parsed
+  }
+
+  return normalizeDbConfig({
+    user: adapterConfig.user,
+    password: adapterConfig.password,
+    host: adapterConfig.host,
+    port: adapterConfig.port,
+    database: adapterConfig.database,
+  })
+}
+
+/**
+ * @param {PrismaClientConfig|undefined} clientConfig
+ * @param {string} datasourceName
+ * @param {DbConfig|undefined} runtimeDbConfig
+ * @returns {DbConfig|undefined}
+ */
+function resolveClientDbConfig (clientConfig, datasourceName, runtimeDbConfig) {
+  return resolveAdapterDbConfig(clientConfig?.adapter) ||
+    parseDBString(clientConfig?.datasources?.[datasourceName]?.url ?? clientConfig?.datasourceUrl) ||
+    runtimeDbConfig
+}
 
-  if (!originalGetPrismaClient) return runtime
+/**
+ * @param {unknown} runtime
+ * @param {string} versions
+ * @param {string} [name]
+ * @param {boolean} [isIitm]
+ * @returns {object}
+ */
+const prismaHook = (runtime, versions, name, isIitm) => {
+  /**
+   * @typedef {{ getPrismaClient?: (config: PrismaRuntimeConfig, ...args: unknown[]) => Function }} PrismaRuntime
+   */
+  const prismaRuntime = /** @type {PrismaRuntime} */ (runtime)
+  const originalGetPrismaClient = prismaRuntime.getPrismaClient
 
-  const prismaHelperCtx = {}
+  if (!originalGetPrismaClient) {
+    return runtime
+  }
 
+  /**
+   * @param {PrismaRuntimeConfig|undefined} config
+   */
   const wrappedGetPrismaClient = function (config) {
-    // Prisma config shapes vary by version/runtime entrypoint. We try a few known locations
-    // and fall back to DATABASE_URL when present.
-    const datasourceUrl =
-      config?.inlineDatasources?.db?.url?.value ??
-      config?.inlineDatasources?.db?.url ??
-      config?.overrideDatasources?.db?.url ??
-      config?.datasources?.db?.url ??
-      config?.datasourceUrl ??
-      getEnvironmentVariable('DATABASE_URL')
-
-    if (datasourceUrl && !prismaHelperCtx.dbConfig) {
-      prismaHelperCtx.dbConfig = parseDBString(datasourceUrl)
-    }
-    prismaHelperInit.publish(prismaHelperCtx)
+    const datasourceName = config?.datasourceNames?.[0] || 'db'
+    const runtimeDatasourceUrl = resolveDatasourceUrl(config, datasourceName)
+    const runtimeDbConfig = parseDBString(runtimeDatasourceUrl)
 
     const PrismaClient = originalGetPrismaClient.call(this, config)
     return class WrappedPrismaClientClass extends PrismaClient {
       constructor (clientConfig) {
         super(clientConfig)
-        this._tracingHelper = prismaHelperCtx.helper
-        this._engine.tracingHelper = prismaHelperCtx.helper
+        /**
+         * @type {PrismaHelperCtx}
+         */
+        const prismaHelperCtx = {
+          dbConfig: resolveClientDbConfig(clientConfig, datasourceName, runtimeDbConfig),
+        }
+        prismaHelperInit.publish(prismaHelperCtx)
+
+        const helper = prismaHelperCtx.helper
+        this._tracingHelper = helper
+        this._engine.tracingHelper = helper
       }
     }
   }
 
   if (isIitm) {
-    runtime.getPrismaClient = wrappedGetPrismaClient
+    prismaRuntime.getPrismaClient = wrappedGetPrismaClient
     return runtime
   }
 
-  return new Proxy(runtime, {
+  return new Proxy(prismaRuntime, {
     get (target, prop) {
       if (prop === 'getPrismaClient') {
         return wrappedGetPrismaClient
@@ -62,14 +203,68 @@ for (const config of prismaConfigs) {
   addHook(config, prismaHook)
 }
 
+/**
+ * @param {string|undefined} dbString
+ * @returns {DbConfig|undefined}
+ */
 function parseDBString (dbString) {
-  const url = new URL(dbString)
-  const dbConfig = {
-    user: url.username,
-    password: url.password,
-    host: url.hostname,
-    port: url.port,
-    database: url.pathname.slice(1), // Remove leading slash
+  if (!dbString || typeof dbString !== 'string') {
+    return
+  }
+
+  const sqlServerConfig = parseSqlServerConnectionString(dbString)
+  if (sqlServerConfig) {
+    return sqlServerConfig
+  }
+
+  try {
+    const url = new URL(dbString)
+    return normalizeDbConfig({
+      user: url.username,
+      password: url.password,
+      host: url.hostname,
+      port: url.port,
+      database: url.pathname?.slice(1) || undefined,
+    })
+  } catch {}
+}
+
+/**
+ * @param {string} dbString
+ * @returns {DbConfig|undefined}
+ */
+function parseSqlServerConnectionString (dbString) {
+  if (!dbString.startsWith('sqlserver://')) {
+    return
+  }
+  const segments = dbString.slice(12).split(';').filter(Boolean)
+  if (!segments.length) {
+    return
+  }
+
+  let hostPart = segments.shift()
+  let user
+  let password
+  if (hostPart?.includes('@')) {
+    const [userInfo, hostInfo] = hostPart.split('@')
+    hostPart = hostInfo
+    ;[user, password] = userInfo.split(':')
   }
-  return dbConfig
+
+  let database
+  for (const segment of segments) {
+    const [rawKey, ...rawValue] = segment.split('=')
+    const value = rawValue.join('=').trim()
+    const key = rawKey?.trim().toLowerCase()
+    if (!key || !value) {
+      continue
+    }
+    if (key === 'database' || key === 'databasename' || key === 'db') database = value
+    else if (key === 'user' || key === 'username' || key === 'uid') user = value
+    else if (key === 'password' || key === 'pwd') password = value
+  }
+
+  const [host, port] = hostPart?.split(':') ?? []
+
+  return normalizeDbConfig({ user, password, host, port, database })
 }

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

@@ -13,6 +13,7 @@ const producerCh = tracingChannel('ws:send')
 const receiverCh = tracingChannel('ws:receive')
 const closeCh = tracingChannel('ws:close')
 const emitCh = channel('tracing:ws:server:connect:emit')
+const setSocketCh = channel('tracing:ws:server:connect:setSocket')
 // TODO: Add a error channel / handle error events properly.
 
 /**
@@ -181,12 +182,33 @@ addHook({
   return ws
 })
 
+/**
+ * Prevent internal event handlers (data, close, etc.) registered by the ws library to
+ * capture the connection span in their async context. Otherwise, the
+ * finished connection span is retained for the entire lifetime of the WebSocket
+ * (via ACF -> handle -> WeakMap).
+ *
+ * @param {Function} setSocket
+ * @returns {(...args: unknown[]) => unknown}
+ */
+function wrapSetSocket (setSocket) {
+  return function wrappedSetSocket (...args) {
+    if (!setSocketCh.hasSubscribers) {
+      return setSocket.apply(this, args)
+    }
+    return setSocketCh.runStores({}, () => {
+      return setSocket.apply(this, args)
+    })
+  }
+}
+
 addHook({
   name: 'ws',
   file: 'lib/websocket.js',
   versions: ['>=8.0.0'],
 }, moduleExports => {
   const ws = /** @type {WebSocketClass} */ (moduleExports)
+  shimmer.wrap(ws.prototype, 'setSocket', wrapSetSocket)
   shimmer.wrap(ws.prototype, 'send', wrapSend)
   shimmer.wrap(ws.prototype, 'close', wrapClose)
 

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

@@ -13,7 +13,6 @@ const {
   isModifiedTest,
   CUCUMBER_IS_PARALLEL,
   ITR_CORRELATION_ID,
-  TEST_BROWSER_DRIVER,
   TEST_CODE_OWNERS,
   TEST_EARLY_FLAKE_ABORT_REASON,
   TEST_EARLY_FLAKE_ENABLED,
@@ -21,7 +20,6 @@ const {
   TEST_IS_MODIFIED,
   TEST_IS_NEW,
   TEST_IS_RETRY,
-  TEST_IS_RUM_ACTIVE,
   TEST_ITR_FORCED_RUN,
   TEST_ITR_UNSKIPPABLE,
   TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
@@ -108,7 +106,9 @@ class CucumberPlugin extends CiPlugin {
       this.testModuleSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
-      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session')
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session', {
+        hasFailedTestReplay: this.libraryConfig?.isDiEnabled || undefined,
+      })
       finishAllTraceSpans(this.testSessionSpan)
       this.telemetry.count(TELEMETRY_TEST_SESSION, {
         provider: this.ciProviderName,
@@ -362,13 +362,7 @@ class CucumberPlugin extends CiPlugin {
         }
       }
 
-      const spanTags = span.context()._tags
-      const telemetryTags = {
-        hasCodeOwners: !!spanTags[TEST_CODE_OWNERS],
-        isNew,
-        isRum: spanTags[TEST_IS_RUM_ACTIVE] === 'true',
-        browserDriver: spanTags[TEST_BROWSER_DRIVER],
-      }
+      const telemetryTags = this.getTestTelemetryTags(span)
       span.finish()
       if (!isStep) {
         this.telemetry.ciVisEvent(

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

@@ -976,11 +976,15 @@ class CypressPlugin {
           this.finishedTestsByFile[testSuite] = [finishedTest]
         }
         // test spans are finished at after:spec
+        const activeSpanTags = this.activeTestSpan.context()._tags
         this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', {
-          hasCodeOwners: !!this.activeTestSpan.context()._tags[TEST_CODE_OWNERS],
+          hasCodeOwners: !!activeSpanTags[TEST_CODE_OWNERS],
           isNew,
           isRum: isRUMActive,
           browserDriver: 'cypress',
+          isQuarantined: isQuarantinedFromSupport,
+          isModified,
+          isDisabled: activeSpanTags[TEST_MANAGEMENT_IS_DISABLED] === 'true',
         })
         this.activeTestSpan = null
 

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -127,9 +127,10 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
     const meta = {
       'gcloud.project_id': subscription.pubsub.projectId,
       'pubsub.topic': topic,
+      'pubsub.message_id': message.messageId,
       'span.kind': 'consumer',
+      'pubsub.subscription': subscription.name,
       'pubsub.subscription_type': 'pull',
-      'pubsub.span_type': 'message_processing',
       'messaging.operation': 'receive',
       base_service: baseService,
       service_override_type: 'custom',
@@ -171,9 +172,6 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
       metrics,
     }, ctx)
 
-    if (message.id) {
-      span.setTag('pubsub.message_id', message.id)
-    }
     if (message.publishTime) {
       span.setTag('pubsub.publish_time', message.publishTime.toISOString())
     }