datadog 2.12.1 → 2.17.0

data/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? ? true : 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

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

@@ -35,7 +35,7 @@ module Datadog
             # The downside is: this leaves us unable to report telemetry during component initialization.
             components = Datadog.send(:components, allow_initialization: false)
 
-            if components && components.telemetry
+            if components&.telemetry
               components.telemetry
             else
               Datadog.logger.warn(

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

@@ -20,7 +20,7 @@ module Datadog
           end
 
           def id
-            @id ||= "#{type}::#{name}::#{tags.join(',')}"
+            @id ||= "#{type}::#{name}::#{tags.join(",")}"
           end
 
           def track(value)
@@ -47,7 +47,7 @@ module Datadog
               values == other.values && tags == other.tags && common == other.common && type == other.type
           end
 
-          alias eql? ==
+          alias_method :eql?, :==
 
           def hash
             [self.class, name, values, tags, common, type].hash
@@ -88,7 +88,7 @@ module Datadog
             super && interval == other.interval
           end
 
-          alias eql? ==
+          alias_method :eql?, :==
 
           def hash
             [super, interval].hash
@@ -108,9 +108,9 @@ module Datadog
             value = value.to_i
 
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] += value
             end
             nil
@@ -129,9 +129,9 @@ module Datadog
 
           def track(value)
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] = value
             end
             nil
@@ -155,7 +155,7 @@ module Datadog
 
           def track(value = 1.0)
             @value += value
-            @values = [[Time.now.to_i, @value / interval]]
+            @values = [[Core::Utils::Time.now.to_i, @value / interval]]
             nil
           end
         end

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

@@ -11,17 +11,17 @@ module Datadog
         class << self
           using Core::Utils::Hash::Refinement
 
