dd-trace 5.7.0 → 5.8.0

package/index.d.ts

@@ -137,8 +137,10 @@ interface Tracer extends opentracing.Tracer {
 // is doesn't need to be exported for Tracer
 /** @hidden */
 interface Plugins {
+  "aerospike": tracer.plugins.aerospike;
   "amqp10": tracer.plugins.amqp10;
   "amqplib": tracer.plugins.amqplib;
+  "apollo": tracer.plugins.apollo;
   "aws-sdk": tracer.plugins.aws_sdk;
   "bunyan": tracer.plugins.bunyan;
   "cassandra-driver": tracer.plugins.cassandra_driver;
@@ -1098,6 +1100,12 @@ declare namespace tracer {
       meta?: boolean;
     }
 
+    /**
+     * This plugin automatically instruments the
+     * [aerospike](https://github.com/aerospike/aerospike-client-nodejs) for module versions >= v3.16.2.
+     */
+    interface aerospike extends Instrumentation {}
+
     /**
      * This plugin automatically instruments the
      * [amqp10](https://github.com/noodlefrenzy/node-amqp10) module.
@@ -1110,6 +1118,33 @@ declare namespace tracer {
      */
     interface amqplib extends Instrumentation {}
 
+    /**
+     * Currently this plugin automatically instruments
+     * [@apollo/gateway](https://github.com/apollographql/federation) for module versions >= v2.3.0.
+     * This module uses graphql operations to service requests & thus generates graphql spans.
+     * We recommend disabling the graphql plugin if you only want to trace @apollo/gateway
+     */
+    interface apollo extends Instrumentation {
+      /**
+       * Whether to include the source of the operation within the query as a tag
+       * on every span. This may contain sensitive information and should only be
+       * enabled if sensitive data is always sent as variables and not in the
+       * query text.
+       *
+       * @default false
+       */
+      source?: boolean;
+
+      /**
+       * Whether to enable signature calculation for the resource name. This can
+       * be disabled if your apollo/gateway operations always have a name. Note that when
+       * disabled all queries will need to be named for this to work properly.
+       *
+       * @default true
+       */
+      signature?: boolean;
+    }
+
     /**
      * This plugin automatically instruments the
      * [aws-sdk](https://github.com/aws/aws-sdk-js) module.

package/package.json

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

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

@@ -0,0 +1,101 @@
+const {
+  addHook,
+  channel
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const tracingChannel = require('dc-polyfill').tracingChannel
+
+const CHANNELS = {
+  'gateway.request': tracingChannel('apm:apollo:gateway:request'),
+  'gateway.plan': tracingChannel('apm:apollo:gateway:plan'),
+  'gateway.validate': tracingChannel('apm:apollo:gateway:validate'),
+  'gateway.execute': tracingChannel('apm:apollo:gateway:execute'),
+  'gateway.fetch': tracingChannel('apm:apollo:gateway:fetch'),
+  'gateway.postprocessing': tracingChannel('apm:apollo:gateway:postprocessing')
+}
+
+const executorCh = channel('apm:apollo:gateway:request:executor')
+const generalErrorCh = channel('apm:apollo:gateway:general:error')
+
+function wrapExecutor (executor) {
+  return function (...args) {
+    const ctx = { requestContext: args[0], gateway: this }
+    executorCh.publish(ctx)
+    return executor.apply(this, args)
+  }
+}
+
+function wrapApolloGateway (ApolloGateway) {
+  class ApolloGatewayWrapper extends ApolloGateway {
+    constructor (...args) {
+      super(...args)
+      shimmer.wrap(this, 'executor', wrapExecutor)
+    }
+  }
+  return ApolloGatewayWrapper
+}
+
+function wrapRecordExceptions (recordExceptions) {
+  return function wrappedRecordExceptions (...args) {
+    const errors = args[1]
+    // only the last exception in the array of exceptions will be reported on the span,
+    // this is mimicking apollo-gateways internal instrumentation
+    // TODO: should we consider a mechanism to report all exceptions? since this method aggregates all exceptions
+    // where as a span can only have one exception set on it at a time
+    generalErrorCh.publish({ error: errors[errors.length - 1] })
+    return recordExceptions.apply(this, args)
+  }
+}
+
+function wrapStartActiveSpan (startActiveSpan) {
+  return function (...args) {
+    const firstArg = args[0]
+    const cb = args[args.length - 1]
+    if (typeof firstArg !== 'string' || typeof cb !== 'function') return startActiveSpan.apply(this, args)
+
+    const method = CHANNELS[firstArg]
+    let ctx = {}
+    if (firstArg === 'gateway.fetch') {
+      ctx = { attributes: args[1].attributes }
+    }
+
+    switch (firstArg) {
+      case 'gateway.plan' :
+      case 'gateway.validate': {
+        args[args.length - 1] = function (...callbackArgs) {
+          return method.traceSync(cb, ctx, this, ...callbackArgs)
+        }
+        break
+      }
+      case 'gateway.request':
+      case 'gateway.execute':
+      case 'gateway.postprocessing' :
+      case 'gateway.fetch': {
+        args[args.length - 1] = function (...callbackArgs) {
+          return method.tracePromise(cb, ctx, this, ...callbackArgs)
+        }
+        break
+      }
+    }
+    return startActiveSpan.apply(this, args)
+  }
+}
+
+addHook({ name: '@apollo/gateway', file: 'dist/utilities/opentelemetry.js', versions: ['>=2.3.0'] },
+  (obj) => {
+    const newTracerObj = Object.create(obj.tracer)
+    shimmer.wrap(newTracerObj, 'startActiveSpan', wrapStartActiveSpan)
+    obj.tracer = newTracerObj
+    return obj
+  })
+
+addHook({ name: '@apollo/gateway', file: 'dist/utilities/opentelemetry.js', versions: ['>=2.6.0'] },
+  (obj) => {
+    shimmer.wrap(obj, 'recordExceptions', wrapRecordExceptions)
+    return obj
+  })
+
+addHook({ name: '@apollo/gateway', versions: ['>=2.3.0'] }, (gateway) => {
+  shimmer.wrap(gateway, 'ApolloGateway', wrapApolloGateway)
+  return gateway
+})

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

@@ -2,6 +2,7 @@
 
 module.exports = {
   '@apollo/server': () => require('../apollo-server'),
+  '@apollo/gateway': () => require('../apollo'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@cucumber/cucumber': () => require('../cucumber'),

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -197,7 +197,7 @@ function instrumentPromise (operation, command, ctx, args, server, ns, ops, opti
 
     const promise = command.apply(ctx, args)
 
-    promise.then(function (res) {
+    return promise.then(function (res) {
       finishCh.publish()
       return res
     }, function (err) {
@@ -206,7 +206,5 @@ function instrumentPromise (operation, command, ctx, args, server, ns, ops, opti
 
       return Promise.reject(err)
     })
-
-    return promise
   })
 }

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

@@ -1,6 +1,9 @@
+const semver = require('semver')
+
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const { parseAnnotations } = require('../../dd-trace/src/plugins/util/test')
+const { parseAnnotations, getTestSuitePath } = require('../../dd-trace/src/plugins/util/test')
+const log = require('../../dd-trace/src/log')
 
 const testStartCh = channel('ci:playwright:test:start')
 const testFinishCh = channel('ci:playwright:test:finish')
@@ -8,6 +11,9 @@ const testFinishCh = channel('ci:playwright:test:finish')
 const testSessionStartCh = channel('ci:playwright:session:start')
 const testSessionFinishCh = channel('ci:playwright:session:finish')
 
+const libraryConfigurationCh = channel('ci:playwright:library-configuration')
+const knownTestsCh = channel('ci:playwright:known-tests')
+
 const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 
@@ -16,6 +22,8 @@ const testSuiteToAr = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 
+let applyRepeatEachIndex = null
+
 let startedSuites = []
 
 const STATUS_TO_TEST_STATUS = {
@@ -26,6 +34,44 @@ const STATUS_TO_TEST_STATUS = {
 }
 
 let remainingTestsByFile = {}
+let isEarlyFlakeDetectionEnabled = false
+let earlyFlakeDetectionNumRetries = 0
+let knownTests = []
+let rootDir = ''
+const MINIMUM_SUPPORTED_VERSION_EFD = '1.38.0'
+
+function isNewTest (test) {
+  const testSuite = getTestSuitePath(test._requireFile, rootDir)
+  const testsForSuite = knownTests?.playwright?.[testSuite] || []
+
+  return !testsForSuite.includes(test.title)
+}
+
+function getSuiteType (test, type) {
+  let suite = test.parent
+  while (suite && suite._type !== type) {
+    suite = suite.parent
+  }
+  return suite
+}
+
+// Copy of Suite#_deepClone but with a function to filter tests
+function deepCloneSuite (suite, filterTest) {
+  const copy = suite._clone()
+  for (const entry of suite._entries) {
+    if (entry.constructor.name === 'Suite') {
+      copy._addSuite(deepCloneSuite(entry, filterTest))
+    } else {
+      if (filterTest(entry)) {
+        const copiedTest = entry._clone()
+        copiedTest._ddIsNew = true
+        copiedTest._ddIsEfdRetry = true
+        copy._addTest(copiedTest)
+      }
+    }
+  }
+  return copy
+}
 
 function getTestsBySuiteFromTestGroups (testGroups) {
   return testGroups.reduce((acc, { requireFile, tests }) => {
@@ -153,8 +199,11 @@ function getTestSuiteError (testSuiteAbsolutePath) {
 function testBeginHandler (test, browserName) {
   const {
     _requireFile: testSuiteAbsolutePath,
-    title: testName, _type,
-    location: { line: testSourceLine }
+    title: testName,
+    _type,
+    location: {
+      line: testSourceLine
+    }
   } = test
 
   if (_type === 'beforeAll' || _type === 'afterAll') {
@@ -198,7 +247,14 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
   const testResult = results[results.length - 1]
   const testAsyncResource = testToAr.get(test)
   testAsyncResource.runInAsyncScope(() => {
-    testFinishCh.publish({ testStatus, steps: testResult.steps, error, extraTags: annotationTags })
+    testFinishCh.publish({
+      testStatus,
+      steps: testResult.steps,
+      error,
+      extraTags: annotationTags,
+      isNew: test._ddIsNew,
+      isEfdRetry: test._ddIsEfdRetry
+    })
   })
 
   if (testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
@@ -309,14 +365,54 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 
 function runnerHook (runnerExport, playwrightVersion) {
   shimmer.wrap(runnerExport.Runner.prototype, 'runAllTests', runAllTests => async function () {
+    let onDone
+
     const testSessionAsyncResource = new AsyncResource('bound-anonymous-fn')
-    const rootDir = getRootDir(this)
+
+    rootDir = getRootDir(this)
 
     const processArgv = process.argv.slice(2).join(' ')
     const command = `playwright ${processArgv}`
     testSessionAsyncResource.runInAsyncScope(() => {
       testSessionStartCh.publish({ command, frameworkVersion: playwrightVersion, rootDir })
     })
+
+    const configurationPromise = new Promise((resolve) => {
+      onDone = resolve
+    })
+
+    testSessionAsyncResource.runInAsyncScope(() => {
+      libraryConfigurationCh.publish({ onDone })
+    })
+
+    try {
+      const { err, libraryConfig } = await configurationPromise
+      if (!err) {
+        isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
+        earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+      }
+    } catch (e) {
+      log.error(e)
+    }
+
+    if (isEarlyFlakeDetectionEnabled && semver.gte(playwrightVersion, MINIMUM_SUPPORTED_VERSION_EFD)) {
+      const knownTestsPromise = new Promise((resolve) => {
+        onDone = resolve
+      })
+      testSessionAsyncResource.runInAsyncScope(() => {
+        knownTestsCh.publish({ onDone })
+      })
+
+      try {
+        const { err, knownTests: receivedKnownTests } = await knownTestsPromise
+        if (!err) {
+          knownTests = receivedKnownTests
+        }
+      } catch (err) {
+        log.error(err)
+      }
+    }
+
     const projects = getProjectsFromRunner(this)
 
     const runAllTestsReturn = await runAllTests.apply(this, arguments)
@@ -334,7 +430,6 @@ function runnerHook (runnerExport, playwrightVersion) {
 
     const sessionStatus = runAllTestsReturn.status || runAllTestsReturn
 
-    let onDone
     const flushWait = new Promise(resolve => {
       onDone = resolve
     })
@@ -394,3 +489,53 @@ addHook({
   file: 'lib/runner/dispatcher.js',
   versions: ['>=1.38.0']
 }, (dispatcher) => dispatcherHookNew(dispatcher, dispatcherRunWrapperNew))
+
+// Hook used for early flake detection. EFD only works from >=1.38.0
+addHook({
+  name: 'playwright',
+  file: 'lib/common/suiteUtils.js',
+  versions: [`>=${MINIMUM_SUPPORTED_VERSION_EFD}`]
+}, suiteUtilsPackage => {
+  // We grab `applyRepeatEachIndex` to use it later
+  // `applyRepeatEachIndex` needs to be applied to a cloned suite
+  applyRepeatEachIndex = suiteUtilsPackage.applyRepeatEachIndex
+  return suiteUtilsPackage
+})
+
+// Hook used for early flake detection. EFD only works from >=1.38.0
+addHook({
+  name: 'playwright',
+  file: 'lib/runner/loadUtils.js',
+  versions: [`>=${MINIMUM_SUPPORTED_VERSION_EFD}`]
+}, (loadUtilsPackage) => {
+  const oldCreateRootSuite = loadUtilsPackage.createRootSuite
+
+  async function newCreateRootSuite () {
+    const rootSuite = await oldCreateRootSuite.apply(this, arguments)
+    if (!isEarlyFlakeDetectionEnabled) {
+      return rootSuite
+    }
+    const newTests = rootSuite
+      .allTests()
+      .filter(isNewTest)
+
+    newTests.forEach(newTest => {
+      newTest._ddIsNew = true
+      if (newTest.expectedStatus !== 'skipped') {
+        const fileSuite = getSuiteType(newTest, 'file')
+        const projectSuite = getSuiteType(newTest, 'project')
+        for (let repeatEachIndex = 0; repeatEachIndex < earlyFlakeDetectionNumRetries; repeatEachIndex++) {
+          const copyFileSuite = deepCloneSuite(fileSuite, isNewTest)
+          applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
+          projectSuite._addSuite(copyFileSuite)
+        }
+      }
+    })
+
+    return rootSuite
+  }
+
+  loadUtilsPackage.createRootSuite = newCreateRootSuite
+
+  return loadUtilsPackage
+})

package/packages/datadog-plugin-apollo/src/gateway/execute.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
+
+class ApolloGatewayExecutePlugin extends ApolloBasePlugin {
+  static get operation () { return 'execute' }
+  static get prefix () {
+    return 'tracing:apm:apollo:gateway:execute'
+  }
+}
+
+module.exports = ApolloGatewayExecutePlugin

package/packages/datadog-plugin-apollo/src/gateway/fetch.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { storage } = require('../../../datadog-core')
+const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
+
+class ApolloGatewayFetchPlugin extends ApolloBasePlugin {
+  static get operation () { return 'fetch' }
+  static get prefix () {
+    return 'tracing:apm:apollo:gateway:fetch'
+  }
+
+  bindStart (ctx) {
+    const store = storage.getStore()
+    const childOf = store ? store.span : null
+
+    const spanData = {
+      childOf,
+      service: this.getServiceName(),
+      type: this.constructor.type,
+      meta: {}
+    }
+
+    const serviceName = ctx?.attributes?.service
+
+    if (serviceName) { spanData.meta['serviceName'] = serviceName }
+
+    const span = this.startSpan(this.getOperationName(), spanData, false)
+
+    ctx.parentStore = store
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = ApolloGatewayFetchPlugin

package/packages/datadog-plugin-apollo/src/gateway/index.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { storage } = require('../../../datadog-core')
+const CompositePlugin = require('../../../dd-trace/src/plugins/composite')
+const ApolloGatewayExecutePlugin = require('./execute')
+const ApolloGatewayPostProcessingPlugin = require('./postprocessing')
+const ApolloGatewayRequestPlugin = require('./request')
+const ApolloGatewayPlanPlugin = require('./plan')
+const ApolloGatewayValidatePlugin = require('./validate')
+const ApolloGatewayFetchPlugin = require('./fetch')
+
+class ApolloGatewayPlugin extends CompositePlugin {
+  static get id () { return 'gateway' }
+  static get plugins () {
+    return {
+      execute: ApolloGatewayExecutePlugin,
+      postprocessing: ApolloGatewayPostProcessingPlugin,
+      request: ApolloGatewayRequestPlugin,
+      plan: ApolloGatewayPlanPlugin,
+      fetch: ApolloGatewayFetchPlugin,
+      validate: ApolloGatewayValidatePlugin
+    }
+  }
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('apm:apollo:gateway:general:error', (ctx) => {
+      const store = storage.getStore()
+      const span = store?.span
+      if (!span) return
+      span.setTag('error', ctx.error)
+    })
+  }
+}
+
+module.exports = ApolloGatewayPlugin

package/packages/datadog-plugin-apollo/src/gateway/plan.js

@@ -0,0 +1,13 @@
+
+'use strict'
+
+const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
+
+class ApolloGatewayPlanPlugin extends ApolloBasePlugin {
+  static get operation () { return 'plan' }
+  static get prefix () {
+    return 'tracing:apm:apollo:gateway:plan'
+  }
+}
+
+module.exports = ApolloGatewayPlanPlugin

package/packages/datadog-plugin-apollo/src/gateway/postprocessing.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
+
+class ApolloGatewayPostProcessingPlugin extends ApolloBasePlugin {
+  static get operation () { return 'postprocessing' }
+  static get prefix () {
+    return 'tracing:apm:apollo:gateway:postprocessing'
+  }
+}
+
+module.exports = ApolloGatewayPostProcessingPlugin

package/packages/datadog-plugin-apollo/src/gateway/request.js

@@ -0,0 +1,139 @@
+'use strict'
+
+const { storage } = require('../../../datadog-core')
+const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
+
+let tools
+
+const OPERATION_DEFINITION = 'OperationDefinition'
+const FRAGMENT_DEFINITION = 'FragmentDefinition'
+
+class ApolloGatewayRequestPlugin extends ApolloBasePlugin {
+  static get operation () { return 'request' }
+  static get prefix () {
+    return 'tracing:apm:apollo:gateway:request'
+  }
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('apm:apollo:gateway:request:executor', (ctx) => {
+      if (ctx.requestContext || ctx.gateway) {
+        this.requestContext = ctx
+      } else {
+        this.requestContext = {}
+      }
+    })
+  }
+
+  bindStart (ctx) {
+    const store = storage.getStore()
+    const childOf = store ? store.span : null
+    const spanData = {
+      childOf,
+      service: this.serviceName(
+        { id: `${this.constructor.id}.${this.constructor.operation}`, pluginConfig: this.config }),
+      type: this.constructor.type,
+      kind: this.constructor.kind,
+      meta: {}
+    }
+
+    const { requestContext, gateway } = this.requestContext
+
+    if (requestContext?.operationName) {
+      spanData.meta['graphql.operation.name'] = requestContext.operationName
+    }
+    if ((this.config.source || gateway?.config?.telemetry?.includeDocument) && requestContext?.source) {
+      spanData.meta['graphql.source'] = requestContext.source
+    }
+
+    const operationContext =
+    buildOperationContext(gateway.schema, requestContext.document, requestContext.request.operationName)
+
+    if (operationContext?.operation?.operation) {
+      const document = requestContext?.document
+      const type = operationContext?.operation?.operation
+      const name = operationContext?.operation?.name && operationContext?.operation?.name?.value
+
+      spanData['resource'] = getSignature(document, name, type, this?.config?.signature)
+      spanData.meta['graphql.operation.type'] = type
+    }
+    const span = this.startSpan(this.operationName({ id: `${this.constructor.id}.${this.constructor.operation}` }),
+      spanData, false)
+
+    ctx.parentStore = store
+    ctx.currentStore = { ...store, span }
+    return ctx.currentStore
+  }
+
+  asyncStart (ctx) {
+    const errors = ctx?.result?.errors
+    // apollo gateway catches certain errors and returns them in the result object
+    // we want to capture these errors as spans
+    if (errors instanceof Array &&
+      errors[errors.length - 1] && errors[errors.length - 1].stack && errors[errors.length - 1].message) {
+      ctx.currentStore.span.setTag('error', errors[errors.length - 1])
+    }
+    ctx.currentStore.span.finish()
+    return ctx.parentStore
+  }
+
+  end () {
+    // do nothing to avoid ApolloBasePlugin's end method
+  }
+}
+
+function buildOperationContext (schema, operationDocument, operationName) {
+  let operation
+  let operationCount = 0
+  const fragments = Object.create(null)
+  try {
+    operationDocument.definitions.forEach(definition => {
+      switch (definition.kind) {
+        case OPERATION_DEFINITION:
+          operationCount++
+          if (!operationName && operationCount > 1) {
+            return
+          }
+          if (
+            !operationName ||
+            (definition.name && definition.name.value === operationName)
+          ) {
+            operation = definition
+          }
+          break
+        case FRAGMENT_DEFINITION:
+          fragments[definition.name.value] = definition
+          break
+      }
+    })
+  } catch (e) {
+    // safety net
+  }
+
+  return {
+    schema,
+    operation,
+    fragments
+  }
+}
+
+function getSignature (document, operationName, operationType, calculate) {
+  if (calculate !== false && tools !== false) {
+    try {
+      try {
+        tools = tools || require('../../../datadog-plugin-graphql/src/tools')
+      } catch (e) {
+        tools = false
+        throw e
+      }
+
+      return tools.defaultEngineReportingSignature(document, operationName)
+    } catch (e) {
+      // safety net
+    }
+  }
+
+  return [operationType, operationName].filter(val => val).join(' ')
+}
+
+module.exports = ApolloGatewayRequestPlugin

package/packages/datadog-plugin-apollo/src/gateway/validate.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const ApolloBasePlugin = require('../../../dd-trace/src/plugins/apollo')
+
+class ApolloGatewayValidatePlugin extends ApolloBasePlugin {
+  static get operation () { return 'validate' }
+  static get prefix () {
+    return 'tracing:apm:apollo:gateway:validate'
+  }
+
+  end (ctx) {
+    const result = ctx.result
+    if (result instanceof Array &&
+      result[result.length - 1] && result[result.length - 1].stack && result[result.length - 1].message) {
+      ctx.currentStore.span.setTag('error', result[result.length - 1])
+    }
+    ctx.currentStore.span.finish()
+  }
+}
+
+module.exports = ApolloGatewayValidatePlugin

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ApolloGatewayPlugin = require('./gateway')
+
+class ApolloPlugin extends CompositePlugin {
+  static get id () { return 'apollo' }
+  static get plugins () {
+    return {
+      gateway: ApolloGatewayPlugin
+    }
+  }
+}
+
+module.exports = ApolloPlugin

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

@@ -11,7 +11,9 @@ const {
   TEST_SOURCE_START,
   TEST_CODE_OWNERS,
   TEST_SOURCE_FILE,
-  TEST_CONFIGURATION_BROWSER_NAME
+  TEST_CONFIGURATION_BROWSER_NAME,
+  TEST_IS_NEW,
+  TEST_IS_RETRY
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT } = require('../../dd-trace/src/constants')
@@ -109,7 +111,7 @@ class PlaywrightPlugin extends CiPlugin {
 
       this.enter(span, store)
     })
-    this.addSub('ci:playwright:test:finish', ({ testStatus, steps, error, extraTags }) => {
+    this.addSub('ci:playwright:test:finish', ({ testStatus, steps, error, extraTags, isNew, isEfdRetry }) => {
       const store = storage.getStore()
       const span = store && store.span
       if (!span) return
@@ -122,6 +124,12 @@ class PlaywrightPlugin extends CiPlugin {
       if (extraTags) {
         span.addTags(extraTags)
       }
+      if (isNew) {
+        span.setTag(TEST_IS_NEW, 'true')
+        if (isEfdRetry) {
+          span.setTag(TEST_IS_RETRY, 'true')
+        }
+      }
 
       steps.forEach(step => {
         const stepStartTime = step.startTime.getTime()

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

@@ -4,7 +4,6 @@ const { channel } = require('dc-polyfill')
 const { isFalse } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')
-const Nomenclature = require('./service-naming')
 
 const loadChannel = channel('dd-trace:instrumentation:load')
 
@@ -102,7 +101,7 @@ module.exports = class PluginManager {
   // like instrumenter.enable()
   configure (config = {}) {
     this._tracerConfig = config
-    Nomenclature.configure(config)
+    this._tracer._nomenclature.configure(config)
 
     for (const name in pluginClasses) {
       this.loadPlugin(name)

package/packages/dd-trace/src/plugins/apollo.js

@@ -0,0 +1,50 @@
+const TracingPlugin = require('./tracing')
+const { storage } = require('../../../datadog-core')
+
+class ApolloBasePlugin extends TracingPlugin {
+  static get id () { return 'apollo.gateway' }
+  static get type () { return 'web' }
+  static get kind () { return 'server' }
+
+  bindStart (ctx) {
+    const store = storage.getStore()
+    const childOf = store ? store.span : null
+
+    const span = this.startSpan(this.getOperationName(), {
+      childOf,
+      service: this.getServiceName(),
+      type: this.constructor.type,
+      kind: this.constructor.kind,
+      meta: {}
+    }, false)
+
+    ctx.parentStore = store
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    ctx?.currentStore?.span.finish()
+  }
+
+  asyncStart (ctx) {
+    ctx?.currentStore?.span.finish()
+    return ctx.parentStore
+  }
+
+  getServiceName () {
+    return this.serviceName({
+      id: `${this.constructor.id}.${this.constructor.operation}`,
+      pluginConfig: this.config
+    })
+  }
+
+  getOperationName () {
+    return this.operationName({
+      id: `${this.constructor.id}.${this.constructor.operation}`
+    })
+  }
+}
+
+module.exports = ApolloBasePlugin

package/packages/dd-trace/src/plugins/composite.js

@@ -12,6 +12,7 @@ class CompositePlugin extends Plugin {
   }
 
   configure (config) {
+    super.configure(config)
     for (const name in this.constructor.plugins) {
       const pluginConfig = config[name] === false ? false : {
         ...config,

package/packages/dd-trace/src/plugins/index.js

@@ -1,6 +1,7 @@
 'use strict'
 
 module.exports = {
+  get '@apollo/gateway' () { return require('../../../datadog-plugin-apollo/src') },
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },
   get '@playwright/test' () { return require('../../../datadog-plugin-playwright/src') },

package/packages/dd-trace/src/plugins/tracing.js

@@ -4,7 +4,6 @@ const Plugin = require('./plugin')
 const { storage } = require('../../../datadog-core')
 const analyticsSampler = require('../analytics_sampler')
 const { COMPONENT } = require('../constants')
-const Nomenclature = require('../service-naming')
 
 class TracingPlugin extends Plugin {
   constructor (...args) {
@@ -29,7 +28,7 @@ class TracingPlugin extends Plugin {
       kind = this.constructor.kind
     } = opts
 
-    return Nomenclature.serviceName(type, kind, id, opts)
+    return this._tracer._nomenclature.serviceName(type, kind, id, opts)
   }
 
   operationName (opts = {}) {
@@ -39,7 +38,7 @@ class TracingPlugin extends Plugin {
       kind = this.constructor.kind
     } = opts
 
-    return Nomenclature.opName(type, kind, id, opts)
+    return this._tracer._nomenclature.opName(type, kind, id, opts)
   }
 
   configure (config) {
@@ -58,8 +57,12 @@ class TracingPlugin extends Plugin {
     this.activeSpan?.finish()
   }
 
-  error (error) {
-    this.addError(error)
+  error (ctxOrError) {
+    if (ctxOrError?.currentStore) {
+      ctxOrError.currentStore?.span.setTag('error', ctxOrError?.error)
+      return
+    }
+    this.addError(ctxOrError)
   }
 
   addTraceSubs () {

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -15,6 +15,8 @@ const MS_TO_NS = 1000000
 const pprofValueType = 'timeline'
 const pprofValueUnit = 'nanoseconds'
 
+const dateOffset = BigInt(Math.round(performance.timeOrigin * MS_TO_NS))
+
 function labelFromStr (stringTable, key, valStr) {
   return new Label({ key, str: stringTable.dedup(valStr) })
 }
@@ -146,6 +148,76 @@ if (node16) {
   decoratorTypes.net = NetDecorator
 }
 
+// Translates performance entries into pprof samples.
+class EventSerializer {
+  constructor () {
+    this.stringTable = new StringTable()
+    this.samples = []
+    this.locations = []
+    this.functions = []
+    this.decorators = {}
+
+    // A synthetic single-frame location to serve as the location for timeline
+    // samples. We need these as the profiling backend (mimicking official pprof
+    // tool's behavior) ignores these.
+    const fn = new Function({ id: this.functions.length + 1, name: this.stringTable.dedup('') })
+    this.functions.push(fn)
+    const line = new Line({ functionId: fn.id })
+    const location = new Location({ id: this.locations.length + 1, line: [line] })
+    this.locations.push(location)
+    this.locationId = [location.id]
+
+    this.timestampLabelKey = this.stringTable.dedup(END_TIMESTAMP_LABEL)
+  }
+
+  addEvent (item) {
+    const { entryType, startTime, duration } = item
+    let decorator = this.decorators[entryType]
+    if (!decorator) {
+      const DecoratorCtor = decoratorTypes[entryType]
+      if (DecoratorCtor) {
+        decorator = new DecoratorCtor(this.stringTable)
+        decorator.eventTypeLabel = labelFromStrStr(this.stringTable, 'event', entryType)
+        this.decorators[entryType] = decorator
+      } else {
+        // Shouldn't happen but it's better to not rely on observer only getting
+        // requested event types.
+        return
+      }
+    }
+    const endTime = startTime + duration
+    const sampleInput = {
+      value: [Math.round(duration * MS_TO_NS)],
+      locationId: this.locationId,
+      label: [
+        decorator.eventTypeLabel,
+        new Label({ key: this.timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) })
+      ]
+    }
+    decorator.decorateSample(sampleInput, item)
+    this.samples.push(new Sample(sampleInput))
+  }
+
+  createProfile (startDate, endDate) {
+    const timeValueType = new ValueType({
+      type: this.stringTable.dedup(pprofValueType),
+      unit: this.stringTable.dedup(pprofValueUnit)
+    })
+
+    return new Profile({
+      sampleType: [timeValueType],
+      timeNanos: endDate.getTime() * MS_TO_NS,
+      periodType: timeValueType,
+      period: 1,
+      durationNanos: (endDate.getTime() - startDate.getTime()) * MS_TO_NS,
+      sample: this.samples,
+      location: this.locations,
+      function: this.functions,
+      stringTable: this.stringTable
+    })
+  }
+}
+
 /**
  * This class generates pprof files with timeline events sourced from Node.js
  * performance measurement APIs.
@@ -155,7 +227,7 @@ class EventsProfiler {
     this.type = 'events'
     this._flushIntervalNanos = (options.flushInterval || 60000) * 1e6 // 60 sec
     this._observer = undefined
-    this.entries = []
+    this.eventSerializer = new EventSerializer()
   }
 
   start () {
@@ -163,7 +235,9 @@ class EventsProfiler {
     if (this._observer) return
 
     function add (items) {
-      this.entries.push(...items.getEntries())
+      for (const item of items.getEntries()) {
+        this.eventSerializer.addEvent(item)
+      }
     }
     this._observer = new PerformanceObserver(add.bind(this))
     this._observer.observe({ entryTypes: Object.keys(decoratorTypes) })
@@ -177,89 +251,12 @@ class EventsProfiler {
   }
 
   profile (restart, startDate, endDate) {
-    if (this.entries.length === 0) {
-      // No events in the period; don't produce a profile
-      return null
-    }
-
-    const stringTable = new StringTable()
-    const locations = []
-    const functions = []
-
-    // A synthetic single-frame location to serve as the location for timeline
-    // samples. We need these as the profiling backend (mimicking official pprof
-    // tool's behavior) ignores these.
-    const locationId = (() => {
-      const fn = new Function({ id: functions.length + 1, name: stringTable.dedup('') })
-      functions.push(fn)
-      const line = new Line({ functionId: fn.id })
-      const location = new Location({ id: locations.length + 1, line: [line] })
-      locations.push(location)
-      return [location.id]
-    })()
-
-    const decorators = {}
-    for (const [eventType, DecoratorCtor] of Object.entries(decoratorTypes)) {
-      const decorator = new DecoratorCtor(stringTable)
-      decorator.eventTypeLabel = labelFromStrStr(stringTable, 'event', eventType)
-      decorators[eventType] = decorator
-    }
-    const timestampLabelKey = stringTable.dedup(END_TIMESTAMP_LABEL)
-
-    const dateOffset = BigInt(Math.round(performance.timeOrigin * MS_TO_NS))
-    const lateEntries = []
-    const perfEndDate = endDate.getTime() - performance.timeOrigin
-    const samples = this.entries.map((item) => {
-      const decorator = decorators[item.entryType]
-      if (!decorator) {
-        // Shouldn't happen but it's better to not rely on observer only getting
-        // requested event types.
-        return null
-      }
-      const { startTime, duration } = item
-      if (startTime >= perfEndDate) {
-        // An event past the current recording end date; save it for the next
-        // profile. Not supposed to happen as long as there's no async activity
-        // between capture of the endDate value in profiler.js _collect() and
-        // here, but better be safe than sorry.
-        lateEntries.push(item)
-        return null
-      }
-      const endTime = startTime + duration
-      const sampleInput = {
-        value: [Math.round(duration * MS_TO_NS)],
-        locationId,
-        label: [
-          decorator.eventTypeLabel,
-          new Label({ key: timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) })
-        ]
-      }
-      decorator.decorateSample(sampleInput, item)
-      return new Sample(sampleInput)
-    }).filter(v => v)
-
-    this.entries = lateEntries
-
-    const timeValueType = new ValueType({
-      type: stringTable.dedup(pprofValueType),
-      unit: stringTable.dedup(pprofValueUnit)
-    })
-
     if (!restart) {
       this.stop()
     }
-
-    return new Profile({
-      sampleType: [timeValueType],
-      timeNanos: endDate.getTime() * MS_TO_NS,
-      periodType: timeValueType,
-      period: 1,
-      durationNanos: (endDate.getTime() - startDate.getTime()) * MS_TO_NS,
-      sample: samples,
-      location: locations,
-      function: functions,
-      stringTable: stringTable
-    })
+    const profile = this.eventSerializer.createProfile(startDate, endDate)
+    this.eventSerializer = new EventSerializer()
+    return profile
   }
 
   encode (profile) {

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

@@ -6,6 +6,7 @@ const runtimeMetrics = require('./runtime_metrics')
 const log = require('./log')
 const { setStartupLogPluginManager } = require('./startup-log')
 const telemetry = require('./telemetry')
+const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
 const remoteConfig = require('./appsec/remote_config')
 const AppsecSdk = require('./appsec/sdk')
@@ -17,6 +18,7 @@ class Tracer extends NoopProxy {
     super()
 
     this._initialized = false
+    this._nomenclature = nomenclature
     this._pluginManager = new PluginManager(this)
     this.dogstatsd = new dogstatsd.NoopDogStatsDClient()
     this._tracingInitialized = false

package/packages/dd-trace/src/service-naming/schemas/v0/web.js

@@ -33,6 +33,30 @@ const web = {
     }
   },
   server: {
+    'apollo.gateway.request': {
+      opName: () => 'apollo.gateway.request',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.plan': {
+      opName: () => 'apollo.gateway.plan',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.validate': {
+      opName: () => 'apollo.gateway.validate',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.execute': {
+      opName: () => 'apollo.gateway.execute',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.fetch': {
+      opName: () => 'apollo.gateway.fetch',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.postprocessing': {
+      opName: () => 'apollo.gateway.postprocessing',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
     grpc: {
       opName: () => DD_MAJOR <= 2 ? 'grpc.request' : 'grpc.server',
       serviceName: identityService

package/packages/dd-trace/src/service-naming/schemas/v1/web.js

@@ -32,6 +32,30 @@ const web = {
     }
   },
   server: {
+    'apollo.gateway.request': {
+      opName: () => 'apollo.gateway.request',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.plan': {
+      opName: () => 'apollo.gateway.plan',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.validate': {
+      opName: () => 'apollo.gateway.validate',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.execute': {
+      opName: () => 'apollo.gateway.execute',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.fetch': {
+      opName: () => 'apollo.gateway.fetch',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
+    'apollo.gateway.postprocessing': {
+      opName: () => 'apollo.gateway.postprocessing',
+      serviceName: ({ pluginConfig, tracerService }) => pluginConfig.service || tracerService
+    },
     grpc: {
       opName: () => 'grpc.server.request',
       serviceName: identityService