datadog 2.18.0 → 2.19.0

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

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative '../../identity'
+
+module Datadog
+  module Kit
+    module AppSec
+      module Events
+        # The second version of Business Logic Events SDK
+        module V2
+          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'
+          }.freeze
+
+          class << self
+            # Attach user login success 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_login_success('alice@example.com')
+            #
+            # @example Login and user attributes
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success(
+            #     '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_login_success(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: LOGIN_SUCCESS_EVENT)
+              set_span_tags(span, user_attributes, namespace: "#{LOGIN_SUCCESS_EVENT}.usr")
+              span.set_tag('appsec.events.users.login.success.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.success.sdk', 'true')
+
+              trace.keep!
+
+              record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_SUCCESS_EVENT)
+
+              # NOTE: Guard-clause will not work with Steep typechecking
+              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id) # steep:ignore
+
+              # NOTE: This is a fallback for the case when we don't have an ID,
+              #       but need to trigger WAF.
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            # Attach user login failure information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_exists [Boolean] Whether the user exists in the system.
+            # @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_login_failure('alice@example.com')
+            #
+            # @example With user existence and metadata
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure(
+            #     'alice@example.com',
+            #     true,
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_failure(login, user_exists = false, 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)
+
+              unless user_exists.is_a?(TrueClass) || user_exists.is_a?(FalseClass)
+                raise TypeError, '`user_exists` argument must be a boolean'
+              end
+
+              set_span_tags(span, metadata, namespace: LOGIN_FAILURE_EVENT)
+              span.set_tag('appsec.events.users.login.failure.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.failure.sdk', 'true')
+              span.set_tag('appsec.events.users.login.failure.usr.login', login)
+              span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists.to_s)
+
+              trace.keep!
+
+              record_event_telemetry_metric(LOGIN_FAILURE_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_FAILURE_EVENT)
+
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            private
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_trace
+              return Datadog::Tracing.active_trace unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.trace
+            end
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_span
+              return Datadog::Tracing.active_span unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.span
+            end
+
+            def build_user_attributes(user_or_id, login)
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+
+              case user_or_id
+              when nil
+                { login: login }
+              when String
+                { login: login, id: user_or_id }
+              when Hash
+                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)
+              else
+                raise TypeError, '`user_or_id` argument must be either String or Hash'
+              end
+            end
+
+            def set_span_tags(span, tags, namespace:)
+              tags.each do |name, value|
+                next if value.nil?
+
+                span.set_tag("appsec.events.#{namespace}.#{name}", value)
+              end
+            end
+
+            # TODO: In case if we need to introduce telemetry metrics to the SDK v1
+            #       or highly increase the number of metrics, this method should be
+            #       extracted into a proper module.
+            def record_event_telemetry_metric(event)
+              telemetry = ::Datadog.send(:components, allow_initialization: false)&.telemetry
+
+              if telemetry.nil?
+                return Datadog.logger.debug(
+                  'Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics'
+                )
+              end
+
+              tags = {
+                event_type: TELEMETRY_METRICS_EVENTS_INTO_TYPES[event],
+                sdk_version: TELEMETRY_METRICS_SDK_VERSION
+              }
+              telemetry.inc(TELEMETRY_METRICS_NAMESPACE, TELEMETRY_METRICS_SDK_EVENT, 1, tags: tags)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -23,6 +23,7 @@ module Datadog
           allocation_profiling_enabled:,
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
+          sighandler_sampling_enabled:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -49,6 +50,7 @@ module Datadog
             allocation_profiling_enabled: allocation_profiling_enabled,
             allocation_counting_enabled: allocation_counting_enabled,
             gvl_profiling_enabled: gvl_profiling_enabled,
+            sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
           )
           @worker_thread = nil

data/lib/datadog/profiling/collectors/info.rb

@@ -28,6 +28,37 @@ module Datadog
 
         private
 
