ddtrace 0.54.2 → 1.8.0

data/lib/ddtrace/configuration/settings.rb

@@ -1,413 +0,0 @@
-# typed: false
-require 'logger'
-require 'ddtrace/configuration/base'
-
-require 'ddtrace/ext/analytics'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/environment'
-require 'ddtrace/ext/profiling'
-require 'ddtrace/ext/sampling'
-require 'ddtrace/ext/test'
-
-module Datadog
-  module Configuration
-    # Global configuration settings for the trace library.
-    # rubocop:disable Metrics/ClassLength
-    class Settings
-      include Base
-
-      def initialize(*_)
-        super
-
-        # WORKAROUND: The values for services, version, and env can get set either directly OR as a side effect of
-        # accessing tags (reading or writing). This is of course really confusing and error-prone, e.g. in an app
-        # WITHOUT this workaround where you define `DD_TAGS=env:envenvtag,service:envservicetag,version:envversiontag`
-        # and do:
-        #
-        # puts Datadog.configuration.instance_exec { "#{service} #{env} #{version}" }
-        # Datadog.configuration.tags
-        # puts Datadog.configuration.instance_exec { "#{service} #{env} #{version}" }
-        #
-        # the output will be:
-        #
-        # [empty]
-        # envservicetag envenvtag envversiontag
-        #
-        # That is -- the proper values for service/env/version are only set AFTER something accidentally or not triggers
-        # the resolution of the tags.
-        # This is really confusing, error prone, etc, so calling tags here is a really hacky but effective way to
-        # avoid this. I could not think of a better way of fixing this issue without massive refactoring of tags parsing
-        # (so that the individual service/env/version get correctly set even from their tags values, not as a side
-        # effect). Sorry :(
-        tags
-      end
-
-      settings :analytics do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
-          o.lazy
-        end
-      end
-
-      option :analytics_enabled do |o|
-        o.delegate_to { get_option(:analytics).enabled }
-        o.on_set do |value|
-          # TODO: Raise deprecation warning
-          get_option(:analytics).enabled = value
-        end
-      end
-
-      option :api_key do |o|
-        o.default { ENV.fetch(Ext::Environment::ENV_API_KEY, nil) }
-        o.lazy
-      end
-
-      settings :diagnostics do
-        option :debug do |o|
-          o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_DEBUG, false) }
-          o.lazy
-          o.on_set do |enabled|
-            # Enable rich debug print statements.
-            # We do not need to unnecessarily load 'pp' unless in debugging mode.
-            require 'pp' if enabled
-          end
-        end
-
-        settings :health_metrics do
-          option :enabled do |o|
-            o.default { env_to_bool(Datadog::Ext::Diagnostics::Health::Metrics::ENV_ENABLED, false) }
-            o.lazy
-          end
-
-          option :statsd
-        end
-
-        settings :startup_logs do
-          option :enabled do |o|
-            # Defaults to nil as we want to know when the default value is being used
-            o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_STARTUP_LOGS, nil) }
-            o.lazy
-          end
-        end
-      end
-
-      settings :distributed_tracing do
-        option :propagation_extract_style do |o|
-          o.default do
-            # Look for all headers by default
-            env_to_list([Ext::DistributedTracing::PROPAGATION_STYLE_EXTRACT_ENV,
-                         Ext::DistributedTracing::PROPAGATION_EXTRACT_STYLE_ENV_OLD],
-                        [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG,
-                         Ext::DistributedTracing::PROPAGATION_STYLE_B3,
-                         Ext::DistributedTracing::PROPAGATION_STYLE_B3_SINGLE_HEADER])
-          end
-
-          o.lazy
-        end
-
-        option :propagation_inject_style do |o|
-          o.default do
-            # Only inject Datadog headers by default
-            env_to_list([Ext::DistributedTracing::PROPAGATION_STYLE_INJECT_ENV,
-                         Ext::DistributedTracing::PROPAGATION_INJECT_STYLE_ENV_OLD],
-                        [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG])
-          end
-
-          o.lazy
-        end
-      end
-
-      option :env do |o|
-        # NOTE: env also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_ENVIRONMENT, nil) }
-        o.lazy
-      end
-
-      settings :logger do
-        option :instance do |o|
-          o.on_set { |value| set_option(:level, value.level) unless value.nil? }
-        end
-
-        option :level, default: ::Logger::INFO
-      end
-
-      def logger=(logger)
-        get_option(:logger).instance = logger
-      end
-
-      settings :profiling do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Profiling::ENV_ENABLED, false) }
-          o.lazy
-        end
-
-        settings :exporter do
-          option :transport
-          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
-
-        settings :advanced do
-          # This should never be reduced, as it can cause the resulting profiles to become biased.
-          # The current default should be enough for most services, allowing 16 threads to be sampled around 30 times
-          # per second for a 60 second period.
-          option :max_events, default: 32768
-
-          # Controls the maximum number of frames for each thread sampled. Can be tuned to avoid omitted frames in the
-          # produced profiles. Increasing this may increase the overhead of profiling.
-          option :max_frames do |o|
-            o.default { env_to_int(Ext::Profiling::ENV_MAX_FRAMES, 400) }
-            o.lazy
-          end
-
-          settings :endpoint do
-            settings :collection do
-              # When using profiling together with tracing, this controls if endpoint names
-              # are gathered and reported together with profiles.
-              option :enabled do |o|
-                o.default { env_to_bool(Ext::Profiling::ENV_ENDPOINT_COLLECTION_ENABLED, true) }
-                o.lazy
-              end
-            end
-          end
-        end
-
-        settings :upload do
-          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
-          end
-        end
-      end
-
-      option :report_hostname do |o|
-        o.default { env_to_bool(Ext::NET::ENV_REPORT_HOSTNAME, false) }
-        o.lazy
-      end
-
-      settings :runtime_metrics do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) }
-          o.lazy
-        end
-
-        option :opts, default: ->(_i) { {} }, lazy: true
-        option :statsd
-      end
-
-      # Backwards compatibility for configuring runtime metrics e.g. `c.runtime_metrics enabled: true`
-      def runtime_metrics(options = nil)
-        settings = get_option(:runtime_metrics)
-        return settings if options.nil?
-
-        # If options were provided (old style) then raise warnings and apply them:
-        # TODO: Raise deprecation warning
-        settings.enabled = options[:enabled] if options.key?(:enabled)
-        settings.statsd = options[:statsd] if options.key?(:statsd)
-        settings
-      end
-
-      option :runtime_metrics_enabled do |o|
-        o.delegate_to { get_option(:runtime_metrics).enabled }
-        o.on_set do |value|
-          # TODO: Raise deprecation warning
-          get_option(:runtime_metrics).enabled = value
-        end
-      end
-
-      settings :sampling do
-        option :default_rate do |o|
-          o.default { env_to_float(Ext::Sampling::ENV_SAMPLE_RATE, nil) }
-          o.lazy
-        end
-
-        option :rate_limit do |o|
-          o.default { env_to_float(Ext::Sampling::ENV_RATE_LIMIT, 100) }
-          o.lazy
-        end
-      end
-
-      option :service do |o|
-        # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, Ext::Environment::FALLBACK_SERVICE_NAME) }
-        o.lazy
-
-        # There's a few cases where we don't want to use the fallback service name, so this helper allows us to get a
-        # nil instead so that one can do
-        # nice_service_name = Datadog.configure.service_without_fallback || nice_service_name_default
-        o.helper(:service_without_fallback) do
-          service_name = service
-          service_name unless service_name.equal?(Ext::Environment::FALLBACK_SERVICE_NAME)
-        end
-      end
-
-      option :site do |o|
-        o.default { ENV.fetch(Ext::Environment::ENV_SITE, nil) }
-        o.lazy
-      end
-
-      option :tags do |o|
-        o.default do
-          tags = {}
-
-          # Parse tags from environment
-          env_to_list(Ext::Environment::ENV_TAGS).each do |tag|
-            pair = tag.split(':')
-            tags[pair.first] = pair.last if pair.length == 2
-          end
-
-          # Override tags if defined
-          tags[Ext::Environment::TAG_ENV] = env unless env.nil?
-          tags[Ext::Environment::TAG_VERSION] = version unless version.nil?
-
-          tags
-        end
-
-        o.setter do |new_value, old_value|
-          # Coerce keys to strings
-          string_tags = new_value.collect { |k, v| [k.to_s, v] }.to_h
-
-          # Cross-populate tag values with other settings
-
-          self.env = string_tags[Ext::Environment::TAG_ENV] if env.nil? && string_tags.key?(Ext::Environment::TAG_ENV)
-
-          if version.nil? && string_tags.key?(Ext::Environment::TAG_VERSION)
-            self.version = string_tags[Ext::Environment::TAG_VERSION]
-          end
-
-          if service_without_fallback.nil? && string_tags.key?(Ext::Environment::TAG_SERVICE)
-            self.service = string_tags[Ext::Environment::TAG_SERVICE]
-          end
-
-          # Merge with previous tags
-          (old_value || {}).merge(string_tags)
-        end
-
-        o.lazy
-      end
-
-      settings :test_mode do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Test::ENV_MODE_ENABLED, false) }
-          o.lazy
-        end
-
-        option :context_flush do |o|
-          o.default { nil }
-          o.lazy
-        end
-
-        option :writer_options do |o|
-          o.default { {} }
-          o.lazy
-        end
-      end
-
-      option :time_now_provider do |o|
-        o.default { ::Time.now }
-
-        o.on_set do |time_provider|
-          Utils::Time.now_provider = time_provider
-        end
-
-        o.resetter do |_value|
-          # TODO: Resetter needs access to the default value
-          # TODO: to help reduce duplication.
-          -> { ::Time.now }.tap do |default|
-            Utils::Time.now_provider = default
-          end
-        end
-      end
-
-      settings :tracer do
-        option :enabled do |o|
-          o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_ENABLED, true) }
-          o.lazy
-        end
-        option :hostname # TODO: Deprecate
-        option :instance
-
-        settings :partial_flush do
-          option :enabled, default: false
-          option :min_spans_threshold
-        end
-
-        option :port # TODO: Deprecate
-        option :priority_sampling # TODO: Deprecate
-        option :sampler
-        option :transport_options, default: ->(_i) { {} }, lazy: true # TODO: Deprecate
-        option :writer # TODO: Deprecate
-        option :writer_options, default: ->(_i) { {} }, lazy: true # TODO: Deprecate
-      end
-
-      # Backwards compatibility for configuring tracer e.g. `c.tracer debug: true`
-      def tracer(options = nil)
-        settings = get_option(:tracer)
-        return settings if options.nil?
-
-        # If options were provided (old style) then raise warnings and apply them:
-        options = options.dup
-
-        if options.key?(:log)
-          # TODO: Raise deprecation warning
-          get_option(:logger).instance = options.delete(:log)
-        end
-
-        if options.key?(:tags)
-          # TODO: Raise deprecation warning
-          set_option(:tags, options.delete(:tags))
-        end
-
-        if options.key?(:env)
-          # TODO: Raise deprecation warning
-          set_option(:env, options.delete(:env))
-        end
-
-        if options.key?(:debug)
-          # TODO: Raise deprecation warning
-          get_option(:diagnostics).debug = options.delete(:debug)
-        end
-
-        if options.key?(:partial_flush)
-          # TODO: Raise deprecation warning
-          settings.partial_flush.enabled = options.delete(:partial_flush)
-        end
-
-        if options.key?(:min_spans_before_partial_flush)
-          # TODO: Raise deprecation warning
-          settings.partial_flush.min_spans_threshold = options.delete(:min_spans_before_partial_flush)
-        end
-
-        # Forward remaining options to settings
-        options.each do |key, value|
-          setter = :"#{key}="
-          settings.send(setter, value) if settings.respond_to?(setter)
-        end
-      end
-
-      def tracer=(tracer)
-        get_option(:tracer).instance = tracer
-      end
-
-      option :version do |o|
-        # NOTE: version also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_VERSION, nil) }
-        o.lazy
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration.rb

