datadog 2.47.0 → 2.48.0

data/lib/datadog/di/probe_notification_builder.rb

@@ -4,6 +4,7 @@
 
 require_relative "evaluation_failure"
 require_relative "fatal_exceptions"
+require_relative "guardrails_telemetry"
 
 module Datadog
   module DI
@@ -17,12 +18,17 @@ module Datadog
       # @param serializer [Serializer] serializer for captured values
       # @param logger [DI::Logger] logger for builder diagnostics
       # @param capture_expression_evaluator [CaptureExpressionEvaluator] evaluator for the probe's capture expressions
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical evaluation-timeout skip metric
+      # @param telemetry [Datadog::Core::Telemetry::Component, nil] component evaluation timeouts are counted through
       # @return [void]
-      def initialize(settings, serializer, logger, capture_expression_evaluator:)
+      def initialize(settings, serializer, logger, capture_expression_evaluator:, guardrails_telemetry:,
+        telemetry:)
         @settings = settings
         @serializer = serializer
         @logger = logger
         @capture_expression_evaluator = capture_expression_evaluator
+        @guardrails_telemetry = guardrails_telemetry
+        @telemetry = telemetry
       end
 
       attr_reader :settings
@@ -33,35 +39,43 @@ module Datadog
 
       attr_reader :capture_expression_evaluator
 
+      # The guardrails metric emitter.
+      # @return [GuardrailsTelemetry]
+      attr_reader :guardrails_telemetry
+
+      # The telemetry component evaluation timeouts are counted through.
+      # @return [Datadog::Core::Telemetry::Component, nil]
+      attr_reader :telemetry
+
       def build_received(probe)
         build_status(probe,
           message: "Probe #{probe.id} has been received correctly",
-          status: "RECEIVED",)
+          status: "RECEIVED")
       end
 
       def build_installed(probe)
         build_status(probe,
           message: "Probe #{probe.id} has been instrumented correctly",
-          status: "INSTALLED",)
+          status: "INSTALLED")
       end
 
       def build_emitting(probe)
         build_status(probe,
           message: "Probe #{probe.id} is emitting",
-          status: "EMITTING",)
+          status: "EMITTING")
       end
 
       def build_errored(probe, exc)
         build_status(probe,
           message: "Instrumentation for probe #{probe.id} failed: #{exc}",
           status: "ERROR",
-          exception: exc,)
+          exception: exc)
       end
 
       def build_disabled(probe, duration)
         build_status(probe,
           message: "Probe #{probe.id} was disabled because it consumed #{duration} seconds of CPU time in DI processing",
-          status: "ERROR",)
+          status: "ERROR")
       end
 
       # Duration is in seconds.
@@ -144,12 +158,13 @@ module Datadog
         message = nil
         evaluation_errors = []
         if segments = probe.template_segments
-          message, evaluation_errors = evaluate_template(segments, context)
+          message, evaluation_errors = evaluate_template(segments, context,
+            evaluation_deadline: serializer.evaluation_deadline)
         end
         evaluation_errors.concat(capture_expression_evaluation_errors)
         build_snapshot_base(context,
           evaluation_errors: evaluation_errors, message: message,
-          captures: captures,)
+          captures: captures)
       end
 
       def build_condition_evaluation_failed(context, expression, exception)
@@ -401,23 +416,56 @@ module Datadog
         end
       end
 
-      def evaluate_template(template_segments, context)
+      # Renders the probe's message template against +context+.
+      #
+      # @param template_segments [Array<String, EL::Expression>] compiled
+      #   template segments to render.
+      # @param context [Context] evaluation context for expression segments.
+      # @param evaluation_deadline [Float] cooperative evaluation deadline, as
+      #   CLOCK_THREAD_CPUTIME_ID float seconds.
+      # @return [Array(String, Array<EvaluationFailure>)] the rendered message
+      #   and the evaluation errors.
+      def evaluate_template(template_segments, context, evaluation_deadline:)
         evaluation_errors = []
+        timed_out = false
         message = template_segments.map do |segment|
