datadog 2.33.0 → 2.35.0

data/lib/datadog/appsec/contrib/rack/request_middleware.rb

@@ -9,9 +9,11 @@ require_relative 'gateway/response'
 require_relative '../../event'
 require_relative '../../response'
 require_relative '../../api_security'
+require_relative '../../default_header_tags'
 require_relative '../../security_event'
 require_relative '../../instrumentation/gateway'
 
+require_relative '../../../core/header_collection'
 require_relative '../../../tracing/client_ip'
 require_relative '../../../tracing/contrib/rack/header_collection'
 
@@ -19,24 +21,6 @@ module Datadog
   module AppSec
     module Contrib
       module Rack
-        RESPONSE_HEADERS_TAGS = %w[
-          content-length
-          content-type
-          content-encoding
-          content-language
-        ].freeze
-
-        WAF_VENDOR_HEADERS_TAGS = %w[
-          X-Amzn-Trace-Id
-          Cloudfront-Viewer-Ja3-Fingerprint
-          Cf-Ray
-          X-Cloud-Trace-Context
-          X-Appgw-Trace-id
-          X-SigSci-RequestID
-          X-SigSci-Tags
-          Akamai-User-Risk
-        ].map(&:downcase).freeze
-
         # Topmost Rack middleware for AppSec
         # This should be inserted just below Datadog::Tracing::Contrib::Rack::TraceMiddleware
         class RequestMiddleware
@@ -44,7 +28,6 @@ module Datadog
             @app = app
 
             @oneshot_tags_sent = false
-            @rack_headers = {}
           end
 
           # rubocop:disable Metrics/MethodLength
@@ -186,38 +169,28 @@ module Datadog
           end
           # standard:enable Metrics/MethodLength
 
-          # standard:disable Metrics/MethodLength
           def add_request_tags(context, env)
             span = context.span
             return unless span
 
-            # Always add WAF vendors headers
-            WAF_VENDOR_HEADERS_TAGS.each do |lowercase_header|
-              rack_header = to_rack_header(lowercase_header)
-              span.set_tag("http.request.headers.#{lowercase_header}", env[rack_header]) if env[rack_header]
-            end
-
-            if span && span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP).nil?
-              request_header_collection = Datadog::Tracing::Contrib::Rack::Header::RequestHeaderCollection.new(env)
+            headers = Tracing::Contrib::Rack::Header::RequestHeaderCollection.new(env)
+            AppSec::DefaultHeaderTags.tag_request(span, headers)
 
+            if span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP).nil?
               # always collect client ip, as this is part of AppSec provided functionality
               Datadog::Tracing::ClientIp.set_client_ip_tag!(
-                span,
-                headers: request_header_collection,
-                remote_ip: env['REMOTE_ADDR']
+                span, headers: headers, remote_ip: env['REMOTE_ADDR']
               )
             end
           end
-          # standard:enable Metrics/MethodLength
 
           def add_response_tags(context, response)
             span = context.span
             return unless span
 
-            RESPONSE_HEADERS_TAGS.each do |name|
-              value = response.headers[name]
-              span.set_tag("http.response.headers.#{name}", value.to_s) if value
-            end
+            AppSec::DefaultHeaderTags.tag_response(
+              span, Datadog::Core::HeaderCollection.from_hash(response.headers)
+            )
 
             unless response.headers.key?('content-length')
               length = ResponseBody.content_length(response.body)
@@ -228,10 +201,6 @@ module Datadog
           def oneshot_tags_sent?
             @oneshot_tags_sent
           end
-
-          def to_rack_header(header)
-            @rack_headers[header] ||= Datadog::Tracing::Contrib::Rack::Header.to_rack_header(header)
-          end
         end
       end
     end

