ddtrace 0.48.0 → 0.49.0

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -0,0 +1,241 @@
+require 'uri'
+
+require 'ddtrace/ext/transport'
+require 'ddtrace/configuration/settings'
+
+module Datadog
+  module Configuration
+    # This class unifies all the different ways that users can configure how we talk to the agent.
+    #
+    # It has quite a lot of complexity, but this complexity just reflects the actual complexity we have around our
+    # configuration today. E.g., this is just all of the complexity regarding agent settings gathered together in a
+    # single place. As we deprecate more and more of the different ways that these things can be configured,
+    # this class will reflect that simplification as well.
+    #
+    # Whenever there is a conflict (different configurations are provided in different orders), it MUST warn the users
+    # about it and pick a value based on the following priority: code > environment variable > defaults.
+    #
+    # rubocop:disable Metrics/ClassLength
+    class AgentSettingsResolver
+      AgentSettings = \
+        Struct.new(
+          :ssl,
+          :hostname,
+          :port,
+          :timeout_seconds,
+          :deprecated_for_removal_transport_configuration_proc,
+          :deprecated_for_removal_transport_configuration_options
+        ) do
+          def initialize(
+            # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
+            ssl: raise(ArgumentError, 'missing keyword :ssl'),
+            hostname: raise(ArgumentError, 'missing keyword :hostname'),
+            port: raise(ArgumentError, 'missing keyword :port'),
+            timeout_seconds: raise(ArgumentError, 'missing keyword :timeout_seconds'),
+            deprecated_for_removal_transport_configuration_proc: \
+              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_proc'),
+            deprecated_for_removal_transport_configuration_options: \
+              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_options')
+          )
+            super(ssl, hostname, port, timeout_seconds, deprecated_for_removal_transport_configuration_proc, \
+              deprecated_for_removal_transport_configuration_options)
+            freeze
+          end
+        end
+
+      def self.call(settings, logger: Datadog.logger)
+        new(settings, logger: logger).send(:call)
+      end
+
+      private
+
+      attr_reader \
+        :logger,
+        :settings
+
+      def initialize(settings, logger: Datadog.logger)
+        @settings = settings
+        @logger = logger
+      end
+
+      def call
+        AgentSettings.new(
+          ssl: ssl?,
+          hostname: hostname,
+          port: port,
+          timeout_seconds: timeout_seconds,
+          # NOTE: When provided, the deprecated_for_removal_transport_configuration_proc can override all
+          # values above (ssl, hostname, port, timeout), or even make them irrelevant (by using an unix socket or
+          # enabling test mode instead).
+          # That is the main reason why it is deprecated -- it's an opaque function that may set a bunch of settings
+          # that we know nothing of until we actually call it.
+          deprecated_for_removal_transport_configuration_proc: deprecated_for_removal_transport_configuration_proc,
+          deprecated_for_removal_transport_configuration_options: deprecated_for_removal_transport_configuration_options
+        )
+      end
+
+      def hostname
+        pick_from(
+          configurations_in_priority_order: [
+            DetectedConfiguration.new(
+              friendly_name: "'c.tracer.hostname'",
+              value: settings.tracer.hostname
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
+              value: parsed_url && parsed_url.hostname
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST} environment variable",
+              value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST]
+            )
+          ],
+          or_use_default: Datadog::Ext::Transport::HTTP::DEFAULT_HOST
+        )
+      end
+
+      def port
+        port_from_env = ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT]
+        parsed_port_from_env =
+          if port_from_env
+            begin
+              Integer(port_from_env)
+            rescue ArgumentError
+              log_warning(
+                "Invalid value for #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable " \
+                "('#{port_from_env}'). Ignoring this configuration."
+              )
+            end
+          end
+
+        pick_from(
+          configurations_in_priority_order: [
+            DetectedConfiguration.new(
+              friendly_name: '"c.tracer.port"',
+              value: settings.tracer.port
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
+              value: parsed_url && parsed_url.port
+            ),
+            DetectedConfiguration.new(
+              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
+              value: parsed_port_from_env
+            )
+          ],
+          or_use_default: Datadog::Ext::Transport::HTTP::DEFAULT_PORT
+        )
+      end
+
+      def ssl?
+        !parsed_url.nil? && parsed_url.scheme == 'https'
+      end
+
+      def timeout_seconds
+        Datadog::Ext::Transport::HTTP::DEFAULT_TIMEOUT_SECONDS
+      end
+
+      def deprecated_for_removal_transport_configuration_proc
+        settings.tracer.transport_options if settings.tracer.transport_options.is_a?(Proc)
+      end
+
+      def deprecated_for_removal_transport_configuration_options
+        options = settings.tracer.transport_options
+
+        if options.is_a?(Hash) && !options.empty?
+          log_warning(
+            'Configuring the tracer via a c.tracer.transport_options hash is deprecated for removal in a future ' \
+            "ddtrace version (c.tracer.transport_options contained '#{options.inspect}')."
+          )
+
+          options
+        end
+      end
+
+      def parsed_url
+        return @parsed_url if defined?(@parsed_url)
+
+        @parsed_url =
+          if unparsed_url_from_env
+            parsed = URI.parse(unparsed_url_from_env)
+
+            if %w[http https].include?(parsed.scheme)
+              parsed
+            else
+              log_warning(
+                "Invalid URI scheme '#{parsed.scheme}' for #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} " \
+                "environment variable ('#{unparsed_url_from_env}'). " \
+                "Ignoring the contents of #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL}."
+              )
+
+              nil
+            end
+          end
+      end
+
+      # NOTE: This should only be used AFTER parsing, via `#parsed_url`. The only other use-case where this can be used
+      # directly without parsing, is when displaying in warning messages, to show users what it actually contains.
+      def unparsed_url_from_env
+        @unparsed_url_from_env ||= ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL]
+      end
+
+      def pick_from(
+        # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
+        configurations_in_priority_order: raise(ArgumentError, 'missing keyword :configurations'),
+        or_use_default: raise(ArgumentError, 'missing keyword :or_use_default')
+      )
+        detected_configurations_in_priority_order = configurations_in_priority_order.select(&:value?)
+
+        if detected_configurations_in_priority_order.any?
+          warn_if_configuration_mismatch(detected_configurations_in_priority_order)
+
+          # The configurations are listed in priority, so we only need to look at the first; if there's more than
+          # one, we emit a warning above
+          detected_configurations_in_priority_order.first.value
+        else
+          or_use_default
+        end
+      end
+
+      def warn_if_configuration_mismatch(detected_configurations_in_priority_order)
+        return unless detected_configurations_in_priority_order.map(&:value).uniq.size > 1
+
+        log_warning(
+          'Configuration mismatch: values differ between ' \
+          "#{detected_configurations_in_priority_order
+            .map { |config| "#{config.friendly_name} ('#{config.value}')" }.join(' and ')}" \
+          ". Using '#{detected_configurations_in_priority_order.first.value}'."
+        )
+      end
+
+      def log_warning(message)
+        logger.warn(message) if logger
+      end
+
+      DetectedConfiguration = Struct.new(:friendly_name, :value) do
+        def initialize(
+          # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
+          friendly_name: raise(ArgumentError, 'missing keyword :friendly_name'),
+          value: raise(ArgumentError, 'missing keyword :value')
+        )
+          super(friendly_name, value)
+          freeze
+        end
+
+        def value?
+          !value.nil?
+        end
+      end
+      private_constant :DetectedConfiguration
+
+      # NOTE: Due to... legacy reasons... Some classes like having an `AgentSettings` instance to fall back to.
+      # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
+      # represents only settings specified via environment variables + the usual defaults.
+      #
+      # YOU DO NOT WANT TO USE THE BELOW INSTANCE ON ANY NEWLY WRITTEN CODE, as it ignores any settings specified
+      # by users via `Datadog.configure`.
+      ENVIRONMENT_AGENT_SETTINGS = call(Settings.new, logger: nil)
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ddtrace/configuration/components.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/configuration/agent_settings_resolver'
 require 'ddtrace/diagnostics/health'
 require 'ddtrace/logger'
 require 'ddtrace/profiling'