+        # Ruby GC tuning environment variables
+        RUBY_GC_TUNING_ENV_VARS = [
+          "RUBY_GC_HEAP_FREE_SLOTS",
+          "RUBY_GC_HEAP_GROWTH_FACTOR",
+          "RUBY_GC_HEAP_GROWTH_MAX_SLOTS",
+          "RUBY_GC_HEAP_FREE_SLOTS_MIN_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_MAX_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_GOAL_RATIO",
+          "RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR",
+          "RUBY_GC_HEAP_REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO",
+          "RUBY_GC_MALLOC_LIMIT",
+          "RUBY_GC_MALLOC_LIMIT_MAX",
+          "RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR",
+          "RUBY_GC_OLDMALLOC_LIMIT",
+          "RUBY_GC_OLDMALLOC_LIMIT_MAX",
+          "RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR",
+          # INIT_SLOTS changed for Ruby 3.3+:
+          # * https://bugs.ruby-lang.org/issues/19785
+          # * https://www.ruby-lang.org/en/news/2023/12/25/ruby-3-3-0-released/#:~:text=Removed%20environment%20variables
+          "RUBY_GC_HEAP_0_INIT_SLOTS",
+          "RUBY_GC_HEAP_1_INIT_SLOTS",
+          "RUBY_GC_HEAP_2_INIT_SLOTS",
+          "RUBY_GC_HEAP_3_INIT_SLOTS",
+          "RUBY_GC_HEAP_4_INIT_SLOTS",
+          # There was only one setting for older Rubies:
+          "RUBY_GC_HEAP_INIT_SLOTS",
+          # Ruby 2.x only, alias for others:
+          "RUBY_FREE_MIN",
+          "RUBY_HEAP_MIN_SLOTS",
+        ].freeze
+
         # Instead of trying to figure out real process start time by checking
         # /proc or some other complex/non-portable way, approximate start time
         # by time of requirement of this file.
@@ -51,6 +82,7 @@ module Datadog
             engine: Datadog::Core::Environment::Identity.lang_engine,
             version: Datadog::Core::Environment::Identity.lang_version,
             platform: Datadog::Core::Environment::Identity.lang_platform,
+            gc_tuning: collect_gc_tuning_info,
           }.freeze
         end
 
@@ -109,6 +141,15 @@ module Datadog
             v.inspect
           end
         end
+
+        def collect_gc_tuning_info
+          return @gc_tuning_info if defined?(@gc_tuning_info)
+
+          @gc_tuning_info = RUBY_GC_TUNING_ENV_VARS.each_with_object({}) do |var, hash|
+            current_value = ENV[var]
+            hash[var.to_sym] = current_value if current_value
+          end.freeze
+        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -67,6 +67,7 @@ module Datadog
           allocation_profiling_enabled: allocation_profiling_enabled,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
           gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
+          sighandler_sampling_enabled: settings.profiling.advanced.sighandler_sampling_enabled,
         )
 
         internal_metadata = {

data/lib/datadog/profiling/exporter.rb

@@ -26,7 +26,8 @@ module Datadog
         :last_flush_finish_at,
         :created_at,
         :internal_metadata,
-        :info_json
+        :info_json,
+        :sequence_tracker
 
       public
 
@@ -37,7 +38,8 @@ module Datadog
         code_provenance_collector:,
         internal_metadata:,
         minimum_duration_seconds: PROFILE_DURATION_THRESHOLD_SECONDS,
-        time_provider: Time
+        time_provider: Time,
+        sequence_tracker: Datadog::Profiling::SequenceTracker
       )
         @pprof_recorder = pprof_recorder
         @worker = worker
@@ -50,6 +52,7 @@ module Datadog
         # NOTE: At the time of this comment collected info does not change over time so we'll hardcode
         #       it on startup to prevent serializing the same info on every flush.
         @info_json = JSON.generate(info_collector.info).freeze
+        @sequence_tracker = sequence_tracker
       end
 
       def flush
@@ -73,7 +76,10 @@ module Datadog
           encoded_profile: encoded_profile,
           code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
           code_provenance_data: uncompressed_code_provenance,
