datadog 2.12.1 → 2.19.0

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/agent_settings_resolver'
+require_relative '../../configuration/agent_settings'
 require_relative 'adapters/registry'
 require_relative 'api/map'
 
@@ -18,9 +18,10 @@ module Datadog
             :api_options,
             :default_adapter,
             :default_api,
-            :default_headers
+            :default_headers,
+            :logger
 
-          def initialize(api_instance_class:)
+          def initialize(api_instance_class:, logger: Datadog.logger)
             # Global settings
             @default_adapter = nil
             @default_headers = {}
@@ -33,25 +34,26 @@ module Datadog
             @api_options = {}
 
             @api_instance_class = api_instance_class
+            @logger = logger
 
             yield(self) if block_given?
           end
 
           def adapter(config, *args, **kwargs)
             @default_adapter = case config
-                               when Core::Configuration::AgentSettingsResolver::AgentSettings
-                                 registry_klass = REGISTRY.get(config.adapter)
-                                 raise UnknownAdapterError, config.adapter if registry_klass.nil?
-
-                                 registry_klass.build(config)
-                               when Symbol
-                                 registry_klass = REGISTRY.get(config)
-                                 raise UnknownAdapterError, config if registry_klass.nil?
-
-                                 registry_klass.new(*args, **kwargs)
-                               else
-                                 config
-                               end
+            when Core::Configuration::AgentSettings
+              registry_klass = REGISTRY.get(config.adapter)
+              raise UnknownAdapterError, config.adapter if registry_klass.nil?
+
+              registry_klass.build(config)
+            when Symbol
+              registry_klass = REGISTRY.get(config)
+              raise UnknownAdapterError, config if registry_klass.nil?
+
+              registry_klass.new(*args, **kwargs)
+            else
+              config
+            end
           end
 
           def headers(values = {})
@@ -86,7 +88,7 @@ module Datadog
           def to_transport(klass)
             raise NoDefaultApiError if @default_api.nil?
 
-            klass.new(to_api_instances, @default_api)
+            klass.new(to_api_instances, @default_api, logger: logger)
           end
 
           def to_api_instances

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

@@ -32,6 +32,14 @@ module Datadog
             self[:path] = value
           end
 
+          def query
+            self[:query]
+          end
+
+          def query=(value)
+            self[:query] = value
+          end
+
           def body
             self[:body]
           end

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

@@ -29,8 +29,45 @@ module Datadog
         # Helper function that delegates to Builder.new
         # but is under HTTP namespace so that client code requires this file
         # to get the adapters configured, and not the builder directly.
-        def build(api_instance_class:, &block)
-          Builder.new(api_instance_class: api_instance_class, &block)
+        def build(api_instance_class:, agent_settings:, logger: Datadog.logger, api_version: nil, headers: nil, &block)
+          Builder.new(api_instance_class: api_instance_class, logger: logger) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers(default_headers)
+
+            # The caller must define APIs before we set the default API.
+            yield transport
+
+            # Apply any settings given by options
+            transport.default_api = api_version if api_version
+            transport.headers(headers) if headers
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG =>
+              Datadog::Core::Environment::Ext::LANG,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION =>
+              Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR =>
+              Core::Environment::Ext::LANG_ENGINE,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
+              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            if (container_id = Datadog::Core::Environment::Container.container_id)
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id
+            end
+            # TODO: inject configuration rather than reading from global here
+            unless Datadog.configuration.apm.tracing.enabled
+              # Sending this header to the agent will disable metrics computation (and billing) on the agent side
+              # by pretending it has already been done on the library side.
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+            end
+          end
         end
       end
     end

data/lib/datadog/core/utils/at_fork_monkey_patch.rb

@@ -51,13 +51,13 @@ module Datadog
           def fork
             # If a block is provided, it must be wrapped to trigger callbacks.
             child_block = if block_given?
-                            proc do
-                              AtForkMonkeyPatch.run_at_fork_blocks(:child)
+              proc do
+                AtForkMonkeyPatch.run_at_fork_blocks(:child)
 
-                              # Invoke original block
-                              yield
-                            end
-                          end
+                # Invoke original block
+                yield
+              end
+            end
 
             # Start fork
             # If a block is provided, use the wrapped version.