@@ -9,7 +10,6 @@ module Datadog
   module Configuration
     # Global components for the trace library.
     # rubocop:disable Layout/LineLength
-    # rubocop:disable Metrics/ClassLength
     class Components
       class << self
         def build_health_metrics(settings)
@@ -45,7 +45,7 @@ module Datadog
           Datadog::Workers::RuntimeMetrics.new(options)
         end
 
-        def build_tracer(settings)
+        def build_tracer(settings, agent_settings)
           # If a custom tracer has been provided, use it instead.
           # Ignore all other options (they should already be configured.)
           tracer = settings.tracer.instance
@@ -63,12 +63,12 @@ module Datadog
           #       tracer initialization for now. Just reconfigure using the
           #       existing mutable #configure function. Remove when these components
           #       are extracted.
-          tracer.configure(build_tracer_options(settings))
+          tracer.configure(agent_settings: agent_settings, **build_tracer_options(settings))
 
           tracer
         end
 
-        def build_profiler(settings)
+        def build_profiler(settings, agent_settings)
           return unless Datadog::Profiling.supported? && settings.profiling.enabled
 
           # Load extensions needed to support some of the Profiling features
@@ -78,7 +78,7 @@ module Datadog
 
           recorder = build_profiler_recorder(settings)
           collectors = build_profiler_collectors(settings, recorder)
