datadog 2.14.0 → 2.16.0

data/lib/datadog/core/remote/client.rb

@@ -140,6 +140,13 @@ module Datadog
             "ruby.gem.libdatadog.platform:#{gem_spec('libdatadog').platform}",
           ]
 
+          if (git_repository_url = Core::Environment::Git.git_repository_url)
+            client_tracer_tags << "git.repository_url:#{git_repository_url}"
+          end
+          if (git_commit_sha = Core::Environment::Git.git_commit_sha)
+            client_tracer_tags << "git.commit.sha:#{git_commit_sha}"
+          end
+
           client_tracer = {
             runtime_id: Core::Environment::Identity.id,
             language: Core::Environment::Identity.lang,

data/lib/datadog/core/runtime/metrics.rb

@@ -14,7 +14,7 @@ module Datadog
     module Runtime
       # For generating runtime metrics
       class Metrics < Core::Metrics::Client
-        def initialize(**options)
+        def initialize(telemetry:, **options)
           super
 
           # Initialize service list

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

@@ -2,12 +2,13 @@
 
 require_relative 'emitter'
 require_relative 'event'
-require_relative 'http/transport'
 require_relative 'metrics_manager'
 require_relative 'worker'
 require_relative 'logging'
+require_relative 'transport/http'
 
 require_relative '../configuration/ext'
+require_relative '../configuration/agentless_settings_resolver'
 require_relative '../utils/forking'
 
 module Datadog
@@ -16,7 +17,7 @@ module Datadog
       # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle.
       # Note: Telemetry does not spawn its worker thread in fork processes, thus no telemetry is sent in forked processes.
       class Component
-        attr_reader :enabled, :logger
+        attr_reader :enabled, :logger, :transport, :worker
 
         include Core::Utils::Forking
         include Telemetry::Logging
@@ -25,89 +26,87 @@ module Datadog
           enabled = settings.telemetry.enabled
           agentless_enabled = settings.telemetry.agentless_enabled
 
-          if !agentless_enabled && agent_settings.adapter != Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-            enabled = false
-            logger.debug { "Telemetry disabled. Agent network adapter not supported: #{agent_settings.adapter}" }
-          end
-
           if agentless_enabled && settings.api_key.nil?
             enabled = false
-            logger.debug { 'Telemetry disabled. Agentless telemetry requires an DD_API_KEY variable to be set.' }
+            logger.debug { 'Telemetry disabled. Agentless telemetry requires a DD_API_KEY variable to be set.' }
           end
 
-          transport = if agentless_enabled
-                        Datadog::Core::Telemetry::Http::Transport.build_agentless_transport(
-                          api_key: settings.api_key,
-                          dd_site: settings.site,
-                          url_override: settings.telemetry.agentless_url_override
-                        )
-                      else
-                        Datadog::Core::Telemetry::Http::Transport.build_agent_transport(agent_settings)
-                      end
-
           Telemetry::Component.new(
-            http_transport: transport,
+            settings: settings,
+            agent_settings: agent_settings,
             enabled: enabled,
-            metrics_enabled: enabled && settings.telemetry.metrics_enabled,
-            heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
-            metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
-            dependency_collection: settings.telemetry.dependency_collection,
             logger: logger,
-            shutdown_timeout_seconds: settings.telemetry.shutdown_timeout_seconds,
-            log_collection_enabled: settings.telemetry.log_collection_enabled
           )
         end
 
         # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
-        # @param metrics_enabled [Boolean] Determines whether telemetry metrics should be sent to the API
-        # @param heartbeat_interval_seconds [Float] How frequently heartbeats will be reported, in seconds.
-        # @param metrics_aggregation_interval_seconds [Float] How frequently metrics will be aggregated, in seconds.
-        # @param [Boolean] dependency_collection Whether to send the `app-dependencies-loaded` event
-        def initialize(
-          heartbeat_interval_seconds:,
-          metrics_aggregation_interval_seconds:,
-          dependency_collection:,
+        def initialize( # rubocop: disable Metrics/MethodLength
+          settings:,
+          agent_settings:,
           logger:,
-          http_transport:,
-          shutdown_timeout_seconds:,
-          enabled: true,
-          metrics_enabled: true,
-          log_collection_enabled: true
+          enabled:
         )
           @enabled = enabled
-          @log_collection_enabled = log_collection_enabled
+          @log_collection_enabled = settings.telemetry.log_collection_enabled
           @logger = logger
 
           @metrics_manager = MetricsManager.new(
-            enabled: enabled && metrics_enabled,
-            aggregation_interval: metrics_aggregation_interval_seconds
+            enabled: @enabled && settings.telemetry.metrics_enabled,
+            aggregation_interval: settings.telemetry.metrics_aggregation_interval_seconds,
           )
 
+          @stopped = false
+
+          return unless @enabled
+
+          @transport = if settings.telemetry.agentless_enabled
+                         agent_settings = Core::Configuration::AgentlessSettingsResolver.call(
+                           settings,
+                           host_prefix: 'instrumentation-telemetry-intake',
+                           url_override: settings.telemetry.agentless_url_override,
+                           url_override_source: 'c.telemetry.agentless_url_override',
+                           logger: logger,
+                         )
+                         Telemetry::Transport::HTTP.agentless_telemetry(
+                           agent_settings: agent_settings,
+                           logger: logger,
+                           # api_key should have already validated to be
+                           # not nil by +build+ method above.
+                           api_key: settings.api_key,
+                         )
+                       else
+                         Telemetry::Transport::HTTP.agent_telemetry(
+                           agent_settings: agent_settings, logger: logger,
+                         )
+                       end
+
           @worker = Telemetry::Worker.new(
             enabled: @enabled,
-            heartbeat_interval_seconds: heartbeat_interval_seconds,
-            metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
-            emitter: Emitter.new(http_transport: http_transport),
+            heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
+            metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
+            emitter: Emitter.new(
+              @transport,
+              logger: @logger,
+              debug: settings.telemetry.debug,
+            ),
             metrics_manager: @metrics_manager,
-            dependency_collection: dependency_collection,
+            dependency_collection: settings.telemetry.dependency_collection,
             logger: logger,
-            shutdown_timeout: shutdown_timeout_seconds
+            shutdown_timeout: settings.telemetry.shutdown_timeout_seconds,
           )
 
-          @stopped = false
-
           @worker.start
         end
 
         def disable!
           @enabled = false
-          @worker.enabled = false
+          @worker&.enabled = false
         end
 
         def stop!
           return if @stopped
 
-          @worker.stop(true)
+          @worker&.stop(true)
           @stopped = true
         end
 
@@ -129,6 +128,17 @@ module Datadog
           @worker.enqueue(event)
         end
 
+        # Wait for the worker to send out all events that have already
+        # been queued, up to 15 seconds. Returns whether all events have
+        # been flushed.
+        #
+        # @api private
+        def flush
+          return if !@enabled || forked?
+
+          @worker.flush
+        end
+
         # Report configuration changes caused by Remote Configuration.
         def client_configuration_change!(changes)
           return if !@enabled || forked?

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'request'
-require_relative 'http/transport'
+require_relative '../transport/response'
 require_relative '../utils/sequence'
 require_relative '../utils/forking'
 
@@ -10,26 +10,32 @@ module Datadog
     module Telemetry
       # Class that emits telemetry events
       class Emitter
-        attr_reader :http_transport
+        attr_reader :transport, :logger
 
         extend Core::Utils::Forking
 
-        # @param http_transport [Datadog::Core::Telemetry::Http::Transport] Transport object that can be used to send
-        #   telemetry requests via the agent
-        def initialize(http_transport:)
-          @http_transport = http_transport
+        # @param transport [Datadog::Core::Telemetry::Transport::Telemetry::Transport]
+        #   Transport object that can be used to send telemetry requests
+        def initialize(transport, logger: Datadog.logger, debug: false)
+          @transport = transport
+          @logger = logger
+          @debug = !!debug
+        end
+
+        def debug?
+          @debug
         end
 
         # Retrieves and emits a TelemetryRequest object based on the request type specified
         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})" }
