datadog 2.46.0 → 2.47.0

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -7,6 +7,7 @@ require_relative "../http"
 require_relative "../analytics"
 require_relative "ext"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 require_relative "../../../core/telemetry/logger"
 
 module Datadog
@@ -45,7 +46,8 @@ module Datadog
 
           # rubocop:disable Metrics/AbcSize
           def annotate!(span, env, options)
-            span.resource = resource_name(env)
+            path = env[:url].path
+            span.resource = resource_name(env, path)
             span.service = service_name(env[:url].host, options)
             span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -69,7 +71,7 @@ module Datadog
               Contrib::Analytics.set_sample_rate(span, options[:analytics_sample_rate])
             end
 
-            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, env[:url].path)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, env[:method].to_s.upcase)
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, env[:url].host)
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, env[:url].port)
@@ -103,8 +105,12 @@ module Datadog
             Contrib::HTTP.inject(trace, env[:request_headers])
           end
 
-          def resource_name(env)
-            env[:method].to_s.upcase
+          def resource_name(env, path)
+            Contrib::Utils::Quantization::HTTP.client_resource(
+              env[:method].to_s.upcase,
+              path,
+              enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+            )
           end
 
           def build_request_options!(env)

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

@@ -34,7 +34,12 @@ module Datadog
                 span.service = service_name(host, request_options, client_config)
                 span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
