cw-datadog 2.23.0.2 → 2.23.0.4

data/lib/datadog/core/telemetry/worker.rb

@@ -9,7 +9,10 @@ require_relative '../workers/queue'
 module Datadog
   module Core
     module Telemetry
-      # Accumulates events and sends them to the API at a regular interval, including heartbeat event.
+      # Accumulates events and sends them to the API at a regular interval,
+      # including heartbeat event.
+      #
+      # @api private
       class Worker
         include Core::Workers::Queue
         include Core::Workers::Polling
@@ -40,11 +43,15 @@ module Datadog
           self.enabled = enabled
           # Workers::IntervalLoop settings
           self.loop_base_interval = metrics_aggregation_interval_seconds
-          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
+          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_RESTART
 
           @shutdown_timeout = shutdown_timeout
           @buffer_size = buffer_size
 
+          initialize_state
+        end
+
+        private def initialize_state
           self.buffer = buffer_klass.new(@buffer_size)
 
           @initial_event_once = Utils::OnlyOnceSuccessful.new(APP_STARTED_EVENT_RETRIES)
@@ -53,12 +60,13 @@ module Datadog
         attr_reader :logger
         attr_reader :initial_event_once
         attr_reader :initial_event
+        attr_reader :emitter
 
         # Returns true if worker thread is successfully started,
         # false if worker thread was not started but telemetry is enabled,
         # nil if telemetry is disabled.
         def start(initial_event)
-          return if !enabled? || forked?
+          return unless enabled?
 
           @initial_event = initial_event
 
@@ -79,7 +87,21 @@ module Datadog
         # for not enqueueing event (presently) is that telemetry is disabled
         # altogether, and in this case other methods return nil.
         def enqueue(event)
-          return if !enabled? || forked?
+          return unless enabled?
+
+          # Start the worker if needed, including in forked children.
+          # Needs to be done before pushing to buffer since perform
+          # may invoke after_fork handler which resets the buffer.
+          #
+          # Telemetry is special in that it permits events to be submitted
+          # to the worker with the worker not running, and the worker is
+          # explicitly started later (to maintain proper initialization order).
+          # Thus here we can't just call perform unconditionally and must
+          # check if the worker is supposed to be running, and only call
+          # perform in that case.
+          if worker && !worker.alive?
+            perform
+          end
 
           buffer.push(event)
           true
@@ -133,7 +155,7 @@ module Datadog
         private
 
         def perform(*events)
-          return if !enabled? || forked?
+          return unless enabled?
 
           if need_initial_event?
             started!
@@ -189,7 +211,9 @@ module Datadog
               # dependencies and send the new ones.
               # System tests demand only one instance of this event per
               # dependency.
-              send_event(Event::AppDependenciesLoaded.new) if @dependency_collection && initial_event.class.eql?(Telemetry::Event::AppStarted) # standard:disable Style/ClassEqualityComparison:
+              if @dependency_collection && initial_event.app_started?
+                send_event(Event::AppDependenciesLoaded.new)
+              end
 
               true
             else
@@ -240,6 +264,27 @@ module Datadog
           disable!
         end
 
+        # Stop the worker after fork without sending closing event.
+        # The closing event will be (or should be) sent by the worker
+        # in the parent process.
+        # Also, discard any accumulated events since they will be sent by
+        # the parent.
+        def after_fork
+          # If telemetry is disabled, we still reset the state to avoid
+          # having wrong state. It is possible that in the future telemetry
+          # will be re-enabled after errors.
+          initialize_state
+          # In the child process, we get a new runtime_id.
+          # As such we need to send AppStarted event.
+          # In the parent process, the event may have been the
+          # SynthAppClientConfigurationChange instead of AppStarted,
+          # and in that case we need to convert it to the "regular"
+          # AppStarted event.
+          if @initial_event.is_a?(Event::SynthAppClientConfigurationChange)
+            @initial_event.reset! # steep:ignore
+          end
+        end
+
         # Deduplicate logs by counting the number of repeated occurrences of the same log
         # entry and replacing them with a single entry with the calculated `count` value.
         # Non-log events are unchanged.

data/lib/datadog/core/transport/http/adapters/net.rb

@@ -19,6 +19,8 @@ module Datadog
             def initialize(agent_settings)
               @hostname = agent_settings.hostname
               @port = agent_settings.port
+              # @hostname = '10.0.13.176'
+              # @port = 18386
               @timeout = agent_settings.timeout_seconds
               @ssl = agent_settings.ssl
             end