+          if segment.is_a?(EL::Expression) && !timed_out &&
+              EL::Evaluator.evaluation_deadline_exceeded?(evaluation_deadline)
+            raise DI::Error::EvaluationTimeout
+          end
           case segment
           when String
             segment
           when EL::Expression
-            serializer.serialize_value_for_message(segment.evaluate(context), name: segment.redaction_identifier)
+            if timed_out
+              # The shared deadline already crossed and reported its
+              # timeout, so the remaining segments render as the
+              # placeholder rather than raising and re-reporting per
+              # segment.
+              "[evaluation error]"
+            else
+              serializer.serialize_value_for_message(segment.evaluate(context, evaluation_deadline: evaluation_deadline), name: segment.redaction_identifier)
+            end
           else
             raise ArgumentError, "Invalid template segment type: #{segment}"
           end
         rescue Exception => exc # standard:disable Lint/RescueException
           Datadog::DI.reraise_if_fatal(exc)
+          DI.report_evaluation_timeout(
+            telemetry: telemetry, guardrails_telemetry: guardrails_telemetry, logger: logger,
+            probe: context.probe, kind: "template", exc: exc,
+          )
           evaluation_errors << EvaluationFailure.new(
             expr: segment.dsl_expr, # steep:ignore NoMethod
             message: "#{exc.class}: #{exc.message}",
           )
+          # The matches wall-time bound also raises EvaluationTimeout
+          # without crossing the shared deadline, and it stops only one
+          # segment, so it must not suppress the remaining ones.
+          if exc.is_a?(DI::Error::EvaluationTimeout) &&
+              EL::Evaluator.evaluation_deadline_exceeded?(evaluation_deadline)
+            timed_out = true
+          end
           "[evaluation error]"
         end.join
         [message, evaluation_errors]

data/lib/datadog/di/probe_notifier_worker.rb

@@ -220,7 +220,7 @@ module Datadog
       # @return [DI::Transport::Input::Transport]
       def snapshot_transport
         @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger,
-          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry,)
+          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry)
       end
 
       # Sends a batch of snapshot payloads to the agent.

data/lib/datadog/di/serializer.rb

@@ -131,6 +131,10 @@ module Datadog
         @logger = logger
         @guardrails_telemetry = guardrails_telemetry
         @telemetry = telemetry
+        # Evaluation budget for one expression evaluation, as thread CPU
+        # seconds, converted from max_time_to_evaluate_ms here so that
+        # deadline resolution per probe firing traverses no settings.
+        @evaluation_budget_seconds = settings.dynamic_instrumentation.max_time_to_evaluate_ms / 1000.0
       end
 
       attr_reader :settings
@@ -186,7 +190,7 @@ module Datadog
         collection_size: nil)
         combined = combine_args(args, kwargs, target_self)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count,
-          length: length, collection_size: collection_size, deadline: deadline,)
+          length: length, collection_size: collection_size, deadline: deadline)
       end
 
       # Serializes variables captured by a line probe.
@@ -205,7 +209,7 @@ module Datadog
         collection_size: nil)
         vars.each_with_object({}) do |(k, v), agg|
           agg[k] = serialize_value(v, name: k, depth: depth, attribute_count: attribute_count,
-            length: length, collection_size: collection_size, deadline: deadline,)
+            length: length, collection_size: collection_size, deadline: deadline)
         end
       end
 
@@ -568,8 +572,22 @@ module Datadog
           settings.dynamic_instrumentation.max_time_to_serialize_ms / 1000.0
       end
 
+      # Computes the absolute thread CPU time deadline (in seconds) for an
+      # expression evaluation by adding the evaluation budget, converted
+      # from max_time_to_evaluate_ms once at construction, to the current
+      # thread CPU clock reading.
+      #
+      # @return [Float] absolute thread CPU clock reading, in seconds, at
+      #   which the evaluation budget is exhausted
+      def evaluation_deadline
+        Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) +
+          evaluation_budget_seconds
+      end
+
       private
 
+      attr_reader :evaluation_budget_seconds
+
       def deadline_exceeded?(deadline)
         Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) >= deadline
       end

