ddtrace 0.34.1 → 1.23.1

data/lib/ddtrace/diagnostics/health.rb

@@ -1,37 +0,0 @@
-require 'ddtrace/ext/diagnostics'
-require 'ddtrace/metrics'
-
-module Datadog
-  module Diagnostics
-    # Health-related diagnostics
-    module Health
-      # Health metrics for diagnostics
-      class Metrics < ::Datadog::Metrics
-        count :api_errors, Ext::Diagnostics::Health::Metrics::METRIC_API_ERRORS
-        count :api_requests, Ext::Diagnostics::Health::Metrics::METRIC_API_REQUESTS
-        count :api_responses, Ext::Diagnostics::Health::Metrics::METRIC_API_RESPONSES
-        count :error_context_overflow, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_CONTEXT_OVERFLOW
-        count :error_instrumentation_patch, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_INSTRUMENTATION_PATCH
-        count :error_span_finish, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_SPAN_FINISH
-        count :error_unfinished_spans, Ext::Diagnostics::Health::Metrics::METRIC_ERROR_UNFINISHED_SPANS
-        count :instrumentation_patched, Ext::Diagnostics::Health::Metrics::METRIC_INSTRUMENTATION_PATCHED
-        count :queue_accepted, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED
-        count :queue_accepted_lengths, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
-        count :queue_dropped, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_DROPPED
-        count :traces_filtered, Ext::Diagnostics::Health::Metrics::METRIC_TRACES_FILTERED
-        count :writer_cpu_time, Ext::Diagnostics::Health::Metrics::METRIC_WRITER_CPU_TIME
-
-        gauge :queue_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_LENGTH
-        gauge :queue_max_length, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
-        gauge :queue_spans, Ext::Diagnostics::Health::Metrics::METRIC_QUEUE_SPANS
-        gauge :sampling_service_cache_length, Ext::Diagnostics::Health::Metrics::METRIC_SAMPLING_SERVICE_CACHE_LENGTH
-      end
-
-      module_function
-
-      def metrics
-        Datadog.configuration.diagnostics.health_metrics
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/b3.rb

@@ -1,44 +0,0 @@
-require 'ddtrace/ext/distributed'
-require 'ddtrace/distributed_tracing/headers/headers'
-require 'ddtrace/distributed_tracing/headers/helpers'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # B3 provides helpers to inject or extract headers for B3 style headers
-      module B3
-        include Ext::DistributedTracing
-
-        def self.inject!(context, env)
-          return if context.nil?
-
-          # DEV: We need these to be hex encoded
-          env[B3_HEADER_TRACE_ID] = context.trace_id.to_s(16)
-          env[B3_HEADER_SPAN_ID] = context.span_id.to_s(16)
-
-          unless context.sampling_priority.nil?
-            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
-            env[B3_HEADER_SAMPLED] = sampling_priority.to_s
-          end
-        end
-
-        def self.extract(env)
-          # Extract values from headers
-          # DEV: B3 doesn't have "origin"
-          headers = Headers.new(env)
-          trace_id = headers.id(B3_HEADER_TRACE_ID, 16)
-          span_id = headers.id(B3_HEADER_SPAN_ID, 16)
-          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
-          sampling_priority = headers.number(B3_HEADER_SAMPLED)
-
-          # Return early if this propagation is not valid
-          return unless trace_id && span_id
-
-          ::Datadog::Context.new(trace_id: trace_id,
-                                 span_id: span_id,
-                                 sampling_priority: sampling_priority)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/b3_single.rb