-          tags_as_array: Datadog::Profiling::TagBuilder.call(settings: Datadog.configuration).to_a,
+          tags_as_array: Datadog::Profiling::TagBuilder.call(
+            settings: Datadog.configuration,
+            profile_seq: sequence_tracker.get_next,
+          ).to_a,
           internal_metadata: internal_metadata.merge(
             {
               worker_stats: worker_stats,

data/lib/datadog/profiling/sequence_tracker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils/forking'
+
+module Datadog
+  module Profiling
+    # Used to generate the `profile_seq` tag, which effectively counts how many profiles we've attempted to report
+    # from a given runtime-id.
+    #
+    # Note that the above implies a few things:
+    # 1. The sequence number only gets incremented when we decide to report a profile and create a `Flush` for it
+    # 2. The `SequenceTracker` must live across profiler reconfigurations and resets, since no matter how many
+    #    profiler instances get created due to reconfiguration, the runtime-id is still the same, so the sequence number
+    #    should be kept and not restarted from 0
+    # 3. The `SequenceTracker` must be reset after a fork, since the runtime-id will change, and we want to start
+    #    counting from 0 again
+    #
+    # This is why this module is implemented as a singleton that we reuse, not as an instance that we recreate.
+    #
+    # Note that this module is not thread-safe, so it's up to the callers to make sure
+    # it's only used by a single thread at a time (which is what the `Profiling::Exporter`)
+    # is doing.
+    module SequenceTracker
+      class << self
+        include Core::Utils::Forking
+
+        def get_next
+          reset! unless defined?(@sequence_number)
+          after_fork! { reset! }
+
+          next_seq = @sequence_number
+          @sequence_number += 1
+          next_seq
+        end
+
+        private
+
+        def reset!
+          @sequence_number = 0
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/tag_builder.rb

@@ -12,10 +12,12 @@ module Datadog
       def self.call(
         settings:,
         # Other metadata
+        profile_seq:,
         profiler_version: Core::Environment::Identity.gem_datadog_version
       )
         hash = Core::TagBuilder.tags(settings).merge(
           FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
+          'profile_seq' => profile_seq.to_s,
         )
         Core::Utils.encode_tags(hash)
       end

data/lib/datadog/profiling.rb

@@ -157,6 +157,7 @@ module Datadog
       require_relative 'profiling/native_extension'
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'
+      require_relative 'profiling/sequence_tracker'
 
       replace_noop_allocation_count
 

data/lib/datadog/single_step_instrument.rb

@@ -5,8 +5,17 @@
 #
 # This file's path is private. Do not reference this file.
 #
+
+module Datadog
+  # This module handles conditional loading of single step auto-instrumentation,
+  # which enables Datadog tracing and profiling features when available.
+  module SingleStepInstrument
+  end
+end
+
 begin
   require_relative 'auto_instrument'
+  Datadog::SingleStepInstrument::LOADED = true
 rescue StandardError, LoadError => e
   warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -45,9 +45,15 @@ module Datadog
                 'cache_write_multi.active_support' => { resource: Ext::RESOURCE_CACHE_MSET, multi_key: true }
               }.freeze
 
-              def trace?(event, _payload)
+              def trace?(event, payload)
                 return false if !Tracing.enabled? || !configuration.enabled
 
+                if (cache_store = configuration[:cache_store])
+                  store = cache_backend(payload[:store])
+
+                  return false unless cache_store.include?(store)
+                end
+
                 # DEV-3.0: Backwards compatibility code for the 2.x gem series.
                 # DEV-3.0: See documentation at {Datadog::Tracing::Contrib::ActiveSupport::Cache::Instrumentation}
                 # DEV-3.0: for the complete information about this backwards compatibility code.

data/lib/datadog/tracing/contrib/active_support/configuration/settings.rb

@@ -49,6 +49,19 @@ module Datadog
                 o.default true
               end
             end
+
+            # Specifies which cache stores to trace.
+            # Accepts a list, with the same format as `config.cache_store`
+            # (e.g. `memory_store`, `file_store`, or symbols like `:file_store`).
+            # Defaults to `nil`, which traces all cache stores.
+            # @see https://github.com/rails/rails/blob/b7520a13adda46c0cc5f3fb4a4c1726633af2bba/guides/source/caching_with_rails.md?plain=1#L576-L582
+            option :cache_store do |o|
+              o.type :array, nilable: true
+              o.default nil
+              o.after_set do |stores|
+                stores&.map!(&:to_s) # Convert symbols to strings to match the Rails configuration format
+              end
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/mysql2/instrumentation.rb

@@ -45,16 +45,13 @@ module Datadog
                 span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
 
-                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+                tag_database_instance(span, query_options[:database])
+
+                set_span_tags(span, query_options)
 
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-                span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, query_options[:database])
-                span.set_tag(Ext::TAG_DB_NAME, query_options[:database])
-                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, query_options[:host])
-                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, query_options[:port])
-
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
 
                 sql = inject_propagation(span, sql, trace_op)
