ddtrace 1.4.2 → 1.19.0

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

data/lib/datadog/tracing/propagation/grpc.rb

@@ -1,98 +0,0 @@
-# typed: false
-
-require_relative '../distributed/metadata/datadog'
-require_relative '../distributed/metadata/b3'
-require_relative '../distributed/metadata/b3_single'
-
-require_relative '../span'
-require_relative '../trace_digest'
-require_relative '../trace_operation'
-
-module Datadog
-  module Tracing
-    module Propagation
-      # opentracing.io compliant methods for distributing trace headers
-      # between two or more distributed services. Note this is very close
-      # to the Propagation::HTTP; the key difference is the way gRPC handles
-      # header information (called "metadata") as it operates over HTTP2
-      module GRPC
-        PROPAGATION_STYLES = {
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_B3 => Distributed::Metadata::B3,
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER => Distributed::Metadata::B3Single,
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG => Distributed::Metadata::Datadog
-        }.freeze
-
-        def self.inject!(digest, metadata)
-          return if digest.nil?
-
-          digest = digest.to_digest if digest.is_a?(TraceOperation)
-
-          Datadog.configuration.tracing.distributed_tracing.propagation_inject_style.each do |style|
-            propagator = PROPAGATION_STYLES[style]
-            begin
-              propagator.inject!(digest, metadata) unless propagator.nil?
-            rescue => e
-              Datadog.logger.error(
-                'Error injecting propagated trace headers into the environment. ' \
-                "Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-          end
-        end
-
-        def self.extract(metadata)
-          trace_digest = nil
-          dd_trace_digest = nil
-
-          Datadog.configuration.tracing.distributed_tracing.propagation_extract_style.each do |style|
-            propagator = PROPAGATION_STYLES[style]
-
-            next if propagator.nil?
-
-            # Extract trace headers
-            begin
-              extracted_trace_digest = propagator.extract(metadata)
-            rescue => e
-              Datadog.logger.error(
-                'Error extracting propagated trace headers from the environment. ' \
-                "Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-
-            # Skip this style if no valid headers were found
-            next if extracted_trace_digest.nil?
-
-            # Keep track of the Datadog extract trace headers, we want to return
-            #   this one if we have one
-            if extracted_trace_digest && style == Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG
-              dd_trace_digest = extracted_trace_digest
-            end
-
-            # No previously extracted trace headers, use the one we just extracted
-            if trace_digest.nil?
-              trace_digest = extracted_trace_digest
-            else
-              unless trace_digest.trace_id == extracted_trace_digest.trace_id \
-                      && trace_digest.span_id == extracted_trace_digest.span_id
-                # Return an empty/new trace headers if we have a mismatch in values extracted
-                msg = "#{trace_digest.trace_id} != #{extracted_trace_digest.trace_id} && " \
-                      "#{trace_digest.span_id} != #{extracted_trace_digest.span_id}"
-                Datadog.logger.debug(
-                  "Cannot extract trace headers from HTTP: extracted trace headers differ, #{msg}"
-                )
-                # DEV: This will return from `self.extract` not this `each` block
-                return TraceDigest.new
-              end
-            end
-          end
-
-          # Return the extracted trace headers if we found one or else a new empty trace headers
-          # Always return the Datadog trace headers if one exists since it has more
-          #   information than the B3 headers e.g. origin, expanded priority
-          #   sampling values, etc
-          dd_trace_digest || trace_digest || nil
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/net.rb

@@ -1,158 +0,0 @@
-# typed: true
-
-require_relative '../../response'
-require_relative '../../../../datadog/core/vendor/multipart-post/net/http/post/multipart'
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # Adapter for Net::HTTP
-        class Net
-          attr_reader \
-            :hostname,
-            :port,
-            :timeout,
-            :ssl
-
-          # in seconds
-          DEFAULT_TIMEOUT = 30
-
-          # @deprecated Positional parameters are deprecated. Use named parameters instead.
-          def initialize(hostname = nil, port = nil, **options)
-            @hostname = hostname || options.fetch(:hostname)
-            @port = port || options.fetch(:port)
-            @timeout = options[:timeout] || DEFAULT_TIMEOUT
-            @ssl = options.key?(:ssl) ? options[:ssl] == true : false
-          end
-
-          def self.build(agent_settings)
-            new(
-              hostname: agent_settings.hostname,
-              port: agent_settings.port,
-              timeout: agent_settings.timeout_seconds,
-              ssl: agent_settings.ssl
-            )
-          end
-
-          def open(&block)
-            # DEV Initializing +Net::HTTP+ directly help us avoid expensive
-            # options processing done in +Net::HTTP.start+:
-            # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
-            req = ::Net::HTTP.new(hostname, port, nil)
-
-            req.use_ssl = ssl
-            req.open_timeout = req.read_timeout = timeout
-
-            req.start(&block)
-          end
-
-          def call(env)
-            if respond_to?(env.verb)
-              send(env.verb, env)
-            else
-              raise UnknownHTTPMethod, env
-            end
-          end
-
-          def post(env)
-            post = nil
-
-            if env.form.nil? || env.form.empty?
-              post = ::Net::HTTP::Post.new(env.path, env.headers)
-              post.body = env.body
-            else
-              post = ::Datadog::Core::Vendor::Net::HTTP::Post::Multipart.new(
-                env.path,
-                env.form,
-                env.headers
-              )
-            end
-
-            # Connect and send the request
-            http_response = open do |http|
-              http.request(post)
-            end
-
-            # Build and return response
-            Response.new(http_response)
-          end
-
-          def url
-            "http://#{hostname}:#{port}?timeout=#{timeout}"
-          end
-
-          # Raised when called with an unknown HTTP method
-          class UnknownHTTPMethod < StandardError
-            attr_reader :verb
-
-            def initialize(verb)
-              @verb = verb
-            end
-
-            def message
-              "No matching Net::HTTP function for '#{verb}'!"
-            end
-          end
-
-          # A wrapped Net::HTTP response that implements the Transport::Response interface
-          class Response
-            include Datadog::Transport::Response
-
-            attr_reader :http_response
-
-            def initialize(http_response)
-              @http_response = http_response
-            end
-
-            def payload
-              return super if http_response.nil?
-
-              http_response.body
-            end
-
-            def code
-              return super if http_response.nil?
-
-              http_response.code.to_i
-            end
-
-            def ok?
-              return super if http_response.nil?
-
-              code.between?(200, 299)
-            end
-
-            def unsupported?
-              return super if http_response.nil?
-
-              code == 415
-            end
-
-            def not_found?
-              return super if http_response.nil?
-
-              code == 404
-            end
-
-            def client_error?
-              return super if http_response.nil?
-
-              code.between?(400, 499)
-            end
-
-            def server_error?
-              return super if http_response.nil?
-
-              code.between?(500, 599)
-            end
-
-            def inspect
-              "#{super}, http_response:#{http_response}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/registry.rb

@@ -1,27 +0,0 @@
-# typed: true
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # List of available adapters
-        class Registry
-          def initialize
-            @adapters = {}
-          end
-
-          def get(name)
-            @adapters[name]
-          end
-
-          def set(klass, name = nil)
-            name ||= klass.to_s
-            return if name.nil?
-
-            @adapters[name] = klass
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/test.rb

@@ -1,87 +0,0 @@
-# typed: true
-
-require_relative '../../response'
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # Adapter for testing
-        class Test
-          attr_reader \
-            :buffer,
-            :status
-
-          # @param buffer [Array] an optional array that will capture all spans sent to this adapter, defaults to +nil+
-          # @deprecated Positional parameters are deprecated. Use named parameters instead.
-          def initialize(buffer = nil, **options)
-            @buffer = buffer || options[:buffer]
-            @mutex = Mutex.new
-            @status = 200
-          end
-
-          def call(env)
-            add_request(env)
-            Response.new(status)
-          end
-
-          def buffer?
-            !@buffer.nil?
-          end
-
-          def add_request(env)
-            @mutex.synchronize { buffer << env } if buffer?
-          end
-
-          def set_status!(status)
-            @status = status
-          end
-
-          def url; end
-
-          # Response for test adapter
-          class Response
-            include Datadog::Transport::Response
-
-            attr_reader \
-              :body,
-              :code
-
-            def initialize(code, body = nil)
-              @code = code
-              @body = body
-            end
-
-            def payload
-              @body
-            end
-
-            def ok?
-              code.between?(200, 299)
-            end
-
-            def unsupported?
-              code == 415
-            end
-
-            def not_found?
-              code == 404
-            end
-
-            def client_error?
-              code.between?(400, 499)
-            end
-
-            def server_error?
-              code.between?(500, 599)
-            end
-
-            def inspect
-              "#{super}, code:#{code}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/adapters/unix_socket.rb

@@ -1,79 +0,0 @@
-# typed: false
-
-require 'net/http'
-require_relative '../../ext'
-require_relative 'net'
-
-module Datadog
-  module Transport
-    module HTTP
-      module Adapters
-        # Adapter for Unix sockets
-        class UnixSocket < Adapters::Net
-          attr_reader \
-            :filepath, # DEV(1.0): Rename to `uds_path`
-            :timeout
-
-          alias_method :uds_path, :filepath
-
-          # @deprecated Positional parameters are deprecated. Use named parameters instead.
-          def initialize(uds_path = nil, **options)
-            @filepath = uds_path || options.fetch(:uds_path)
-            @timeout = options[:timeout] || Transport::Ext::UnixSocket::DEFAULT_TIMEOUT_SECONDS
-          end
-
-          def self.build(agent_settings)
-            new(
-              uds_path: agent_settings.uds_path,
-              timeout: agent_settings.timeout_seconds,
-            )
-          end
-
-          def open(&block)
-            # Open connection
-            connection = HTTP.new(
-              uds_path,
-              read_timeout: timeout,
-              continue_timeout: timeout
-            )
-
-            connection.start(&block)
-          end
-
-          def url
-            "http+unix://#{uds_path}?timeout=#{timeout}"
-          end
-
-          # Re-implements Net:HTTP with underlying Unix socket
-          class HTTP < ::Net::HTTP
-            DEFAULT_TIMEOUT = 1
-
-            attr_reader \
-              :filepath, # DEV(1.0): Rename to `uds_path`
-              :unix_socket
-
-            alias_method :uds_path, :filepath
-
-            def initialize(uds_path, options = {})
-              super('localhost', 80)
-              @filepath = uds_path
-              @read_timeout = options.fetch(:read_timeout, DEFAULT_TIMEOUT)
-              @continue_timeout = options.fetch(:continue_timeout, DEFAULT_TIMEOUT)
-              @debug_output = options[:debug_output] if options.key?(:debug_output)
-            end
-
-            def connect
-              @unix_socket = UNIXSocket.open(uds_path)
-              @socket = ::Net::BufferedIO.new(@unix_socket).tap do |socket|
-                socket.read_timeout = @read_timeout
-                socket.continue_timeout = @continue_timeout
-                socket.debug_output = @debug_output
-              end
-              on_connect
-            end
-          end
-        end
-      end
-    end
-  end
-end