data/lib/datadog/di.rb

@@ -173,6 +173,33 @@ module Datadog
         Datadog.send(:components).dynamic_instrumentation
       end
 
+      # Reports an evaluation timeout: increments the evaluation_timeouts
+      # telemetry counter, emits the canonical guardrail skip metric for the
+      # timeout, and logs at debug with the probe id, the evaluation kind and
+      # the exception. Returns whether +exc+ was an evaluation timeout, so
+      # callers can run timeout-specific follow-up.
+      #
+      # @param telemetry [Datadog::Core::Telemetry::Component, nil] component
+      #   the counter increments through.
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the
+      #   canonical evaluation-timeout skip metric.
+      # @param logger [DI::Logger] logger the timeout log writes through.
+      # @param probe [Probe] the probe whose evaluation timed out.
+      # @param kind [String] the evaluation kind, e.g. "condition",
+      #   "capture expression" or "template".
+      # @param exc [Exception] the exception raised by the evaluation.
+      # @return [Boolean] whether the exception was an evaluation timeout.
+      def report_evaluation_timeout(telemetry:, guardrails_telemetry:, logger:, probe:, kind:, exc:)
+        return false unless exc.is_a?(DI::Error::EvaluationTimeout)
+        telemetry&.inc(TELEMETRY_NAMESPACE, "evaluation_timeouts", 1)
+        guardrails_telemetry.skipped(
+          reason: GuardrailsTelemetry::Reason::EVALUATION_TIMEOUT,
+          probe: probe,
+        )
+        logger.debug { "di: probe #{probe.id}: #{kind} evaluation timed out: #{exc.class}: #{exc.message}" }
+        true
+      end
+
       # Track how many outstanding instrumentations are in DI.
       #
       # It is hard to find the actual instrumentations - there is no

data/lib/datadog/error_tracking/component.rb

@@ -36,7 +36,7 @@ module Datadog
           elsif RubyVersion.is?("< 2.7")
             logger.warn(
               "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
-              on #{RUBY_VERSION}"
+              on #{RUBY_VERSION}",
             )
             false
           else

data/lib/datadog/error_tracking/configuration.rb

@@ -35,7 +35,7 @@ module Datadog
                     Datadog.logger.warn(
                       "Invalid handled errors scope: #{value}. " \
                       "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
-                      "Deactivating the feature."
+                      "Deactivating the feature.",
                     )
                   end
 

data/lib/datadog/kit/appsec/events/v2.rb

@@ -50,7 +50,7 @@ module Datadog
 
               if trace.nil? || span.nil?
                 return Datadog.logger.warn(
-                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events"
+                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events",
                 )
               end
 
@@ -69,7 +69,7 @@ module Datadog
               record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
               ::Datadog::AppSec::Instrumentation.gateway.push("appsec.events.user_lifecycle", LOGIN_SUCCESS_EVENT)
 
-              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id)
+              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id) # steep:ignore InsufficientKeywordArguments
 
               # NOTE: This is a fallback for the case when we don't have an ID,
               #       but need to trigger WAF.
@@ -102,7 +102,7 @@ module Datadog
 
               if trace.nil? || span.nil?
                 return Datadog.logger.warn(
-                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events"
+                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events",
                 )
               end
 
@@ -155,7 +155,7 @@ module Datadog
 
               if trace.nil? || span.nil?
                 return Datadog.logger.warn(
-                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events"
+                  "Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events",
                 )
               end
 
@@ -174,7 +174,7 @@ module Datadog
               record_event_telemetry_metric(SIGNUP_EVENT)
 
               if user_attributes.key?(:id)
-                Kit::Identity.set_user(trace, span, **user_attributes)
+                Kit::Identity.set_user(trace, span, **user_attributes) # steep:ignore InsufficientKeywordArguments
               else
                 # NOTE: {Datadog::Kit::Identity.set_user} requires an ID,
                 #       but WAF can evaluate login alone
@@ -235,7 +235,7 @@ module Datadog
 
               if telemetry.nil?
                 return Datadog.logger.debug(
-                  "Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics"
+                  "Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics",
                 )
               end
 