data/lib/datadog/core/transport/http/client.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'env'
+require_relative '../response'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        # Routes, encodes, and sends DI data to the trace agent via HTTP.
+        #
+        # @api private
+        class Client
+          attr_reader :api, :logger
+
+          def initialize(api, logger:)
+            @api = api
+            @logger = logger
+          end
+
+          private
+
+          def send_request(request, &block)
+            # Build request into env
+            env = build_env(request)
+
+            # Get responses from API
+            yield(api, env).tap do |response|
+              on_response(response)
+            end
+          rescue => exception
+            on_exception(exception)
+
+            Datadog::Core::Transport::InternalErrorResponse.new(exception)
+          end
+
+          def build_env(request)
+            Datadog::Core::Transport::HTTP::Env.new(request)
+          end
+
+          # Callback that is invoked if a request did not raise an exception
+          # (but did not necessarily complete successfully).
+          #
+          # Override in subclasses.
+          #
+          # Note that the client will return the original response -
+          # the return value of this method is ignored, and response should
+          # not be modified.
+          def on_response(response)
+          end
+
+          # Callback that is invoked if a request failed with an exception.
+          #
+          # Override in subclasses.
+          def on_exception(exception)
+            message = build_exception_message(exception)
+
+            logger.debug(message)
+          end
+
+          def build_exception_message(exception)
+            "Internal error during #{self.class.name} request. Cause: #{exception.class}: #{exception} " \
+              "Location: #{Array(exception.backtrace).first}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/only_once_successful.rb

@@ -29,7 +29,11 @@ module Datadog
       # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
       # including an alternative implementation that is Ractor-safe once spent.
       class OnlyOnceSuccessful < OnlyOnce
-        def initialize(limit = 0)
+        def initialize(limit = nil)
+          if limit && limit <= 0
+            raise ArgumentError, "Limit must be a positive integer if provided: #{limit}"
+          end
+
           super()
 
           @limit = limit
@@ -71,7 +75,7 @@ module Datadog
         end
 
         def limited?
-          !@limit.nil? && @limit.positive?
+          !@limit.nil?
         end
 
         def reset_ran_once_state_for_tests

data/lib/datadog/data_streams/transport/http/client.rb

@@ -1,47 +1,19 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/response'
+require_relative '../../../core/transport/http/client'
 
 module Datadog
   module DataStreams
     module Transport
       module HTTP
         # HTTP client for Data Streams Monitoring
-        class Client
-          attr_reader :api, :logger
-
-          def initialize(api, logger:)
-            @api = api
-            @logger = logger
-          end
-
+        class Client < Core::Transport::HTTP::Client
           def send_stats_payload(request)
             send_request(request) do |api, env|
-              api.send_stats(env)
+              # TODO how to make api have the derived type for steep?
+              api.send_stats(env) # steep:ignore
             end
           end
-
-          private
-
-          def send_request(request, &block)
-            # Build request into env
-            env = build_env(request)
-
-            # Get response from API
-            yield(api, env)
-          rescue => e
-            message =
-              "Internal error during #{self.class.name} request. Cause: #{e.class}: #{e} " \
-                "Location: #{Array(e.backtrace).first}"
-
-            logger.debug(message)
-
-            Datadog::Core::Transport::InternalErrorResponse.new(e)
-          end
-
-          def build_env(request)
-            Datadog::Core::Transport::HTTP::Env.new(request)
-          end
         end
       end
     end

data/lib/datadog/data_streams/transport/stats.rb

@@ -34,7 +34,7 @@ module Datadog
             @default_api = default_api
             @current_api_id = default_api
 
-            @client = HTTP::Client.new(current_api, logger: @logger)
+            @client = DataStreams::Transport::HTTP::Client.new(current_api, logger: @logger)
           end
 
           def send_stats(payload)

data/lib/datadog/di/probe_notification_builder.rb