@@ -1,195 +0,0 @@
-# typed: true
-require 'forwardable'
-require 'ddtrace/configuration/pin_setup'
-require 'ddtrace/configuration/settings'
-require 'ddtrace/configuration/components'
-
-module Datadog
-  # Configuration provides a unique access point for configurations
-  module Configuration # rubocop:disable Metrics/ModuleLength
-    include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-    extend Forwardable
-
-    # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
-    #
-    # This is important because components can end up being accessed from multiple application threads (for instance on
-    # a threaded webserver), and we don't want their initialization to clash (for instance, starting two profilers...).
-    #
-    # Note that a Mutex **IS NOT** reentrant: the same thread cannot grab the same Mutex more than once.
-    # This means below we are careful not to nest calls to methods that would trigger initialization and grab the lock.
-    #
-    # Every method that directly or indirectly mutates @components should be holding the lock (through
-    # #safely_synchronize) while doing so.
-    COMPONENTS_WRITE_LOCK = Mutex.new
-    private_constant :COMPONENTS_WRITE_LOCK
-
-    # We use a separate lock when reading the @components, so that they continue to be accessible during reconfiguration.
-    # This was needed because we ran into several issues where we still needed to read the old
-    # components while the COMPONENTS_WRITE_LOCK was being held (see https://github.com/DataDog/dd-trace-rb/pull/1387
-    # and https://github.com/DataDog/dd-trace-rb/pull/1373#issuecomment-799593022 ).
-    #
-    # Technically on MRI we could get away without this lock, but on non-MRI Rubies, we may run into issues because
-    # we fall into the "UnsafeDCLFactory" case of https://shipilev.net/blog/2014/safe-public-construction/ .
-    # Specifically, on JRuby reads from the @components do NOT have volatile semantics, and on TruffleRuby they do
-    # BUT just as an implementation detail, see https://github.com/jruby/jruby/wiki/Concurrency-in-jruby#volatility and
-    # https://github.com/DataDog/dd-trace-rb/pull/1329#issuecomment-776750377 .
-    # Concurrency is hard.
-    COMPONENTS_READ_LOCK = Mutex.new
-    private_constant :COMPONENTS_READ_LOCK
-
-    attr_writer :configuration
-
-    def configuration
-      @configuration ||= Settings.new
-    end
-
-    def configure(target = configuration, opts = {})
-      if target.is_a?(Settings)
-        yield(target) if block_given?
-
-        safely_synchronize do |write_components|
-          write_components.call(
-            if components?
-              replace_components!(target, @components)
-            else
-              build_components(target)
-            end
-          )
-        end
-
-        target
-      else
-        PinSetup.new(target, opts).call
-      end
-    end
-
-    def_delegators \
-      :components,
-      :health_metrics,
-      :profiler,
-      :runtime_metrics,
-      :tracer
-
-    def logger
-      # avoid initializing components if they didn't already exist
-      current_components = components(allow_initialization: false)
-
-      if current_components
-        @temp_logger = nil
-        current_components.logger
-      else
-        logger_without_components
-      end
-    end
-
-    # Gracefully shuts down all components.
-    #
-    # Components will still respond to method calls as usual,
-    # but might not internally perform their work after shutdown.
-    #
-    # This avoids errors being raised across the host application
-    # during shutdown, while allowing for graceful decommission of resources.
-    #
-    # Components won't be automatically reinitialized after a shutdown.
-    def shutdown!
-      safely_synchronize do
-        @components.shutdown! if components?
-      end
-    end
-
-    protected
-
-    def components(allow_initialization: true)
-      current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
-      return current_components if current_components || !allow_initialization
-
-      safely_synchronize do |write_components|
-        (defined?(@components) && @components) || write_components.call(build_components(configuration))
-      end
-    end
-
-    private
-
-    # Gracefully shuts down the tracer and disposes of component references,
-    # allowing execution to start anew.
-    #
-    # In contrast with +#shutdown!+, components will be automatically
-    # reinitialized after a reset.
-    #
-    # Used internally to ensure a clean environment between test runs.
-    def reset!
-      safely_synchronize do |write_components|
-        @components.shutdown! if components?
-        write_components.call(nil)
-        configuration.reset!
-      end
-    end
-
-    def safely_synchronize
-      # Writes to @components should only happen through this proc. Because this proc is only accessible to callers of
-      # safely_synchronize, this forces all writers to go through this method.
-      write_components = proc do |new_value|
-        COMPONENTS_READ_LOCK.synchronize { @components = new_value }
-      end
-
-      COMPONENTS_WRITE_LOCK.synchronize do
-        begin
-          yield write_components
-        rescue ThreadError => e
-          logger_without_components.error(
-            'Detected deadlock during ddtrace initialization. ' \
-            'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug' \
-            "\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
-          )
-          nil
-        end
-      end
-    end
-
-    def components?
-      # This does not need to grab the COMPONENTS_READ_LOCK because it's not returning the components
-      (defined?(@components) && @components) != nil
-    end
-
-    def build_components(settings)
-      components = Components.new(settings)
-      components.startup!(settings)
-      components
-    end
-
-    def replace_components!(settings, old)
-      components = Components.new(settings)
-
-      old.shutdown!(components)
-      components.startup!(settings)
-      components
-    end
-
-    def logger_without_components
-      # Use default logger without initializing components.
-      # This enables logging during initialization, otherwise we'd run into deadlocks.
-      @temp_logger ||= begin
-        logger = configuration.logger.instance || Datadog::Logger.new($stdout)
-        logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
-        logger
-      end
-    end
-
-    # Called from our at_exit hook whenever there was a pending Interrupt exception (e.g. typically due to ctrl+c)
-    # to print a nice message whenever we're taking a bit longer than usual to finish the process.
-    def handle_interrupt_shutdown!
-      logger = Datadog.logger
-      shutdown_thread = Thread.new { shutdown! }
-      print_message_treshold_seconds = 0.2
-
-      slow_shutdown = shutdown_thread.join(print_message_treshold_seconds).nil?
-
-      if slow_shutdown
-        logger.info 'Reporting remaining data... Press ctrl+c to exit immediately.'
-        shutdown_thread.join
-      end
-
-      nil
-    end
-  end
-end