@@ -1,56 +0,0 @@
-require 'ddtrace/ext/distributed'
-require 'ddtrace/distributed_tracing/headers/headers'
-require 'ddtrace/distributed_tracing/headers/helpers'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # B3Single provides helpers to inject or extract headers for B3 single header style headers
-      module B3Single
-        include Ext::DistributedTracing
-
-        def self.inject!(context, env)
-          return if context.nil?
-
-          # Header format:
-          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
-          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
-          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
-
-          # DEV: We need these to be hex encoded
-          header = "#{context.trace_id.to_s(16)}-#{context.span_id.to_s(16)}"
-
-          unless context.sampling_priority.nil?
-            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
-            header += "-#{sampling_priority}"
-          end
-
-          env[B3_HEADER_SINGLE] = header
-        end
-
-        def self.extract(env)
-          # Header format:
-          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
-          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
-          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
-
-          headers = Headers.new(env)
-          value = headers.header(B3_HEADER_SINGLE)
-          return if value.nil?
-
-          parts = value.split('-')
-          trace_id = headers.value_to_id(parts[0], 16) unless parts.empty?
-          span_id = headers.value_to_id(parts[1], 16) if parts.length > 1
-          sampling_priority = headers.value_to_number(parts[2]) if parts.length > 2
-
-          # Return early if this propagation is not valid
-          return unless trace_id && span_id
-
-          ::Datadog::Context.new(trace_id: trace_id,
-                                 span_id: span_id,
-                                 sampling_priority: sampling_priority)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/datadog.rb

@@ -1,42 +0,0 @@
-require 'ddtrace/ext/distributed'
-require 'ddtrace/distributed_tracing/headers/headers'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # Datadog provides helpers to inject or extract headers for Datadog style headers
-      module Datadog
-        include Ext::DistributedTracing
-
-        def self.inject!(context, env)
-          return if context.nil?
-
-          env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
-          env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
-          env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s unless context.sampling_priority.nil?
-          env[HTTP_HEADER_ORIGIN] = context.origin.to_s unless context.origin.nil?
-        end
-
-        def self.extract(env)
-          # Extract values from headers
-          headers = Headers.new(env)
-          trace_id = headers.id(HTTP_HEADER_TRACE_ID)
-          parent_id = headers.id(HTTP_HEADER_PARENT_ID)
-          origin = headers.header(HTTP_HEADER_ORIGIN)
-          sampling_priority = headers.number(HTTP_HEADER_SAMPLING_PRIORITY)
-
-          # Return early if this propagation is not valid
-          # DEV: To be valid we need to have a trace id and a parent id or when it is a synthetics trace, just the trace id
-          # DEV: `DistributedHeaders#id` will not return 0
-          return unless (trace_id && parent_id) || (origin && trace_id)
-
-          # Return new context
-          ::Datadog::Context.new(trace_id: trace_id,
-                                 span_id: parent_id,
-                                 origin: origin,
-                                 sampling_priority: sampling_priority)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/headers.rb

@@ -1,70 +0,0 @@
-require 'ddtrace/configuration'
-require 'ddtrace/span'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # Headers provides easy access and validation methods for Rack headers
-      class Headers
-        include Ext::DistributedTracing
-
-        def initialize(env)
-          @env = env
-        end
-
-        # TODO: Don't assume Rack format.
-        #       Make distributed tracing headers apathetic.
-        def header(name)
-          rack_header = "http-#{name}".upcase!.tr('-', '_')
-
-          hdr = @env[rack_header]
-
-          # Only return the value if it is not an empty string
-          hdr if hdr != ''
-        end
-
-        def id(hdr, base = 10)
-          value_to_id(header(hdr), base)
-        end
-
-        def value_to_id(value, base = 10)
-          id = value_to_number(value, base)
-
-          # Return early if we could not parse a number
-          return if id.nil?
-
-          # Zero or greater than max allowed value of 2**64
-          return if id.zero? || id > Span::EXTERNAL_MAX_ID
-          id < 0 ? id + (2**64) : id
-        end
-
-        def number(hdr, base = 10)
-          value_to_number(header(hdr), base)
-        end
-
-        def value_to_number(value, base = 10)
-          # It's important to make a difference between no header,
-          # and a header defined to zero.
-          return if value.nil?
-
-          # Be sure we have a string
-          value = value.to_s
-
-          # If we are parsing base16 number then truncate to 64-bit
-          value = DistributedTracing::Headers::Helpers.truncate_base16_number(value) if base == 16
-
-          # Convert header to an integer
-          # DEV: Ruby `.to_i` will return `0` if a number could not be parsed
-          num = value.to_i(base)
-
-          # Ensure the parsed number is the same as the original string value
-          # e.g. We want to make sure to throw away `'nan'.to_i == 0`
-          return unless num.to_s(base) == value
-
-          num
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/distributed_tracing/headers/helpers.rb