data/lib/datadog/core/utils/duration.rb

@@ -7,42 +7,42 @@ module Datadog
       module Duration
         def self.call(value, base: :s)
           cast = if value.include?('.')
-                   method(:Float)
-                 else
-                   method(:Integer)
-                 end
+            method(:Float)
+          else
+            method(:Integer)
+          end
 
           scale = case base
-                  when :s
-                    1_000_000_000
-                  when :ms
-                    1_000_000
-                  when :us
-                    1000
-                  when :ns
-                    1
-                  else
-                    raise ArgumentError, "invalid base: #{base.inspect}"
-                  end
+          when :s
+            1_000_000_000
+          when :ms
+            1_000_000
+          when :us
+            1000
+          when :ns
+            1
+          else
+            raise ArgumentError, "invalid base: #{base.inspect}"
+          end
 
           result = case value
-                   when /^(\d+(?:\.\d+)?)h$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 * 60 / scale
-                   when /^(\d+(?:\.\d+)?)m$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 / scale
-                   when /^(\d+(?:\.\d+)?)s$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000_000 / scale
-                   when /^(\d+(?:\.\d+)?)ms$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000 / scale
-                   when /^(\d+(?:\.\d+)?)us$/
-                     cast.call(Regexp.last_match(1)) * 1_000 / scale
-                   when /^(\d+(?:\.\d+)?)ns$/
-                     cast.call(Regexp.last_match(1)) / scale
-                   when /^(\d+(?:\.\d+)?)$/
-                     cast.call(Regexp.last_match(1))
-                   else
-                     raise ArgumentError, "invalid duration: #{value.inspect}"
-                   end
+          when /^(\d+(?:\.\d+)?)h$/
+            cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 * 60 / scale
+          when /^(\d+(?:\.\d+)?)m$/
+            cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 / scale
+          when /^(\d+(?:\.\d+)?)s$/
+            cast.call(Regexp.last_match(1)) * 1_000_000_000 / scale
+          when /^(\d+(?:\.\d+)?)ms$/
+            cast.call(Regexp.last_match(1)) * 1_000_000 / scale
+          when /^(\d+(?:\.\d+)?)us$/
+            cast.call(Regexp.last_match(1)) * 1_000 / scale
+          when /^(\d+(?:\.\d+)?)ns$/
+            cast.call(Regexp.last_match(1)) / scale
+          when /^(\d+(?:\.\d+)?)$/
+            cast.call(Regexp.last_match(1))
+          else
+            raise ArgumentError, "invalid duration: #{value.inspect}"
+          end
           # @type var result: Numeric
           result.round
         end

data/lib/datadog/core/utils/forking.rb

@@ -47,12 +47,12 @@ module Datadog
           # This wrapper prevents this by initializing the fork PID when the object is created.
           if RUBY_VERSION >= '3'
             def initialize(*args, **kwargs, &block)
-              super(*args, **kwargs, &block)
+              super
               update_fork_pid!
             end
           else
             def initialize(*args, &block)
-              super(*args, &block)
+              super
               update_fork_pid!
             end
           end

data/lib/datadog/core/utils/network.rb

@@ -32,7 +32,7 @@ module Datadog
           def stripped_ip_from_request_headers(headers, ip_headers_to_check: DEFAULT_IP_HEADERS_NAMES)
             ip = ip_header(headers, ip_headers_to_check)
 
-            ip ? ip.to_s : nil
+            ip&.to_s
           end
 
           # @param [String] IP value.
@@ -40,7 +40,7 @@ module Datadog
           # @return [nil] when no valid IP value found.
           def stripped_ip(ip)
             ip = ip_to_ipaddr(ip)
-            ip ? ip.to_s : nil
+            ip&.to_s
           end
 
           private
@@ -52,10 +52,10 @@ module Datadog
             return unless ip
 
             clean_ip = if likely_ipv4?(ip)
-                         strip_ipv4_port(ip)
-                       else
-                         strip_zone_specifier(strip_ipv6_port(ip))
-                       end
+              strip_ipv4_port(ip)
+            else
+              strip_zone_specifier(strip_ipv6_port(ip))
+            end
 
             begin
               IPAddr.new(clean_ip)

