datadog 2.36.0 → 2.37.0

data/lib/datadog/di.rb

@@ -71,6 +71,69 @@ module Datadog
         Datadog.configuration.dynamic_instrumentation.enabled
       end
 
+      # Returns a human-readable reason why dynamic instrumentation cannot run
+      # under the given settings, or nil if all build-time preconditions are met.
+      #
+      # Single source of truth for the preconditions checked in
+      # {Component.build} and reported back by {Remote.handle_rc_enablement}
+      # when an implicit enablement signal arrives but the component was not
+      # built at startup. Checks are ordered from most-actionable to
+      # platform-constraint so the most useful reason wins.
+      #
+      # The settings argument is optional so the helper can be called from
+      # contexts that don't have settings in scope (e.g. the RC handler).
+      #
+      # @param settings [Datadog::Core::Configuration::Settings]
+      # @return [String, nil] reason string or nil when supported
+      def unsupported_reason(settings = Datadog.configuration)
+        # Symmetric to the respond_to?(:remote) guard below: in unusual
+        # configurations (test doubles, partial Settings) the DI namespace
+        # may be absent. Returning a reason here lets callers — most
+        # importantly Remote.handle_rc_enablement — emit the customer-facing
+        # warn instead of raising NoMethodError on the unguarded access at
+        # line 92 (`settings.dynamic_instrumentation.internal.development`).
+        unless settings.respond_to?(:dynamic_instrumentation)
+          return "dynamic instrumentation settings are not available"
+        end
+        unless settings.respond_to?(:remote) && settings.remote.enabled
+          return "Remote Configuration is not enabled. See https://docs.datadoghq.com/agent/remote_config"
+        end
+        unless settings.dynamic_instrumentation.internal.development
+          if Datadog::Core::Environment::Execution.development?
+            return "development environment detected"
+          end
+        end
+        if (reason = unsupported_platform_reason)
+          return reason
+        end
+        unless respond_to?(:exception_message)
+          return "C extension is not available"
+        end
+        nil
+      end
+
+      # Whether the current Ruby runtime can run dynamic instrumentation:
+      # MRI (CRuby) on Ruby 2.6 or later.
+      #
+      # @return [Boolean]
+      def supported_runtime?
+        unsupported_platform_reason.nil?
+      end
+
+      # Reason the current Ruby runtime cannot run dynamic instrumentation, or
+      # nil when the platform is supported. Single source of truth for the
+      # minimum-runtime definition, shared by {unsupported_reason} (which layers
+      # the settings and C-extension checks on top) and {supported_runtime?}.
+      #
+      # @return [String, nil]
+      private def unsupported_platform_reason
+        if RUBY_ENGINE != 'ruby'
+          "MRI is required, but running on #{RUBY_ENGINE}"
+        elsif Datadog::RubyVersion.is?('< 2.6')
+          "Ruby 2.6+ is required, but running on #{RUBY_VERSION}"
+        end
+      end
+
       # Returns iseqs that correspond to loaded files (filtering out eval'd code).
       #
       # There are several types of iseqs returned by +all_iseqs+:

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

@@ -9,14 +9,17 @@ module Datadog
       module Events
         # The second version of Business Logic Events SDK
         module V2
+          SIGNUP_EVENT = 'users.signup'
           LOGIN_SUCCESS_EVENT = 'users.login.success'
           LOGIN_FAILURE_EVENT = 'users.login.failure'
+
           TELEMETRY_METRICS_NAMESPACE = 'appsec'
           TELEMETRY_METRICS_SDK_EVENT = 'sdk.event'
           TELEMETRY_METRICS_SDK_VERSION = 'v2'
           TELEMETRY_METRICS_EVENTS_INTO_TYPES = {
             LOGIN_SUCCESS_EVENT => 'login_success',
-            LOGIN_FAILURE_EVENT => 'login_failure'
+            LOGIN_FAILURE_EVENT => 'login_failure',
+            SIGNUP_EVENT => 'signup'
           }.freeze
 
           class << self
@@ -125,6 +128,61 @@ module Datadog
               ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
             end
 