@@ -1,45 +0,0 @@
-require 'ddtrace/configuration'
-require 'ddtrace/span'
-require 'ddtrace/ext/priority'
-
-module Datadog
-  module DistributedTracing
-    module Headers
-      # Helpers module provides common helper functions for distributed tracing headers
-      module Helpers
-        # Base provides common methods for distributed header helper classes
-        def self.clamp_sampling_priority(sampling_priority)
-          # B3 doesn't have our -1 (USER_REJECT) and 2 (USER_KEEP) priorities so convert to acceptable 0/1
-          if sampling_priority < 0
-            sampling_priority = Ext::Priority::AUTO_REJECT
-          elsif sampling_priority > 1
-            sampling_priority = Ext::Priority::AUTO_KEEP
-          end
-
-          sampling_priority
-        end
-
-        def self.truncate_base16_number(value)
-          # Lowercase if we want to parse base16 e.g. 3E8 => 3e8
-          # DEV: Ruby will parse `3E8` just fine, but to test
-          #      `num.to_s(base) == value` we need to lowercase
-          value = value.downcase
-
-          # Truncate to trailing 16 characters if length is greater than 16
-          # https://github.com/apache/incubator-zipkin/blob/21fe362899fef5c593370466bc5707d3837070c2/zipkin/src/main/java/zipkin2/storage/StorageComponent.java#L49-L53
-          # DEV: This ensures we truncate B3 128-bit trace and span ids to 64-bit
-          value = value[value.length - 16, 16] if value.length > 16
-
-          # Remove any leading zeros
-          # DEV: When we call `num.to_s(16)` later Ruby will not add leading zeros
-          #      for us so we want to make sure the comparision will work as expected
-          # DEV: regex, remove all leading zeros up until we find the last 0 in the string
-          #      or we find the first non-zero, this allows `'0000' -> '0'` and `'00001' -> '1'`
-          value = value.sub(/^0*(?=(0$)|[^0])/, '')
-
-          value
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/encoding.rb

@@ -1,95 +0,0 @@
-require 'json'
-require 'msgpack'
-
-module Datadog
-  # Encoding module that encodes data for the AgentTransport
-  module Encoding
-    # Encoder interface that provides the logic to encode traces and service
-    module Encoder
-      def content_type
-        raise NotImplementedError
-      end
-
-      # Encodes a list of traces, expecting a list of items where each items
-      # is a list of spans. Before dump the string in a serialized format all
-      # traces are normalized. The traces nesting is not changed.
-      def encode_traces(traces)
-        to_send = []
-        traces.each do |trace|
-          to_send << trace.map(&:to_hash)
-        end
-        encode(to_send)
-      end
-
-      # Defines the underlying format used during traces or services encoding.
-      # This method must be implemented and should only be used by the internal functions.
-      def encode(_)
-        raise NotImplementedError
-      end
-    end
-
-    # Encoder for the JSON format
-    module JSONEncoder
-      extend Encoder
-
-      CONTENT_TYPE = 'application/json'.freeze
-
-      module_function
-
-      def content_type
-        CONTENT_TYPE
-      end
-
-      def encode(obj)
-        JSON.dump(obj)
-      end
-
-      # New version of JSON Encoder that is API compliant.
-      module V2
-        extend JSONEncoder
-
-        ENCODED_IDS = [
-          :trace_id,
-          :span_id,
-          :parent_id
-        ].freeze
-
-        module_function
-
-        def encode_traces(traces)
-          trace_hashes = traces.collect do |trace|
-            # Convert each trace to hash
-            trace.map(&:to_hash).tap do |spans|
-              # Convert IDs to hexadecimal
-              spans.each do |span|
-                ENCODED_IDS.each do |id|
-                  span[id] = span[id].to_s(16) if span.key?(id)
-                end
-              end
-            end
-          end
-
-          # Wrap traces & encode them
-          encode(traces: trace_hashes)
-        end
-      end
-    end
-
-    # Encoder for the Msgpack format
-    module MsgpackEncoder
-      extend Encoder
-
-      module_function
-
-      CONTENT_TYPE = 'application/msgpack'.freeze
-
-      def content_type
-        CONTENT_TYPE
-      end
-
-      def encode(obj)
-        MessagePack.pack(obj)
-      end
-    end
-  end
-end