data/lib/datadog/core/utils/only_once_successful.rb

@@ -5,14 +5,25 @@ require_relative 'only_once'
 module Datadog
   module Core
     module Utils
-      # Helper class to execute something with only one success.
+      # Helper class to execute something with only one successful execution.
       #
-      # This is useful for cases where we want to ensure that a block of code is only executed once, and only if it
-      # succeeds. One such example is sending app-started telemetry event.
+      # If limit is not provided to the constructor, +run+ will execute the
+      # block an unlimited number of times until the block indicates that it
+      # executed successfully by returning a truthy value. After a block
+      # executes successfully, subsequent +run+ calls will not invoke the
+      # block.
       #
-      # Successful execution is determined by the return value of the block: any truthy value is considered success.
+      # If a non-zero limit is provided to the constructor, +run+ will
+      # execute the block up to that many times, and will mark the instance
+      # of OnlyOneSuccessful as failed if none of the executions succeeded.
       #
-      # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class).
+      # One consumer of this class is sending the app-started telemetry event.
+      #
+      # Successful execution is determined by the return value of the block:
+      # any truthy value is considered success.
+      #
+      # This class is thread-safe (however, instances of it must also be
+      # created in a thread-safe manner).
       #
       # Note: In its current state, this class is not Ractor-safe.
       # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,

data/lib/datadog/core/utils/time.rb

@@ -31,6 +31,16 @@ module Datadog
         #
         # @param block [Proc] block that returns a `Time` object representing the current wall time
         def now_provider=(block)
+          class << self
+            # Avoid method redefinition warning.
+            # `rescue nil` is added in case customers remove the method
+            # themselves to squelch the warning.
+            begin
+              remove_method(:now)
+            rescue
+              nil
+            end
+          end
           define_singleton_method(:now, &block)
         end
 
@@ -43,6 +53,16 @@ module Datadog
         #
         # @param block [Proc] block that accepts unit and returns timestamp in the requested unit
         def get_time_provider=(block)
+          class << self
+            # Avoid method redefinition warning
+            # `rescue nil` is added in case customers remove the method
+            # themselves to squelch the warning.
+            begin
+              remove_method(:get_time)
+            rescue
+              nil
+            end
+          end
           define_singleton_method(:get_time, &block)
         end
 

data/lib/datadog/core/utils/truncation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for truncating data
+      module Truncation
+        module_function
+
+        def truncate_in_middle(string, max_prefix_length, max_suffix_length)
+          max_length = max_prefix_length + 3 + max_suffix_length
+          if string.length > max_length
+            "#{string[0...max_prefix_length]}...#{string[-max_suffix_length..-1]}"
+          else
+            string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils.rb

@@ -66,6 +66,13 @@ module Datadog
         placeholder
       end
 
+      def self.encode_tags(hash)
+        # Make sure everything is an utf-8 string, to avoid encoding issues in downstream
+        hash.each_with_object({}) do |(key, value), h|
+          h[utf8_encode(key)] = utf8_encode(value)
+        end
+      end
+
       # @!visibility private
       def self.without_warnings
         # This is typically used when monkey patching functions such as

data/lib/datadog/core/vendor/multipart-post/multipart/post/composite_read_io.rb

@@ -108,7 +108,7 @@ module Datadog
             end
 
             def respond_to?(meth, include_all = false)
-              @io.respond_to?(meth, include_all) || super(meth, include_all)
+              @io.respond_to?(meth, include_all) || super
             end
           end
         end

data/lib/datadog/core/vendor/multipart-post/multipart/post/multipartable.rb

@@ -28,29 +28,29 @@ module Datadog
               "--#{SecureRandom.uuid}"
             end
 
-            def initialize(path, params, headers={}, boundary = Multipartable.secure_boundary)
+            def initialize(path, params, headers = {}, boundary = Multipartable.secure_boundary)
               headers = headers.clone # don't want to modify the original variable
               parts_headers = headers.delete(:parts) || {}
               super(path, headers)
-              parts = params.map do |k,v|
+              parts = params.map do |k, v|
                 case v
                 when Array
