ddtrace 0.52.0 → 1.8.0

data/lib/ddtrace/diagnostics/health.rb

@@ -1,34 +0,0 @@
-# typed: strict
-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 :transport_trace_too_large, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_TRACE_TOO_LARGE
-        count :transport_chunked, Ext::Diagnostics::Health::Metrics::METRIC_TRANSPORT_CHUNKED
-        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
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# typed: true
-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,57 +0,0 @@
-# typed: true
-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,43 +0,0 @@
-# typed: true
-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,72 +0,0 @@
-# typed: false
-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,44 +0,0 @@
-# typed: true
-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.sub(/^0*(?=(0$)|[^0])/, '')
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/encoding.rb

@@ -1,72 +0,0 @@
-# typed: true
-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
-      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
-      def content_type
-        raise NotImplementedError
-      end
-
-      # Concatenates a list of elements previously encoded by +#encode+.
-      def join(encoded_elements)
-        raise NotImplementedError
-      end
-
-      # Serializes a single trace into a String suitable for network transmission.
-      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
-
-      def join(encoded_data)
-        "[#{encoded_data.join(',')}]"
-      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
-
-      def join(encoded_data)
-        packer = MessagePack::Packer.new
-        packer.write_array_header(encoded_data.size)
-
-        (packer.buffer.to_a + encoded_data).join
-      end
-    end
-  end
-end

data/lib/ddtrace/error.rb

@@ -1,97 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-# Datadog global namespace
-module Datadog
-  # Error is a value-object responsible for sanitizing/encapsulating error data
-  class Error
-    attr_reader :type, :message, :backtrace
-
-    class << self
-      def build_from(value)
-        case value
-        when Error then value
-        when Array then new(*value)
-        when Exception then new(value.class, value.message, full_backtrace(value))
-        when ContainsMessage then new(value.class, value.message)
-        else BlankError
-        end
-      end
-
-      private
-
-      # Returns a stack trace with nested error causes and details.
-      #
-      # This manually implements Ruby >= 2.6 error output for two reasons:
-      #
-      # 1. It is not available in Ruby < 2.6.
-      # 2. It's measurably faster to manually implement it in Ruby.
-      #
-      # This method mimics the exact output of
-      # `ex.full_message(highlight: false, order: :top)`
-      # but it's around 3x faster in our benchmark test
-      # at `error_spec.rb`.
-      def full_backtrace(ex)
-        backtrace = String.new
-        backtrace_for(ex, backtrace)
-
-        # Avoid circular causes
-        causes = {}
-        causes[ex] = true
-
-        cause = ex
-        while (cause = cause.cause) && !causes.key?(cause)
-          backtrace_for(cause, backtrace)
-          causes[cause] = true
-        end
-
-        backtrace
-      end
-
-      # Outputs the following format for exceptions:
-      #
-      # ```
-      # error_spec.rb:55:in `wrapper': wrapper layer (RuntimeError)
-      # 	from error_spec.rb:40:in `wrapper'
-      # 	from error_spec.rb:61:in `caller'
-      #   ...
-      # ```
-      def backtrace_for(ex, backtrace)
-        trace = ex.backtrace
-        return unless trace
-
-        if trace[0]
-          # Add Exception information to error line
-          backtrace << trace[0]
-          backtrace << ': '
-          backtrace << ex.message.to_s
-          backtrace << ' ('
-          backtrace << ex.class.to_s
-          backtrace << ')'
-        end
-
-        if trace[1]
-          # Ident stack trace for caller lines, to separate
-          # them from the main error lines.
-          trace[1..-1].each do |line|
-            backtrace << "\n\tfrom "
-            backtrace << line
-          end
-        end
-
-        backtrace << "\n"
-      end
-    end
-
-    def initialize(type = nil, message = nil, backtrace = nil)
-      backtrace = Array(backtrace).join("\n") unless backtrace.is_a?(String)
-
-      @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,53 +0,0 @@
-# typed: true
-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.debug("Error while handling '#{key}' for '#{name}' event: #{e.message}")
-          end
-        end
-
-        true
-      end
-    end
-  end
-end

data/lib/ddtrace/ext/analytics.rb

@@ -1,13 +0,0 @@
-# typed: true
-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,12 +0,0 @@
-# typed: true
-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,12 +0,0 @@
-# typed: true
-module Datadog
-  module Ext
-    module Correlation
-      ATTR_ENV = 'dd.env'.freeze
-      ATTR_SERVICE = 'dd.service'.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,37 +0,0 @@
-# typed: true
-module Datadog
-  module Ext
-    module Diagnostics
-      DD_TRACE_STARTUP_LOGS = 'DD_TRACE_STARTUP_LOGS'.freeze
-      DD_TRACE_DEBUG = 'DD_TRACE_DEBUG'.freeze
-      DD_TRACE_ENABLED = 'DD_TRACE_ENABLED'.freeze
-      # 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_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
-          METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
-          METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/ext/distributed.rb

@@ -1,40 +0,0 @@
-# typed: true
-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_STYLE_INJECT_ENV = 'DD_PROPAGATION_STYLE_INJECT'.freeze
-      PROPAGATION_STYLE_EXTRACT_ENV = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
-      # NOTE: the below inject/extract values are deprecated and were defined erronously
-      # they were never part of the datadog language client standard or documentation
-      # some users may already be relying on them, but we should look to remove these in the future
-      # or before 1.0.
-      PROPAGATION_INJECT_STYLE_ENV_OLD = 'DD_PROPAGATION_INJECT_STYLE'.freeze
-      PROPAGATION_EXTRACT_STYLE_ENV_OLD = '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,24 +0,0 @@
-# typed: true
-module Datadog
-  module Ext
-    module Environment
-      ENV_API_KEY = 'DD_API_KEY'.freeze
-      ENV_ENVIRONMENT = 'DD_ENV'.freeze
-      ENV_SERVICE = 'DD_SERVICE'.freeze
-      ENV_SITE = 'DD_SITE'.freeze
-      ENV_TAGS = 'DD_TAGS'.freeze
-      ENV_VERSION = 'DD_VERSION'.freeze
-
-      FALLBACK_SERVICE_NAME =
-        begin
-          File.basename($PROGRAM_NAME, '.*')
-        rescue StandardError
-          'ruby'
-        end.freeze
-
-      TAG_ENV = 'env'.freeze
-      TAG_SERVICE = 'service'.freeze
-      TAG_VERSION = 'version'.freeze
-    end
-  end
-end

data/lib/ddtrace/ext/errors.rb

@@ -1,11 +0,0 @@
-# typed: true
-module Datadog
-  module Ext
-    module Errors
-      STATUS = 1
-      MSG = 'error.msg'.freeze
-      TYPE = 'error.type'.freeze
-      STACK = 'error.stack'.freeze
-    end
-  end
-end