-          def build_payload(event, seq_id)
+          def build_payload(event, seq_id, api_version: 'v2', debug: false)
             hash = {
-              api_version: Http::Ext::API_VERSION,
+              api_version: api_version,
               application: application,
-              debug: false,
+              debug: debug,
               host: host,
               payload: event.payload,
               request_type: event.type,
               runtime_id: Core::Environment::Identity.id,
               seq_id: seq_id,
-              tracer_time: Time.now.to_i,
+              tracer_time: Core::Utils::Time.now.to_i,
             }
             hash.compact!
             hash

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../../encoding'
+require_relative '../../../transport/http/api/map'
+require_relative '../../../transport/http/api/instance'
+require_relative '../../../transport/http/api/spec'
+require_relative 'telemetry'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module HTTP
+          # Namespace for API components
+          module API
+            # Default API versions
+            AGENT_TELEMETRY = 'agent_telemetry'
+            AGENTLESS_TELEMETRY = 'agentless_telemetry'
+
+            module_function
+
+            def defaults
+              Datadog::Core::Transport::HTTP::API::Map[
+                AGENT_TELEMETRY => Telemetry::API::Spec.new do |s|
+                  s.telemetry = Telemetry::API::Endpoint.new(
+                    '/telemetry/proxy/api/v2/apmtelemetry',
+                    Core::Encoding::JSONEncoder,
+                  )
+                end,
+                AGENTLESS_TELEMETRY => Telemetry::API::Spec.new do |s|
+                  s.telemetry = Telemetry::API::Endpoint.new(
+                    '/api/v2/apmtelemetry',
+                    Core::Encoding::JSONEncoder,
+                  )
+                end,
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../../transport/http/env'
+require_relative '../../../transport/http/response'
+
+# TODO: Decouple transport/http/client
+#
+# The standard one does `include Transport::HTTP::Statistics` and performs
+# stats updates, which may or may not be desirable in general.
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module HTTP
+          # Routes, encodes, and sends DI data to the trace agent via HTTP.
+          class Client
+            attr_reader :api, :logger
+
+            def initialize(api, logger:)
+              @api = api
+              @logger = logger
+            end
+
+            def send_request(request, &block)
+              # Build request into env
+              env = build_env(request)
+
+              # Get responses from API
+              yield(api, env)
+            rescue => e
+              message =
+                "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
+                  "Location: #{Array(e.backtrace).first}"
+
+              logger.debug(message)
+
+              Datadog::Core::Transport::InternalErrorResponse.new(e)
+            end
+
+            def build_env(request)
+              Datadog::Core::Transport::HTTP::Env.new(request)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../../../transport/http/api/endpoint'
+require_relative '../../../transport/http/api/instance'
+require_relative '../../../transport/http/api/spec'
+require_relative '../../../transport/request'
+require_relative 'client'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module HTTP
+          module Telemetry
+            module Client
+              def send_telemetry_payload(request)
+                send_request(request) do |api, env| # steep:ignore
+                  api.send_telemetry(env)
+                end
+              end
+            end
+
+            module API
+              class Instance < Core::Transport::HTTP::API::Instance
+                def send_telemetry(env)
+                  raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('telemetry', self) unless spec.is_a?(Telemetry::API::Spec)
+
+                  spec.send_telemetry(env) do |request_env|
+                    call(request_env)
+                  end
+                end
+              end
+
+              class Spec < Core::Transport::HTTP::API::Spec
+                attr_accessor :telemetry
+
+                def send_telemetry(env, &block)
+                  raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('telemetry', self) if telemetry.nil?
+
+                  telemetry.call(env, &block)
+                end
+              end
+
+              class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+                HEADER_CONTENT_TYPE = 'Content-Type'
+
+                attr_reader \
+                  :encoder
+
+                def initialize(path, encoder)
+                  super(:post, path)
+                  @encoder = encoder
+                end
+
+                def call(env, &block)
+                  # Encode body & type
+                  env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                  env.headers.update(headers(
+                    request_type: env.request.request_type,
+                    api_key: env.request.api_key,
+                  ))
+                  env.body = env.request.parcel.data
+
+                  super
+                end
+
+                def headers(request_type:, api_key:, api_version: 'v2')
+                  {
+                    Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
+                    # Provided by encoder
+                    # 'Content-Type' => 'application/json',
+                    'DD-Telemetry-API-Version' => api_version,
+                    'DD-Telemetry-Request-Type' => request_type,
+                    'DD-Client-Library-Language' => Core::Environment::Ext::LANG,
+                    'DD-Client-Library-Version' => Core::Environment::Identity.gem_datadog_version_semver2,
+
+                    # Enable debug mode for telemetry
+                    # 'DD-Telemetry-Debug-Enabled' => 'true',
+                  }.tap do |result|
+                    result['DD-API-KEY'] = api_key unless api_key.nil?
+                  end
+                end
+              end
+            end
+          end
+
+          HTTP::Client.include(Telemetry::Client)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'telemetry'
+require_relative 'http/api'
+require_relative '../../transport/http'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        # Namespace for HTTP transport components
+        module HTTP
+          module_function
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def agentless_telemetry(
+            agent_settings:,
+            logger:,
+            api_key: nil,
+            api_version: nil,
+            headers: nil
+          )
+            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+              logger: logger,
+              agent_settings: agent_settings,
+              api_version: api_version,
+              headers: headers) do |transport|
+              apis = API.defaults
+
+              transport.api API::AGENTLESS_TELEMETRY, apis[API::AGENTLESS_TELEMETRY]
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end.to_transport(Core::Telemetry::Transport::Telemetry::Transport).tap do |transport|
+              transport.api_key = api_key
+            end
+          end
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def agent_telemetry(
+            agent_settings:,
+            logger:,
+            api_version: nil,
+            headers: nil
+          )
+            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+              logger: logger,
+              agent_settings: agent_settings, api_version: api_version, headers: headers) do |transport|
+              apis = API.defaults
+
+              transport.api API::AGENT_TELEMETRY, apis[API::AGENT_TELEMETRY]
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end.to_transport(Core::Telemetry::Transport::Telemetry::Transport)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../transport/parcel'
+require_relative 'http/client'
+require_relative 'http/telemetry'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module Telemetry
+          class EncodedParcel
+            include Datadog::Core::Transport::Parcel
+          end
+
+          class Request < Datadog::Core::Transport::Request
+            attr_reader :request_type
+            attr_reader :api_key
+
+            def initialize(request_type, parcel, api_key)
+              @request_type = request_type
+              super(parcel)
+              @api_key = api_key
+            end
+          end
+
+          class Transport
+            attr_reader :client, :apis, :default_api, :current_api_id, :logger
+            attr_accessor :api_key
+
+            def initialize(apis, default_api, logger:)
+              @apis = apis
+              @logger = logger
+
+              @client = HTTP::Client.new(@apis[default_api], logger: logger)
+            end
+
+            def send_telemetry(request_type:, payload:)
+              json = JSON.dump(payload)
+              parcel = EncodedParcel.new(json)
+              request = Request.new(request_type, parcel, api_key)
+
+              @client.send_telemetry_payload(request)
+              # Perform no error checking here
+            end
+          end
+        end
+      end
+    end
+  end
+end