-          exporters = build_profiler_exporters(settings)
+          exporters = build_profiler_exporters(settings, agent_settings)
           scheduler = build_profiler_scheduler(settings, recorder, exporters)
 
           Datadog::Profiler.new(collectors, scheduler)
@@ -97,13 +97,10 @@ module Datadog
           settings = settings.tracer
 
           {}.tap do |opts|
-            opts[:hostname] = settings.hostname unless settings.hostname.nil?
             opts[:min_spans_before_partial_flush] = settings.partial_flush.min_spans_threshold unless settings.partial_flush.min_spans_threshold.nil?
             opts[:partial_flush] = settings.partial_flush.enabled unless settings.partial_flush.enabled.nil?
-            opts[:port] = settings.port unless settings.port.nil?
             opts[:priority_sampling] = settings.priority_sampling unless settings.priority_sampling.nil?
             opts[:sampler] = settings.sampler unless settings.sampler.nil?
-            opts[:transport_options] = settings.transport_options
             opts[:writer] = settings.writer unless settings.writer.nil?
             opts[:writer_options] = settings.writer_options if settings.writer.nil?
           end
@@ -126,22 +123,16 @@ module Datadog
           ]
         end
 
-        def build_profiler_exporters(settings)
-          if settings.profiling.exporter.instances.is_a?(Array)
-            settings.profiling.exporter.instances
-          else
-            transport = if settings.profiling.exporter.transport
-                          settings.profiling.exporter.transport
-                        else
-                          transport_options = settings.profiling.exporter.transport_options.dup
-                          transport_options[:site] ||= settings.site if settings.site
-                          transport_options[:api_key] ||= settings.api_key if settings.api_key
-                          transport_options[:timeout] ||= settings.profiling.upload.timeout
-                          Datadog::Profiling::Transport::HTTP.default(transport_options)
-                        end
-
-            [Datadog::Profiling::Exporter.new(transport)]
-          end
+        def build_profiler_exporters(settings, agent_settings)
+          transport =
+            settings.profiling.exporter.transport || Datadog::Profiling::Transport::HTTP.default(
+              agent_settings: agent_settings,
+              site: settings.site,
+              api_key: settings.api_key,
+              profiling_upload_timeout_seconds: settings.profiling.upload.timeout_seconds
+            )
+
+          [Datadog::Profiling::Exporter.new(transport)]
         end
 
         def build_profiler_scheduler(settings, recorder, exporters)
@@ -160,11 +151,13 @@ module Datadog
         # Logger
         @logger = self.class.build_logger(settings)
 
+        agent_settings = AgentSettingsResolver.call(settings, logger: @logger)
+
         # Tracer
-        @tracer = self.class.build_tracer(settings)
+        @tracer = self.class.build_tracer(settings, agent_settings)
 
         # Profiler
-        @profiler = self.class.build_profiler(settings)
+        @profiler = self.class.build_profiler(settings, agent_settings)
 
         # Runtime metrics
         @runtime_metrics = self.class.build_runtime_metrics_worker(settings)
@@ -180,9 +173,9 @@ module Datadog
             @logger.debug('Profiling started')
             profiler.start
           else