data/lib/datadog/appsec/default_header_tags.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    # Sets the always-on span tags built from a fixed allowlist of request and
+    # response headers.
+    #
+    # NOTE: Unlike {Event#record}, which reports request headers only when
+    #       a security event fires, these are tagged on every request/response
+    #
+    # @api private
+    module DefaultHeaderTags
+      WAF_VENDOR_HEADERS_TAGS = %w[
+        x-amzn-trace-id
+        cloudfront-viewer-ja3-fingerprint
+        cf-ray
+        x-cloud-trace-context
+        x-appgw-trace-id
+        x-sigsci-requestid
+        x-sigsci-tags
+        akamai-user-risk
+      ].freeze
+
+      RESPONSE_HEADERS_TAGS = %w[
+        content-length
+        content-type
+        content-encoding
+        content-language
+      ].freeze
+
+      module_function
+
+      def tag_request(span, headers)
+        WAF_VENDOR_HEADERS_TAGS.each do |name|
+          value = headers.get(name)
+          span.set_tag("http.request.headers.#{name}", value) if value
+        end
+      end
+
+      def tag_response(span, headers)
+        RESPONSE_HEADERS_TAGS.each do |name|
+          value = headers.get(name)
+          span.set_tag("http.response.headers.#{name}", value.to_s) if value
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,8 @@ require_relative '../../profiling/component'
 require_relative '../../appsec/component'
 require_relative '../../ai_guard/component'
 require_relative '../../di/component'
+require_relative '../../symbol_database'
+require_relative '../../symbol_database/component'
 require_relative '../../open_feature/component'
 require_relative '../../error_tracking/component'
 require_relative '../crashtracking/component'
@@ -120,6 +122,7 @@ module Datadog
           :ai_guard,
           :agent_info,
           :data_streams,
+          :symbol_database,
           :open_feature
 
         def initialize(settings)
@@ -133,7 +136,7 @@ module Datadog
           self.class::PATCH_ONLY_ONCE.run do
             Utils::AtForkMonkeyPatch.apply!
             Utils::SpawnMonkeyPatch.apply!(
-              lineage_envs_provider: Core::Environment::Identity.method(:runtime_propagation_envs),
+              env_provider: Core::Environment::Identity.method(:runtime_propagation_envs),
             )
 
             # Register callback that calls Components.after_fork
@@ -171,6 +174,7 @@ module Datadog
           @ai_guard = Datadog::AIGuard::Component.build(settings, logger: @logger, telemetry: telemetry)
           @open_feature = OpenFeature::Component.build(settings, agent_settings, logger: @logger, telemetry: telemetry)
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
+          @symbol_database = Datadog::SymbolDatabase::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
           @error_tracking = Datadog::ErrorTracking::Component.build(settings, @tracer, @logger)
           @data_streams = self.class.build_data_streams(settings, agent_settings, @logger, @agent_info)
           @environment_logger_extra[:dynamic_instrumentation_enabled] = !!@dynamic_instrumentation
@@ -241,6 +245,9 @@ module Datadog
           # Shutdown DI after remote, since remote config triggers DI operations.
           dynamic_instrumentation&.shutdown!
 
+          # Shutdown Symbol Database
+          symbol_database&.shutdown!
+
           # Shutdown OpenFeature component
           open_feature&.shutdown!
 

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

@@ -6,6 +6,7 @@ require_relative 'base'
 require_relative 'ext'
 require_relative '../environment/execution'
 require_relative '../environment/ext'
+require_relative '../environment/process'
 require_relative '../runtime/ext'
 require_relative '../telemetry/ext'
 require_relative '../remote/ext'
@@ -106,6 +107,7 @@ module Datadog
         option :api_key do |o|
           o.type :string, nilable: true
           o.env Core::Environment::Ext::ENV_API_KEY
+          o.skip_telemetry true
         end
 
         # Datadog diagnostic settings.
@@ -393,16 +395,19 @@ module Datadog
               o.default false
             end
 