-                span.resource = req.method
+                quantize_resource = Datadog.configuration.tracing.http_client_resource_name_quantize
+                span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                  req.method,
+                  quantize_resource ? request_uri_path(req) : nil,
+                  enabled: quantize_resource
+                )
 
                 if Tracing::Distributed::PropagationPolicy.enabled?(
                   pin_config: client_config,
@@ -116,6 +121,16 @@ module Datadog
 
             private
 
+            def request_uri_path(request)
+              uri = request.uri if request.respond_to?(:uri)
+              return uri.path if uri
+              return request.path.split(/[?#]/, 2).first if request.path.start_with?("/")
+
+              URI.parse(request.path).path
+            rescue URI::InvalidURIError
+              nil
+            end
+
             def host_and_port(request)
               if request.respond_to?(:uri) && request.uri
                 [request.uri.host, request.uri.port]

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

@@ -4,6 +4,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "../analytics"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 require_relative "../../../core/telemetry/logger"
 
 module Datadog
@@ -74,10 +75,15 @@ module Datadog
 
               http_method = req.header.request_method.upcase
               uri = req.header.request_uri
+              path = uri.path
 
-              span.resource = http_method
+              span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                http_method,
+                path,
+                enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+              )
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
 

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

@@ -4,6 +4,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "../analytics"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 require_relative "../../../core/telemetry/logger"
 
 module Datadog
@@ -70,17 +71,22 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
 
+              uri = req.uri
+              path = uri&.path
               if req.verb&.is_a?(String) || req.verb.is_a?(Symbol)
                 http_method = req.verb.to_s.upcase
-                span.resource = http_method
+                span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                  http_method,
+                  path,
+                  enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+                )
                 span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
               else
                 logger.debug("service #{req_options[:service_name]} span #{Ext::SPAN_REQUEST} missing request verb")
               end
 
-              if req.uri
-                uri = req.uri
-                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              if uri
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
 

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -6,6 +6,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "../analytics"
 require_relative "ext"
+require_relative "../utils/quantization/http"
 
 module Datadog
   module Tracing
@@ -38,7 +39,13 @@ module Datadog
 
             def datadog_tag_request(uri, span)
               span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
-              span.resource = method.to_s.upcase
+              http_method = method.to_s.upcase
+              path = uri.path
+              span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                http_method,
+                path,
+                enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+              )
 
               if datadog_configuration[:peer_service]
                 span.set_tag(
@@ -57,8 +64,8 @@ module Datadog
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, method.to_s.upcase)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
               span.set_tags(

data/lib/datadog/tracing/contrib/utils/quantization/http.rb

@@ -20,6 +20,96 @@ module Datadog
 
             module_function
 
+            def client_resource(method, path, enabled:)
+              return method unless enabled && path
+
+              resource = method.dup
+              resource << (+" ").force_encoding(resource.encoding)
+              quantized_path = quantize_path(decode_path(path))
+              resource << quantized_path.force_encoding(resource.encoding)
+            end
+
+            def decode_path(path)
+              decoded = String.new(encoding: Encoding::BINARY)
+              index = 0
+
+              while index < path.bytesize
+                byte = path.getbyte(index)
+                break unless byte
+
+                if byte == 37 && index + 2 < path.bytesize
+                  high_byte = path.getbyte(index + 1)
+                  low_byte = path.getbyte(index + 2)
+                  if high_byte && low_byte
+                    high = decode_hex_byte(high_byte)
+                    low = decode_hex_byte(low_byte)
+                    if high && low
+                      decoded << high * 16 + low
+                      index += 3
+                      next
+                    end
+                  end
+                end
+
+                decoded << byte
+                index += 1
+              end
+
+              decoded.force_encoding(path.encoding)
+            end
+
+            def quantize_path(path)
+              slash = (+"/").force_encoding(path.encoding)
+              normalized = if path.getbyte(0) == 47
+                path
+              else
+                String.new(encoding: path.encoding) << slash << path
+              end
+
+              output = String.new(encoding: path.encoding)
+              index = 1
+              replacements = 0
+
+              while index < normalized.bytesize
+                segment_end = index
+                allowed = 0
+                digits = 0
+                specials = 0
+
+                while segment_end < normalized.bytesize && normalized.getbyte(segment_end) != 47
+                  byte = normalized.getbyte(segment_end)
+                  break unless byte
+
+                  if byte.between?(48, 57)
+                    digits += 1
+                  elsif byte.between?(65, 90) || byte.between?(97, 122) || byte == 45 || byte == 95
+                    allowed += 1
+                  else
+                    specials += 1
+                  end
+                  segment_end += 1
+                end
+
+                output << slash
+                segment = normalized.byteslice(index, segment_end - index) || String.new(encoding: path.encoding)
+                if normalized.getbyte(index) == 118 && allowed == 1 && digits > 0 && specials.zero?
+                  output << segment
+                elsif specials > 0 || digits > 0
+                  output << (+"*").force_encoding(path.encoding)
+                  replacements += 1
+                else
+                  output << segment
+                end
+
+                index = segment_end + 1
+              end
+
+              return normalized.dup if replacements.zero?
+
+              output << slash if normalized.getbyte(normalized.bytesize - 1) == 47
+              output
+            end
+
             def url(url, options = {})
               url!(url, options)
             rescue
@@ -118,6 +208,18 @@ module Datadog
 
             private_class_method :collect_query
 
+            def decode_hex_byte(byte)
+              if byte.between?(48, 57)
+                byte - 48
+              elsif byte.between?(65, 70)
+                byte - 55
+              elsif byte.between?(97, 102)
+                byte - 87
+              end
+            end
+
+            private_class_method :decode_hex_byte
+
             # Scans over the query string and obfuscates sensitive data by
             # replacing matches with an opaque value
             def obfuscate_query(query, options = {})

data/lib/datadog/tracing/remote.rb

@@ -62,6 +62,8 @@ module Datadog
 
           # @type var parsed: Array[[::Datadog::Core::Remote::Configuration::Content, ::Hash[::String, untyped]]]
           parsed = []
+          # @type var unparseable_contents: Array[Datadog::Core::Remote::Configuration::Content]
+          unparseable_contents = []
           repository.contents.each do |content|
             next unless content.path.product == PRODUCT
 
@@ -76,9 +78,8 @@ module Datadog
               # A present but non-object lib_config (e.g. {"lib_config": []}) is a
               # schema violation the customer can fix. Acknowledging it as applied
               # would tell the backend the config was successfully applied when it
-              # was not, and an empty merge would revert active tracing overrides
-              # to their non-RC values. Reject it per content so the malformed
-              # payload is reported errored instead. A null or absent lib_config
+              # was not. Reject it per content so the malformed payload is
+              # reported errored instead. A null or absent lib_config
               # carries no overrides and is left as a no-op.
               lib_config = config["lib_config"]
               if !lib_config.nil? && !lib_config.is_a?(Hash)
@@ -92,6 +93,7 @@ module Datadog
                 description: "Failed to parse APM_TRACING remote config",
               )
               content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