-            # Display a warning for users who expected profiling to autostart
-            protobuf = Datadog::Profiling.google_protobuf_supported?
-            logger.warn("Profiling was enabled but is not supported; profiling disabled. (google-protobuf?: #{protobuf})")
+            # Display a warning for users who expected profiling to be enabled
+            unsupported_reason = Datadog::Profiling.unsupported_reason
+            logger.warn("Profiling was requested but is not supported, profiling disabled: #{unsupported_reason}")
           end
         else
           @logger.debug('Profiling is disabled')

data/lib/ddtrace/configuration/settings.rb

@@ -14,9 +14,6 @@ module Datadog
     class Settings
       include Base
 
-      #
-      # Configuration options
-      #
       settings :analytics do
         option :enabled do |o|
           o.default { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
@@ -116,9 +113,22 @@ module Datadog
         end
 
         settings :exporter do
-          option :instances
           option :transport
-          option :transport_options, default: ->(_o) { {} }, lazy: true
+          option :transport_options do |o|
+            o.setter do
+              # NOTE: As of April 2021 there may be a few profiler private beta customers with this setting, but since I'm
+              # marking this as deprecated before public beta, we can remove this for 1.0 without concern.
+              Datadog.logger.warn(
+                'Configuring the profiler c.profiling.exporter.transport_options is no longer needed, as the profiler ' \
+                'will reuse your existing global or tracer configuration. ' \
+                'This setting is deprecated for removal in a future ddtrace version ' \
+                '(1.0 or profiling GA, whichever comes first).'
+              )
+              nil
+            end
+            o.default { nil }
+            o.lazy
+          end
         end
 
         option :max_events, default: 32768
@@ -131,7 +141,7 @@ module Datadog
         end
 
         settings :upload do
-          option :timeout do |o|
+          option :timeout_seconds do |o|
             o.setter { |value| value.nil? ? 30.0 : value.to_f }
             o.default { env_to_float(Ext::Profiling::ENV_UPLOAD_TIMEOUT, 30.0) }
             o.lazy

data/lib/ddtrace/contrib/action_pack/action_controller/instrumentation.rb

@@ -61,7 +61,7 @@ module Datadog
                 # [christian] in some cases :status is not defined,
                 # rather than firing an error, simply acknowledge we don't know it.
                 status = payload.fetch(:status, '?').to_s
-                span.status = 1 if status.starts_with?('5')
+                span.status = 1 if status.start_with?('5')
               elsif Utils.exception_is_error?(exception)
                 span.set_error(exception)
               end

data/lib/ddtrace/contrib/action_pack/utils.rb

@@ -11,7 +11,7 @@ module Datadog
             # You can add custom errors via `config.action_dispatch.rescue_responses`
             status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
             # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
-            status.to_s.starts_with?('5')
+            status.to_s.start_with?('5')
           else
             true
           end

data/lib/ddtrace/contrib/auto_instrument.rb

@@ -19,7 +19,6 @@ module Datadog
           else
             AutoInstrument.patch_all
           end
-          AutoInstrument.patch_all
         end
       end
 

data/lib/ddtrace/contrib/sucker_punch/instrumentation.rb

@@ -10,6 +10,7 @@ module Datadog
         module_function
 
         # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
         def patch!
           # rubocop:disable Metrics/BlockLength
           ::SuckerPunch::Job::ClassMethods.class_eval do
@@ -34,6 +35,7 @@ module Datadog
             rescue => e
               ::SuckerPunch.__exception_handler.call(e, self, args)
             end
+            ruby2_keywords :__run_perform if respond_to?(:ruby2_keywords, true)
 
             alias_method :__perform_async, :perform_async
             def perform_async(*args)
@@ -46,6 +48,7 @@ module Datadog
                 __perform_async(*args)
               end
             end
+            ruby2_keywords :perform_async if respond_to?(:ruby2_keywords, true)
 
             alias_method :__perform_in, :perform_in
             def perform_in(interval, *args)
@@ -59,6 +62,7 @@ module Datadog
                 __perform_in(interval, *args)
               end
             end
+            ruby2_keywords :perform_in if respond_to?(:ruby2_keywords, true)
 
             private