dd-trace 5.109.0 → 5.110.0

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -72,44 +72,53 @@ class Sqs extends BaseAwsSdkPlugin {
     })
   }
 
+  /**
+   * Start the consumer (`aws.response`) span for a receive. The first message carrying trace
+   * context becomes the parent; every additional one fans in as a span link.
+   *
+   * @param {{ request: object, response: object, needsFinish?: boolean, currentStore?: object }} ctx
+   * @returns {object | undefined} The store to activate for the consumer span, else the parent store.
+   */
   #startResponseSpan (ctx) {
     const { request, response } = ctx
-    const contextExtraction = this.responseExtract(request.params, request.operation, response)
+    const carriers = this.responseExtract(request.params, request.operation, response)
 
     let store = this._parentMap.get(request)
     let span
-    let parsedMessageAttributes
-    let parsedFirstBody
-    let firstBodyChecked = false
-    if (contextExtraction !== undefined) {
-      parsedFirstBody = contextExtraction.parsedBody
-      firstBodyChecked = contextExtraction.bodyChecked === true
-      if (contextExtraction.datadogContext !== undefined) {
-        parsedMessageAttributes = contextExtraction.parsedAttributes
-        // request:start records requestTags only after the isEnabled gate, so an absent entry
-        // means this consumer is disabled — gate on it instead of paying isEnabled again here.
-        const requestTags = this.requestTags.get(request)
-        if (requestTags !== undefined) {
-          ctx.needsFinish = true
-          const options = {
-            childOf: contextExtraction.datadogContext,
-            meta: {
-              ...requestTags,
-              'span.kind': 'server',
-            },
-            integrationName: 'aws-sdk',
+
+    if (carriers !== undefined) {
+      // request:start records requestTags only after the isEnabled gate, so an absent entry
+      // means this consumer is disabled — gate on it instead of paying isEnabled again here.
+      const requestTags = this.requestTags.get(request)
+      if (requestTags !== undefined) {
+        // A receive can return messages from many producers; fanning the extra ones in as span
+        // links is the shape dd-trace-java and dd-trace-py use for batch SQS receives.
+        for (const carrier of carriers) {
+          if (carrier === undefined) continue
+          const datadogContext = this.tracer.extract('text_map', carrier)
+          // A DSM-only carrier (a non-first sendMessageBatch entry when batchPropagationEnabled
+          // is off) extracts to null; span.addLink dereferences the context and would throw on it.
+          if (datadogContext === null) continue
+          if (span === undefined) {
+            ctx.needsFinish = true
+            span = this.startSpan('aws.response', {
+              childOf: datadogContext,
+              meta: {
+                ...requestTags,
+                'span.kind': 'server',
+              },
+              integrationName: 'aws-sdk',
+            }, ctx)
+            store = ctx.currentStore
+          } else {
+            span.addLink({ context: datadogContext })
           }
-          span = this.startSpan('aws.response', options, ctx)
-          store = ctx.currentStore
         }
       }
     }
 
     // Extract DSM context after, as we might not have a parent-child but may have a DSM context.
-    this.responseExtractDSMContext(
-      request.operation, request.params, response, span ?? null,
-      { parsedAttributes: parsedMessageAttributes, parsedFirstBody, firstBodyChecked }
-    )
+    this.responseExtractDSMContext(request.operation, request.params, response, span ?? null, carriers)
 
     return store
   }
@@ -183,19 +192,39 @@ class Sqs extends BaseAwsSdkPlugin {
     return tags
   }
 
+  /**
+   * Parse the trace-context carrier of every received message, in message order.
+   * Entries are `undefined` for messages that carry no `_datadog` context.
+   *
+   * @param {{ MaxNumberOfMessages?: number }} params
+   * @param {string} operation
+   * @param {{ Messages?: object[] }} response
+   * @returns {Array<Record<string, string> | undefined> | undefined}
+   */
   responseExtract (params, operation, response) {
     if (operation !== 'receiveMessage') return
-    if (params.MaxNumberOfMessages && params.MaxNumberOfMessages !== 1) return
-    if (!response || !response.Messages || !response.Messages[0]) return
+    if (!response?.Messages?.length) return
 
-    let message = response.Messages[0]
-    let parsedBody
+    return response.Messages.map(message => this.parseMessageCarrier(message))
+  }
 
+  /**
+   * Resolve the trace-context carrier for a single received message. The
+   * `MessageAttributes._datadog` text map (direct SQS or SNS to SQS) wins;
+   * otherwise the EventBridge envelope, optionally wrapped in an SNS
+   * `Notification` (see getEventBridgeContext). Checking MessageAttributes first
+   * avoids parsing a large SNS `Message` just to rule out an EventBridge envelope.
+   *
+   * @param {object} message A single `response.Messages` entry.
+   * @returns {Record<string, string> | undefined}
+   */
+  parseMessageCarrier (message) {
+    let parsedBody
     if (message.Body) {
       try {
         parsedBody = JSON.parse(message.Body)
       } catch {
-        // SQS to SQS
+        // Opaque, non-JSON body (SQS to SQS).
       }
       // SNS to SQS
       if (parsedBody?.Type === 'Notification') {
@@ -203,34 +232,9 @@ class Sqs extends BaseAwsSdkPlugin {
       }
     }
 
-    // Check MessageAttributes first (common direct-SQS/SNS path): avoids parsing
-    // the body (e.g. a large SNS `Message`) just to rule out an EventBridge
-    // envelope. Precedence matches responseExtractDSMContext.
     const datadogAttribute = message.MessageAttributes?._datadog
-    if (datadogAttribute) {
-      const parsedAttributes = this.parseDatadogAttributes(datadogAttribute)
-      if (parsedAttributes) {
-        return {
-          datadogContext: this.tracer.extract('text_map', parsedAttributes),
-          parsedAttributes,
-          parsedBody,
-          bodyChecked: true,
-        }
-      }
-    }
-
-    // Then the EventBridge envelope (optionally via SNS); see getEventBridgeContext.
-    const eventBridgeContext = getEventBridgeContext(parsedBody)
-    if (eventBridgeContext) {
-      return {
-        datadogContext: this.tracer.extract('text_map', eventBridgeContext),
-        parsedAttributes: eventBridgeContext,
-        parsedBody,
-        bodyChecked: true,
-      }
-    }
-
-    return { parsedBody, bodyChecked: true }
+    const carrier = datadogAttribute ? this.parseDatadogAttributes(datadogAttribute) : undefined
+    return carrier ?? getEventBridgeContext(parsedBody)
   }
 
   parseDatadogAttributes (attributes) {
@@ -247,51 +251,39 @@ class Sqs extends BaseAwsSdkPlugin {
     }
   }
 
-  responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
-    let { parsedAttributes } = kwargs
-    const { parsedFirstBody, firstBodyChecked } = kwargs
+  /**
+   * @param {string} operation
+   * @param {{ QueueUrl: string }} params
+   * @param {{ Messages?: object[] }} response
+   * @param {import('../../../dd-trace/src/opentracing/span') | null} span
+   * @param {Array<Record<string, string> | undefined>} [carriers] Per-message carriers already
+   *   parsed by `responseExtract`; reused so each message body is parsed once. When omitted, the
+   *   carriers are parsed here.
+   */
+  responseExtractDSMContext (operation, params, response, span, carriers) {
     if (!this.config.dsmEnabled) return
     if (operation !== 'receiveMessage') return
-    if (!response || !response.Messages || !response.Messages[0]) return
+    if (!response?.Messages?.length) return
 
+    const messages = response.Messages
     // Only attribute payloadSize to the span when there is a single message.
-    span = response.Messages.length > 1 ? null : span
+    span = messages.length > 1 ? null : span
 
     // QueueUrl is the same for the whole receive batch.
     const queue = params.QueueUrl.slice(params.QueueUrl.lastIndexOf('/') + 1)
 
-    for (let i = 0; i < response.Messages.length; i++) {
-      let message = response.Messages[i]
-      if (!parsedAttributes) {
-        let body
-        // responseExtract already parsed message[0]; reuse that result instead of re-parsing.
-        if (i === 0 && firstBodyChecked) {
-          body = parsedFirstBody
-        } else if (message.Body) {
-          try {
-            body = JSON.parse(message.Body)
-          } catch {
-            // SQS to SQS
-          }
-        }
-        // SNS to SQS
-        if (body?.Type === 'Notification') {
-          message = body
-        }
-        // MessageAttributes for direct SQS/SNS; else the EventBridge envelope.
-        parsedAttributes = message.MessageAttributes?._datadog
-          ? this.parseDatadogAttributes(message.MessageAttributes._datadog)
-          : getEventBridgeContext(body)
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]
+      const carrier = carriers === undefined ? this.parseMessageCarrier(message) : carriers[i]
+      if (carrier) {
+        // Inert for EventBridge until its producer emits a pathway (separate
+        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
+        this.tracer.decodeDataStreamsContext(carrier)
       }
       const payloadSize = getHeadersSize({
         Body: message.Body,
         MessageAttributes: message.MessageAttributes,
       })
-      if (parsedAttributes) {
-        // Inert for EventBridge until its producer emits a pathway (separate
-        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
-        this.tracer.decodeDataStreamsContext(parsedAttributes)
-      }
       this.tracer
         .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
     }

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

@@ -11,6 +11,7 @@ const {
   TEST_IS_RUM_ACTIVE,
   TEST_CODE_OWNERS,
   getTestEnvironmentMetadata,
+  getTestLevelsMetadataTags,
   CI_APP_ORIGIN,
   getTestParentSpan,
   getCodeOwnersFileEntries,
@@ -23,6 +24,7 @@ const {
   TEST_MODULE_ID,
   TEST_SESSION_ID,
   TEST_COMMAND,
+  TEST_LEVELS_METADATA,
   TEST_MODULE,
   TEST_SOURCE_START,
   finishAllTraceSpans,
@@ -1043,7 +1045,13 @@ class CypressPlugin {
     )
 
     if (this.tracer._tracer._exporter?.addMetadataTags) {
-      const metadataTags = { '*': { [TEST_COMMAND]: this.command, [TEST_SESSION_NAME]: testSessionName } }
+      const metadataTags = {
+        [TEST_LEVELS_METADATA]: {
+          [TEST_COMMAND]: this.command,
+          [TEST_SESSION_NAME]: testSessionName,
+          ...getTestLevelsMetadataTags(this.testEnvironmentMetadata),
+        },
+      }
       const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, this.frameworkVersion)
       metadataTags.test = {
         ...libraryCapabilitiesTags,

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

@@ -8,6 +8,7 @@ const tags = require('../../../ext/tags')
 const formats = require('../../../ext/formats')
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 const log = require('../../dd-trace/src/log')
 const { CLIENT_PORT_KEY, COMPONENT, ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
 
@@ -27,13 +28,17 @@ class HttpClientPlugin extends ClientPlugin {
     const protocol = options.protocol || agent.protocol || 'http:'
     const hostname = options.hostname || options.host || 'localhost'
     const host = options.port ? `${hostname}:${options.port}` : hostname
-    const pathname = options.path || options.pathname
+    const base = `${protocol}//${host}`
+    // A URL object (e.g. from the fetch integration) carries the query in
+    // `options.search`, not `options.path`; keep it so url.full retains the query.
+    const pathname = options.path || `${options.pathname || ''}${options.search || ''}`
     const path = pathname ? pathname.split(/[?#]/)[0] : '/'
-    const uri = `${protocol}//${host}${path}`
+    const uri = `${base}${path}`
 
     const allowed = this.config.filter(uri)
 
     const method = (options.method || 'GET').toUpperCase()
+    const otelSemantics = this.config.DD_TRACE_OTEL_SEMANTICS_ENABLED
     const childOf = store && allowed ? store.span : null
     // TODO delegate to super.startspan
     const span = this.startSpan(this.operationName(), {
@@ -46,7 +51,7 @@ class HttpClientPlugin extends ClientPlugin {
         'resource.name': method,
         'span.type': 'http',
         'http.method': method,
-        'http.url': uri,
+        'http.url': otelSemantics ? buildClientHttpUrl(this.config, base, pathname, uri) : uri,
         'out.host': hostname,
       },
       metrics: {

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

@@ -10,6 +10,7 @@ const kinds = require('../../../ext/kinds')
 const formats = require('../../../ext/formats')
 const { COMPONENT, CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
@@ -33,8 +34,10 @@ class Http2ClientPlugin extends ClientPlugin {
     const path = headers[HTTP2_HEADER_PATH] || '/'
     const pathname = path.split(/[?#]/)[0]
     const method = headers[HTTP2_HEADER_METHOD] || HTTP2_METHOD_GET
-    const uri = `${sessionDetails.protocol}//${sessionDetails.host}:${sessionDetails.port}${pathname}`
+    const base = `${sessionDetails.protocol}//${sessionDetails.host}:${sessionDetails.port}`
+    const uri = `${base}${pathname}`
     const allowed = this.config.filter(uri)
+    const otelSemantics = this.config.DD_TRACE_OTEL_SEMANTICS_ENABLED
 
     const store = storage('legacy').getStore()
     const childOf = store && allowed ? store.span : null
@@ -48,7 +51,7 @@ class Http2ClientPlugin extends ClientPlugin {
         'resource.name': method,
         'span.type': 'http',
         'http.method': method,
-        'http.url': uri,
+        'http.url': otelSemantics ? buildClientHttpUrl(this.config, base, path, uri) : uri,
         'out.host': sessionDetails.host,
       },
       metrics: {

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

@@ -11,11 +11,16 @@ class MySQLPlugin extends DatabasePlugin {
   constructor () {
     super(...arguments)
 
+    // Capture into `currentStore` (not `parentStore`) so connection:finish can
+    // restore the caller context even when the connection resolves inside an
+    // instrumentation skip (a noop store), as the mariadb pool does: the store
+    // binding only honors an explicit `currentStore` through a noop store.
+    // Without a skip (mysql/mysql2) this is unchanged.
     this.addSub(`apm:${this.component}:connection:start`, ctx => {
-      ctx.parentStore = storage('legacy').getStore()
+      ctx.currentStore = storage('legacy').getStore()
     })
 
-    this.addBind(`apm:${this.component}:connection:finish`, ctx => ctx.parentStore)
+    this.addBind(`apm:${this.component}:connection:finish`, ctx => ctx.currentStore)
   }
 
   bindStart (ctx) {

package/packages/datadog-plugin-protobufjs/src/schema_iterator.js

@@ -47,10 +47,10 @@ class SchemaExtractor {
 
   static extractProperty (field, schemaName, fieldName, builder, depth) {
     let array = false
-    let description
     let ref
     let enumValues
 
+    const description = field.comment
     const resolvedType = field.resolvedType ? field.resolvedType.constructor.name : field.type
 
     const isRepeatedField = field.rule === 'repeated'
@@ -124,7 +124,7 @@ class SchemaExtractor {
   }
 
   iterateOverSchema (builder) {
-    this.constructor.extractSchema(this.schema, builder, 0)
+    SchemaExtractor.extractSchema(this.schema, builder, 0)
   }
 
   static attachSchemaOnSpan (args, span, operation, tracer) {

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

@@ -6,6 +6,7 @@ const tags = require('../../../ext/tags')
 const formats = require('../../../ext/formats')
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const log = require('../../dd-trace/src/log')
+const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 
 const {
@@ -60,10 +61,12 @@ class UndiciPlugin extends HttpClientPlugin {
     }
 
     const host = port ? `${hostname}:${port}` : hostname
+    const base = `${protocol}//${host}`
     const pathname = path.split(/[?#]/)[0]
-    const uri = `${protocol}//${host}${pathname}`
+    const uri = `${base}${pathname}`
 
     const allowed = this.config.filter(uri)
+    const otelSemantics = this.config.DD_TRACE_OTEL_SEMANTICS_ENABLED
     const childOf = store && allowed ? store.span : null
 
     const span = this.startSpan(this.operationName(), {
@@ -71,7 +74,7 @@ class UndiciPlugin extends HttpClientPlugin {
       meta: {
         'span.kind': 'client',
         'http.method': method,
-        'http.url': uri,
+        'http.url': otelSemantics ? buildClientHttpUrl(this.config, base, path, uri) : uri,
         'out.host': hostname,
       },
       metrics: {

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

@@ -9,6 +9,7 @@ const {
   finishAllTraceSpans,
   getTestSuitePath,
   getTestSuiteCommonTags,
+  getTestLevelsMetadataTags,
   getTestSessionName,
   getIsFaultyEarlyFlakeDetection,
   TEST_SOURCE_FILE,
@@ -16,6 +17,7 @@ const {
   TEST_CODE_COVERAGE_LINES_PCT,
   TEST_CODE_OWNERS,
   TEST_COMMAND,
+  TEST_LEVELS_METADATA,
   TEST_SESSION_NAME,
   TEST_SOURCE_START,
   TEST_IS_NEW,
@@ -328,7 +330,11 @@ class VitestPlugin extends CiPlugin {
       const testSessionName = getTestSessionName(this.config, trimmedCommand, this.testEnvironmentMetadata)
       if (this.tracer._exporter.addMetadataTags) {
         this.tracer._exporter.addMetadataTags({
-          '*': { [TEST_COMMAND]: testCommand, [TEST_SESSION_NAME]: testSessionName },
+          [TEST_LEVELS_METADATA]: {
+            [TEST_COMMAND]: testCommand,
+            [TEST_SESSION_NAME]: testSessionName,
+            ...getTestLevelsMetadataTags(this.testEnvironmentMetadata),
+          },
           test: getLibraryCapabilitiesTags(this.constructor.id),
         })
       }

package/packages/datadog-webpack/index.js

@@ -6,6 +6,7 @@ const fs = require('node:fs')
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
 const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { matchesOptionalPeerFile } = require('../datadog-instrumentations/src/helpers/optional-peer-bundler')
 const { isESMFile } = require('../datadog-esbuild/src/utils')
 const log = require('./src/log')
 
@@ -130,11 +131,26 @@ class DatadogWebpackPlugin {
       nmf.hooks.afterResolve.tap(PLUGIN_NAME, (resolveData) => {
         const { createData } = resolveData
         const resource = createData?.resource
-        if (!resource || !resource.includes('node_modules')) {
+        if (!resource) {
           return
         }
 
         const normalizedResource = resource.replaceAll('\\', '/')
+
+        // Rewrite optional-peer loads so installed peers get bundled and survive relocation
+        // (#8980); absent peers stay opaque, so a build that does not opt into the feature does
+        // not follow their dependency chain (#8635).
+        if (matchesOptionalPeerFile(normalizedResource)) {
+          createData.loaders = createData.loaders || []
+          createData.loaders.push({ loader: require.resolve('./src/optional-peer-loader') })
+          log.debug('INLINE: optional-peer loader applied to %s', normalizedResource)
+          return
+        }
+
+        if (!resource.includes('node_modules')) {
+          return
+        }
+
         const { pkg, path: modulePath, pkgJson } = extractPackageAndModulePath(normalizedResource)
         if (!pkg) {
           return

package/packages/datadog-webpack/src/optional-peer-loader.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { rewriteOptionalPeerLoads } = require('../../datadog-instrumentations/src/helpers/optional-peer-bundler')
+
+/**
+ * Webpack loader applied to the optional-peer loader files. Rewrites each
+ * `requireOptionalPeer('name')` whose peer is installed at build time into a literal
+ * `require('name')` so webpack bundles the peer (#8980). Peers that are absent stay opaque, so
+ * builds that do not opt into the feature keep the #8635 guarantee.
+ *
+ * @param {string} source
+ * @returns {string}
+ */
+module.exports = function optionalPeerLoader (source) {
+  this.cacheable(false)
+  return rewriteOptionalPeerLoads(source, this.context)
+}

package/packages/dd-trace/src/aiguard/sdk.js

@@ -63,6 +63,18 @@ class AIGuardClientError extends Error {
   }
 }
 
+/**
+ * Resolves the AI Guard host for a given Datadog site. Sites with a single subdomain level
+ * (e.g. `datadoghq.com`, `ddog-gov.com`) are served from the `app.` subdomain, while regional
+ * sites (e.g. `us3.datadoghq.com`, `ap1.datadoghq.com`) are used as-is.
+ *
+ * @param {string} site - Datadog site (e.g. `datadoghq.com`, `us3.datadoghq.com`)
+ * @returns {string} The host to use for the AI Guard endpoint
+ */
+function aiGuardHost (site) {
+  return site.split('.').length === 2 ? `app.${site}` : site
+}
+
 class AIGuard extends NoopAIGuard {
   #initialized
   #tracer
@@ -94,7 +106,7 @@ class AIGuard extends NoopAIGuard {
       'DD-AI-GUARD-SOURCE': 'SDK',
       'DD-AI-GUARD-LANGUAGE': 'nodejs',
     }
-    const endpoint = config.experimental.aiguard.endpoint || `https://app.${config.site}/api/v2/ai-guard`
+    const endpoint = config.experimental.aiguard.endpoint || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
     this.#evaluateUrl = `${endpoint}/evaluate`
     this.#timeout = config.experimental.aiguard.timeout
     this.#maxMessagesLength = config.experimental.aiguard.maxMessagesLength

package/packages/dd-trace/src/appsec/api_security/index.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const web = require('../../plugins/util/web')
+const { isSchemaAttribute } = require('../reporter')
+const appsecTelemetry = require('../telemetry')
+const sampler = require('./sampler')
+
+/**
+ * Map a sampling decision into the corresponding API Security telemetry metric.
+ *
+ * The decision is done by the sampler, here the outcome is translated to emitted metrics:
+ *   - SAMPLE: request.schema / request.no_schema depending on WAF schema attributes
+ *   - MISSING_ROUTE: missing_route
+ *   - SKIP: no metric emitted
+ *
+ * @param {import('http').IncomingMessage} req
+ * @param {'sample' | 'missing_route' | 'skip'} samplingDecision Sampler decision
+ * @param {{ attributes?: Record<string, unknown> } | undefined} wafResult WAF run result
+ */
+function reportRequest (req, samplingDecision, wafResult) {
+  switch (samplingDecision) {
+    case sampler.SamplingDecision.SAMPLE: {
+      const framework = getFramework(req)
+      if (hasSchemaAttributes(wafResult?.attributes)) {
+        appsecTelemetry.incrementApiSecRequestSchemaMetric(framework)
+      } else {
+        appsecTelemetry.incrementApiSecRequestNoSchemaMetric(framework)
+      }
+      break
+    }
+    case sampler.SamplingDecision.MISSING_ROUTE:
+      appsecTelemetry.incrementApiSecMissingRouteMetric(getFramework(req))
+      break
+  }
+}
+
+function getFramework (req) {
+  return web.root(req)?.context()?.getTag?.('component')
+}
+
+function hasSchemaAttributes (attributes) {
+  if (!attributes) return false
+  for (const key of Object.keys(attributes)) {
+    if (isSchemaAttribute(key)) return true
+  }
+  return false
+}
+
+module.exports = {
+  configure: sampler.configure,
+  disable: sampler.disable,
+  sampleRequest: sampler.sampleRequest,
+  reportRequest,
+  SamplingDecision: sampler.SamplingDecision,
+}