+              unparseable_contents << content
             end
           end
 
@@ -117,10 +119,26 @@ module Datadog
           # deterministic merge.
           ordered = applicable.sort_by { |content, config| [-config_priority(config), content.path.config_id] }
           merged = merge_lib_configs(ordered.map { |_content, config| config })
+          # The applicable configs carrying a non-null dynamic_instrumentation_enabled
+          # value: any of their paths can still supply the signal after a later
+          # replacement, so the DI component records them all.
+          # @type var enable_signal_paths: Array[Datadog::Core::Remote::Configuration::Path]
+          enable_signal_paths = Core::Utils::EnumerableCompat.filter_map(ordered) do |pair|
+            content, config = pair
+            lib_config = config["lib_config"]
+            if lib_config.is_a?(Hash) && !lib_config["dynamic_instrumentation_enabled"].nil?
+              content.path
+            end
+          end
 
           # Applied even when the set is empty: an emptied repository (last config
           # removed) reverts the tracing overrides to their non-RC values.
-          apply_lib_config(merged, repository)
+          apply_lib_config(
+            merged,
+            repository,
+            unparseable_contents: unparseable_contents,
+            enable_signal_paths: enable_signal_paths,
+          )
 
           parsed.each { |content, _config| content.applied }
           nil
@@ -205,8 +223,10 @@ module Datadog
         #
         # @param lib_config [Hash[String, untyped]] the lib_config to apply
         # @param repository [Core::Remote::Configuration::Repository, nil] forwarded to DI enablement
+        # @param unparseable_contents [Array<Core::Remote::Configuration::Content>] the APM_TRACING contents that failed to parse
+        # @param enable_signal_paths [Array<Core::Remote::Configuration::Path>] the paths of the applicable configs carrying the field
         # @return [nil]
-        def apply_lib_config(lib_config, repository)
+        def apply_lib_config(lib_config, repository, unparseable_contents:, enable_signal_paths:)
           env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
             value = lib_config[name]
 
@@ -218,13 +238,30 @@ module Datadog
             [env_var, telemetry_value]
           end
 
-          if (di_enabled = lib_config["dynamic_instrumentation_enabled"]) != nil # rubocop:disable Style/NonNilCheck
-            # repository is forwarded so that an enable signal can reconcile DI
-            # against probes delivered in an earlier poll while DI was stopped
-            # (see Datadog::DI::Remote.handle_rc_enablement).
+          di_enabled = lib_config["dynamic_instrumentation_enabled"]
+          # allow_initialization: false because this runs on the remote-config worker
+          # thread, and the default would build the component tree from that thread.
+          components = Datadog.send(:components, allow_initialization: false)
+          di_component = components&.dynamic_instrumentation
+          if di_enabled.nil? && di_component&.rc_enablement_signal_withdrawn?(unparseable_contents)
+            di_enabled = false
+          end
+
+          # Records the parsed carrier paths and the previously recorded paths whose
+          # replacements remain unparseable, on every merge including merges that keep
+          # the DI state.
+          if di_component
+            unparseable_recorded_paths = di_component.rc_enablement_signal_paths.select do |path|
+              unparseable_contents.any? { |content| content.path == path }
+            end
+            di_component.record_rc_enablement_signal_paths(enable_signal_paths + unparseable_recorded_paths)
+          end
+
+          unless di_enabled.nil?
+            # repository is forwarded for the stopped->started replay in
+            # Datadog::DI::Remote.handle_rc_enablement.
             Datadog::DI::Remote.handle_rc_enablement(di_enabled, repository)
 
