DEBUG-3700 Remove duplicated classes from Telemetry transport

lib/datadog/core/telemetry/emitter.rb

@@ -2,6 +2,7 @@
 
 require_relative 'request'
 require_relative 'http/transport'
+require_relative '../transport/response'
 require_relative '../utils/sequence'
 require_relative '../utils/forking'
 
@@ -25,11 +26,11 @@ def request(event)
           seq_id = self.class.sequence.next
           payload = Request.build_payload(event, seq_id)
           res = @http_transport.request(request_type: event.type, payload: payload.to_json)
-          Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (code: #{res.code.inspect})" }
+          Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (response: #{res})" }
           res
         rescue => e
           Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
-          Telemetry::Http::InternalErrorResponse.new(e)
+          Core::Transport::InternalErrorResponse.new(e)
         end
 
         # Initializes a Sequence object to track seq_id if not already initialized; else returns stored

lib/datadog/core/telemetry/http/adapters/net.rb

@@ -1,108 +1,23 @@
 # frozen_string_literal: true
 
-require_relative '../response'
+# datadog-ci-rb versions 1.15.0 and lower require this file and guard
+# the require with a rescue of StandardError. Unfortunately LoadError,
+# which would be raised if the file is missing, is not a subclass of
+# StandardError and thus would not be caught by the rescue.
+# We provide this file with a dummy class in it to avoid exceptions
+# in datadog-ci-rb until version 2.0 is released.
+#
+# Note that datadog-ci-rb patches telemetry transport to be "real" even when
+# webmock is used; this patching won't work with datadog-ci-rb versions
+# 1.15.0 and older and dd-trace-rb 2.16.0 and newer. There will be no
+# errors/exceptions reported but telemetry events will not be sent.
 
 module Datadog
   module Core
     module Telemetry
       module Http
         module Adapters
-          # Class defining methods to make http requests via NET
-          class Net
-            attr_reader \
-              :hostname,
-              :port,
-              :timeout,
-              :ssl
-
-            DEFAULT_TIMEOUT = 2
-
-            def initialize(hostname:, port: nil, timeout: DEFAULT_TIMEOUT, ssl: true)
-              @hostname = hostname
-              @port = port
-              @timeout = timeout
-              @ssl = ssl.nil? || ssl
-            end
-
-            def open(&block)
-              req = ::Net::HTTP.new(@hostname, @port)
-
-              req.use_ssl = @ssl
-              req.open_timeout = req.read_timeout = @timeout
-
-              req.start(&block)
-            end
-
-            def post(env)
-              post = ::Net::HTTP::Post.new(env.path, env.headers)
-              post.body = env.body
-
-              http_response = open do |http|
-                http.request(post)
-              end
-
-              Response.new(http_response)
-            rescue StandardError => e
-              Datadog.logger.debug("Unable to send telemetry event to agent: #{e}")
-              Telemetry::Http::InternalErrorResponse.new(e)
-            end
-
-            # Data structure for an HTTP Response
-            class Response
-              include Datadog::Core::Telemetry::Http::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
+          class Net # rubocop:disable Lint/EmptyClass
           end
         end
       end

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

@@ -3,9 +3,8 @@
 require_relative '../../configuration/settings'
 require_relative '../../environment/ext'
 require_relative '../../transport/ext'
-require_relative 'env'
 require_relative 'ext'
-require_relative 'adapters/net'
+require_relative '../../transport/http/adapters/net'
 
 module Datadog
   module Core
@@ -53,7 +52,7 @@ def initialize(host:, port:, path:, ssl: false, api_key: nil)
           end
 
           def request(request_type:, payload:)
-            env = Http::Env.new
+            env = Core::Transport::HTTP::Env.new(Core::Transport::Request.new)
             env.path = @path
             env.body = payload
             env.headers = headers(request_type: request_type)
@@ -81,7 +80,16 @@ def headers(request_type:, api_version: Http::Ext::API_VERSION)
           end
 
           def adapter
-            @adapter ||= Http::Adapters::Net.new(hostname: @host, port: @port, ssl: @ssl)
+            @adapter ||= begin
+              agent_settings = Core::Configuration::AgentSettingsResolver::AgentSettings.new(
+                adapter: Core::Configuration::Ext::Agent::HTTP::ADAPTER,
+                ssl: @ssl,
+                hostname: @host,
+                port: @port,
+                # TODO: get timeout_seconds from somewhere
+              )
+              Core::Transport::HTTP::Adapters::Net.new(agent_settings)
+            end
           end
         end
       end

sig/datadog/core/configuration/agent_settings_resolver.rbs

@@ -3,9 +3,9 @@ module Datadog
     module Configuration
       class AgentSettingsResolver
         class AgentSettings
-          def initialize: (adapter: untyped, ssl: untyped, hostname: untyped, port: untyped, uds_path: untyped, timeout_seconds: untyped) -> void
+          def initialize: (?adapter: untyped, ?ssl: untyped, ?hostname: untyped, ?port: untyped, ?uds_path: untyped, ?timeout_seconds: untyped) -> void
 
-          attr_reader adapter: untyped
+          attr_reader adapter: :net_http | :unix
           attr_reader ssl: untyped
           attr_reader hostname: untyped
           attr_reader port: untyped

sig/datadog/core/telemetry/emitter.rbs

@@ -8,7 +8,7 @@ module Datadog
 
         extend Core::Utils::Forking
         def initialize: (http_transport: Datadog::Core::Telemetry::Http::Transport) -> void
-        def request: (Datadog::Core::Telemetry::Event::Base event) -> (Datadog::Core::Telemetry::Http::Adapters::Net::Response | Datadog::Core::Telemetry::Http::InternalErrorResponse)
+        def request: (Datadog::Core::Telemetry::Event::Base event) -> (Datadog::Core::Transport::HTTP::Adapters::Net::Response | Datadog::Core::Transport::InternalErrorResponse)
         def self.sequence: () -> Datadog::Core::Utils::Sequence
       end
     end

sig/datadog/core/telemetry/http/adapters/net.rbs

@@ -4,47 +4,6 @@ module Datadog
       module Http
         module Adapters
           class Net
-            type response = Datadog::Core::Telemetry::Http::Adapters::Net::Response | ::Datadog::Core::Telemetry::Http::InternalErrorResponse
-
-            attr_reader hostname: String
-
-            attr_reader port: Integer?
-
-            attr_reader timeout: Float | Integer
-
-            attr_reader ssl: bool
-
-            DEFAULT_TIMEOUT: 2
-
-            def initialize: (hostname: String, ?port: Integer?, ?timeout: Float | Integer, ?ssl: bool?) -> void
-
-            def open: () { (::Net::HTTP http) -> ::Net::HTTPResponse } -> untyped
-
-            def post: (untyped env) -> response
-
-            class Response
-              include Datadog::Core::Telemetry::Http::Response
-
-              attr_reader http_response: untyped
-
-              def initialize: (untyped http_response) -> void
-
-              def payload: () -> untyped
-
-              def code: () -> untyped
-
-              def ok?: () -> untyped
-
-              def unsupported?: () -> untyped
-
-              def not_found?: () -> untyped
-
-              def client_error?: () -> untyped
-
-              def server_error?: () -> untyped
-
-              def inspect: () -> ::String
-            end
           end
         end
       end