dd-trace 5.6.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.
@@ -1624,6 +1659,10 @@ declare namespace tracer {
        * The service name to be used for this plugin. If a function is used, it will be passed the connection parameters and its return value will be used as the service name.
        */
       service?: string | ((params: any) => string);
+      /**
+       * The database monitoring propagation mode to be used for this plugin.
+       */
+      dbmPropagationMode?: string;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.6.0",
+  "version": "5.8.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "@datadog/native-appsec": "7.1.0",
-    "@datadog/native-iast-rewriter": "2.2.3",
+    "@datadog/native-iast-rewriter": "2.3.0",
     "@datadog/native-iast-taint-tracking": "1.7.0",
     "@datadog/native-metrics": "^2.0.0",
     "@datadog/pprof": "5.1.0",

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