data/lib/ddtrace/environment.rb

@@ -1,27 +0,0 @@
-require 'ddtrace/ext/environment'
-
-module Datadog
-  # Namespace for handling application environment
-  module Environment
-    # Defines helper methods for environment
-    module Helpers
-      def env_to_bool(var, default = nil)
-        ENV.key?(var) ? ENV[var].to_s.downcase == 'true' : default
-      end
-
-      def env_to_float(var, default = nil)
-        ENV.key?(var) ? ENV[var].to_f : default
-      end
-
-      def env_to_list(var, default = [])
-        if ENV.key?(var)
-          ENV[var].split(',').map(&:strip)
-        else
-          default
-        end
-      end
-    end
-
-    extend Helpers
-  end
-end

data/lib/ddtrace/error.rb

@@ -1,27 +0,0 @@
-# Datadog global namespace
-module Datadog
-  # Error is a value-object responsible for sanitizing/encapsulating error data
-  class Error
-    attr_reader :type, :message, :backtrace
-
-    def self.build_from(value)
-      case value
-      when Error then value
-      when Array then new(*value)
-      when Exception then new(value.class, value.message, value.backtrace)
-      when ContainsMessage then new(value.class, value.message)
-      else BlankError
-      end
-    end
-
-    def initialize(type = nil, message = nil, backtrace = nil)
-      backtrace = Array(backtrace).join("\n")
-      @type = Utils.utf8_encode(type)
-      @message = Utils.utf8_encode(message)
-      @backtrace = Utils.utf8_encode(backtrace)
-    end
-
-    BlankError = Error.new
-    ContainsMessage = ->(v) { v.respond_to?(:message) }
-  end
-end

data/lib/ddtrace/event.rb

@@ -1,52 +0,0 @@
-require 'ddtrace/logger'
-
-module Datadog
-  # A simple pub-sub event model for components to exchange messages through.
-  class Event
-    attr_reader \
-      :name,
-      :subscriptions
-
-    def initialize(name)
-      @name = name
-      @subscriptions = {}
-      @mutex = Mutex.new
-    end
-
-    def subscribe(key, &block)
-      raise ArgumentError, 'Must give a block to subscribe!' unless block
-
-      @mutex.synchronize do
-        subscriptions[key] = block
-      end
-    end
-
-    def unsubscribe(key)
-      @mutex.synchronize do
-        subscriptions.delete(key)
-      end
-    end
-
-    def unsubscribe_all!
-      @mutex.synchronize do
-        subscriptions.clear
-      end
-
-      true
-    end
-
-    def publish(*args)
-      @mutex.synchronize do
-        subscriptions.each do |key, block|
-          begin
-            block.call(*args)
-          rescue StandardError => e
-            Datadog::Logger.log.debug("Error while handling '#{key}' for '#{name}' event: #{e.message}")
-          end
-        end
-
-        true
-      end
-    end
-  end
-end

data/lib/ddtrace/ext/analytics.rb

@@ -1,12 +0,0 @@
-module Datadog
-  module Ext
-    # Defines constants for trace analytics
-    module Analytics
-      DEFAULT_SAMPLE_RATE = 1.0
-      ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
-      TAG_ENABLED = 'analytics.enabled'.freeze
-      TAG_MEASURED = '_dd.measured'.freeze
-      TAG_SAMPLE_RATE = '_dd1.sr.eausr'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/app_types.rb

@@ -1,11 +0,0 @@
-module Datadog
-  module Ext
-    module AppTypes
-      WEB = 'web'.freeze
-      DB = 'db'.freeze
-      CACHE = 'cache'.freeze
-      WORKER = 'worker'.freeze
-      CUSTOM = 'custom'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/correlation.rb

@@ -1,10 +0,0 @@
-module Datadog
-  module Ext
-    module Correlation
-      ATTR_ENV = 'dd.env'.freeze
-      ATTR_SPAN_ID = 'dd.span_id'.freeze
-      ATTR_TRACE_ID = 'dd.trace_id'.freeze
-      ATTR_VERSION = 'dd.version'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/diagnostics.rb

