ddtrace 1.4.2 → 1.23.3

data/lib/datadog/profiling/transport/http.rb

@@ -1,118 +0,0 @@
-# typed: true
-
-require_relative '../../core/environment/ext'
-require_relative '../../../ddtrace/transport/ext'
-
-require_relative '../../core/environment/container'
-require_relative '../../core/environment/variable_helpers'
-
-require_relative 'http/builder'
-require_relative 'http/api'
-
-require_relative '../../../ddtrace/transport/http/adapters/net'
-require_relative '../../../ddtrace/transport/http/adapters/test'
-require_relative '../../../ddtrace/transport/http/adapters/unix_socket'
-
-module Datadog
-  module Profiling
-    module Transport
-      # Namespace for HTTP transport components
-      module HTTP
-        # Builds a new Transport::HTTP::Client
-        def self.new(&block)
-          Builder.new(&block).to_transport
-        end
-
-        # Builds a new Transport::HTTP::Client with default settings
-        def self.default(
-          profiling_upload_timeout_seconds:,
-          agent_settings:,
-          site: nil,
-          api_key: nil,
-          agentless_allowed: agentless_allowed?
-        )
-          new do |transport|
-            transport.headers default_headers
-
-            # Configure adapter & API
-            if site && api_key && agentless_allowed
-              configure_for_agentless(
-                transport,
-                profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
-                site: site,
-                api_key: api_key
-              )
-            else
-              configure_for_agent(
-                transport,
-                profiling_upload_timeout_seconds: profiling_upload_timeout_seconds,
-                agent_settings: agent_settings
-              )
-            end
-          end
-        end
-
-        def self.default_headers
-          {
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG => Core::Environment::Ext::LANG,
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Core::Environment::Ext::LANG_VERSION,
-            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER => Core::Environment::Ext::LANG_INTERPRETER,
-            Datadog::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION => Core::Environment::Ext::TRACER_VERSION
-          }.tap do |headers|
-            # Add container ID, if present.
-            container_id = Core::Environment::Container.container_id
-            headers[Datadog::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
-          end
-        end
-
-        private_class_method def self.configure_for_agent(transport, profiling_upload_timeout_seconds:, agent_settings:)
-          apis = API.agent_defaults
-
-          transport.adapter(agent_settings.merge(timeout_seconds: profiling_upload_timeout_seconds))
-          transport.api(API::V1, apis[API::V1], default: true)
-
-          # NOTE: This proc, when it exists, usually overrides the transport specified above
-          if agent_settings.deprecated_for_removal_transport_configuration_proc
-            agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
-          end
-        end
-
-        private_class_method def self.configure_for_agentless(transport, profiling_upload_timeout_seconds:, site:, api_key:)
-          apis = API.api_defaults
-
-          site_uri = URI(format(Profiling::OldExt::Transport::HTTP::URI_TEMPLATE_DD_API, site))
-          hostname = site_uri.host
-          port = site_uri.port
-
-          transport.adapter(
-            Datadog::Transport::Ext::HTTP::ADAPTER,
-            hostname,
-            port,
-            timeout: profiling_upload_timeout_seconds,
-            ssl: site_uri.scheme == 'https'
-          )
-          transport.api(API::V1, apis[API::V1], default: true)
-          transport.headers(Datadog::Transport::Ext::HTTP::HEADER_DD_API_KEY => api_key)
-        end
-
-        private_class_method def self.agentless_allowed?
-          Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
-        end
-
-        # Add adapters to registry
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Transport::HTTP::Adapters::Net,
-          Datadog::Transport::Ext::HTTP::ADAPTER
-        )
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Transport::HTTP::Adapters::Test,
-          Datadog::Transport::Ext::Test::ADAPTER
-        )
-        Datadog::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Transport::HTTP::Adapters::UnixSocket,
-          Datadog::Transport::Ext::UnixSocket::ADAPTER
-        )
-      end
-    end
-  end
-end

data/lib/datadog/tracing/contrib/sinatra/headers.rb