-            # Controls data collection for the timeline feature.
-            #
-            # If you needed to disable this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>,
-            # so we can fix it!
-            #
-            # @default `DD_PROFILING_TIMELINE_ENABLED` environment variable as a boolean, otherwise `true`
+            # DEV-3.0: Remove `timeline_enabled` option
             option :timeline_enabled do |o|
               o.type :bool
               o.env 'DD_PROFILING_TIMELINE_ENABLED'
               o.default true
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Core.log_deprecation(key: :timeline_enabled) do
+                    'The profiling.advanced.timeline_enabled setting has been deprecated for removal and no longer does anything. ' \
+                      'Please remove it from your Datadog.configure block and do not set DD_PROFILING_TIMELINE_ENABLED.'
+                  end
+                end
+              end
             end
 
             # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
@@ -692,12 +697,16 @@ module Datadog
           o.env Core::Environment::Ext::ENV_SERVICE
           o.default Core::Environment::Ext::FALLBACK_SERVICE_NAME
 
+          o.after_set do |service_name|
+            Core::Environment::Process.set_service(service_name, user_configured: !using_default?(:service))
+          end
+
           # There's a few cases where we don't want to use the fallback service name, so this helper allows us to get a
           # nil instead so that one can do
           # nice_service_name = Datadog.configuration.service_without_fallback || nice_service_name_default
           o.helper(:service_without_fallback) do
             service_name = service
-            service_name unless service_name.equal?(Core::Environment::Ext::FALLBACK_SERVICE_NAME)
+            service_name unless using_default?(:service)
           end
         end
 

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

@@ -70,6 +70,7 @@ module Datadog
           "DD_INSTRUMENTATION_TELEMETRY_ENABLED",
           "DD_INTERNAL_FORCE_SYMBOL_DATABASE_UPLOAD",
           "DD_LOGS_INJECTION",
+          "DD_LOGS_OTEL_ENABLED",
           "DD_METRICS_OTEL_ENABLED",
           "DD_METRIC_AGENT_PORT",
           "DD_PROFILING_ALLOCATION_ENABLED",
@@ -350,8 +351,16 @@ module Datadog
           "DD_TRACE_WATERDROP_ENABLED",
           "DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH",
           "DD_VERSION",
+          "OTEL_BLRP_EXPORT_TIMEOUT",
+          "OTEL_BLRP_MAX_EXPORT_BATCH_SIZE",
+          "OTEL_BLRP_MAX_QUEUE_SIZE",
+          "OTEL_BLRP_SCHEDULE_DELAY",
           "OTEL_EXPORTER_OTLP_ENDPOINT",
           "OTEL_EXPORTER_OTLP_HEADERS",
+          "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+          "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+          "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL",
+          "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT",
           "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
           "OTEL_EXPORTER_OTLP_METRICS_HEADERS",
           "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL",
@@ -359,6 +368,7 @@ module Datadog
           "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT",
           "OTEL_EXPORTER_OTLP_PROTOCOL",
           "OTEL_EXPORTER_OTLP_TIMEOUT",
+          "OTEL_LOGS_EXPORTER",
           "OTEL_LOG_LEVEL",
           "OTEL_METRICS_EXPORTER",
           "OTEL_METRIC_EXPORT_INTERVAL",

data/lib/datadog/core/environment/ext.rb

@@ -45,6 +45,10 @@ module Datadog
         TAG_RAILS_APPLICATION = "rails.application"
         TAG_PROCESS_TAGS = "_dd.tags.process"
         TAG_SERVICE = 'service'
+        # Service name was automatically populated by this library
+        TAG_SVC_AUTO = 'svc.auto'
+        # Service name was explicitly configured by the library user
+        TAG_SVC_USER = 'svc.user'
         TAG_VERSION = 'version'
 
         GEM_DATADOG_VERSION = Datadog::VERSION::STRING

data/lib/datadog/core/environment/identity.rb

@@ -76,7 +76,21 @@ module Datadog
           Core::Environment::Ext::GEM_DATADOG_VERSION
         end
 