-                  v.map {|item| Parts::Part.new(boundary, "#{k}[]", item, parts_headers[k]) }
+                  v.map { |item| Parts::Part.new(boundary, "#{k}[]", item, parts_headers[k]) }
                 else
                   Parts::Part.new(boundary, k, v, parts_headers[k])
                 end
               end.flatten
               parts << Parts::EpiloguePart.new(boundary)
-              ios = parts.map {|p| p.to_io }
-              self.set_content_type(headers["Content-Type"] || "multipart/form-data",
-                                    { "boundary" => boundary })
-              self.content_length = parts.inject(0) {|sum,i| sum + i.length }
+              ios = parts.map { |p| p.to_io }
+              set_content_type(headers["Content-Type"] || "multipart/form-data",
+                {"boundary" => boundary})
+              self.content_length = parts.inject(0) { |sum, i| sum + i.length }
               self.body_stream = CompositeReadIO.new(*ios)
 
               @boundary = boundary
             end
 
-            attr :boundary
+            attr_reader :boundary
           end
         end
       end

data/lib/datadog/core/vendor/multipart-post/multipart/post/parts.rb

@@ -58,7 +58,7 @@ module Datadog
                 part = ''
                 part << "--#{boundary}\r\n"
                 part << "Content-ID: #{headers["Content-ID"]}\r\n" if headers["Content-ID"]
-                part << "Content-Disposition: form-data; name=\"#{name.to_s}\"\r\n"
+                part << "Content-Disposition: form-data; name=\"#{name}\"\r\n"
                 part << "Content-Type: #{headers["Content-Type"]}\r\n" if headers["Content-Type"]
                 part << "\r\n"
                 part << "#{value}\r\n"
@@ -76,9 +76,9 @@ module Datadog
               # @param io [IO]
               # @param headers [Hash]
               def initialize(boundary, name, io, headers = {})
-                file_length = io.respond_to?(:length) ?  io.length : File.size(io.local_path)
+                file_length = io.respond_to?(:length) ? io.length : File.size(io.local_path)
                 @head = build_head(boundary, name, io.original_filename, io.content_type, file_length,
-                                  io.respond_to?(:opts) ? io.opts.merge(headers) : headers)
+                  io.respond_to?(:opts) ? io.opts.merge(headers) : headers)
                 @foot = "\r\n"
                 @length = @head.bytesize + file_length + @foot.length
                 @io = CompositeReadIO.new(StringIO.new(@head), io, StringIO.new(@foot))
@@ -98,16 +98,16 @@ module Datadog
 
                 part = ''
                 part << "--#{boundary}\r\n"
-                part << "Content-Disposition: #{content_disposition}; name=\"#{name.to_s}\"; filename=\"#{filename}\"\r\n"
+                part << "Content-Disposition: #{content_disposition}; name=\"#{name}\"; filename=\"#{filename}\"\r\n"
                 part << "Content-Length: #{content_len}\r\n"
                 if content_id = opts.delete("Content-ID")
                   part << "Content-ID: #{content_id}\r\n"
                 end
 
-                if opts["Content-Type"] != nil
-                  part <<  "Content-Type: " + opts["Content-Type"] + "\r\n"
+                part << if !opts["Content-Type"].nil?
+                  "Content-Type: " + opts["Content-Type"] + "\r\n"
                 else
-                  part << "Content-Type: #{type}\r\n"
+                  "Content-Type: #{type}\r\n"
                 end
 
                 part << "Content-Transfer-Encoding: #{trans_encoding}\r\n"

data/lib/datadog/core/worker.rb

@@ -12,7 +12,7 @@ module Datadog
       end
 
       def perform(*args)
-        task.call(*args) unless task.nil?
+        task&.call(*args)
       end
 
       protected

data/lib/datadog/core/workers/async.rb

@@ -47,6 +47,14 @@ module Datadog
             @run_async = false
             Datadog.logger.debug { "Forcibly terminating worker thread for: #{self}" }
             worker.terminate
+            # Wait for the worker thread to end
+            begin
+              Timeout.timeout(SHUTDOWN_TIMEOUT) do
+                worker.join
+              end
+            rescue Timeout::Error
+              Datadog.logger.debug { "Worker thread did not end after #{SHUTDOWN_TIMEOUT} seconds: #{self}" }
+            end
             true
           end
 