-            components = Datadog.send(:components, allow_initialization: false)
             di_products = Datadog::DI::Remote.products +
               Datadog::SymbolDatabase::Remote.deferred_products(Datadog.configuration)
 
@@ -236,7 +273,7 @@ module Datadog
               # by DD_DYNAMIC_INSTRUMENTATION_ENABLED=false. Advertising then would
               # report DI as in use when it is not and invite probe configs the
               # tracer must refuse; withdraw the products otherwise.
-              if components&.dynamic_instrumentation&.started?
+              if di_component&.started?
                 components&.remote&.add_products(*di_products)
               else
                 components&.remote&.remove_products(*di_products)
@@ -249,13 +286,7 @@ module Datadog
             Datadog.logger.debug { "APM_TRACING RC: merged dynamic_instrumentation_enabled=#{di_enabled}" }
           end
 
-          # allow_initialization: false because this runs on the remote-config
-          # worker thread. If components haven't been built yet (e.g. during a
-          # teardown/reset window), the default value would synchronously build
-          # the entire component tree from this thread. The &. chain matches the
-          # pattern used by DI::Remote.handle_rc_enablement in the same dispatch
-          # path.
-          Datadog.send(:components, allow_initialization: false)&.telemetry&.client_configuration_change!(env_vars)
+          components&.telemetry&.client_configuration_change!(env_vars)
           nil
         end
 
@@ -269,7 +300,7 @@ module Datadog
 
         def receiver(products = [PRODUCT], &block)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
-          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+          [Core::Remote::Dispatcher::Receiver.new(matcher, initial_reconcile: true, &block)]
         end
 
         private

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 46
+    MINOR = 47
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.46.0
+  version: 2.47.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -49,28 +49,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.30.0.0.0
+        version: 1.30.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.30.0.0.0
+        version: 1.30.0.1.0
 - !ruby/object:Gem::Dependency
   name: libdatadog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 46.0.0.1.1
+        version: 46.1.0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 46.0.0.1.1
+        version: 46.1.0.1.1
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -342,7 +342,6 @@ files:
 - lib/datadog/appsec/thread_safe_ref.rb
 - lib/datadog/appsec/trace_keeper.rb
 - lib/datadog/appsec/utils.rb
-- lib/datadog/appsec/utils/hash_coercion.rb
 - lib/datadog/appsec/utils/http.rb
 - lib/datadog/appsec/utils/http/body.rb
 - lib/datadog/appsec/utils/http/body_reader.rb
@@ -611,6 +610,7 @@ files:
 - lib/datadog/open_feature/ext.rb
 - lib/datadog/open_feature/flag_evaluation/aggregator.rb
 - lib/datadog/open_feature/flag_evaluation/writer.rb
+- lib/datadog/open_feature/hooks/evaluation_telemetry_opt_out_hook.rb
 - lib/datadog/open_feature/hooks/flag_eval_evp_hook.rb
 - lib/datadog/open_feature/hooks/flag_eval_metrics_hook.rb
 - lib/datadog/open_feature/hooks/span_enrichment_hook.rb
@@ -1199,8 +1199,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.46.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.46.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.47.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.47.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths:

data/lib/datadog/appsec/utils/hash_coercion.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Utils
-      # A module for coercing arbitrary objects into hashes.
-      module HashCoercion
-        # A best effort to coerce an object to a hash with methods known to various
-        # frameworks with a fallback to standard library.
-        #
-        # @param object [Object] The object to coerce.
-        # @return [Hash, nil] The coerced `Hash` or `nil` if the object is not coercible.
-        def self.coerce(object)
-          return object.as_json if object.respond_to?(:as_json)
-          return object.to_hash if object.respond_to?(:to_hash)
-          return object.to_h if object.respond_to?(:to_h)
-
-          nil
-        end
-      end
-    end
-  end
-end