@@ -1,35 +0,0 @@
-# typed: true
-
-require_relative '../../metadata/ext'
-
-module Datadog
-  module Tracing
-    module Contrib
-      module Sinatra
-        # Gets and sets trace information from a Rack headers Hash
-        module Headers
-          module_function
-
-          def response_header_tags(headers, target_headers)
-            target_headers ||= []
-
-            {}.tap do |result|
-              target_headers.each do |header|
-                if headers.key?(header)
-                  result[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
-                else
-                  # Try a case-insensitive lookup
-                  uppercased_header = header.to_s.upcase
-                  matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
-                  if matching_header
-                    result[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/headers/b3.rb

@@ -1,55 +0,0 @@
-# typed: true
-
-require_relative 'parser'
-require_relative '../helpers'
-require_relative 'ext'
-require_relative '../../trace_digest'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Headers
-        # B3 provides helpers to inject or extract headers for B3 style headers
-        module B3
-          include Ext
-
-          def self.inject!(digest, env)
-            return if digest.nil?
-
-            # DEV: We need these to be hex encoded
-            env[B3_HEADER_TRACE_ID] = digest.trace_id.to_s(16)
-            env[B3_HEADER_SPAN_ID] = digest.span_id.to_s(16)
-
-            if digest.trace_sampling_priority
-              sampling_priority = Helpers.clamp_sampling_priority(
-                digest.trace_sampling_priority
-              )
-              env[B3_HEADER_SAMPLED] = sampling_priority.to_s
-            end
-
-            env
-          end
-
-          def self.extract(env)
-            # Extract values from headers
-            # DEV: B3 doesn't have "origin"
-            headers = Parser.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
-
-            TraceDigest.new(
-              trace_id: trace_id,
-              span_id: span_id,
-              trace_sampling_priority: sampling_priority
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/headers/b3_single.rb

@@ -1,67 +0,0 @@
-# typed: true
-
-require_relative 'parser'
-require_relative '../helpers'
-require_relative 'ext'
-require_relative '../../trace_digest'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Headers
-        # B3Single provides helpers to inject or extract headers for B3 single header style headers
-        module B3Single
-          include Ext
-
-          def self.inject!(digest, env)
-            return if digest.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 = "#{digest.trace_id.to_s(16)}-#{digest.span_id.to_s(16)}"
-
-            if digest.trace_sampling_priority
-              sampling_priority = Helpers.clamp_sampling_priority(
-                digest.trace_sampling_priority
-              )
-              header += "-#{sampling_priority}"
-            end
-
-            env[B3_HEADER_SINGLE] = header
-
-            env
-          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 = Parser.new(env)
-            value = headers.header(B3_HEADER_SINGLE)
-            return if value.nil?
-
-            parts = value.split('-')
-            trace_id = Helpers.value_to_id(parts[0], 16) unless parts.empty?
-            span_id = Helpers.value_to_id(parts[1], 16) if parts.length > 1
-            sampling_priority = Helpers.value_to_number(parts[2]) if parts.length > 2
-
-            # Return early if this propagation is not valid
-            return unless trace_id && span_id
-
-            TraceDigest.new(
-              span_id: span_id,
-              trace_id: trace_id,
-              trace_sampling_priority: sampling_priority
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/headers/datadog.rb

@@ -1,52 +0,0 @@
-# typed: true
-
-require_relative 'parser'
-require_relative 'ext'
-require_relative '../../trace_digest'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Headers
-        # Datadog provides helpers to inject or extract headers for Datadog style headers
-        module Datadog
-          include Ext
-
-          def self.inject!(digest, env)
-            return if digest.nil?
-
-            env[HTTP_HEADER_TRACE_ID] = digest.trace_id.to_s
-            env[HTTP_HEADER_PARENT_ID] = digest.span_id.to_s
-            env[HTTP_HEADER_SAMPLING_PRIORITY] = digest.trace_sampling_priority.to_s if digest.trace_sampling_priority
-            env[HTTP_HEADER_ORIGIN] = digest.trace_origin.to_s unless digest.trace_origin.nil?
-
-            env
-          end
-
-          def self.extract(env)
-            # Extract values from headers
-            headers = Parser.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: `Parser#id` will not return 0
-            return unless (trace_id && parent_id) || (origin && trace_id)
-
-            # Return new trace headers
-            TraceDigest.new(
-              span_id: parent_id,
-              trace_id: trace_id,
-              trace_origin: origin,
-              trace_sampling_priority: sampling_priority
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/headers/parser.rb

@@ -1,37 +0,0 @@
-# typed: false
-
-require_relative '../helpers'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Headers
-        # Parser provides easy access and validation methods for Rack headers
-        class Parser
-          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)
-            Helpers.value_to_id(header(hdr), base)
-          end
-
-          def number(hdr, base = 10)
-            Helpers.value_to_number(header(hdr), base)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/metadata/b3.rb

@@ -1,55 +0,0 @@
-# typed: true
-
-require_relative '../helpers'
-require_relative 'parser'
-require_relative '../headers/ext'
-require_relative '../../trace_digest'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Metadata
-        # B3 provides helpers to inject or extract metadata for B3 style headers
-        module B3
-          include Distributed::Headers::Ext
-
-          def self.inject!(digest, metadata)
-            return if digest.nil?
-
-            # DEV: We need these to be hex encoded
-            metadata[B3_HEADER_TRACE_ID] = digest.trace_id.to_s(16)
-            metadata[B3_HEADER_SPAN_ID] = digest.span_id.to_s(16)
-
-            if digest.trace_sampling_priority
-              sampling_priority = Helpers.clamp_sampling_priority(
-                digest.trace_sampling_priority
-              )
-              metadata[B3_HEADER_SAMPLED] = sampling_priority.to_s
-            end
-
-            metadata
-          end
-
-          def self.extract(metadata)
-            # Extract values from gRPC metadata
-            # DEV: B3 doesn't have "origin"
-            metadata = Parser.new(metadata)
-            trace_id = metadata.id(B3_HEADER_TRACE_ID, 16)
-            span_id = metadata.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 = metadata.number(B3_HEADER_SAMPLED)
-
-            # Return early if this propagation is not valid
-            return unless trace_id && span_id
-
-            TraceDigest.new(
-              trace_id: trace_id,
-              span_id: span_id,
-              trace_sampling_priority: sampling_priority
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/metadata/b3_single.rb

@@ -1,66 +0,0 @@
-# typed: true
-
-require_relative 'parser'
-require_relative '../helpers'
-require_relative '../headers/ext'
-require_relative '../../trace_digest'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Metadata
-        # B3Single provides helpers to inject or extract metadata for B3 single header style headers
-        module B3Single
-          include Distributed::Headers::Ext
-
-          def self.inject!(digest, metadata)
-            return if digest.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
-            b3_header = "#{digest.trace_id.to_s(16)}-#{digest.span_id.to_s(16)}"
-
-            if digest.trace_sampling_priority
-              sampling_priority = Helpers.clamp_sampling_priority(
-                digest.trace_sampling_priority
-              )
-              b3_header += "-#{sampling_priority}"
-            end
-
-            metadata[B3_HEADER_SINGLE] = b3_header
-
-            metadata
-          end
-
-          def self.extract(metadata)
-            # Metadata format:
-            #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
-            # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
-            # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
-
-            b3_single = Parser.new(metadata).metadata_for_key(B3_HEADER_SINGLE)
-            return if b3_single.nil?
-
-            parts = b3_single.split('-')
-            trace_id = Helpers.value_to_id(parts[0], 16) unless parts.empty?
-            span_id = Helpers.value_to_id(parts[1], 16) if parts.length > 1
-            sampling_priority = Helpers.value_to_number(parts[2]) if parts.length > 2
-
-            # Return early if this propagation is not valid
-            return unless trace_id && span_id
-
-            TraceDigest.new(
-              span_id: span_id,
-              trace_id: trace_id,
-              trace_sampling_priority: sampling_priority
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/metadata/datadog.rb

@@ -1,73 +0,0 @@
-require_relative '../headers/ext'
-require_relative 'parser'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Metadata
-        # Datadog provides helpers to inject or extract metadata for Datadog style headers
-        class Datadog
-          include Distributed::Headers::Ext
-
-          def self.inject!(digest, metadata)
-            return if digest.nil?
-
-            metadata[GRPC_METADATA_TRACE_ID] = digest.trace_id.to_s
-            metadata[GRPC_METADATA_PARENT_ID] = digest.span_id.to_s
-            if digest.trace_sampling_priority
-              metadata[GRPC_METADATA_SAMPLING_PRIORITY] =
-                digest.trace_sampling_priority.to_s
-            end
-            metadata[GRPC_METADATA_ORIGIN] = digest.trace_origin.to_s if digest.trace_origin
-
-            metadata
-          end
-
-          def self.extract(metadata)
-            carrier = Carrier.new(metadata)
-
-            return nil unless carrier.valid?
-
-            TraceDigest.new(
-              span_id: carrier.parent_id,
-              trace_id: carrier.trace_id,
-              trace_origin: carrier.origin,
-              trace_sampling_priority: carrier.sampling_priority
-            )
-          end
-
-          # opentracing.io compliant carrier object
-          class Carrier
-            include Distributed::Headers::Ext
-
-            def initialize(metadata = {})
-              @metadata = Parser.new(metadata || {})
-            end
-
-            def valid?
-              (trace_id && parent_id) || (origin && trace_id)
-            end
-
-            def trace_id
-              @metadata.id(GRPC_METADATA_TRACE_ID)
-            end
-
-            def parent_id
-              @metadata.id(GRPC_METADATA_PARENT_ID)
-            end
-
-            def sampling_priority
-              value = @metadata.metadata_for_key(GRPC_METADATA_SAMPLING_PRIORITY)
-              value && value.to_i
-            end
-
-            def origin
-              value = @metadata.metadata_for_key(GRPC_METADATA_ORIGIN)
-              value if value != ''
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/tracing/distributed/metadata/parser.rb

@@ -1,34 +0,0 @@
-require_relative '../helpers'
-
-module Datadog
-  module Tracing
-    module Distributed
-      module Metadata
-        # Parser provides easy access and validation methods for metadata headers
-        class Parser
-          def initialize(metadata)
-            @metadata = metadata
-          end
-
-          def id(key, base = 10)
-            Helpers.value_to_id(metadata_for_key(key), base)
-          end
-
-          def number(key, base = 10)
-            Helpers.value_to_number(metadata_for_key(key), base)
-          end
-
-          def metadata_for_key(key)
-            # metadata values can be arrays (multiple headers with the same key)
-            value = @metadata[key]
-            if value.is_a?(Array)
-              value.first
-            else
-              value
-            end
-          end
-        end
-      end
-    end
-  end
-end