@@ -91,6 +88,19 @@ module Datadog
             def analytics_sample_rate
               datadog_configuration[:analytics_sample_rate]
             end
+
+            def tag_database_instance(span, database)
+              return if database.nil? || database.empty?
+
+              span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, database)
+              span.set_tag(Ext::TAG_DB_NAME, database)
+            end
+
+            def set_span_tags(span, query_options)
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, query_options[:host])
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, query_options[:port])
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/rails/patcher.rb

@@ -86,7 +86,10 @@ module Datadog
 
           # Instruments the `bin/rails runner` command.
           def patch_rails_runner
-            ::Rails::Command.singleton_class.prepend(Command) if defined?(::Rails::Command)
+            # The `RunnerCommand` class is only available in Rails 5.1 and later.
+            if defined?(::Rails::Command::RunnerCommand) && Integration.version >= Gem::Version.new('5.1')
+              ::Rails::Command::RunnerCommand.prepend(Runner)
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -10,34 +10,48 @@ module Datadog
         # * `-`: for code provided through the STDIN.
         # * File path: for code provided through a local file.
         # * `inline code`: for code provided directly as a command line argument.
+        #
+        # The difficulty in instrumenting the Rails Runner is that
+        # the Rails application (and as a consequence the Datadog tracing library)
+        # is loaded very late in the runner execution.
+        # The Rails application is loaded inside the same method the method
+        # that directly executes the code the user wants the runner to execute:
+        #
+        # ```ruby
+        # def perform(code_or_file = nil, *command_argv)
+        #   boot_application! # Loads the Rails and Datadog
+        #
+        #   if code_or_file == "-"
+        #     eval($stdin.read, TOPLEVEL_BINDING, "stdin") # Calls the user code for this Runner
+        #   # ...
+        # ```
+        #
+        # This means that there's no time to instrument the calling method, `perform`, which
+        # would be ideal. Instead, we resort to instrumenting `eval` and `load`, but
+        # only for calls from the `Rails::Command::RunnerCommand` class.
+        #
         # @see https://guides.rubyonrails.org/v6.1/command_line.html#bin-rails-runner
         module Runner
           # Limit the maximum size of the source code captured in the source tag.
           MAX_TAG_VALUE_SIZE = 4096
           private_constant :MAX_TAG_VALUE_SIZE
 
-          def runner(code_or_file = nil, *_command_argv)
-            if code_or_file == '-'
+          # Instruments the `Kernel.eval` method, but only for the
+          # `Rails::Command::RunnerCommand` class.
+          def eval(*args)
+            source = args[0]
+
+            if args[2] == 'stdin'
               name = Ext::SPAN_RUNNER_STDIN
-              resource = nil
               operation = Ext::TAG_OPERATION_STDIN
-              # The source is not yet available for STDIN, but it will be captured in `eval`.
-            elsif File.exist?(code_or_file)
-              name = Ext::SPAN_RUNNER_FILE
-              resource = code_or_file
-              operation = Ext::TAG_OPERATION_FILE
-              source = File.read(code_or_file)
             else
               name = Ext::SPAN_RUNNER_INLINE
-              resource = nil
               operation = Ext::TAG_OPERATION_INLINE