-        # Returns tracer version, comforming to https://semver.org/spec/v2.0.0.html
+        # Returns the tracer version in SemVer-2 form (https://semver.org/spec/v2.0.0.html).
+        #
+        # Converts the RubyGems-style version returned by {.gem_datadog_version}
+        # (dot-separated prerelease/build segments, e.g. "2.34.0.dev") into the
+        # SemVer-2 form expected by cross-language Datadog consumers (hyphen-separated
+        # prerelease, "+" build metadata, e.g. "2.34.0-dev").
+        #
+        # Called by reporters that emit a tracer version on the wire and must match
+        # the format used by other-language tracers:
+        # - process discovery memfd (`Core::ProcessDiscovery.get_metadata` → `tracer_version`)
+        # - telemetry payloads (`Core::Telemetry::Request#application`)
+        # - remote configuration client identification (`Core::Remote::Client#tracer_version`)
+        #
+        # Use {.gem_datadog_version} (not this method) when a RubyGems-style string is
+        # required (e.g. gem-internal contexts, gemspec interop).
         def gem_datadog_version_semver2
           major, minor, patch, rest = gem_datadog_version.split('.', 4)
 

data/lib/datadog/core/environment/process.rb

@@ -10,18 +10,17 @@ module Datadog
       #
       # @api private
       module Process
-        # This method returns a key/value part of serialized tags in the format of k1:v1,k2:v2,k3:v3
-        # @return [String] comma-separated normalized key:value pairs
+        # Returns a comma-separated string of normalized key:value pairs.
+        # Includes svc.user or svc.auto based on whether the service was explicitly configured.
+        # @return [String]
         def self.serialized
-          return @serialized if defined?(@serialized)
-
-          @serialized = tags.join(',').freeze
+          tags.join(',').freeze
         end
 
-        # This method returns an array in the format ["k1:v1","k2:v2","k3:v3"]
-        # @return [Array<String>] array of normalized key:value pairs
+        # Returns an array of normalized key:value pair strings.
+        # Includes svc.user or svc.auto based on whether the service was explicitly configured.
+        # @return [Array<String>]
         def self.tags
-          return @tags if defined?(@tags)
           tags = []
 
           workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
@@ -35,17 +34,46 @@ module Datadog
 
           tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
 
-          rails_application_name = TagNormalizer.normalize_process_value(@rails_application_name.to_s)
-          tags << "#{Environment::Ext::TAG_RAILS_APPLICATION}:#{rails_application_name}" unless rails_application_name.empty?
+          if defined?(@rails_application_name)
+            rails_name = TagNormalizer.normalize_process_value(@rails_application_name.to_s)
+            tags << "#{Environment::Ext::TAG_RAILS_APPLICATION}:#{rails_name}" unless rails_name.empty?
+          end
+
+          if defined?(@service_user_configured)
+            if @service_user_configured
+              tags << "#{Environment::Ext::TAG_SVC_USER}:true"
+            else
+              svc = TagNormalizer.normalize_process_value(@service_name.to_s)
+              tags << "#{Environment::Ext::TAG_SVC_AUTO}:#{svc}" unless svc.empty?
+            end
+          end
+
+          tags.freeze
+        end
+
+        # Called via after_set on option :service in settings.rb whenever the service value changes.
+        # @param name [String] the service name
+        # @param user_configured [Boolean] whether the service was explicitly set by the user
+        # @return [void]
+        def self.set_service(name, user_configured:)
+          @service_name = name
+          @service_user_configured = user_configured
+        end
 
-          @tags = tags.freeze
+        # Sets the rails application name from other places in code
+        # @param name [String] the rails application name
+        # @return [void]
+        def self.rails_application_name=(name)
+          @rails_application_name = name
         end
 
         # Returns the last segment of the working directory of the process
         # Example: /app/myapp -> myapp
         # @return [String] the last segment of the working directory
         def self.entrypoint_workdir