+          payload = Request.build_payload(event, seq_id, debug: debug?)
+          res = @transport.send_telemetry(request_type: event.type, payload: payload)
+          logger.debug { "Telemetry sent for event `#{event.type}` (response code: #{res.code})" }
           res
         rescue => e
-          Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
-          Telemetry::Http::InternalErrorResponse.new(e)
+          logger.debug { "Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}" }
+          Core::Transport::InternalErrorResponse.new(e)
         end
 
         # Initializes a Sequence object to track seq_id if not already initialized; else returns stored

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

@@ -74,10 +74,9 @@ module Datadog
               profiler: {
                 enabled: Datadog::Profiling.enabled?,
               },
-              # DEV: Not implemented yet
-              # dynamic_instrumentation: {
-              #   enabled: true,
-              # }
+              dynamic_instrumentation: {
+                enabled: defined?(Datadog::DI) && Datadog::DI.respond_to?(:enabled?) && Datadog::DI.enabled?,
+              }
             }
 
             if (unsupported_reason = Datadog::Profiling.unsupported_reason)
@@ -91,6 +90,7 @@ module Datadog
           end
 
           TARGET_OPTIONS = %w[
+            dynamic_instrumentation.enabled
             logger.level
             profiling.advanced.code_provenance_enabled
             profiling.advanced.endpoint.collection.enabled
@@ -114,6 +114,9 @@ module Datadog
             seq_id = Event.configuration_sequence.next
 
             list = [
+              conf_value('DD_GIT_REPOSITORY_URL', Core::Environment::Git.git_repository_url, seq_id, 'env_var'),
+              conf_value('DD_GIT_COMMIT_SHA', Core::Environment::Git.git_commit_sha, seq_id, 'env_var'),
+
               conf_value('DD_AGENT_HOST', config.agent.host, seq_id),
               conf_value('DD_AGENT_TRANSPORT', agent_transport(config), seq_id),
               conf_value('DD_TRACE_SAMPLE_RATE', to_value(config.tracing.sampling.default_rate), seq_id),

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? || 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/metric.rb

@@ -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_version: 'v2', api_key:)
+                  {
+                    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