ddtrace 1.12.1 → 1.23.2

data/lib/datadog/profiling/pprof/template.rb

@@ -1,118 +0,0 @@
-require_relative 'payload'
-require_relative 'message_set'
-require_relative 'builder'
-
-require_relative '../events/stack'
-require_relative 'stack_sample'
-
-module Datadog
-  module Profiling
-    module Pprof
-      # Converts a collection of profiling events into a Perftools::Profiles::Profile
-      class Template
-        DEFAULT_MAPPINGS = {
-          Events::StackSample => Pprof::StackSample
-        }.freeze
-
-        attr_reader \
-          :builder,
-          :converters,
-          :sample_type_mappings
-
-        def self.for_event_classes(event_classes)
-          # Build a map of event class --> converter class
-          mappings = event_classes.each_with_object({}) do |event_class, m|
-            converter_class = DEFAULT_MAPPINGS[event_class]
-            raise NoProfilingEventConversionError, event_class unless converter_class
-
-            m[event_class] = converter_class
-          end
-
-          new(mappings)
-        end
-
-        def initialize(mappings)
-          @builder = Builder.new
-          @converters = Hash.new { |_h, event_class| raise NoProfilingEventConversionError, event_class }
-          @sample_type_mappings = Hash.new { |_h, type| raise UnknownSampleTypeMappingError, type }
-
-          # Add default mapping
-          builder.mappings.fetch($PROGRAM_NAME, &builder.method(:build_mapping))
-
-          # Combine all sample types from each converter class
-          types = mappings.values.each_with_object({}) do |converter_class, t|
-            t.merge!(converter_class.sample_value_types)
-          end
-
-          # Build the sample types into sample type objects
-          types.each do |type_name, type_args|
-            index = nil
-
-            sample_type = builder.sample_types.fetch(*type_args) do |id, type, unit|
-              index = id
-              builder.build_value_type(type, unit)
-            end
-
-            # Create mapping between the type and index to which its assigned.
-            # Do this for faster lookup while building profile sample values.
-            sample_type_mappings[type_name] = index || builder.sample_types.messages.index(sample_type)
-          end
-
-          # Freeze them so they can't be modified.
-          # We don't want the number of sample types to vary between samples within the same profile.
-          builder.sample_types.freeze
-          sample_type_mappings.freeze
-
-          # Add converters
-          mappings.each do |event_class, converter_class|
-            converters[event_class] = converter_class.new(builder, sample_type_mappings)
-          end
-
-          converters.freeze
-        end
-
-        def add_events!(event_class, events)
-          converters[event_class].add_events!(events)
-        end
-
-        def debug_statistics
-          converters.values.map(&:debug_statistics).join(', ')
-        end
-
-        def to_pprof(start:, finish:)
-          profile = builder.build_profile(start: start, finish: finish)
-          data = builder.encode_profile(profile)
-          types = sample_type_mappings.keys
-
-          Payload.new(data, types)
-        end
-
-        # Error when an unknown event type is given to be converted
-        class NoProfilingEventConversionError < ArgumentError
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-
-          def message
-            "Profiling event type '#{type}' cannot be converted to pprof."
-          end
-        end
-
-        # Error when the mapping of a sample type to value index is unknown
-        class UnknownSampleTypeMappingError < ArgumentError
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-
-          def message
-            "Mapping for sample value type '#{type}' is unknown."
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/trace_identifiers/ddtrace.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../tracing'
-require_relative '../../tracing/metadata/ext'
-
-module Datadog
-  module Profiling
-    module TraceIdentifiers
-      # Used by Datadog::Profiling::TraceIdentifiers::Helper to get the trace identifiers (root span id and span id)
-      # for a given thread, if there is an active trace for that thread in the supplied tracer object.
-      class Ddtrace
-        def initialize(tracer:)
-          @tracer = (tracer if tracer.respond_to?(:active_trace))
-        end
-
-        def trace_identifiers_for(thread)
-          return unless @tracer
-
-          trace = @tracer.active_trace(thread)
-          return unless trace
-
-          root_span = trace.send(:root_span)
-          span = trace.active_span
-          return unless span && root_span
-
-          root_span_id = root_span.id || 0
-          span_id = span.id || 0
-
-          [root_span_id, span_id, maybe_extract_resource(trace, root_span)] if root_span_id != 0 && span_id != 0
-        end
-
-        private
-
-        # NOTE: Currently we're only interested in HTTP service endpoints. Over time, this list may be expanded.
-        # Resources MUST NOT include personal identifiable information (PII); this should not be the case with
-        # ddtrace integrations, but worth mentioning just in case :)
-        def maybe_extract_resource(trace, root_span)
-          trace.resource if root_span.span_type == Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
-        end
-      end
-    end
-  end
-end