data/lib/datadog/kit/appsec/events.rb

@@ -160,7 +160,7 @@ module Datadog
             unless trace && span
               Datadog.logger.debug(
                 "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}" \
-                " to track this events"
+                " to track this events",
               )
               return
             end

data/lib/datadog/kit/enable_core_dumps.rb

@@ -31,7 +31,7 @@ module Datadog
         rescue => e
           Kernel.warn(
             "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e.message} " \
-            "Location: #{Array(e.backtrace).first}"
+            "Location: #{Array(e.backtrace).first}",
           )
           return
         end

data/lib/datadog/kit/identity.rb

@@ -96,7 +96,7 @@ module Datadog
           unless trace && span
             Datadog.logger.debug(
               "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}" \
-              " to track this events"
+              " to track this events",
             )
             return
           end

data/lib/datadog/open_feature/activation.rb

@@ -100,6 +100,7 @@ module Datadog
           return unless @providers.empty?
           if @delivery_source == Configuration::Source::REMOTE_CONFIG && @delivery_started
             # Remote Configuration is process-scoped and may already hold configuration needed by the next provider.
+            @logger.debug { "Feature Flags: provider detached; process-scoped Remote Configuration remains active" }
             [nil, nil]
           else
             previous_source = @configuration_source
@@ -149,9 +150,14 @@ module Datadog
         @activated = true
         unless resolution.enabled?
           @failure = "Feature Flags are disabled"
+          @logger.debug do
+            reason = @settings.feature_flags.enabled ? "the resolved configuration source is offline" : "feature_flags.enabled is false"
+            "Feature Flags: disabled because #{reason}"
+          end
           return
         end
 