-          File.basename(Dir.pwd)
+          return @entrypoint_workdir if defined?(@entrypoint_workdir)
+
+          @entrypoint_workdir = File.basename(Dir.pwd)
         end
 
         # Returns the entrypoint type of the process
@@ -55,10 +83,10 @@ module Datadog
           Environment::Ext::PROCESS_TYPE
         end
 
-        # Returns the last segment of the base directory of the process
+        # Returns the basename of the script being run
         # Example 1: /bin/mybin -> mybin
-        # Example 2: ruby /test/myapp.rb -> myapp
-        # @return [String] the last segment of base directory of the script
+        # Example 2: ruby /test/myapp.rb -> myapp.rb
+        # @return [String] the basename of the script
         #
         # @note Determining true entrypoint name is rather complicated. This method
         # is the initial implementation but it does not produce optimal output in all cases.
@@ -66,12 +94,14 @@ module Datadog
         # as their entrypoint name.
         # We might improve the behavior in the future if there is customer demand for it.
         def self.entrypoint_name
-          File.basename($0)
+          return @entrypoint_name if defined?(@entrypoint_name)
+
+          @entrypoint_name = File.basename($0)
         end
 
-        # Returns the last segment of the base directory of the process
+        # Returns the last segment of the directory containing the script
         # Example 1: /bin/mybin -> bin
-        # Example 2: ruby /test/myapp.js -> test
+        # Example 2: ruby /test/myapp.rb -> test
         # @return [String] the last segment of the base directory of the script
         #
         # @note As with entrypoint name, determining true entrypoint directory is complicated.
@@ -80,16 +110,9 @@ module Datadog
         # the entrypoint basedir is `bin` which is not very helpful.
         # We might improve this in the future if there is customer demand.
         def self.entrypoint_basedir
-          File.basename(File.expand_path(File.dirname($0)))
-        end
+          return @entrypoint_basedir if defined?(@entrypoint_basedir)
 
-        # Sets the rails application name from other places in code
-        # @param name [String] the rails application name
-        # @return [void]
-        def self.rails_application_name=(name)
-          @rails_application_name = name
-          remove_instance_variable(:@tags) if instance_variable_defined?(:@tags)
-          remove_instance_variable(:@serialized) if instance_variable_defined?(:@serialized)
+          @entrypoint_basedir = File.basename(File.expand_path(File.dirname($0)))
         end
 
         private_class_method :entrypoint_workdir, :entrypoint_type, :entrypoint_name, :entrypoint_basedir

data/lib/datadog/core/remote/client/capabilities.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../../utils/base64'
+require_relative '../../utils/base64_codec'
 require_relative '../../../appsec/remote'
 require_relative '../../../tracing/remote'
+require_relative '../../../di/remote'
+require_relative '../../../symbol_database/remote'
 require_relative '../../../open_feature/remote'
 
 module Datadog
@@ -37,6 +39,13 @@ module Datadog
               register_capabilities(Datadog::DI::Remote.capabilities)
               register_products(Datadog::DI::Remote.products)
               register_receivers(Datadog::DI::Remote.receivers(@telemetry))
+
+              # Symbol Database
+              if settings.respond_to?(:symbol_database) && settings.symbol_database.enabled
+                register_capabilities(Datadog::SymbolDatabase::Remote.capabilities)
+                register_products(Datadog::SymbolDatabase::Remote.products)
+                register_receivers(Datadog::SymbolDatabase::Remote.receivers(@telemetry))
+              end
             end
 
             if settings.respond_to?(:open_feature) && settings.open_feature.enabled
@@ -68,7 +77,7 @@ module Datadog
             cap_to_hexs = capabilities.reduce(:|).to_s(16).tap { |s| s.size.odd? && s.prepend('0') }.scan(/\h\h/)
             binary = cap_to_hexs.each_with_object([]) { |hex, acc| acc << hex }.map { |e| e.to_i(16) }.pack('C*')
 
-            Datadog::Core::Utils::Base64.strict_encode64(binary)
+            Datadog::Core::Utils::Base64Codec.strict_encode64(binary)
           end
         end
       end

