ddtrace 0.54.0 → 1.1.0

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -1,309 +0,0 @@
-# typed: false
-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(
-          :adapter,
-          :ssl,
-          :hostname,
-          :port,
-          :uds_path,
-          :timeout_seconds,
-          :deprecated_for_removal_transport_configuration_proc,
-          :deprecated_for_removal_transport_configuration_options
-        ) do
-          def initialize(
-            adapter:,
-            ssl:,
-            hostname:,
-            port:,
-            uds_path:,
-            timeout_seconds:,
-            deprecated_for_removal_transport_configuration_proc:,
-            deprecated_for_removal_transport_configuration_options:
-          )
-            super(
-              adapter,
-              ssl,
-              hostname,
-              port,
-              uds_path,
-              timeout_seconds,
-              deprecated_for_removal_transport_configuration_proc,
-              deprecated_for_removal_transport_configuration_options,
-            )
-            freeze
-          end
-
-          # Returns a frozen copy of this struct
-          # with the provided +member_values+ modified.
-          def merge(**member_values)
-            new_struct = dup
-
-            member_values.each do |member, value|
-              new_struct[member] = value
-            end
-
-            new_struct.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(
-          adapter: adapter,
-          ssl: ssl?,
-          hostname: hostname,
-          port: port,
-          uds_path: uds_path,
-          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 adapter
-        # If no agent settings have been provided, we try to connect using a local unix socket.
-        # We only do so if the socket is present when `ddtrace` runs.
-        if should_use_uds_fallback?
-          Ext::Transport::UnixSocket::ADAPTER
-        else
-          Ext::Transport::HTTP::ADAPTER
-        end
-      end
-
-      def configured_hostname
-        return @configured_hostname if defined?(@configured_hostname)
-
-        @configured_hostname = pick_from(
-          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]
-          )
-        )
-      end
-
-      def configured_port
-        return @configured_port if defined?(@configured_port)
-
-        parsed_port_from_env =
-          try_parsing_as_integer(
-            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
-            value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT],
-          )
-
-        parsed_settings_tracer_port =
-          try_parsing_as_integer(
-            friendly_name: '"c.tracer.port"',
-            value: settings.tracer.port,
-          )
-
-        @configured_port = pick_from(
-          DetectedConfiguration.new(
-            friendly_name: '"c.tracer.port"',
-            value: parsed_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,
-          )
-        )
-      end
-
-      def try_parsing_as_integer(value:, friendly_name:)
-        return unless value
-
-        begin
-          Integer(value)
-        rescue ArgumentError, TypeError
-          log_warning("Invalid value for #{friendly_name} (#{value.inspect}). Ignoring this configuration.")
-
-          nil
-        end
-      end
-
-      def ssl?
-        !parsed_url.nil? && parsed_url.scheme == 'https'
-      end
-
-      def hostname
-        configured_hostname || (should_use_uds_fallback? ? nil : Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
-      end
-
-      def port
-        configured_port || (should_use_uds_fallback? ? nil : Datadog::Ext::Transport::HTTP::DEFAULT_PORT)
-      end
-
-      # Unix socket path in the file system
-      def uds_path
-        uds_fallback
-      end
-
-      # Defaults to +nil+, letting the adapter choose what default
-      # works best in their case.
-      def timeout_seconds
-        nil
-      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
-
-      # We only use the default unix socket if it is already present.
-      # This is by design, as we still want to use the default host:port if no unix socket is present.
-      def uds_fallback
-        return @uds_fallback if defined?(@uds_fallback)
-
-        @uds_fallback =
-          if configured_hostname.nil? &&
-             configured_port.nil? &&
-             deprecated_for_removal_transport_configuration_proc.nil? &&
-             deprecated_for_removal_transport_configuration_options.nil? &&
-             File.exist?(Ext::Transport::UnixSocket::DEFAULT_PATH)
-
-            Ext::Transport::UnixSocket::DEFAULT_PATH
-          end
-      end
-
-      def should_use_uds_fallback?
-        uds_fallback != nil
-      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(*configurations_in_priority_order)
-        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
-        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.inspect})" }.join(' and ')}" \
-          ". Using #{detected_configurations_in_priority_order.first.value.inspect}."
-        )
-      end
-
-      def log_warning(message)
-        logger.warn(message) if logger
-      end
-
-      DetectedConfiguration = Struct.new(:friendly_name, :value) do
-        def initialize(friendly_name:, 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/base.rb

@@ -1,82 +0,0 @@
-# typed: false
-require 'datadog/core/environment/variable_helpers'
-require 'ddtrace/configuration/options'
-
-module Datadog
-  module Configuration
-    # Basic configuration behavior
-    module Base
-      def self.included(base)
-        base.extend(Datadog::Core::Environment::VariableHelpers)
-        base.include(Datadog::Core::Environment::VariableHelpers)
-        base.include(Options)
-
-        base.extend(ClassMethods)
-        base.include(InstanceMethods)
-      end
-
-      # Class methods for configuration
-      module ClassMethods
-        protected
-
-        # Allows subgroupings of settings to be defined.
-        # e.g. `settings :foo { option :bar }` --> `config.foo.bar`
-        def settings(name, &block)
-          settings_class = new_settings_class(&block)
-
-          option(name) do |o|
-            o.default { settings_class.new }
-            o.lazy
-            o.resetter do |value|
-              value.reset! if value.respond_to?(:reset!)
-              value
-            end
-          end
-        end
-
-        private
-
-        def new_settings_class(&block)
-          Class.new { include Datadog::Configuration::Base }.tap do |klass|
-            klass.instance_eval(&block) if block
-          end
-        end
-      end
-
-      # Instance methods for configuration
-      module InstanceMethods
-        def initialize(options = {})
-          configure(options) unless options.empty?
-        end
-
-        def configure(opts = {})
-          # Sort the options in preference of dependency order first
-          ordering = self.class.options.dependency_order
-          sorted_opts = opts.sort_by do |name, _value|
-            ordering.index(name) || (ordering.length + 1)
-          end.to_h
-
-          # Apply options in sort order
-          sorted_opts.each do |name, value|
-            if respond_to?("#{name}=")
-              send("#{name}=", value)
-            elsif option_defined?(name)
-              set_option(name, value)
-            end
-          end
-
-          # Apply any additional settings from block
-          yield(self) if block_given?
-        end
-
-        def to_h
-          options_hash
-        end
-
-        def reset!
-          reset_options!
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/components.rb

@@ -1,292 +0,0 @@
-# typed: true
-require 'ddtrace/configuration/agent_settings_resolver'
-require 'ddtrace/diagnostics/health'
-require 'ddtrace/logger'
-require 'ddtrace/profiling'
-require 'ddtrace/runtime/metrics'
-require 'ddtrace/tracer'
-require 'ddtrace/sync_writer'
-require 'ddtrace/workers/runtime_metrics'
-
-module Datadog
-  module Configuration
-    # Global components for the trace library.
-    # rubocop:disable Metrics/ClassLength
-    # rubocop:disable Layout/LineLength
-    class Components
-      class << self
-        def build_health_metrics(settings)
-          settings = settings.diagnostics.health_metrics
-          options = { enabled: settings.enabled }
-          options[:statsd] = settings.statsd unless settings.statsd.nil?
-
-          Datadog::Diagnostics::Health::Metrics.new(**options)
-        end
-
-        def build_logger(settings)
-          logger = settings.logger.instance || Datadog::Logger.new($stdout)
-          logger.level = settings.diagnostics.debug ? ::Logger::DEBUG : settings.logger.level
-
-          logger
-        end
-
-        def build_runtime_metrics(settings)
-          options = { enabled: settings.runtime_metrics.enabled }
-          options[:statsd] = settings.runtime_metrics.statsd unless settings.runtime_metrics.statsd.nil?
-          options[:services] = [settings.service] unless settings.service.nil?
-
-          Datadog::Runtime::Metrics.new(**options)
-        end
-
-        def build_runtime_metrics_worker(settings)
-          # NOTE: Should we just ignore building the worker if its not enabled?
-          options = settings.runtime_metrics.opts.merge(
-            enabled: settings.runtime_metrics.enabled,
-            metrics: build_runtime_metrics(settings)
-          )
-
-          Datadog::Workers::RuntimeMetrics.new(options)
-        end
-
-        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
-          return tracer unless tracer.nil?
-
-          tracer = Tracer.new(
-            default_service: settings.service,
-            enabled: settings.tracer.enabled,
-            partial_flush: settings.tracer.partial_flush.enabled,
-            tags: build_tracer_tags(settings),
-            sampler: PrioritySampler.new(
-              base_sampler: AllSampler.new,
-              post_sampler: Sampling::RuleSampler.new(
-                rate_limit: settings.sampling.rate_limit,
-                default_sample_rate: settings.sampling.default_rate
-              )
-            )
-          )
-
-          # TODO: We reconfigure the tracer here because it has way too many
-          #       options it allows to mutate, and it's overwhelming to rewrite
-          #       tracer initialization for now. Just reconfigure using the
-          #       existing mutable #configure function. Remove when these components
-          #       are extracted.
-          tracer.configure(agent_settings: agent_settings, **build_tracer_options(settings, agent_settings))
-
-          tracer
-        end
-
-        def build_profiler(settings, agent_settings, tracer)
-          return unless Datadog::Profiling.supported? && settings.profiling.enabled
-
-          unless defined?(Datadog::Profiling::Tasks::Setup)
-            # In #1545 a user reported a NameError due to this constant being uninitialized
-            # I've documented my suspicion on why that happened in
-            # https://github.com/DataDog/dd-trace-rb/issues/1545#issuecomment-856049025
-            #
-            # > Thanks for the info! It seems to feed into my theory: there's two moments in the code where we check if
-            # > profiler is "supported": 1) when loading ddtrace (inside preload) and 2) when starting the profile
-            # > after Datadog.configure gets run.
-            # > The problem is that the code assumes that both checks 1) and 2) will always reach the same conclusion:
-            # > either profiler is supported, or profiler is not supported.
-            # > In the problematic case, it looks like in your case check 1 decides that profiler is not
-            # > supported => doesn't load it, and then check 2 decides that it is => assumes it is loaded and tries to
-            # > start it.
-            #
-            # I was never able to validate if this was the issue or why exactly .supported? would change its mind BUT
-            # just in case it happens again, I've left this check which avoids breaking the user's application AND
-            # would instead direct them to report it to us instead, so that we can investigate what's wrong.
-            #
-            # TODO: As of June 2021, most checks in .supported? are related to the google-protobuf gem; so it's
-            # very likely that it was the origin of the issue we saw. Thus, if, as planned we end up moving away from
-            # protobuf OR enough time has passed and no users saw the issue again, we can remove this check altogether.
-            Datadog.logger.error(
-              'Profiling was marked as supported and enabled, but setup task was not loaded properly. ' \
-              'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug'
-            )
-
-            return
-          end
-
-          # Load extensions needed to support some of the Profiling features
-          Datadog::Profiling::Tasks::Setup.new.run
-
-          # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
-
-          trace_identifiers_helper = Datadog::Profiling::TraceIdentifiers::Helper.new(
-            tracer: tracer,
-            endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled
-          )
-
-          recorder = build_profiler_recorder(settings)
-          collectors = build_profiler_collectors(settings, recorder, trace_identifiers_helper)
-          exporters = build_profiler_exporters(settings, agent_settings)
-          scheduler = build_profiler_scheduler(settings, recorder, exporters)
-
-          Datadog::Profiler.new(collectors, scheduler)
-        end
-
-        private
-
-        def build_tracer_tags(settings)
-          settings.tags.dup.tap do |tags|
-            tags[Ext::Environment::TAG_ENV] = settings.env unless settings.env.nil?
-            tags[Ext::Environment::TAG_VERSION] = settings.version unless settings.version.nil?
-          end
-        end
-
-        def build_tracer_options(settings, agent_settings)
-          tracer_options = {}.tap do |opts|
-            tset = settings.tracer
-            opts[:min_spans_before_partial_flush] = tset.partial_flush.min_spans_threshold unless tset.partial_flush.min_spans_threshold.nil?
-            opts[:partial_flush] = tset.partial_flush.enabled unless tset.partial_flush.enabled.nil?
-            opts[:priority_sampling] = tset.priority_sampling unless tset.priority_sampling.nil?
-            opts[:sampler] = tset.sampler unless tset.sampler.nil?
-            opts[:writer] = tset.writer unless tset.writer.nil?
-            opts[:writer_options] = tset.writer_options if tset.writer.nil?
-          end
-
-          # Apply test mode settings if test mode is activated
-          if settings.test_mode.enabled
-            build_tracer_test_mode_options(tracer_options, settings, agent_settings)
-          else
-            tracer_options
-          end
-        end
-
-        def build_tracer_test_mode_options(tracer_options, settings, agent_settings)
-          tracer_options.tap do |opts|
-            # Do not sample any spans for tests; all must be preserved.
-            opts[:sampler] = Datadog::AllSampler.new
-
-            # If context flush behavior is provided, use it instead.
-            opts[:context_flush] = settings.test_mode.context_flush if settings.test_mode.context_flush
-
-            # Flush traces synchronously, to guarantee they are written.
-            writer_options = settings.test_mode.writer_options || {}
-            writer_options[:agent_settings] = agent_settings if agent_settings
-            opts[:writer] = Datadog::SyncWriter.new(writer_options)
-          end
-        end
-
-        def build_profiler_recorder(settings)
-          event_classes = [Datadog::Profiling::Events::StackSample]
-
-          Datadog::Profiling::Recorder.new(event_classes, settings.profiling.advanced.max_events)
-        end
-
-        def build_profiler_collectors(settings, recorder, trace_identifiers_helper)
-          [
-            Datadog::Profiling::Collectors::Stack.new(
-              recorder,
-              trace_identifiers_helper: trace_identifiers_helper,
-              max_frames: settings.profiling.advanced.max_frames
-              # TODO: Provide proc that identifies Datadog worker threads?
-              # ignore_thread: settings.profiling.ignore_profiler
-            )
-          ]
-        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)
-          Datadog::Profiling::Scheduler.new(recorder, exporters)
-        end
-      end
-
-      attr_reader \
-        :health_metrics,
-        :logger,
-        :profiler,
-        :runtime_metrics,
-        :tracer
-
-      def initialize(settings)
-        # Logger
-        @logger = self.class.build_logger(settings)
-
-        agent_settings = AgentSettingsResolver.call(settings, logger: @logger)
-
-        # Tracer
-        @tracer = self.class.build_tracer(settings, agent_settings)
-
-        # Profiler
-        @profiler = self.class.build_profiler(settings, agent_settings, @tracer)
-
-        # Runtime metrics
-        @runtime_metrics = self.class.build_runtime_metrics_worker(settings)
-
-        # Health metrics
-        @health_metrics = self.class.build_health_metrics(settings)
-      end
-
-      # Starts up components
-      def startup!(settings)
-        if settings.profiling.enabled
-          if profiler
-            @logger.debug('Profiling started')
-            profiler.start
-          else
-            # 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')
-        end
-      end
-
-      # Shuts down all the components in use.
-      # If it has another instance to compare to, it will compare
-      # and avoid tearing down parts still in use.
-      def shutdown!(replacement = nil)
-        # Shutdown the old tracer, unless it's still being used.
-        # (e.g. a custom tracer instance passed in.)
-        tracer.shutdown! unless replacement && tracer == replacement.tracer
-
-        # Shutdown old profiler
-        profiler.shutdown! unless profiler.nil?
-
-        # Shutdown workers
-        runtime_metrics.stop(true, close_metrics: false)
-
-        # Shutdown the old metrics, unless they are still being used.
-        # (e.g. custom Statsd instances.)
-        #
-        # TODO: This violates the encapsulation created by Runtime::Metrics and
-        # Health::Metrics, by directly manipulating `statsd` and changing
-        # it's lifecycle management.
-        # If we need to directly have ownership of `statsd` lifecycle, we should
-        # have direct ownership of it.
-        old_statsd = [
-          runtime_metrics.metrics.statsd,
-          health_metrics.statsd
-        ].compact.uniq
-
-        new_statsd =  if replacement
-                        [
-                          replacement.runtime_metrics.metrics.statsd,
-                          replacement.health_metrics.statsd
-                        ].compact.uniq
-                      else
-                        []
-                      end
-
-        unused_statsd = (old_statsd - (old_statsd & new_statsd))
-        unused_statsd.each(&:close)
-      end
-    end
-  end
-end