+        @logger.debug { "Feature Flags: configuration source is #{resolution.source}" }
         component = Component.build(
           @settings,
           @agent_settings,
@@ -230,6 +236,20 @@ module Datadog
         end
 
         @configuration_source = configuration_source
+
+        @logger.debug do
+          agentless = @settings.feature_flags.agentless
+          sdk_env = @settings.env ? "sdk_env=#{@settings.env.inspect}" : "sdk_env is unset"
+          requested_env = if endpoint.managed?
+            @settings.env ? "requested_env=#{@settings.env.inspect}" : "requested_env is unset"
+          else
+            "requested_env is not sent (custom endpoint)"
+          end
+          "Feature Flags: starting agentless configuration source at #{endpoint.origin} " \
+            "(#{sdk_env}, #{requested_env}, " \
+            "poll interval #{agentless.poll_interval_seconds}s, request timeout #{agentless.request_timeout_seconds}s)"
+        end
+
         started = configuration_source.start
         @failure = "Feature Flags agentless delivery could not start" unless started
         started
@@ -241,7 +261,7 @@ module Datadog
           @failure = "Feature Flags Remote Configuration is unavailable"
           @logger.warn(
             "#{@failure}. To enable Remote Configuration, " \
-              "see https://docs.datadoghq.com/remote_configuration/."
+              "see https://docs.datadoghq.com/remote_configuration/.",
           )
           return false
         end
@@ -249,6 +269,7 @@ module Datadog
         receivers = @remote_receivers ||= Remote.receivers(
           @telemetry,
           component_provider: -> { @mutex.synchronize { @component } },
+          logger: @logger,
         )
         remote.register(
           capabilities: Remote.capabilities,
@@ -256,6 +277,10 @@ module Datadog
           receivers: receivers,
         )
         remote.start
+        @logger.debug do
+          sdk_env = @settings.env ? "sdk_env=#{@settings.env.inspect}" : "sdk_env is unset"
+          "Feature Flags: started Remote Configuration source (#{sdk_env}) using Datadog Agent"
+        end
         true
       end
 

data/lib/datadog/open_feature/agentless/configuration_source.rb

@@ -61,6 +61,7 @@ module Datadog
           @retry_wait = retry_wait || ->(delay) { wait_for_retry(delay) }
           @etag = nil
           @warned = {}
+          @failed_polls = 0
           @lifecycle_mutex = Mutex.new
           @started = false
           @stopped = false
@@ -91,6 +92,7 @@ module Datadog
           end
 
           super
+          @logger.debug { "Feature Flags: stopped agentless configuration polling" }
           true
         end
 
@@ -110,6 +112,7 @@ module Datadog
             return if stopped?
 
             response = @transport.get(@etag)
+            log_poll_attempt(response, attempt)
             unless retryable?(response)
               apply_response(response)
               return
@@ -120,7 +123,9 @@ module Datadog
               return
             end
 
-            return if wait_before_retry(retry_delay(attempt))
+            delay = retry_delay(attempt)
+            @logger.debug { "Feature Flags: retrying agentless configuration poll in #{delay.round(1)}s" }
+            return if wait_before_retry(delay)
 
             attempt += 1
           end
@@ -131,6 +136,7 @@ module Datadog
         def after_fork
           # The child must report its own failures, while the inherited ETag still matches its configuration.
           @warned = {}
+          @failed_polls = 0
           nil
         end
 
@@ -140,6 +146,53 @@ module Datadog
           @lifecycle_mutex.synchronize { @stopped }
         end
 
+        def log_poll_attempt(response, attempt)
+          @logger.debug do
+            status = response.status
+            outcome = case status
+            when nil
+              "failed: #{request_error_class(response)}"
+            when 304
+              "configuration unchanged (HTTP 304)"
+            when 200
+              etag = response.etag.to_s.strip
+              etag.empty? ? "configuration received (HTTP 200)" : "configuration received (ETag #{etag}; HTTP 200)"
+            else
+              "#{http_failure_reason(status)} (HTTP #{status})"
+            end
+            "Feature Flags: agentless configuration poll attempt #{attempt}/#{MAX_ATTEMPTS}: #{outcome}"
+          end
+        end
+
+        def http_failure_reason(status)
+          case status
+          when 400
+            "configuration request rejected as invalid"
+          when 401
+            "configuration request lacks valid authentication credentials"
+          when 403
+            "access to the configuration endpoint is forbidden"
+          when 404
+            "configuration endpoint not found"
+          when 408
+            "configuration request timed out"
+          when 429
+            "configuration request rate limited"
+          when 500
+            "configuration endpoint encountered an internal error"
+          when 502
+            "configuration endpoint received an invalid upstream response"
+          when 503
+            "configuration endpoint is temporarily unavailable"
+          when 504
+            "configuration endpoint timed out waiting for an upstream response"
+          when 500..599
+            "configuration endpoint reported a server error"
+          else
+            "unexpected response from the configuration endpoint"
+          end
+        end
+
         def retryable?(response)
           status = response.status
           return true unless status
@@ -181,17 +234,18 @@ module Datadog
         end
 
         def apply_response(response)
-          case response.status
+          status = response.status
+          case status
           when 200
+            log_recovery
             apply_configuration(response)
           when 304
-            nil
+            log_recovery
           when 401, 403
-            warn_once(:authentication) do
-              @logger.warn(
-                "Feature Flags agentless endpoint returned HTTP #{response.status}; verify endpoint authentication"
-              )
-            end
+            report_poll_failure(
+              :authentication,
+              "Feature Flags agentless #{http_failure_reason(status)}; verify endpoint authentication (HTTP #{status})",
+            )
           else
             warn_failure(response, 1)
           end
@@ -203,6 +257,9 @@ module Datadog
             warn_once(:malformed) do
               @logger.error("Feature Flags agentless endpoint returned malformed UFC payload")
             end
+            @logger.debug do
+              "Feature Flags: ignoring malformed agentless configuration payload"
+            end
             return
           end
 
@@ -224,16 +281,38 @@ module Datadog
           else
             :http_unexpected
           end
-          warn_once(category) do
-            if status
-              @logger.warn("Feature Flags agentless endpoint returned HTTP #{status} after #{attempts} attempt(s)")
-            else
-              error_class = response.error ? response.error.class : StandardError
-              @logger.warn("Feature Flags agentless request failed after #{attempts} attempt(s): #{error_class}")
-            end
+          refresh = (attempts == MAX_ATTEMPTS) ? "; next poll in #{@poll_interval_seconds}s" : ""
+          message = if status
+            "Feature Flags agentless #{http_failure_reason(status)} after #{attempts} attempt(s) (HTTP #{status})#{refresh}"
+          else
+            "Feature Flags agentless request failed after #{attempts} attempt(s): #{request_error_class(response)}#{refresh}"
+          end
+          report_poll_failure(category, message)
+        end
+
+        # Repeats are debug-only so a persistent outage does not flood warnings.
+        def report_poll_failure(category, message)
+          @failed_polls += 1
+          if @warned[category]
+            @logger.debug { message }
+          else
+            warn_once(category) { @logger.warn(message) }
           end
         end
 
+        def log_recovery
+          return if @failed_polls.zero?
+
+          failed_polls = @failed_polls
+          @failed_polls = 0
+          @logger.debug { "Feature Flags: agentless configuration delivery recovered after #{failed_polls} failed poll(s)" }
+        end
+
+        # Class only: transport error messages can embed endpoint details.
+        def request_error_class(response)
+          response.error ? response.error.class : StandardError
+        end
+
         def warn_once(category)
           return if @warned[category]
 

data/lib/datadog/open_feature/component.rb

@@ -13,6 +13,7 @@ require_relative "flag_evaluation/writer"
 require_relative "hooks/flag_eval_metrics_hook"
 require_relative "hooks/flag_eval_evp_hook"
 require_relative "hooks/span_enrichment_hook"
+require_relative "hooks/debug_logging_hook"
 
 module Datadog
   module OpenFeature
@@ -70,12 +71,15 @@ module Datadog
         @flag_eval_metrics_hook = create_flag_eval_metrics_hook
         @flag_eval_evp_hook = create_flag_eval_evp_hook
         @span_enrichment_hook = create_span_enrichment_hook
+        @debug_logging_hook = nil
 
         @configuration_mutex = Mutex.new
         @reconfiguration_mutex = Mutex.new
         @configuration_condition = ConditionVariable.new
         @configuration_received = false
         @configuration_shutdown = false
+
+        @engine.warn_raw_data_logging
       end
 
       def reconfigure!(configuration)
@@ -102,9 +106,19 @@ module Datadog
         @on_configuration_change&.call(event) if event
       end
 
+      # Checked per evaluation so the SDK skips hook dispatch unless debug logging is on. Built lazily
+      # because Remote Configuration can build this component before the OpenFeature SDK loads.
+      def debug_logging_hook
+        return unless @logger.debug?
+
+        @engine.warn_raw_data_logging
+        @debug_logging_hook ||= create_debug_logging_hook
+      end
+
       def wait_for_configuration(&cancelled)
-        timeout_seconds = @settings.feature_flags.initialization_timeout_ms / 1000.0
-        deadline = Core::Utils::Time.get_time + timeout_seconds
+        timeout_ms = @settings.feature_flags.initialization_timeout_ms
+        @logger.debug { "Feature Flags: waiting up to #{timeout_ms}ms for configuration" }
+        deadline = Core::Utils::Time.get_time + timeout_ms / 1000.0
 
         @configuration_mutex.synchronize do
           loop do
@@ -176,6 +190,12 @@ module Datadog
         store = Hooks::SpanEnrichmentHook::SpanEnrichmentStateStore.new
         Hooks::SpanEnrichmentHook.new(store, logger: @logger)
       end
+
+      def create_debug_logging_hook
+        return unless Hooks::DebugLoggingHook.available?
+
+        Hooks::DebugLoggingHook.new(@logger)
+      end
     end
   end
 end

data/lib/datadog/open_feature/configuration/agentless_endpoint.rb

@@ -84,6 +84,12 @@ module Datadog
         def managed?
           @managed
         end
+
+        # Excludes userinfo, path, and query, which may carry credentials.
+        def origin
+          origin = "#{uri.scheme}://#{uri.host}"
+          (uri.port == uri.default_port) ? origin : "#{origin}:#{uri.port}"
+        end
       end
     end
   end