cw-datadog 2.23.0.2

data/lib/datadog/core/configuration/agentless_settings_resolver.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/*
+
+require 'uri'
+
+require_relative 'agent_settings_resolver'
+
+module Datadog
+  module Core
+    module Configuration
+      # Agent settings resolver for agentless operations (currently, telemetry
+      # in agentless mode).
+      #
+      # The terminology gets a little confusing here, but transports communicate
+      # with servers which are - for most components in the tracer - the
+      # (local) agent. Hence, "agent settings" to refer to where the server
+      # is located. Telemetry supports sending to the local agent but also
+      # implements agentless mode where it sends directly to Datadog intake
+      # endpoints. The agentless mode is configured using different settings,
+      # and this class produces AgentSettings instances when in agentless mode.
+      #
+      # Agentless settings resolver uses the following configuration sources:
+      #
+      # 1. url_override constructor parameter, if provided
+      # 2. Built-in default host/port/TLS settings for the backend
+      #    intake endpoint
+      #
+      # The agentless resolver does NOT use agent settings (since it is
+      # for agentless operation), specifically it ignores:
+      #
+      # - c.agent.host
+      # - DD_AGENT_HOST
+      # - c.agent.port
+      # - DD_AGENT_PORT
+      #
+      # However, agentless resolver does respect the timeout specified via
+      # c.agent.timeout_seconds or DD_TRACE_AGENT_TIMEOUT_SECONDS.
+      class AgentlessSettingsResolver < AgentSettingsResolver
+        # To avoid coupling this class to telemetry, the URL override is
+        # taken here as a parameter instead of being read out of
+        # c.telemetry.agentless_url_override. For the same reason, the
+        # +url_override_source+ parameter should be set to the string
+        # "c.telemetry.agentless_url_override".
+        def self.call(settings, host_prefix:, url_override: nil, url_override_source: nil, logger: Datadog.logger)
+          new(
+            settings,
+            host_prefix: host_prefix,
+            url_override: url_override,
+            url_override_source: url_override_source,
+            logger: logger
+          ).send(:call)
+        end
+
+        private
+
+        attr_reader \
+          :host_prefix,
+          :url_override,
+          :url_override_source
+
+        def initialize(settings, host_prefix:, url_override: nil, url_override_source: nil, logger: Datadog.logger)
+          if url_override && url_override_source.nil?
+            raise ArgumentError, 'url_override_source must be provided when url_override is provided'
+          end
+
+          super(settings, logger: logger)
+
+          @host_prefix = host_prefix
+          @url_override = url_override
+          @url_override_source = url_override_source
+        end
+
+        def hostname
+          if should_use_uds?
+            nil
+          else
+            configured_hostname || "#{host_prefix}.#{settings.site}"
+          end
+        end
+
+        def configured_hostname
+          return @configured_hostname if defined?(@configured_hostname)
+
+          if should_use_uds?
+            nil
+          else
+            @configured_hostname = (parsed_url.hostname if parsed_url)
+          end
+        end
+
+        def configured_port
+          return @configured_port if defined?(@configured_port)
+
+          @configured_port = (parsed_url.port if parsed_url)
+        end
+
+        # Note that this method should always return true or false
+        def ssl?
+          if configured_hostname
+            configured_ssl || false
+          else
+            if should_use_uds?
+              false
+            else
+              # If no hostname is specified, we are communicating with the
+              # default Datadog intake, which uses TLS.
+              true
+            end
+          end
+        end
+
+        # Note that this method can return nil
+        def configured_ssl
+          return @configured_ssl if defined?(@configured_ssl)
+
+          @configured_ssl = (parsed_url_ssl? if parsed_url)
+        end
+
+        def port
+          if configured_port
+            configured_port
+          else
+            if should_use_uds?
+              nil
+            else
+              # If no hostname is specified, we are communicating with the
+              # default Datadog intake, which exists on port 443.
+              443
+            end
+          end
+        end
+
+        def mixed_http_and_uds
+          false
+        end
+
+        def configured_uds_path
+          return @configured_uds_path if defined?(@configured_uds_path)
+
+          parsed_url_uds_path
+        end
+
+        def can_use_uds?
+          # While in theory agentless transport could communicate via UDS,
+          # in practice "agentless" means we are communicating with Datadog
+          # infrastructure which is always remote.
+          # Permit UDS for proxy usage?
+          !configured_uds_path.nil?
+        end
+
+        def parsed_url
+          return @parsed_url if defined?(@parsed_url)
+
+          @parsed_url =
+            if @url_override
+              parsed = URI.parse(@url_override)
+
+              # Agentless URL should never refer to a UDS?
+              if http_scheme?(parsed) || unix_scheme?(parsed)
+                parsed
+              else
+                log_warning(
+                  "Invalid URI scheme '#{parsed.scheme}' for #{url_override_source}. " \
+                  "Ignoring the contents of #{url_override_source}."
+                )
+                nil
+              end
+            end
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Style/*

data/lib/datadog/core/configuration/base.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'options'
+
+module Datadog
+  module Core
+    module Configuration
+      # Basic configuration behavior
+      # @public_api
+      module Base
+        def self.included(base)
+          base.include(Options)
+
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        # Class methods for configuration
+        # @public_api
+        module ClassMethods
+          protected
+
+          # Allows subgroupings of settings to be defined.
+          # e.g. `settings :foo { option :bar }` --> `config.foo.bar`
+          # @param [Symbol] name option name. Methods will be created based on this name.
+          def settings(name, &block)
+            settings_class = new_settings_class(name, &block)
+
+            option(name) do |o|
+              o.default { settings_class.new }
+
+              o.resetter do |value|
+                value.reset! if value.respond_to?(:reset!)
+                value
+              end
+            end
+
+            settings_class
+          end
+
+          private
+
+          def new_settings_class(name, &block)
+            Class.new { include Configuration::Base }.tap do |klass|
+              klass.instance_variable_set(:@settings_name, name)
+              klass.instance_eval(&block) if block
+            end
+          end
+        end
+
+        # Instance methods for configuration
+        # @public_api
+        module InstanceMethods
+          def initialize(options = {})
+            configure(options) unless options.empty?
+          end
+
+          def configure(opts = {})
+            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
+
+          # Retrieves a nested option from a list of symbols
+          def dig(*options)
+            raise ArgumentError, 'expected at least one option' if options.empty?
+
+            options.inject(self) do |receiver, option|
+              receiver.send(option)
+            end
+          end
+
+          def reset!
+            reset_options!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/configuration/components.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require_relative 'agent_settings_resolver'
+require_relative 'components_state'
+require_relative 'ext'
+require_relative 'deprecations'
+require_relative '../diagnostics/environment_logger'
+require_relative '../diagnostics/health'
+require_relative '../logger'
+require_relative '../runtime/metrics'
+require_relative '../telemetry/component'
+require_relative '../workers/runtime_metrics'
+require_relative '../remote/component'
+require_relative '../../tracing/component'
+require_relative '../../profiling/component'
+require_relative '../../appsec/component'
+require_relative '../../di/component'
+require_relative '../../error_tracking/component'
+require_relative '../crashtracking/component'
+require_relative '../environment/agent_info'
+require_relative '../process_discovery'
+require_relative '../../data_streams/processor'
+
+module Datadog
+  module Core
+    module Configuration
+      # Global components for the trace library.
+      class Components
+        class << self
+          def build_health_metrics(settings, logger, telemetry)
+            settings = settings.health_metrics
+            options = {enabled: settings.enabled}
+            options[:statsd] = settings.statsd unless settings.statsd.nil?
+
+            Core::Diagnostics::Health::Metrics.new(telemetry: telemetry, logger: logger, **options)
+          end
+
+          def build_logger(settings)
+            logger = settings.logger.instance || Core::Logger.new($stdout)
+            logger.level = settings.diagnostics.debug ? ::Logger::DEBUG : settings.logger.level
+
+            logger
+          end
+
+          def build_runtime_metrics(settings, logger, telemetry)
+            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?
+            options[:experimental_runtime_id_enabled] = settings.runtime_metrics.experimental_runtime_id_enabled
+
+            Core::Runtime::Metrics.new(logger: logger, telemetry: telemetry, **options)
+          end
+
+          def build_runtime_metrics_worker(settings, logger, telemetry)
+            # 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, logger, telemetry),
+              logger: logger,
+            )
+
+            Core::Workers::RuntimeMetrics.new(telemetry: telemetry, **options)
+          end
+
+          def build_telemetry(settings, agent_settings, logger)
+            Telemetry::Component.build(settings, agent_settings, logger)
+          end
+
+          def build_crashtracker(settings, agent_settings, logger:)
+            return unless settings.crashtracking.enabled
+
+            if (libdatadog_api_failure = Datadog::Core::LIBDATADOG_API_FAILURE)
+              logger.debug("Cannot enable crashtracking: #{libdatadog_api_failure}")
+              return
+            end
+
+            Datadog::Core::Crashtracking::Component.build(settings, agent_settings, logger: logger)
+          end
+
+          def build_data_streams(settings, agent_settings, logger)
+            return unless settings.data_streams.enabled
+
+            Datadog::DataStreams::Processor.new(
+              interval: settings.data_streams.interval,
+              logger: logger,
+              settings: settings,
+              agent_settings: agent_settings
+            )
+          rescue => e
+            logger.warn("Failed to initialize Data Streams Monitoring: #{e.class}: #{e}")
+            nil
+          end
+
+          def build_cloudwise(settings, logger)
+            require_relative '../cloudwise/component'
+
+            # Use singleton pattern - all Components instances share the same Cloudwise instance
+            # This ensures ProbeState is consistent across all Tracer instances
+            @cloudwise_singleton ||= Datadog::Core::Cloudwise::Component.new(
+              settings: settings,
+              logger: logger
+            )
+          rescue => e
+            Datadog.logger.warn("Failed to initialize Cloudwise: #{e.class}: #{e}")
+            # Return a disabled component
+            NullCloudwise.new
+          end
+
+          # Null object pattern for when Cloudwise fails to load
+          class NullCloudwise
+            def enabled?
+              false
+            end
+
+            def initialize_async(&block)
+              # If Cloudwise is disabled/failed, immediately call the callback
+              # to allow Datadog components to initialize normally
+              block&.call
+              true
+            end
+
+            def start
+              # No-op
+            end
+
+            def stop
+              # No-op
+            end
+
+            def probe_state
+              # Return a mock probe state that always allows collection
+              @probe_state ||= MockProbeState.new
+            end
+
+            class MockProbeState
+              def suspended?
+                false  # Always active
+              end
+
+              def active?
+                true
+              end
+
+              def can_collect_data?
+                true
+              end
+            end
+          end
+        end
+
+        attr_reader \
+          :health_metrics,
+          :settings,
+          :logger,
+          :remote,
+          :profiler,
+          :runtime_metrics,
+          :telemetry,
+          :tracer,
+          :crashtracker,
+          :error_tracking,
+          :dynamic_instrumentation,
+          :appsec,
+          :agent_info,
+          :data_streams,
+          :cloudwise
+
+        def initialize(settings)
+          @settings = settings
+          @logger = self.class.build_logger(settings)
+          @environment_logger_extra = {}
+          @datadog_components_initialized = false
+          @pending_startup = nil
+          StableConfig.log_result(@logger)
+          Deprecations.log_deprecations_from_all_sources(@logger)
+
+          # ============================================================
+          # STEP 1: Initialize Cloudwise FIRST (Async - Non-blocking)
+          # ============================================================
+          # Cloudwise starts in background and doesn't block application startup.
+          # Host ID generation runs async and retries until success.
+          # Datadog components will NOT be initialized until Host ID is ready.
+          # Application can still serve requests normally.
+          # ============================================================
+
+          @cloudwise = self.class.build_cloudwise(settings, @logger)
+
+          if @cloudwise.enabled?
+            # Pass a callback to initialize Datadog components
+            # Note: If this is the first Components instance, Datadog components initialize immediately
+            # If Cloudwise is already running, this callback executes immediately for this instance
+            @cloudwise.initialize_async do
+              initialize_datadog_components(settings)
+            end
+          else
+            # If Cloudwise is disabled, initialize Datadog components immediately
+            initialize_datadog_components(settings)
+          end
+        end
+
+        # Initialize Datadog components
+        # This is called either:
+        # 1. Immediately if Cloudwise is disabled
+        # 2. After Host ID is ready if Cloudwise is enabled
+        def initialize_datadog_components(settings)
+
+          # This agent_settings is intended for use within Core. If you require
+          # agent_settings within a product outside of core you should extend
+          # the Core resolver from within your product/component's namespace.
+          agent_settings = AgentSettingsResolver.call(settings, logger: @logger)
+
+          # Exposes agent capability information for detection by any components
+          @agent_info = Core::Environment::AgentInfo.new(agent_settings, logger: @logger)
+
+          @telemetry = self.class.build_telemetry(settings, agent_settings, @logger)
+
+          @remote = Remote::Component.build(settings, agent_settings, logger: @logger, telemetry: telemetry)
+          @tracer = Datadog::Tracing::Component.build_tracer(settings, agent_settings, logger: @logger)
+
+          # Set the components reference on the tracer so it can check Cloudwise state
+          @tracer.instance_variable_set(:@components, self) if @tracer
+
+          @crashtracker = self.class.build_crashtracker(settings, agent_settings, logger: @logger)
+
+          @profiler, profiler_logger_extra = Datadog::Profiling::Component.build_profiler_component(
+            settings: settings,
+            agent_settings: agent_settings,
+            optional_tracer: @tracer,
+            logger: @logger,
+          )
+          @environment_logger_extra.merge!(profiler_logger_extra) if profiler_logger_extra
+
+          @runtime_metrics = self.class.build_runtime_metrics_worker(settings, @logger, telemetry)
+          @health_metrics = self.class.build_health_metrics(settings, @logger, telemetry)
+          @appsec = Datadog::AppSec::Component.build_appsec_component(settings, telemetry: telemetry)
+          @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
+          @error_tracking = Datadog::ErrorTracking::Component.build(settings, @tracer, @logger)
+          @data_streams = self.class.build_data_streams(settings, agent_settings, @logger)
+          @environment_logger_extra[:dynamic_instrumentation_enabled] = !!@dynamic_instrumentation
+
+          # Configure non-privileged components.
+          Datadog::Tracing::Contrib::Component.configure(settings)
+
+          # Mark that Datadog components are ready
+          @datadog_components_initialized = true
+
+          # If startup was deferred, call it now
+          if @pending_startup
+            startup!(@pending_startup[:settings], old_state: @pending_startup[:old_state])
+            @pending_startup = nil
+          end
+        rescue => e
+          Datadog.logger.error { "Failed to initialize Datadog components: #{e.class.name} #{e.message}" }
+        end
+
+        # Check if Datadog components have been initialized
+        def datadog_components_initialized?
+          @datadog_components_initialized == true
+        end
+
+        # Hot-swaps with a new sampler.
+        # This operation acquires the Components lock to ensure
+        # there is no concurrent modification of the sampler.
+        def reconfigure_sampler(settings = Datadog.configuration)
+          sampler = Datadog::Tracing::Component.build_sampler(settings)
+          Datadog.send(:safely_synchronize) { tracer.sampler.sampler = sampler }
+        end
+
+        # Starts up components
+        def startup!(settings, old_state: nil)
+          # If Datadog components are not initialized yet (waiting for Cloudwise),
+          # skip startup - it will be called after Datadog components are initialized
+          unless datadog_components_initialized?
+            @pending_startup = { settings: settings, old_state: old_state }
+            return
+          end
+
+          telemetry.start(old_state&.telemetry_enabled?)
+
+          if settings.profiling.enabled
+            if profiler
+              profiler.start
+            else
+              # Display a warning for users who expected profiling to be enabled
+              unsupported_reason = Profiling.unsupported_reason
+              logger.warn("Profiling was requested but is not supported, profiling disabled: #{unsupported_reason}")
+            end
+          end
+
+          if settings.remote.enabled && old_state&.remote_started?
+            # The library was reconfigured and previously it already started
+            # the remote component (i.e., it received at least one request
+            # through the installed Rack middleware which started the remote).
+            # If the new configuration also has remote enabled, start the
+            # new remote right away.
+            # remote should always be not nil here but steep doesn't know this.
+            remote&.start
+          end
+
+          # This should stay here, not in initialize. During reconfiguration, the order of the calls is:
+          # initialize new components, shutdown old components, startup new components.
+          # Because this is a singleton, if we call it in initialize, it will be shutdown right away.
+          Core::ProcessDiscovery.publish(settings)
+
+          Core::Diagnostics::EnvironmentLogger.collect_and_log!(@environment_logger_extra)
+        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)
+          # Don't shutdown Cloudwise if it's a singleton shared across all Components
+          # Only shutdown if there's no replacement (final shutdown) or replacement uses different Cloudwise
+          if !replacement || (cloudwise && !cloudwise.equal?(replacement.cloudwise))
+            cloudwise&.stop
+          end
+
+          # Shutdown remote configuration
+          remote&.shutdown!
+
+          # Shutdown DI after remote, since remote config triggers DI operations.
+          dynamic_instrumentation&.shutdown!
+
+          # Decommission AppSec
+          appsec&.shutdown!
+
+          # Shutdown the old tracer, unless it's still being used.
+          # (e.g. a custom tracer instance passed in.)
+          tracer&.shutdown! unless replacement && tracer&.equal?(replacement.tracer)
+
+          # Shutdown old profiler
+          profiler&.shutdown!
+
+          # Shutdown workers
+          runtime_metrics&.stop(true, close_metrics: false)
+
+          # Shutdown Data Streams Monitoring processor
+          data_streams&.stop(true)
+
+          # 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.
+
+          # Only process statsd if components are initialized
+          if datadog_components_initialized?
+            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)
+
+            # enqueue closing event before stopping telemetry so it will be sent out on shutdown
+            telemetry&.emit_closing! unless replacement&.telemetry&.enabled
+            telemetry&.shutdown!
+          end
+
+          Core::ProcessDiscovery.shutdown!
+        end
+
+        # Returns the current state of various components.
+        def state
+          ComponentsState.new(
+            telemetry_enabled: telemetry&.enabled || false,
+            remote_started: remote&.started?,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/configuration/components_state.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Configuration
+      # Stores the state of component tree when replacing the tree.
+      class ComponentsState
+        def initialize(telemetry_enabled:, remote_started:)
+          @telemetry_enabled = !!telemetry_enabled
+          @remote_started = !!remote_started
+        end
+
+        def telemetry_enabled?
+          @telemetry_enabled
+        end
+
+        def remote_started?
+          @remote_started
+        end
+      end
+    end
+  end
+end