data/lib/datadog/core/remote/transport/http/config.rb

@@ -4,7 +4,7 @@ require 'json'
 
 require_relative '../../../transport/http/api/endpoint'
 require_relative '../../../transport/http/response'
-require_relative '../../../utils/base64'
+require_relative '../../../utils/base64_codec'
 require_relative '../../../utils/truncation'
 
 module Datadog
@@ -35,7 +35,7 @@ module Datadog
 
                 # TODO: these fallbacks should be improved
                 roots = payload[:roots] || []
-                targets = payload[:targets] || Datadog::Core::Utils::Base64.strict_encode64('{}')
+                targets = payload[:targets] || Datadog::Core::Utils::Base64Codec.strict_encode64('{}')
                 target_files = payload[:target_files] || []
                 client_configs = payload[:client_configs] || []
 
@@ -45,7 +45,7 @@ module Datadog
                   raise TypeError.new(String, root) unless root.is_a?(String)
 
                   decoded = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
                   rescue ArgumentError
                     raise DecodeError.new(:roots, root)
                   end
@@ -65,7 +65,7 @@ module Datadog
 
                 @targets = begin
                   decoded = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(targets)
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(targets)
                   rescue ArgumentError
                     raise DecodeError.new(:targets, targets)
                   end
@@ -93,7 +93,7 @@ module Datadog
                   raise TypeError.new(String, raw) unless raw.is_a?(String)
 
                   content = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(raw)
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(raw)
                   rescue ArgumentError
                     raise DecodeError.new(:target_files, raw)
                   end

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

@@ -10,8 +10,6 @@ module Datadog
       # Module defining methods for collecting metadata for telemetry
       module Request
         class << self
-          using Core::Utils::Hash::Refinement
-
           def build_payload(event, seq_id, debug: false)
             hash = {
               api_version: 'v2',

data/lib/datadog/core/transport/response.rb

@@ -70,7 +70,7 @@ module Datadog
         end
 
         def to_s
-          "#{super}, error_type:#{error.class} error:#{error}"
+          "#{self.class}, error_type:#{error.class} error:#{error}"
         end
 
         def inspect

data/lib/datadog/core/utils/{base64.rb → base64_codec.rb}

@@ -3,8 +3,9 @@
 module Datadog
   module Core
     module Utils
-      # Helper methods for encoding and decoding base64
-      module Base64
+      # Base64 encoding/decoding without using the `base64` gem,
+      # which is no longer a default gem since Ruby 3.4.
+      module Base64Codec
         def self.encode64(bin)
           [bin].pack('m')
         end

data/lib/datadog/core/utils/{array.rb → enumerable_compat.rb}

@@ -3,8 +3,8 @@
 module Datadog
   module Core
     module Utils
-      # Common array-related utility functions.
-      module Array
+      # Bring newer Enumerable methods to older Ruby versions.
+      module EnumerableCompat
         def self.filter_map(array, &block)
           if array.respond_to?(:filter_map)
             # DEV Supported since Ruby 2.7, saves an intermediate object creation

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

@@ -3,30 +3,7 @@
 module Datadog
   module Core
     module Utils
-      # Refinements for {Hash}.
       module Hash
-        # This refinement ensures modern rubies are allowed to use newer,
-        # simpler, and more performant APIs.
-        module Refinement
-          # Introduced in Ruby 2.4
-          unless ::Hash.method_defined?(:compact)
-            refine ::Hash do
-              def compact
-                reject { |_k, v| v.nil? }
-              end
-            end
-          end
-
-          # Introduced in Ruby 2.4
-          unless ::Hash.method_defined?(:compact!)
-            refine ::Hash do
-              def compact!
-                reject! { |_k, v| v.nil? }
-              end
-            end
-          end
-        end
-
         # A minimal {Hash} wrapper that provides case-insensitive access
         # to hash keys, without the overhead of copying the original hash.
         #