-              source = code_or_file
             end
 
             Tracing.trace(
               name,
               service: Datadog.configuration.tracing[:rails][:service_name],
-              resource: resource,
               tags: {
                 Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
                 Tracing::Metadata::Ext::TAG_OPERATION => operation,
@@ -55,39 +69,46 @@ module Datadog
             end
           end
 
-          # Capture the executed source code when provided from STDIN.
-          def eval(*args)
-            span = Datadog::Tracing.active_span
-            if span&.name == Ext::SPAN_RUNNER_STDIN
-              source = args[0]
-              span.set_tag(
-                Ext::TAG_RUNNER_SOURCE,
-                Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
-              )
-            end
-
-            super
+          def self.prepend(base)
+            base.const_set(:Kernel, Kernel)
           end
 
-          ruby2_keywords :eval if respond_to?(:ruby2_keywords, true)
-        end
+          # Instruments the `Kernel.load` method, but only for the
+          # `Rails::Command::RunnerCommand` class.
+          module Kernel
+            def self.load(file, wrap = true)
+              name = Ext::SPAN_RUNNER_FILE
+              resource = file
+              operation = Ext::TAG_OPERATION_FILE
+
+              begin
+                # Reads one more byte than the limit to allow us to check if the source exceeds the limit.
+                source = File.read(file, MAX_TAG_VALUE_SIZE + 1)
+              rescue => e
+                Datadog.logger.debug("Failed to read file '#{file}' for Rails runner: #{e.message}")
+              end
 
-        # The instrumentation target, {Rails::Command::RunnerCommand} is only loaded
-        # right before `bin/rails runner` is executed. This means there's not much
-        # opportunity to patch it ahead of time.
-        # To ensure we can patch it successfully, we patch it's caller, {Rails::Command}
-        # and promptly patch {Rails::Command::RunnerCommand} when it is loaded.
-        module Command
-          def find_by_namespace(*args)
-            ret = super
-            # Patch RunnerCommand if it is loaded and not already patched.
-            if defined?(::Rails::Command::RunnerCommand) && !(::Rails::Command::RunnerCommand < Runner)
-              ::Rails::Command::RunnerCommand.prepend(Runner)
+              Tracing.trace(
+                name,
+                service: Datadog.configuration.tracing[:rails][:service_name],
+                resource: resource,
+                tags: {
+                  Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
+                  Tracing::Metadata::Ext::TAG_OPERATION => operation,
+                }
+              ) do |span|
+                if source
+                  span.set_tag(
+                    Ext::TAG_RUNNER_SOURCE,
+                    Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
+                  )
+                end
+                Contrib::Analytics.set_rate!(span, Datadog.configuration.tracing[:rails])
+
+                super
+              end
             end
-            ret
           end
-
-          ruby2_keywords :find_by_namespace if respond_to?(:ruby2_keywords, true)
         end
       end
     end

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -84,7 +84,7 @@ module Datadog
           # @return [Numeric, nil] tracer sample rate configured
           def sample_rate
             sampler = Datadog.configuration.tracing.sampler
-            return nil unless sampler
+            return Datadog.configuration.tracing.sampling.default_rate unless sampler
 
             sampler.sample_rate(nil) rescue nil
           end
@@ -97,6 +97,8 @@ module Datadog
           # @return [Hash, nil] sample rules configured
           def sampling_rules
             sampler = Datadog.configuration.tracing.sampler
+            return Datadog.configuration.tracing.sampling.rules unless sampler
+
             return nil unless sampler.is_a?(Tracing::Sampling::PrioritySampler) &&
               sampler.priority_sampler.is_a?(Tracing::Sampling::RuleSampler)
 

data/lib/datadog/tracing/span_event.rb

@@ -56,7 +56,7 @@ module Datadog
         attr = {}
         @attributes.each do |key, value|
           attr[key] = if value.is_a?(Array)
-                        { type: ARRAY_TYPE, array_value: value.map { |v| serialize_native_attribute(v) } }
+                        { type: ARRAY_TYPE, array_value: { values: value.map { |v| serialize_native_attribute(v) } } }
                       else
                         serialize_native_attribute(value)
                       end