@@ -112,23 +120,33 @@ module Datadog
             @worker ||= nil
           end
 
+          # Returns true if worker thread is successfully started,
+          # false if it is not started. Reasons for not starting the worker
+          # thread: it is already running, or the process forked and fork
+          # policy is to stop the workers on fork (which means they are
+          # not started in children, really).
           def start_async(&block)
             mutex.synchronize do
-              return if running?
+              return false if running?
 
               if forked?
                 case fork_policy
                 when FORK_POLICY_STOP
                   stop_fork
+                  false
                 when FORK_POLICY_RESTART
+                  # restart_after_fork should return true
                   restart_after_fork(&block)
                 end
               elsif !run_async?
+                # start_worker should return true
                 start_worker(&block)
               end
             end
           end
 
+          # Returns true if worker thread is successfully started,
+          # which should generally be always.
           def start_worker
             @run_async = true
             @pid = Process.pid
@@ -136,22 +154,21 @@ module Datadog
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
             @worker = ::Thread.new do
-              begin
-                yield
-              # rubocop:disable Lint/RescueException
-              rescue Exception => e
-                @error = e
-                Datadog.logger.debug(
-                  "Worker thread error. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-                )
-                raise
-              end
+              yield
+            # rubocop:disable Lint/RescueException
+            rescue Exception => e
+              @error = e
+              Datadog.logger.debug(
+                "Worker thread error. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+              )
+              raise
+
               # rubocop:enable Lint/RescueException
             end
             @worker.name = self.class.name
             @worker.thread_variable_set(:fork_safe, true)
 
-            nil
+            true
           end
 
           def stop_fork

data/lib/datadog/core/workers/interval_loop.rb

@@ -21,7 +21,18 @@ module Datadog
         # Methods that must be prepended
         module PrependedMethods
           def perform(*args)
-            perform_loop { super(*args) }
+            perform_loop do
+              @in_iteration = true
+              begin
+                super(*args)
+              ensure
+                @in_iteration = false
+              end
+            end
+          end
+
+          def in_iteration?
+            defined?(@in_iteration) && @in_iteration
           end
         end
 

data/lib/datadog/core/workers/runtime_metrics.rb

@@ -20,8 +20,8 @@ module Datadog
         attr_reader \
           :metrics
 
-        def initialize(options = {})
-          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new(logger: options[:logger]) }
+        def initialize(telemetry:, **options)
+          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new(logger: options[:logger], telemetry: telemetry) }
 
           # Workers::Async::Thread settings
           self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)

data/lib/datadog/core.rb

@@ -11,6 +11,14 @@ module Datadog
   # for higher-level features.
   module Core
     extend Core::Deprecations
+
+    LIBDATADOG_API_FAILURE =
+      begin
+        require "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}"
+        nil
+      rescue LoadError => e
+        e.message
+      end
   end
 
   extend Core::Extensions

data/lib/datadog/di/boot.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+require_relative 'base'
+require_relative 'error'
+require_relative 'code_tracker'
+require_relative 'component'
+require_relative 'instrumenter'
+require_relative 'probe'
+require_relative 'probe_builder'
+require_relative 'probe_manager'
+require_relative 'probe_notification_builder'
+require_relative 'probe_notifier_worker'
+require_relative 'redactor'
+require_relative 'serializer'
+require_relative 'transport/http'
+require_relative 'utils'
+
+if %w[1 true yes].include?(ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED']) # steep:ignore
+  # For initial release of Dynamic Instrumentation, activate code tracking
+  # only if DI is explicitly requested in the environment.
+  # Code tracking is required for line probes to work; see the comments
+  # above for the implementation of the method.
+  #
+  # If DI is enabled programmatically, the application can (and must,
+  # for line probes to work) activate tracking in an initializer.
+  # We seem to have Datadog.logger here already
+  Datadog.logger.debug("di: activating code tracking")
+  Datadog::DI.activate_tracking
+end
+
+require_relative 'contrib'
+
+Datadog::DI::Contrib.load_now_or_later

data/lib/datadog/di/component.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../core'
-
 module Datadog
   module DI
     # Component for dynamic instrumentation.