ddtrace 1.14.0 → 1.16.0

data/lib/datadog/core/telemetry/collector.rb

@@ -11,7 +11,7 @@ require_relative 'v1/dependency'
 require_relative 'v1/host'
 require_relative 'v1/integration'
 require_relative 'v1/product'
-require_relative '../../../ddtrace/transport/ext'
+require_relative '../transport/ext'
 
 module Datadog
   module Core
@@ -146,6 +146,7 @@ module Datadog
           options['logger.instance'] = configuration.logger.instance.class.to_s
           options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
           options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
+          options['tracing.opentracing.enabled'] = !defined?(Datadog::OpenTracer::LOADED).nil?
           options.compact!
           options
         end
@@ -190,7 +191,7 @@ module Datadog
 
         def agent_transport
           adapter = Core::Configuration::AgentSettingsResolver.call(Datadog.configuration).adapter
-          if adapter == Datadog::Transport::Ext::UnixSocket::ADAPTER
+          if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
             'UDS'
           else
             'TCP'

data/lib/datadog/core/telemetry/http/transport.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../configuration/settings'
+require_relative '../../transport/ext'
 require_relative 'env'
 require_relative 'ext'
 require_relative 'adapters/net'
@@ -38,7 +39,7 @@ module Datadog
 
           def headers(request_type:, api_version: Http::Ext::API_VERSION)
             {
-              Datadog::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
+              Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
               Http::Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
               Http::Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
               Http::Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,

data/lib/datadog/core/transport/ext.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../configuration/ext'
+# DEV(2.0): This file should replace /ddtrace/transport/ext.rb
+# WARN: This file is used in /dd trace/transport/ext.rb which is a public API. Any changes here
+# should be treated as changes to a public API.
+module Datadog
+  module Core
+    module Transport
+      module Ext
+        module HTTP
+          ADAPTER = Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+          DEFAULT_HOST = Datadog::Core::Configuration::Ext::Agent::HTTP::DEFAULT_HOST
+          DEFAULT_PORT = Datadog::Core::Configuration::Ext::Agent::HTTP::DEFAULT_PORT
+
+          HEADER_CONTAINER_ID = 'Datadog-Container-ID'
+          HEADER_DD_API_KEY = 'DD-API-KEY'
+          # Tells agent that `_dd.top_level` metrics have been set by the tracer.
+          # The agent will not calculate top-level spans but instead trust the tracer tagging.
+          #
+          # This prevents partially flushed traces being mistakenly marked as top-level.
+          #
+          # Setting this header to any non-empty value enables this feature.
+          HEADER_CLIENT_COMPUTED_TOP_LEVEL = 'Datadog-Client-Computed-Top-Level'
+          HEADER_META_LANG = 'Datadog-Meta-Lang'
+          HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'
+          HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'
+          HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'
+
+          # Header that prevents the Net::HTTP integration from tracing internal trace requests.
+          # Set it to any value to skip tracing.
+          HEADER_DD_INTERNAL_UNTRACED_REQUEST = 'DD-Internal-Untraced-Request'
+        end
+
+        module Test
+          ADAPTER = :test
+        end
+
+        module UnixSocket
+          ADAPTER = Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
+          DEFAULT_PATH = Datadog::Core::Configuration::Ext::Agent::UnixSocket::DEFAULT_PATH
+          DEFAULT_TIMEOUT_SECONDS = Datadog::Core::Configuration::Ext::Agent::UnixSocket::DEFAULT_TIMEOUT_SECONDS
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/adapters/net.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/response'
+require_relative '../../../../core/vendor/multipart-post/net/http/post/multipart'
+
+module Datadog
+  module Core
+    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)
+                super("No matching Net::HTTP function for '#{verb}'!")
+              end
+            end
+
+            # A wrapped Net::HTTP response that implements the Transport::Response interface
+            class Response
+              include Datadog::Core::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
+end

data/lib/datadog/core/transport/http/adapters/registry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    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
+end

data/lib/datadog/core/transport/http/adapters/test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/response'
+
+module Datadog
+  module Core
+    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::Core::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
+end

data/lib/datadog/core/transport/http/adapters/unix_socket.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require_relative '../../../transport/ext'
+require_relative 'net'
+
+module Datadog
+  module Core
+    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.
+            # rubocop:disable Lint/MissingSuper
+            def initialize(uds_path = nil, **options)
+              @filepath = uds_path || options.fetch(:uds_path)
+              @timeout = options[:timeout] || Datadog::Core::Transport::Ext::UnixSocket::DEFAULT_TIMEOUT_SECONDS
+            end
+            # rubocop:enable Lint/MissingSuper
+
+            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
+end

data/lib/datadog/core/transport/http/api/endpoint.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Datadog
+  module Core
+    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
+end

data/lib/datadog/core/transport/http/api/fallbacks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    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
+end

data/lib/datadog/core/transport/http/api/map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'fallbacks'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module API
+          # A mapping of API version => API Routes/Instance
+          class Map < Hash
+            include Fallbacks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/env.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        # Data structure for an HTTP request
+        class Env < Hash
+          attr_reader \
+            :request
+
+          # rubocop:disable Lint/MissingSuper
+          def initialize(request, options = nil)
+            @request = request
+            merge!(options) unless options.nil?
+          end
+          # rubocop:enable Lint/MissingSuper
+
+          def verb
+            self[:verb]
+          end
+
+          def verb=(value)
+            self[:verb] = value
+          end
+
+          def path
+            self[:path]
+          end
+
+          def path=(value)
+            self[:path] = value
+          end
+
+          def body
+            self[:body]
+          end
+
+          def body=(value)
+            self[:body] = value
+          end
+
+          def headers
+            self[:headers] ||= {}
+          end
+
+          def headers=(value)
+            self[:headers] = value
+          end
+
+          def form
+            self[:form] ||= {}
+          end
+
+          def form=(value)
+            self[:form] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/response'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        # Wraps an HTTP response from an adapter.
+        #
+        # Used by endpoints to wrap responses from adapters with
+        # fields or behavior that's specific to that endpoint.
+        module Response
+          def initialize(http_response)
+            @http_response = http_response
+          end
+
+          # (see Datadog::Core::Transport::Response#payload)
+          def payload
+            @http_response.payload
+          end
+
+          # (see Datadog::Core::Transport::Response#internal_error?)
+          def internal_error?
+            @http_response.internal_error?
+          end
+
+          # (see Datadog::Core::Transport::Response#unsupported?)
+          def unsupported?
+            @http_response.unsupported?
+          end
+
+          # (see Datadog::Core::Transport::Response#ok?)
+          def ok?
+            @http_response.ok?
+          end
+
+          # (see Datadog::Core::Transport::Response#not_found?)
+          def not_found?
+            @http_response.not_found?
+          end
+
+          # (see Datadog::Core::Transport::Response#client_error?)
+          def client_error?
+            @http_response.client_error?
+          end
+
+          # (see Datadog::Core::Transport::Response#server_error?)
+          def server_error?
+            @http_response.server_error?
+          end
+
+          def code
+            @http_response.respond_to?(:code) ? @http_response.code : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/parcel.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      # Data transfer object for generic data
+      # @abstract
+      module Parcel
+        attr_reader \
+          :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def encode_with(encoder)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end