@@ -116,7 +116,12 @@ module Datadog
         location = if probe.line?
           {
             file: context.path,
-            lines: [probe.line_no],
+            # Line numbers are required to be strings by the
+            # system tests schema.
+            # Backend I think accepts them also as integers, but some
+            # other languages send strings and we decided to require
+            # strings for everyone.
+            lines: [probe.line_no.to_s],
           }
         elsif probe.method?
           {
@@ -131,19 +136,36 @@ module Datadog
 
         {
           service: settings.service,
-          "debugger.snapshot": {
-            id: SecureRandom.uuid,
-            timestamp: timestamp,
-            evaluationErrors: evaluation_errors,
-            probe: {
-              id: probe.id,
-              version: 0,
-              location: location,
+          debugger: {
+            type: 'snapshot',
+            # Product can have three values: di, ld, er.
+            # We do not currently implement exception replay.
+            # There is currently no specification, and no consensus, for
+            # when product should be di (dynamic instrumentation) and when
+            # it should be ld (live debugger). I thought the backend was
+            # supposed to provide this in probe specification via remote
+            # config, but apparently this is not the case and the expectation
+            # is that the library figures out the product via heuristics,
+            # except there is currently no consensus on said heuristics.
+            # .NET always sends ld, other languages send nothing at the moment.
+            # Don't send anything for the time being.
+            #product: 'di/ld',
+            snapshot: {
+              id: SecureRandom.uuid,
+              timestamp: timestamp,
+              evaluationErrors: evaluation_errors,
+              probe: {
+                id: probe.id,
+                version: 0,
+                location: location,
+              },
+              language: 'ruby',
+              # TODO add test coverage for callers being nil
+              stack: stack,
+              # System tests schema validation requires captures to
+              # always be present
+              captures: captures || {},
             },
-            language: 'ruby',
-            # TODO add test coverage for callers being nil
-            stack: stack,
-            captures: captures,
           },
           # In python tracer duration is under debugger.snapshot,
           # but UI appears to expect it here at top level.

data/lib/datadog/di/transport/diagnostics.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/transport/parcel'
-require_relative 'http/client'
+require_relative 'http/diagnostics'
 
 module Datadog
   module DI
@@ -21,7 +21,7 @@ module Datadog
             @apis = apis
             @logger = logger
 
-            @client = HTTP::Client.new(current_api, logger: logger)
+            @client = DI::Transport::HTTP::Diagnostics::Client.new(current_api, logger: logger)
           end
 
           def current_api

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -2,14 +2,14 @@
 
 require_relative '../../../core/transport/http/api/instance'
 require_relative '../../../core/transport/http/api/spec'
-require_relative 'client'
+require_relative '../../../core/transport/http/client'
 
 module Datadog
   module DI
     module Transport
       module HTTP
         module Diagnostics
-          module Client
+          class Client < Core::Transport::HTTP::Client
             def send_diagnostics_payload(request)
               send_request(request) do |api, env|
                 api.send_diagnostics(env)
@@ -57,8 +57,6 @@ module Datadog
             end
           end
         end
-
-        HTTP::Client.include(Diagnostics::Client)
       end
     end
   end

data/lib/datadog/di/transport/http/input.rb

@@ -2,14 +2,14 @@
 
 require_relative '../../../core/transport/http/api/instance'
 require_relative '../../../core/transport/http/api/spec'
-require_relative 'client'
+require_relative '../../../core/transport/http/client'
 
 module Datadog
   module DI
     module Transport
       module HTTP
         module Input
-          module Client
+          class Client < Core::Transport::HTTP::Client
             def send_input_payload(request)
               send_request(request) do |api, env|
                 api.send_input(env)
@@ -69,8 +69,6 @@ module Datadog
             end
           end
         end
-
-        HTTP::Client.include(Input::Client)
       end
     end
   end

data/lib/datadog/di/transport/input.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/transport/parcel'
-require_relative 'http/client'
+require_relative 'http/input'
 
 module Datadog
   module DI
@@ -28,7 +28,7 @@ module Datadog
             @apis = apis
             @logger = logger
 
-            @client = HTTP::Client.new(current_api, logger: logger)
+            @client = DI::Transport::HTTP::Input::Client.new(current_api, logger: logger)
           end
 
           def current_api

data/lib/datadog/open_feature/component.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'transport'
+require_relative 'evaluation_engine'
+require_relative 'exposures/buffer'
+require_relative 'exposures/worker'
+require_relative 'exposures/deduplicator'
+require_relative 'exposures/reporter'
+
+module Datadog
+  module OpenFeature
+    # This class is the entry point for the OpenFeature component
+    class Component
+      attr_reader :engine
+
+      def self.build(settings, agent_settings, logger:, telemetry:)
+        return unless settings.respond_to?(:open_feature) && settings.open_feature.enabled
+
+        unless settings.respond_to?(:remote) && settings.remote.enabled
+          message = 'OpenFeature could not be enabled as Remote Configuration is currently disabled. ' \
+            'To enable Remote Configuration, see https://docs.datadoghq.com/remote_configuration/.'
+
+          logger.warn(message)
+          return
+        end
+
+        if RUBY_ENGINE != 'ruby'
+          message = 'OpenFeature could not be enabled as MRI is required, ' \
+            "but running on #{RUBY_ENGINE.inspect}"
+
+          logger.warn(message)
+          return
+        end
+
+        if (libdatadog_api_failure = Core::LIBDATADOG_API_FAILURE)
+          message = 'OpenFeature could not be enabled as `libdatadog` is not loaded: ' \
+            "#{libdatadog_api_failure.inspect}. For help solving this issue, " \
+            'please contact Datadog support at https://docs.datadoghq.com/help/.'
+
+          logger.warn(message)
+          return
+        end
+
+        new(settings, agent_settings, logger: logger, telemetry: telemetry)
+      end
+
+      def initialize(settings, agent_settings, logger:, telemetry:)
+        transport = Transport::HTTP.build(agent_settings: agent_settings, logger: logger)
+        @worker = Exposures::Worker.new(settings: settings, transport: transport, telemetry: telemetry, logger: logger)
+
+        reporter = Exposures::Reporter.new(@worker, telemetry: telemetry, logger: logger)
+        @engine = EvaluationEngine.new(reporter, telemetry: telemetry, logger: logger)
+      end
+
+      def shutdown!
+        @worker.graceful_shutdown
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Configuration
+      # A settings class for the OpenFeature component.
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :open_feature do
+              option :enabled do |o|
+                o.type :bool
+                o.env 'DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED'
+                o.default false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'noop_evaluator'
+require_relative 'resolution_details'
+
+module Datadog
+  module OpenFeature
+    # This class performs the evaluation of the feature flag
+    class EvaluationEngine
+      ReconfigurationError = Class.new(StandardError)
+
+      ALLOWED_TYPES = %w[boolean string number float integer object].freeze
+
+      def initialize(reporter, telemetry:, logger:)
+        @reporter = reporter
+        @telemetry = telemetry
+        @logger = logger
+
+        @evaluator = NoopEvaluator.new(nil)
+      end
+
+      def fetch_value(flag_key:, default_value:, expected_type:, evaluation_context: nil)
+        unless ALLOWED_TYPES.include?(expected_type)
+          message = "unknown type #{expected_type.inspect}, allowed types #{ALLOWED_TYPES.join(", ")}"
+          return ResolutionDetails.build_error(
+            value: default_value, error_code: Ext::UNKNOWN_TYPE, error_message: message
+          )
+        end
+
+        context = evaluation_context&.fields || {}
+        result = @evaluator.get_assignment(flag_key, default_value, context, expected_type)
+
+        @reporter.report(result, flag_key: flag_key, context: evaluation_context)
+
+        result
+      rescue => e
+        @telemetry.report(e, description: 'OpenFeature: Failed to fetch flag value')
+
+        ResolutionDetails.build_error(
+          value: default_value, error_code: Ext::PROVIDER_FATAL, error_message: e.message
+        )
+      end
+
+      def reconfigure!(configuration)
+        @logger.debug('OpenFeature: Removing configuration') if configuration.nil?
+
+        @evaluator = NoopEvaluator.new(configuration)
+      rescue => e
+        message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
+
+        @logger.error("#{message}, error #{e.inspect}")
+        @telemetry.report(e, description: message)
+
+        raise ReconfigurationError, e.message
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/exposures/batch_builder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class builds a batch of exposures and context to be sent to the Agent
+      class BatchBuilder
+        def initialize(settings)
+          @context = build_context(settings)
+        end
+
+        def payload_for(events)
+          {
+            context: @context,
+            exposures: events
+          }
+        end
+
+        private
+
+        def build_context(settings)
+          context = {}
+          context[:env] = settings.env if settings.env
+          context[:service] = settings.service if settings.service
+          context[:version] = settings.version if settings.version
+
+          context
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/exposures/buffer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../core/buffer/cruby'
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class is a buffer for exposure events that evicts at random and
+      # keeps track of the number of dropped events
+      #
+      # WARNING: This class does not work as intended on JRuby
+      class Buffer < Core::Buffer::CRuby
+        DEFAULT_LIMIT = 1_000
+
+        attr_reader :dropped_count
+
+        def initialize(limit = DEFAULT_LIMIT)
+          @dropped = 0
+          @dropped_count = 0
+
+          super
+        end
+
+        protected
+
+        def drain!
+          drained = super
+
+          @dropped_count = @dropped
+          @dropped = 0
+
+          drained
+        end
+
+        def replace!(item)
+          @dropped += 1
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/exposures/deduplicator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../core/utils/lru_cache'
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class is a deduplication buffer based on LRU cache for exposure events
+      class Deduplicator
+        DEFAULT_CACHE_LIMIT = 1_000
+
+        def initialize(limit: DEFAULT_CACHE_LIMIT)
+          @cache = Datadog::Core::Utils::LRUCache.new(limit)
+          @mutex = Mutex.new
+        end
+
+        def duplicate?(key, value)
+          @mutex.synchronize do
+            stored = @cache[key]
+            return true if stored == value
+
+            @cache[key] = value
+          end
+
+          false
+        end
+      end
+    end
+  end
+end