data/lib/datadog/profiling/trace_identifiers/helper.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'ddtrace'
-
-module Datadog
-  module Profiling
-    module TraceIdentifiers
-      # Helper used to retrieve the trace identifiers (root span id and span id) for a given thread,
-      # if there is an active trace for that thread for the supported tracing APIs.
-      #
-      # This data is used to connect profiles to the traces -- samples in a profile will be tagged with this data and
-      # the profile can be filtered down to look at only the samples for a given trace.
-      class Helper
-        DEFAULT_SUPPORTED_APIS = [
-          Profiling::TraceIdentifiers::Ddtrace
-        ].freeze
-        private_constant :DEFAULT_SUPPORTED_APIS
-
-        def initialize(
-          tracer:,
-          # If this is disabled, the helper will strip the optional trace_resource_container even if provided by the api
-          endpoint_collection_enabled:,
-          supported_apis: DEFAULT_SUPPORTED_APIS.map { |api| api.new(tracer: tracer) }
-        )
-          @endpoint_collection_enabled = endpoint_collection_enabled
-          @supported_apis = supported_apis
-        end
-
-        # Expected output of the #trace_identifiers_for
-        # duck type is [root_span_id, span_id, (optional trace_resource_container)]
-        def trace_identifiers_for(thread)
-          @supported_apis.each do |api|
-            trace_identifiers = api.trace_identifiers_for(thread)
-
-            if trace_identifiers
-              return @endpoint_collection_enabled ? trace_identifiers : trace_identifiers[0..1]
-            end
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: 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/ddtrace/transport/http/adapters/net.rb

@@ -1,168 +0,0 @@
-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 get(env)
-            get = ::Net::HTTP::Get.new(env.path, env.headers)
-
-            # Connect and send the request
-            http_response = open do |http|
-              http.request(get)
-            end
-
-            # Build and return response
-            Response.new(http_response)
-          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 @@
-# frozen_string_literal: 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,85 +0,0 @@
-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,77 +0,0 @@
-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

data/lib/ddtrace/transport/http/api/endpoint.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # Endpoint
-        class Endpoint
-          attr_reader \
-            :verb,
-            :path
-
-          def initialize(verb, path)
-            @verb = verb
-            @path = path
-          end
-
-          def call(env)
-            env.verb = verb
-            env.path = path
-            yield(env)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/fallbacks.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # Extension for Map with adds fallback versions.
-        module Fallbacks
-          def fallbacks
-            @fallbacks ||= {}
-          end
-
-          def with_fallbacks(fallbacks)
-            tap { add_fallbacks!(fallbacks) }
-          end
-
-          def add_fallbacks!(fallbacks)
-            self.fallbacks.merge!(fallbacks)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/http/api/instance.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Transport
-    module HTTP
-      module API
-        # An API configured with adapter and routes
-        class Instance
-          attr_reader \
-            :adapter,
-            :headers,
-            :spec
-
-          def initialize(spec, adapter, options = {})
-            @spec = spec
-            @adapter = adapter
-            @headers = options.fetch(:headers, {})
-          end
-
-          def encoder
-            spec.encoder
-          end
-
-          def call(env)
-            # Add headers to request env, unless empty.
-            env.headers.merge!(headers) unless headers.empty?
-
-            # Send request env to the adapter.
-            adapter.call(env)
-          end
-        end
-      end
-    end
-  end
-end