@@ -1,31 +0,0 @@
-module Datadog
-  module Ext
-    module Diagnostics
-      # Health
-      module Health
-        # Metrics
-        module Metrics
-          ENV_ENABLED = 'DD_HEALTH_METRICS_ENABLED'.freeze
-
-          METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
-          METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
-          METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
-          METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'.freeze
-          METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'.freeze
-          METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'.freeze
-          METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'.freeze
-          METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'.freeze
-          METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
-          METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
-          METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
-          METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
-          METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
-          METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
-          METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
-          METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
-          METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/ext/distributed.rb

@@ -1,33 +0,0 @@
-module Datadog
-  module Ext
-    module DistributedTracing
-      # HTTP headers one should set for distributed tracing.
-      # These are cross-language (eg: Python, Go and other implementations should honor these)
-      HTTP_HEADER_TRACE_ID = 'x-datadog-trace-id'.freeze
-      HTTP_HEADER_PARENT_ID = 'x-datadog-parent-id'.freeze
-      HTTP_HEADER_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
-      SAMPLING_PRIORITY_KEY = '_sampling_priority_v1'.freeze
-      HTTP_HEADER_ORIGIN = 'x-datadog-origin'.freeze
-      ORIGIN_KEY = '_dd.origin'.freeze
-
-      # B3 headers used for distributed tracing
-      B3_HEADER_TRACE_ID = 'x-b3-traceid'.freeze
-      B3_HEADER_SPAN_ID = 'x-b3-spanid'.freeze
-      B3_HEADER_SAMPLED = 'x-b3-sampled'.freeze
-      B3_HEADER_SINGLE = 'b3'.freeze
-
-      # Distributed tracing propagation options
-      PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
-      PROPAGATION_STYLE_B3 = 'B3'.freeze
-      PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
-      PROPAGATION_INJECT_STYLE_ENV = 'DD_PROPAGATION_INJECT_STYLE'.freeze
-      PROPAGATION_EXTRACT_STYLE_ENV = 'DD_PROPAGATION_EXTRACT_STYLE'.freeze
-
-      # gRPC metadata keys for distributed tracing. https://github.com/grpc/grpc-go/blob/v1.10.x/Documentation/grpc-metadata.md
-      GRPC_METADATA_TRACE_ID = 'x-datadog-trace-id'.freeze
-      GRPC_METADATA_PARENT_ID = 'x-datadog-parent-id'.freeze
-      GRPC_METADATA_SAMPLING_PRIORITY = 'x-datadog-sampling-priority'.freeze
-      GRPC_METADATA_ORIGIN = 'x-datadog-origin'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/environment.rb

@@ -1,13 +0,0 @@
-module Datadog
-  module Ext
-    module Environment
-      ENV_ENVIRONMENT = 'DD_ENV'.freeze
-      ENV_SERVICE = 'DD_SERVICE'.freeze
-      ENV_TAGS = 'DD_TAGS'.freeze
-      ENV_VERSION = 'DD_VERSION'.freeze
-
-      TAG_ENV = 'env'.freeze
-      TAG_VERSION = 'version'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/errors.rb

@@ -1,10 +0,0 @@
-module Datadog
-  module Ext
-    module Errors
-      STATUS = 1
-      MSG = 'error.msg'.freeze
-      TYPE = 'error.type'.freeze
-      STACK = 'error.stack'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/forced_tracing.rb

@@ -1,25 +0,0 @@
-require 'ddtrace/ext/manual_tracing'
-require 'ddtrace/tracer'
-
-module Datadog
-  module Ext
-    # Defines constants for forced tracing
-    module ForcedTracing
-      @deprecation_warning_shown = false
-
-      def self.const_missing(name)
-        super unless Ext::ManualTracing.const_defined?(name)
-
-        # Only log each deprecation warning once (safeguard against log spam)
-        unless @deprecation_warning_shown
-          Datadog::Logger.log.warn(
-            'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
-          )
-          @deprecation_warning_shown = true
-        end
-
-        Ext::ManualTracing.const_get(name)
-      end
-    end
-  end
-end