@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,267 @@
+'use strict'
+
+const { globMatch } = require('../src/util')
+const RateLimiter = require('./rate_limiter')
+const Sampler = require('./sampler')
+
+/**
+ * Typedefs for clarity when matching spans.
+ *
+ * @typedef {import('./opentracing/span')} DatadogSpan
+ * @typedef {import('./opentracing/span_context')} DatadogSpanContext
+ *
+ * @callback Locator
+ * A function that derives a string subject from a span.
+ * @param {DatadogSpan} span
+ * @returns {string|undefined}
+ *
+ * @typedef {object} RuleMatcher
+ * @property {(span: DatadogSpan) => boolean} match - Returns true if the span matches.
+ */
+
+/**
+ * Matcher that always returns true.
+ * Implements the minimal `RuleMatcher` interface.
+ * @implements {RuleMatcher}
+ */
+class AlwaysMatcher {
+  /**
+   * @param {DatadogSpan} span
+   * @returns {boolean}
+   */
+  match (span) {
+    return true
+  }
+}
+
+/**
+ * Matcher that evaluates a glob pattern against a derived subject.
+ */
+class GlobMatcher {
+  /**
+   * @param {string} pattern - Glob pattern used to match the subject.
+   * @param {Locator} locator - Function extracting the subject to match.
+   */
+  constructor (pattern, locator) {
+    this.pattern = pattern
+    this.locator = locator
+  }
+
+  /**
+   * @param {DatadogSpan} span
+   * @returns {boolean}
+   */
+  match (span) {
+    const subject = this.locator(span)
+    if (!subject) return false
+    return globMatch(this.pattern, subject)
+  }
+}
+
+/**
+ * Matcher that evaluates a regular expression against a derived subject.
+ */
+class RegExpMatcher {
+  /**
+   * @param {RegExp} pattern - Regular expression used to test the subject.
+   * @param {Locator} locator - Function extracting the subject to test.
+   */
+  constructor (pattern, locator) {
+    this.pattern = pattern
+    this.locator = locator
+  }
+
+  /**
+   * @param {DatadogSpan} span
+   * @returns {boolean}
+   */
+  match (span) {
+    const subject = this.locator(span)
+    if (!subject) return false
+    return this.pattern.test(subject)
+  }
+}
+
+/**
+ * Creates a matcher for the provided pattern and locator.
+ * Returns a glob matcher for non-trivial strings, a regexp matcher for RegExp,
+ * or an always-true matcher for wildcard or missing patterns.
+ *
+ * @param {string|RegExp|undefined} pattern
+ * @param {Locator} locator
+ * @returns {RuleMatcher}
+ */
+function matcher (pattern, locator) {
+  if (pattern instanceof RegExp) {
+    return new RegExpMatcher(pattern, locator)
+  }
+
+  if (typeof pattern === 'string' && pattern !== '*' && pattern !== '**' && pattern !== '***') {
+    return new GlobMatcher(pattern, locator)
+  }
+  return new AlwaysMatcher()
+}
+
+/**
+ * Creates a locator that reads a specific tag from the span context.
+ *
+ * @param {string} tag
+ * @returns {Locator}
+ */
+function makeTagLocator (tag) {
+  return (span) => span.context()._tags[tag]
+}
+
+/**
+ * Extracts the operation name from the span context.
+ *
+ * @param {DatadogSpan} span
+ * @returns {string|undefined}
+ */
+function nameLocator (span) {
+  return span.context()._name
+}
+
+/**
+ * Extracts the service name from the span context or tracer configuration.
+ *
+ * @param {DatadogSpan} span
+ * @returns {string|undefined}
+ */
+function serviceLocator (span) {
+  const { _tags: tags } = span.context()
+  return tags.service ||
+    tags['service.name'] ||
+    span.tracer()._service
+}
+
+/**
+ * Extracts the resource name from the span context.
+ *
+ * @param {DatadogSpan} span
+ * @returns {string|undefined}
+ */
+function resourceLocator (span) {
+  const { _tags: tags } = span.context()
+  return tags.resource ||
+    tags['resource.name']
+}
+
+/**
+ * Configuration options for a sampling rule.
+ *
+ * @typedef {object} SamplingRuleConfig
+ * @property {string|RegExp} [name] - Match on span operation name.
+ * @property {string|RegExp} [service] - Match on service name.
+ * @property {string|RegExp} [resource] - Match on resource name.
+ * @property {Record<string, string|RegExp>} [tags] - Match on specific tag values by key.
+ * @property {number} [sampleRate=1] - Deterministic sampling rate in [0, 1].
+ * @property {string} [provenance] - Optional provenance/metadata for this rule.
+ * @property {number} [maxPerSecond] - Maximum samples per second (rate limit).
+ */
+
+/**
+ * SamplingRule encapsulates matching criteria and sampling/limiting behavior
+ * to decide whether a span should be sampled.
+ */
+class SamplingRule {
+  /**
+   * @param {SamplingRuleConfig} [config]
+   */
+  constructor ({ name, service, resource, tags, sampleRate = 1, provenance, maxPerSecond } = {}) {
+    this.matchers = []
+
+    if (name) {
+      this.matchers.push(matcher(name, nameLocator))
+    }
+    if (service) {
+      this.matchers.push(matcher(service, serviceLocator))
+    }
+    if (resource) {
+      this.matchers.push(matcher(resource, resourceLocator))
+    }
+    for (const [key, value] of Object.entries(tags || {})) {
+      this.matchers.push(matcher(value, makeTagLocator(key)))
+    }
+
+    this._sampler = new Sampler(sampleRate)
+    this._limiter = undefined
+    this.provenance = provenance
+
+    if (Number.isFinite(maxPerSecond)) {
+      this._limiter = new RateLimiter(maxPerSecond)
+    }
+  }
+
+  /**
+   * Constructs a SamplingRule from the given configuration.
+   * @param {SamplingRuleConfig} config
+   * @returns {SamplingRule}
+   */
+  static from (config) {
+    return new SamplingRule(config)
+  }
+
+  /**
+   * Deterministic sampling rate in [0, 1].
+   * @returns {number}
+   */
+  get sampleRate () {
+    return this._sampler.rate()
+  }
+
+  /**
+   * Effective rate applied by the rate limiter, if configured.
+   * @returns {number|undefined}
+   */
+  get effectiveRate () {
+    return this._limiter && this._limiter.effectiveRate()
+  }
+
+  /**
+   * Maximum samples per second if a limiter is present.
+   * @returns {number|undefined}
+   */
+  get maxPerSecond () {
+    return this._limiter && this._limiter._rateLimit
+  }
+
+  /**
+   * Checks whether the provided span matches all configured criteria.
+   *
+   * @param {DatadogSpan} span
+   * @returns {boolean}
+   */
+  match (span) {
+    for (const matcher of this.matchers) {
+      // Rule is a special object with a .match() property.
+      // It has nothing to do with a regular expression.
+      // eslint-disable-next-line unicorn/prefer-regexp-test
+      if (!matcher.match(span)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * Determines whether a span should be sampled based on the configured sampling rule.
+   *
+   * @param {DatadogSpan|DatadogSpanContext} span - The span or span context to evaluate.
+   * @returns {boolean} `true` if the span should be sampled, otherwise `false`.
+   */
+  sample (span) {
+    if (!this._sampler.isSampled(span)) {
+      return false
+    }
+
+    if (this._limiter) {
+      return this._limiter.isAllowed()
+    }
+
+    return true
+  }
+}
+
+module.exports = SamplingRule

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+
+// TODO: refactor bind to use shimmer once the new internal tracer lands
+
+const originals = new WeakMap()
+
+class Scope {
+  active () {
+    const store = storage('legacy').getStore()
+
+    return (store && store.span) || null
+  }
+
+  activate (span, callback) {
+    if (typeof callback !== 'function') return callback
+
+    const oldStore = storage('legacy').getStore()
+    const newStore = span ? storage('legacy').getStore(span._store) : oldStore
+
+    storage('legacy').enterWith({ ...newStore, span })
+
+    try {
+      return callback()
+    } catch (e) {
+      if (span && typeof span.setTag === 'function') {
+        span.setTag('error', e)
+      }
+
+      throw e
+    } finally {
+      storage('legacy').enterWith(oldStore)
+    }
+  }
+
+  bind (fn, span) {
+    if (typeof fn !== 'function') return fn
+
+    const scope = this
+    const spanOrActive = this._spanOrActive(span)
+
+    const bound = function () {
+      return scope.activate(spanOrActive, () => {
+        return fn.apply(this, arguments)
+      })
+    }
+
+    originals.set(bound, fn)
+
+    return bound
+  }
+
+  _spanOrActive (span) {
+    return span === undefined ? this.active() : span
+  }
+
+  _isPromise (promise) {
+    return promise && typeof promise.then === 'function'
+  }
+}
+
+module.exports = Scope

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

@@ -0,0 +1,52 @@
+'use strict'
+
+const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
+const { isFalse } = require('./util')
+
+function getIsGCPFunction () {
+  const isDeprecatedGCPFunction =
+    getEnvironmentVariable('FUNCTION_NAME') !== undefined &&
+    getEnvironmentVariable('GCP_PROJECT') !== undefined
+  const isNewerGCPFunction =
+    getEnvironmentVariable('K_SERVICE') !== undefined &&
+    getEnvironmentVariable('FUNCTION_TARGET') !== undefined
+
+  return isDeprecatedGCPFunction || isNewerGCPFunction
+}
+
+/**
+ * Enable GCP Pub/Sub PUSH subscription tracing for Cloud Run (K_SERVICE present).
+ * PUSH: GCP sends HTTP POST requests to the service with message data in headers.
+ */
+function enableGCPPubSubPushSubscription () {
+  const isGCPPubSubPushSubscriptionEnabled = getValueFromEnvSources('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED')
+  return getEnvironmentVariable('K_SERVICE') !== undefined && !isFalse(isGCPPubSubPushSubscriptionEnabled)
+}
+
+function getIsAzureFunction () {
+  const isAzureFunction =
+    getEnvironmentVariable('FUNCTIONS_EXTENSION_VERSION') !== undefined &&
+    getEnvironmentVariable('FUNCTIONS_WORKER_RUNTIME') !== undefined
+
+  return isAzureFunction
+}
+
+function getIsFlexConsumptionAzureFunction () {
+  return getIsAzureFunction() && getEnvironmentVariable('WEBSITE_SKU') === 'FlexConsumption'
+}
+
+function isInServerlessEnvironment () {
+  const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
+  const isGCPFunction = getIsGCPFunction()
+  const isAzureFunction = getIsAzureFunction()
+
+  return inAWSLambda || isGCPFunction || isAzureFunction
+}
+
+module.exports = {
+  getIsGCPFunction,
+  getIsAzureFunction,
+  enableGCPPubSubPushSubscription,
+  getIsFlexConsumptionAzureFunction,
+  IS_SERVERLESS: isInServerlessEnvironment(),
+}

package/packages/dd-trace/src/service-naming/extra-services.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const maxExtraServices = 64
+const extraServices = new Set()
+
+function getExtraServices () {
+  return [...extraServices]
+}
+
+function registerExtraService (serviceName) {
+  if (serviceName && extraServices.size < maxExtraServices) {
+    extraServices.add(serviceName)
+  }
+}
+
+function clear () {
+  extraServices.clear()
+}
+
+module.exports = {
+  registerExtraService,
+  getExtraServices,
+  clear,
+}

package/packages/dd-trace/src/service-naming/index.js

@@ -0,0 +1,75 @@
+'use strict'
+
+class SchemaManager {
+  /**
+   * @type {object}
+   */
+  config = {
+    spanAttributeSchema: 'v0',
+    spanRemoveIntegrationFromService: false,
+  }
+
+  schemas = {
+    v0: require('./schemas/v0'),
+  }
+
+  get schema () {
+    return this.schemas[this.version]
+  }
+
+  get version () {
+    return this.config.spanAttributeSchema
+  }
+
+  get shouldUseConsistentServiceNaming () {
+    return this.config.spanRemoveIntegrationFromService && this.version === 'v0'
+  }
+
+  /**
+   * @param {string} type
+   * @param {string} kind
+   * @param {string} plugin
+   * @param {object} opts
+   * @returns {string}
+   */
+  opName (type, kind, plugin, opts) {
+    return this.schema.getOpName(type, kind, plugin, opts)
+  }
+
+  /**
+   * @param {string} type
+   * @param {string} kind
+   * @param {string} plugin
+   * @param {object} opts
+   * @returns {string}
+   */
+  serviceName (type, kind, plugin, opts) {
+    const schema = this.shouldUseConsistentServiceNaming
+      ? this.schemas.v1
+      : this.schema
+
+    return schema.getServiceName(type, kind, plugin, { ...opts, tracerService: this.config.service })
+  }
+
+  /**
+   * @param {object} config
+   * @param {string} config.spanAttributeSchema
+   * @param {boolean} config.spanRemoveIntegrationFromService
+   * @param {string} [config.service]
+   */
+  configure (config) {
+    const { spanAttributeSchema, spanRemoveIntegrationFromService } = config
+
+    if (!this.schemas.v0 && spanAttributeSchema === 'v0') {
+      this.schemas.v0 = require('./schemas/v0')
+    }
+
+    if (!this.schemas.v1 && (spanAttributeSchema === 'v1' || spanRemoveIntegrationFromService)) {
+      this.schemas.v1 = require('./schemas/v1')
+    }
+
+    this.config = config
+  }
+}
+
+module.exports = new SchemaManager()

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

@@ -0,0 +1,19 @@
+'use strict'
+
+class SchemaDefinition {
+  constructor (schema) {
+    this.schema = schema
+  }
+
+  getOpName (type, kind, plugin, opts) {
+    const item = this.schema[type][kind][plugin]
+    return item.opName(opts)
+  }
+
+  getServiceName (type, kind, plugin, opts) {
+    const item = this.schema[type][kind][plugin]
+    return item.serviceName(opts)
+  }
+}
+
+module.exports = SchemaDefinition

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

@@ -0,0 +1,25 @@
+'use strict'
+
+function identityService ({ tracerService }) {
+  return tracerService
+}
+
+function getFormattedHostString ({ host, port }) {
+  return [host, port].filter(Boolean).join(':')
+}
+
+function httpPluginClientService ({ tracerService, pluginConfig, sessionDetails }) {
+  if (pluginConfig.splitByDomain) {
+    return getFormattedHostString(sessionDetails)
+  } else if (pluginConfig.service) {
+    return pluginConfig.service
+  }
+
+  return tracerService
+}
+
+function awsServiceV0 ({ tracerService, awsService }) {
+  return `${tracerService}-aws-${awsService}`
+}
+
+module.exports = { identityService, httpPluginClientService, awsServiceV0 }

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

@@ -0,0 +1,14 @@
+'use strict'
+
+const { identityService } = require('../util')
+
+const graphql = {
+  server: {
+    graphql: {
+      opName: () => 'graphql.execute',
+      serviceName: identityService,
+    },
+  },
+}
+
+module.exports = graphql

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

@@ -0,0 +1,11 @@
+'use strict'
+
+const SchemaDefinition = require('../definition')
+const messaging = require('./messaging')
+const storage = require('./storage')
+const graphql = require('./graphql')
+const web = require('./web')
+const serverless = require('./serverless')
+const websocket = require('./websocket')
+
+module.exports = new SchemaDefinition({ messaging, storage, web, graphql, serverless, websocket })

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

@@ -0,0 +1,102 @@
+'use strict'
+
+const { identityService, awsServiceV0 } = require('../util')
+
+function amqpServiceName ({ tracerService }) {
+  return `${tracerService}-amqp`
+}
+
+const messaging = {
+  producer: {
+    amqplib: {
+      opName: () => 'amqp.command',
+      serviceName: amqpServiceName,
+    },
+    amqp10: {
+      opName: () => 'amqp.send',
+      serviceName: amqpServiceName,
+    },
+    'azure-event-hubs': {
+      opName: () => 'azure.eventhubs.send',
+      serviceName: ({ tracerService }) => `${tracerService}-azure-event-hubs`,
+    },
+    'azure-service-bus': {
+      opName: () => 'azure.servicebus.send',
+      serviceName: ({ tracerService }) => `${tracerService}-azure-service-bus`,
+    },
+    'google-cloud-pubsub': {
+      opName: () => 'pubsub.request',
+      serviceName: ({ tracerService }) => `${tracerService}-pubsub`,
+    },
+    kafkajs: {
+      opName: () => 'kafka.produce',
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+    },
+    'confluentinc-kafka-javascript': {
+      opName: () => 'kafka.produce',
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+    },
+    rhea: {
+      opName: () => 'amqp.send',
+      serviceName: ({ tracerService }) => `${tracerService}-amqp-producer`,
+    },
+    sqs: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0,
+    },
+    sns: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0,
+    },
+    bullmq: {
+      opName: () => 'bullmq.add',
+      serviceName: ({ tracerService }) => `${tracerService}-bullmq`,
+    },
+  },
+  consumer: {
+    amqplib: {
+      opName: () => 'amqp.command',
+      serviceName: amqpServiceName,
+    },
+    amqp10: {
+      opName: () => 'amqp.receive',
+      serviceName: amqpServiceName,
+    },
+    'google-cloud-pubsub': {
+      opName: () => 'pubsub.receive',
+      serviceName: identityService,
+    },
+    kafkajs: {
+      opName: () => 'kafka.consume',
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+    },
+    'confluentinc-kafka-javascript': {
+      opName: () => 'kafka.consume',
+      serviceName: ({ tracerService }) => `${tracerService}-kafka`,
+    },
+    rhea: {
+      opName: () => 'amqp.receive',
+      serviceName: identityService,
+    },
+    sqs: {
+      opName: () => 'aws.request',
+      serviceName: awsServiceV0,
+    },
+    bullmq: {
+      opName: () => 'bullmq.processJob',
+      serviceName: ({ tracerService }) => `${tracerService}-bullmq`,
+    },
+  },
+  client: {
+    amqplib: {
+      opName: () => 'amqp.command',
+      serviceName: amqpServiceName,
+    },
+    'google-cloud-pubsub': {
+      opName: () => 'pubsub.request',
+      serviceName: ({ tracerService }) => `${tracerService}-pubsub`,
+    },
+  },
+}
+
+module.exports = messaging

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

@@ -0,0 +1,18 @@
+'use strict'
+
+const { identityService } = require('../util')
+
+const serverless = {
+  server: {
+    'azure-functions': {
+      opName: () => 'azure.functions.invoke',
+      serviceName: identityService,
+    },
+    'azure-durable-functions': {
+      opName: () => 'azure.functions.invoke',
+      serviceName: identityService,
+    },
+  },
+}
+
+module.exports = serverless