+            # Attach user signup information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_or_id [String, Hash<Symbol, String>] (optional) If a
+            #   String, considered as a user ID, if a Hash, considered as a user
+            #   attributes. The Hash must include `:id` as a key.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_signup('alice@example.com')
+            #
+            # @example Login, user attributes, and metadata
+            #   Datadog::Kit::AppSec::Events::V2.track_user_signup(
+            #     'alice@example.com',
+            #     { id: 'user-123', email: 'alice@example.com', name: 'Alice' },
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_signup(login, user_or_id = nil, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              user_attributes = build_user_attributes(user_or_id, login)
+
+              set_span_tags(span, metadata, namespace: SIGNUP_EVENT)
+              set_span_tags(span, user_attributes, namespace: "#{SIGNUP_EVENT}.usr")
+              span.set_tag('appsec.events.users.signup.track', 'true')
+              span.set_tag('_dd.appsec.events.users.signup.sdk', 'true')
+
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
+
+              record_event_telemetry_metric(SIGNUP_EVENT)
+
+              if user_attributes.key?(:id)
+                Kit::Identity.set_user(trace, span, **user_attributes)
+              else
+                # NOTE: {Datadog::Kit::Identity.set_user} requires an ID,
+                #       but WAF can evaluate login alone
+                user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+                ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+              end
+            end
+
             private
 
             # NOTE: Current tracer implementation does not provide a way to
@@ -155,7 +213,7 @@ module Datadog
                 raise ArgumentError, 'missing required user key `:id`' unless user_or_id.key?(:id)
                 raise TypeError, 'user key `:id` must be a String' unless user_or_id[:id].is_a?(String)
 
-                user_or_id.merge(login: login) #: {login: ::String, ?id: ::String?}
+                user_or_id.merge(login: login)
               else
                 raise TypeError, '`user_or_id` argument must be either String or Hash'
               end

data/lib/datadog/open_feature/component.rb

@@ -12,7 +12,7 @@ module Datadog
   module OpenFeature
     # This class is the entry point for the OpenFeature component
     class Component
-      attr_reader :engine, :flag_eval_hook
+      attr_reader :engine, :flag_eval_metrics_hook, :flag_eval_evp_hook
 
       def self.build(settings, agent_settings, logger:, telemetry:)
         return unless settings.respond_to?(:open_feature) && settings.open_feature.enabled
@@ -54,21 +54,44 @@ module Datadog
 
         @telemetry = telemetry
         @logger = logger
-        @flag_eval_hook = create_flag_eval_hook
+        @settings = settings
+        @agent_settings = agent_settings
+        @flag_eval_metrics_hook = create_flag_eval_metrics_hook
+        @flag_eval_evp_hook = create_flag_eval_evp_hook
       end
 
       def shutdown!
         @worker.graceful_shutdown
+        @flag_eval_evp_writer&.stop
       end
 
       private
 
-      def create_flag_eval_hook
-        require_relative 'hooks/flag_eval_hook'
-        return unless Hooks::FlagEvalHook.available?
+      def create_flag_eval_metrics_hook
+        require_relative 'hooks/flag_eval_metrics_hook'
+        return unless Hooks::FlagEvalMetricsHook.available?
 
         metrics = Metrics::FlagEvalMetrics.new(telemetry: @telemetry, logger: @logger)
-        Hooks::FlagEvalHook.new(metrics)
+        Hooks::FlagEvalMetricsHook.new(metrics)
+      rescue LoadError
+        nil
+      end
+
+      # Killswitch: DD_FLAGGING_EVALUATION_COUNTS_ENABLED (default on) gates only the EVP path.
+      # Read through the datadog config registry, not raw ENV.
+      def create_flag_eval_evp_hook
+        return unless @settings.open_feature.evaluation_counts_enabled
+
+        require_relative 'hooks/flag_eval_evp_hook'
+        return unless Hooks::FlagEvalEVPHook.available?
+
+        evp_transport = Transport::HTTP.build_flagevaluations(
+          agent_settings: @agent_settings,
+          logger: @logger,
+        )
+        require_relative 'flag_evaluation/writer'
+        @flag_eval_evp_writer = FlagEvaluation::Writer.new(transport: evp_transport, logger: @logger, telemetry: @telemetry)
+        Hooks::FlagEvalEVPHook.new(@flag_eval_evp_writer)
       rescue LoadError
         nil
       end

data/lib/datadog/open_feature/configuration.rb

@@ -20,6 +20,14 @@ module Datadog
                 o.env 'DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED'
                 o.default false
               end
+
+              # Killswitch for the EVP `flagevaluation` emission path only. Default on; when
+              # disabled the existing OTel `feature_flag.evaluations` metric is unaffected.
+              option :evaluation_counts_enabled do |o|
+                o.type :bool
+                o.env 'DD_FLAGGING_EVALUATION_COUNTS_ENABLED'
+                o.default true
+              end
             end
           end
         end

data/lib/datadog/open_feature/ext.rb

@@ -4,8 +4,10 @@ module Datadog
   module OpenFeature
     module Ext
       ERROR = 'ERROR'
+      DEFAULT = 'DEFAULT'
       INITIALIZING = 'INITIALIZING'
       UNKNOWN_TYPE = 'UNKNOWN_TYPE'
+      PARSE_ERROR = 'PARSE_ERROR'
       GENERAL = 'GENERAL'
       PROVIDER_FATAL = 'PROVIDER_FATAL'
       PROVIDER_NOT_READY = 'PROVIDER_NOT_READY'

data/lib/datadog/open_feature/flag_evaluation/aggregator.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module FlagEvaluation
+      # Two-tier aggregation for EVP flagevaluation events.
+      #
+      # Two-tier design:
+      # - full-tier  key: (flag_key, variant, allocation_key, runtime_default, error_message, targeting_key, canonical_context_key)
+      # - degraded-tier key: (flag_key, variant, allocation_key, runtime_default, error_message)
+      # - Drop-and-count when degraded tier is full
+      # - canonical_context_key: sorted type-tagged length-delimited encoding (no hash digest)
+      # - Caps: global_cap=131_072 / per_flag_cap=10_000 / degraded_cap=32_768
+      # - Context pruning: 256 fields / 256 chars (matches flageval-worker backend limits)
+      class Aggregator
+        MAX_CONTEXT_FIELDS = 256
+        MAX_FIELD_LENGTH = 256
+        MAX_CONTEXT_DEPTH = 32
+
+        # Type tags so values of different Ruby types never collide in the canonical key.
+        CTX_TAG_STRING = 's'
+        CTX_TAG_BOOL = 'b'
+        CTX_TAG_INTEGER = 'i'
+        CTX_TAG_FLOAT = 'f'
+        CTX_TAG_OTHER = 'o'
+
+        EVAL_SCALE_TARGET_FLAGS = 2_500
+        EVAL_SCALE_FULL_BUCKETS_PER_FLAG = 50
+        EVAL_SCALE_USERS_PER_FLAG = 1_000
+        EVAL_SCALE_PER_FLAG_HEADROOM_MULTIPLIER = 10
+        EVAL_SCALE_DEGRADED_BUCKETS_PER_FLAG = 10
+        EVAL_SCALE_FULL_BUCKET_TARGET = EVAL_SCALE_TARGET_FLAGS * EVAL_SCALE_FULL_BUCKETS_PER_FLAG
+        EVAL_SCALE_PER_FLAG_BUCKET_TARGET = EVAL_SCALE_PER_FLAG_HEADROOM_MULTIPLIER * EVAL_SCALE_USERS_PER_FLAG
+        EVAL_SCALE_DEGRADED_BUCKET_TARGET = EVAL_SCALE_TARGET_FLAGS * EVAL_SCALE_DEGRADED_BUCKETS_PER_FLAG
+
+        DEFAULT_GLOBAL_CAP = 131_072
+        DEFAULT_PER_FLAG_CAP = EVAL_SCALE_PER_FLAG_BUCKET_TARGET
+        DEFAULT_DEGRADED_CAP = 32_768
+
+        attr_reader :dropped_degraded_overflow
+
+        def initialize(
+          global_cap: DEFAULT_GLOBAL_CAP,
+          per_flag_cap: DEFAULT_PER_FLAG_CAP,
+          degraded_cap: DEFAULT_DEGRADED_CAP
+        )
+          @global_cap = global_cap
+          @per_flag_cap = per_flag_cap
+          @degraded_cap = degraded_cap
+
+          @mutex = Mutex.new
+          # full-tier: Array key -> Hash entry
+          @full = {}
+          # degraded-tier: Array key -> Hash entry
+          @degraded = {}
+          # per-flag full-bucket count for per_flag_cap enforcement
+          @per_flag_full = Hash.new(0)
+          @global_count = 0
+          @dropped_degraded_overflow = 0
+        end
+
+        # Record one evaluation event. Thread-safe. Called from the background writer.
+        def record(
+          flag_key:, variant:, allocation_key:, targeting_key:, eval_time_ms:, attrs:, error_message: nil,
+          runtime_default: nil
+        )
+          runtime_default = variant.nil? if runtime_default.nil?
+          runtime_default = !!runtime_default
+
+          # Normalize nil/empty strings
+          variant = variant.to_s
+          allocation_key = allocation_key.to_s
+          error_message = error_message.to_s
+          targeting_key = targeting_key.to_s
+
+          # Context pruning + canonical key (see prune_context and canonical_context_key).
+          # Runs in the background writer so caller eval threads do not pay the flatten/prune cost.
+          pruned_context = prune_context(attrs)
+          context_key = canonical_context_key(pruned_context)
+
+          full_key = [flag_key, variant, allocation_key, runtime_default, error_message, targeting_key, context_key]
+          evaluation_time_ms = eval_time_ms.to_i
+
+          @mutex.synchronize do
+            # --- Full tier ---
+            if (entry = @full[full_key])
+              observe(entry, evaluation_time_ms)
+              return
+            end
+
+            per_flag_count = @per_flag_full[flag_key]
+            if per_flag_count >= @per_flag_cap
+              add_to_degraded(flag_key, variant, allocation_key, runtime_default, error_message, evaluation_time_ms)
+              return
+            end
+
+            # Count the full-tier attempt before checking the global cap so per-flag overflow stays
+            # active even when the global full-tier cap is already saturated.
+            @per_flag_full[flag_key] = per_flag_count + 1
+
+            if @global_count < @global_cap
+              entry = new_entry(
+                evaluation_time_ms,
+                runtime_default: runtime_default,
+                error_message: error_message,
+                targeting_key: targeting_key,
+                context_attrs: pruned_context
+              )
+              @full[full_key] = entry
+              @global_count += 1
+            else
+              # Route to degraded tier
+              add_to_degraded(flag_key, variant, allocation_key, runtime_default, error_message, evaluation_time_ms)
+            end
+          end
+        end
+
+        # Flush aggregation maps, reset state, return snapshot.
+        # Returns { full: Hash, degraded: Hash, dropped_degraded_overflow: Integer }.
+        # The overflow count is included in the snapshot so the caller can EMIT it before it is
+        # reset — the count is never reset-without-emit (backpressure stays observable).
+        def flush_and_reset
+          @mutex.synchronize do
+            full_snapshot = @full
+            degraded_snapshot = @degraded
+            dropped_snapshot = @dropped_degraded_overflow
+
+            @full = {}
+            @degraded = {}
+            @per_flag_full = Hash.new(0)
+            @global_count = 0
+            @dropped_degraded_overflow = 0
+
+            {full: full_snapshot, degraded: degraded_snapshot, dropped_degraded_overflow: dropped_snapshot}
+          end
+        end
+
+        # Prune context: keep first MAX_CONTEXT_FIELDS fields (sorted), skip string values >256 chars.
+        # Keys are sorted before pruning to ensure deterministic subset selection.
+        def prune_context(attrs)
+          self.class.prune_context(attrs)
+        end
+
+        def self.prune_context(attrs)
+          flattened_context = flatten_context(attrs)
+          return {} if flattened_context.empty?
+
+          pruned_context = {}
+          count = 0
+          flattened_context.keys.sort.each do |key|
+            break if count >= MAX_CONTEXT_FIELDS
+
+            value = flattened_context[key]
+            # Skip oversized string values (mirrors flageval-worker pruning behavior).
+            next if value.is_a?(String) && value.length > MAX_FIELD_LENGTH
+
+            pruned_context[key] = value
+            count += 1
+          end
+          pruned_context
+        end
+
+        def self.flatten_context(attrs)
+          return {} unless attrs.is_a?(Hash) && !attrs.empty?
+
+          flattened_context = {}
+          seen = {attrs.object_id => true}
+          attrs.each do |key, value|
+            flatten_value(key.to_s, value, flattened_context, seen, 0)
+          end
+          flattened_context
+        end
+
+        # Canonical context key: sorted type-tagged length-delimited encoding.
+        # Each field is: 8-byte big-endian key length + key bytes + type-tag byte +
+        #                8-byte big-endian value length + value bytes.
+        # No hash digest — the key IS the full encoding (collision-free, no FNV).
+        def canonical_context_key(attrs)
+          return '' if attrs.nil? || attrs.empty?
+
+          buffer = String.new('', encoding: Encoding::BINARY)
+          attrs.keys.sort.each do |key|
+            value = attrs[key]
+            buffer << length_delimited(key.to_s)
+            buffer << context_value_bytes(value)
+          end
+          buffer
+        end
+
+        def self.flatten_value(prefix, value, output, seen, depth)
+          return if depth > MAX_CONTEXT_DEPTH
+
+          case value
+          when Hash
+            object_id = value.object_id
+            return if seen[object_id]
+
+            seen[object_id] = true
+            value.each do |key, child_value|
+              flatten_value("#{prefix}.#{key}", child_value, output, seen, depth + 1)
+            end
+            seen.delete(object_id)
+          when Array
+            object_id = value.object_id
+            return if seen[object_id]
+
+            seen[object_id] = true
+            value.each_with_index do |child_value, index|
+              flatten_value("#{prefix}.#{index}", child_value, output, seen, depth + 1)
+            end
+            seen.delete(object_id)
+          else
+            output[prefix] = value unless value.nil?
+          end
+        end
+        private_class_method :flatten_value
+
+        private
+
+        def context_value_bytes(value)
+          tag, encoded = case value
+          when String then [CTX_TAG_STRING, value.to_s]
+          when TrueClass, FalseClass then [CTX_TAG_BOOL, value.to_s]
+          when Integer then [CTX_TAG_INTEGER, value.to_s]
+          when Float then [CTX_TAG_FLOAT, value.to_s]
+          else [CTX_TAG_OTHER, value.to_s]
+          end
+          String.new(tag, encoding: Encoding::BINARY) + length_delimited(encoded)
+        end
+
+        # 8-byte big-endian length prefix + raw bytes. Unambiguous field boundary.
+        def length_delimited(string)
+          bytes = string.encode(Encoding::BINARY, invalid: :replace, undef: :replace)
+          byte_length = bytes.bytesize
+          # Build 8-byte big-endian length
+          length_bytes = String.new('', encoding: Encoding::BINARY)
+          8.times do |index|
+            length_bytes.prepend(((byte_length >> (8 * index)) & 0xFF).chr(Encoding::BINARY))
+          end
+          length_bytes + bytes
+        end
+
+        def new_entry(evaluation_time_ms, runtime_default:, error_message: nil, targeting_key: nil, context_attrs: nil)
+          {
+            count: 1,
+            first_evaluation: evaluation_time_ms,
+            last_evaluation: evaluation_time_ms,
+            runtime_default: runtime_default,
+            error_message: error_message,
+            targeting_key: targeting_key,
+            context_attrs: context_attrs,
+          }
+        end
+
+        def observe(entry, evaluation_time_ms)
+          entry[:count] += 1
+          entry[:first_evaluation] = evaluation_time_ms if evaluation_time_ms < entry[:first_evaluation]
+          entry[:last_evaluation] = evaluation_time_ms if evaluation_time_ms > entry[:last_evaluation]
+        end
+
+        def add_to_degraded(flag_key, variant, allocation_key, runtime_default, error_message, evaluation_time_ms)
+          degraded_key = [flag_key, variant, allocation_key, runtime_default, error_message]
+
+          if (entry = @degraded[degraded_key])
+            observe(entry, evaluation_time_ms)
+            return
+          end
+
+          # New degraded bucket — check degraded_cap (terminal tier)
+          if @degraded.size >= @degraded_cap
+            # Terminal tier full — drop and count (explicit overflow counter)
+            @dropped_degraded_overflow += 1
+            return
+          end
+
+          # Degraded entry omits targeting_key + context_attrs (schema omitempty fields)
+          @degraded[degraded_key] = new_entry(
+            evaluation_time_ms,
+            runtime_default: runtime_default,
+            error_message: error_message
+          )
+        end
+      end
+    end
+  end
+end