ddtrace 1.12.1 → 1.13.0

data/lib/datadog/tracing/distributed/trace_context.rb

@@ -44,7 +44,15 @@ module Datadog
 
           tracestate, sampling_priority, origin, tags, unknown_fields = extract_tracestate(fetcher[@tracestate_key])
 
-          sampling_priority = parse_priority_sampling(sampled, sampling_priority)
+          sampling_priority = parse_priority_sampling(sampled, sampling_priority) do |decision|
+            case decision
+            when String
+              tags ||= {}
+              tags[Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER] = decision
+            when :drop
+              tags.delete(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER) if tags
+            end
+          end
 
           TraceDigest.new(
             span_id: parent_id,
@@ -160,8 +168,10 @@ module Datadog
             tracestate.chop! # Removes trailing `;` from Datadog trace state string.
 
             if digest.trace_state
+              trace_state = digest.trace_state.strip
+
               # Delete existing `dd=` tracestate fields, if present.
-              vendors = split_tracestate(digest.trace_state)
+              vendors = split_tracestate(trace_state)
               vendors.reject! { |v| v.start_with?('dd=') }
             end
 
@@ -179,13 +189,21 @@ module Datadog
         end
 
         # If any characters in <origin_value> are invalid, replace each invalid character with 0x5F (underscore).
-        # Invalid characters are: characters outside the ASCII range 0x20 to 0x7E, 0x2C (comma), and 0x3D (equals).
+        # Invalid characters are: characters outside the ASCII range 0x20 to 0x7E,
+        # 0x2C (comma), 0x3B (semi-colon), and 0x7E (tilde).
+        # Then, remap 0x3D (equals) to 0x7E (tilde)
         def serialize_origin(value)
           # DEV: It's unlikely that characters will be out of range, as they mostly
           # DEV: come from Datadog-controlled sources.
           # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
-          if INVALID_ORIGIN_CHARS.match?(value)
-            value.gsub(INVALID_ORIGIN_CHARS, '_')
+          value = if INVALID_ORIGIN_CHARS.match?(value)
+                    value.gsub(INVALID_ORIGIN_CHARS, '_')
+                  else
+                    value
+                  end
+
+          if REMAP_ORIGIN_CHARS.match?(value)
+            value.gsub(REMAP_ORIGIN_CHARS, '~')
           else
             value
           end
@@ -245,13 +263,15 @@ module Datadog
 
           version, trace_id, parent_id, trace_flags, extra = traceparent.strip.split('-')
 
+          return if version.size != 2 || version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
+
           return if version == INVALID_VERSION
 
           # Extra fields are not allowed in version 00, but we have to be lenient for future versions.
           return if version == SPEC_VERSION && extra
 
           # Invalid field sizes
-          return if version.size != 2 || trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
+          return if trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
 
           [Integer(trace_id, 16), Integer(parent_id, 16), Integer(trace_flags, 16)]
         rescue ArgumentError # Conversion to integer failed
@@ -324,20 +344,31 @@ module Datadog
 
         # If `sampled` and `sampling_priority` disagree, `sampled` overrides the decision.
         # @return [Integer] one of the {Datadog::Tracing::Sampling::Ext::Priority} values
+        # @yieldparam the new decision maker (either :drop or a new decision maker String value).
         def parse_priority_sampling(sampled, sampling_priority)
-          # If both fields agree
-          if sampling_priority &&
-              (!Tracing::Sampling::PrioritySampler.sampled?(sampling_priority) && sampled == 0 || # Both drop
-                Tracing::Sampling::PrioritySampler.sampled?(sampling_priority) && sampled == 1) # Both keep
-
-            return sampling_priority # Return the richer `sampling_priority`
+          if sampled == 1
+            if sampling_priority && Tracing::Sampling::PrioritySampler.sampled?(sampling_priority)
+              # Both sampling fields agree.
+              sampling_priority
+            else
+              # Sampling fields disagree.
+              # Let's force the trace to be kept, while also updating the decision maker to ourselves.
+              yield Tracing::Sampling::Ext::Decision::DEFAULT
+              sampled
+            end
+          elsif sampling_priority && !Tracing::Sampling::PrioritySampler.sampled?(sampling_priority)
+            sampling_priority
+          # Both sampling fields agree.
+          else
+            # Sampling fields disagree.
+            # Let's drop the trace and remove the sampling decision tag, as dropped spans don't carry sampling decision.
+            yield :drop
+            sampled
           end
-
-          sampled # Sampled flag trumps `sampling_priority` on conflict
         end
 
         def split_tracestate(tracestate)
-          tracestate.split(/[ \t]*,[ \t]*/)[0..31]
+          tracestate.split(/[ \t]*+,[ \t]*+/)[0..31]
         end
 
         # Version 0xFF is invalid as per spec
@@ -361,10 +392,14 @@ module Datadog
         private_constant :TRACESTATE_VALUE_SIZE_LIMIT
 
         # Replace all characters with `_`, except ASCII characters 0x20-0x7E.
-        # Additionally, `,`, ';', and `=` must also be replaced by `_`.
-        INVALID_ORIGIN_CHARS = /[\u0000-\u0019,;=\u007F-\u{10FFFF}]/.freeze
+        # Additionally, `,`, ';', and `~` must also be replaced by `_`.
+        INVALID_ORIGIN_CHARS = /[\u0000-\u0019,;~\u007F-\u{10FFFF}]/.freeze
         private_constant :INVALID_ORIGIN_CHARS
 
+        # Additionally, remap `=` to `~`
+        REMAP_ORIGIN_CHARS = /=/.freeze
+        private_constant :REMAP_ORIGIN_CHARS
+
         # Replace all characters with `_`, except ASCII characters 0x21-0x7E.
         # Additionally, `,` and `=` must also be replaced by `_`.
         INVALID_TAG_KEY_CHARS = /[\u0000-\u0020,=\u007F-\u{10FFFF}]/.freeze

data/lib/datadog/tracing/metadata/ext.rb

@@ -23,6 +23,10 @@ module Datadog
         # Set this tag to `1.0` if the span is a Service Entry span.
         TAG_TOP_LEVEL = '_dd.top_level'
 
+        # Set to `1.0` if profiling is enabled together with tracing, and `0.0` otherwise
+        # See Datadog-internal "RFC: Identifying which spans have profiling enabled " for details
+        TAG_PROFILING_ENABLED = '_dd.profiling.enabled'
+
         # Defines constants for trace analytics
         # @public_api
         module Analytics
@@ -90,7 +94,10 @@ module Datadog
             INVALID_TAG_CHARACTERS = %r{[^a-z0-9_\-:./]}.freeze
 
             # Normalizes an HTTP header string into a valid tag string.
-            def to_tag(name)
+            #
+            # By default, tags cannot create nested span tag levels:
+            # `allow_nested` allows you to override this behavior.
+            def to_tag(name, allow_nested: false)
               # Tag normalization based on: https://docs.datadoghq.com/getting_started/tagging/#defining-tags.
               #
               # Only the following characters are accepted.
@@ -109,7 +116,7 @@ module Datadog
               # Additional HTTP header normalization.
               #
               # Periods are replaced with an underscore.
-              tag.tr!('.', '_')
+              tag.tr!('.', '_') unless allow_nested
               tag
             end
           end
@@ -178,10 +185,6 @@ module Datadog
         end
 
         # @public_api
-        module SpanAttributeSchema
-          # current span attribute schema version
-          TAG_SCHEMA_VERSION = '_dd.trace_span_attribute_schema'
-        end
       end
     end
   end

data/lib/datadog/tracing/remote.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../core/remote/dispatcher'
+require_relative 'configuration/dynamic'
+
+module Datadog
+  module Tracing
+    # Remote configuration declaration
+    module Remote
+      class ReadError < StandardError; end
+
+      class << self
+        PRODUCT = 'APM_TRACING'
+
+        def products
+          [PRODUCT]
+        end
+
+        def capabilities
+          [] # No capabilities advertised
+        end
+
+        def process_config(config, content)
+          lib_config = config['lib_config']
+
+          env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
+            value = lib_config[name]
+
+            # Guard for RBS/Steep
+            raise "option is a #{option.class}, expected Option" unless option.is_a?(Configuration::Dynamic::Option)
+
+            option.call(value)
+
+            [env_var, value]
+          end
+
+          content.applied
+
+          Datadog.send(:components).telemetry.client_configuration_change!(env_vars)
+        rescue => e
+          content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
+        end
+
+        def receivers
+          receiver do |repository, _changes|
+            # DEV: Filter our by product. Given it will be very common
+            # DEV: we can filter this out before we receive the data in this method.
+            # DEV: Apply this refactor to AppSec as well if implemented.
+            repository.contents.map do |content|
+              case content.path.product
+              when PRODUCT
+                config = parse_content(content)
+                process_config(config, content)
+              end
+            end
+          end
+        end
+
+        def receiver(products = [PRODUCT], &block)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
+          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+        end
+
+        private
+
+        def parse_content(content)
+          data = content.data.read
+
+          content.data.rewind
+
+          raise ReadError, 'EOF reached' if data.nil?
+
+          JSON.parse(data)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -48,6 +48,35 @@ module Datadog
                              end
         end
 
+        def self.parse(rules, rate_limit, default_sample_rate)
+          parsed_rules = JSON.parse(rules).map do |rule|
+            sample_rate = rule['sample_rate']
+
+            begin
+              sample_rate = Float(sample_rate)
+            rescue
+              raise "Rule '#{rule.inspect}' does not contain a float property `sample_rate`"
+            end
+
+            kwargs = {
+              name: rule['name'],
+              service: rule['service'],
+              sample_rate: sample_rate,
+            }
+
+            Core::BackportFrom24.hash_compact!(kwargs)
+
+            SimpleRule.new(**kwargs)
+          end
+
+          new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
+        rescue => e
+          Datadog.logger.error do
+            "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          end
+          nil
+        end
+
         # /RuleSampler's components (it's rate limiter, for example) are
         # not be guaranteed to be size-effect free.
         # It is not possible to guarantee that a call to {#sample?} will

data/lib/datadog/tracing/span_operation.rb

@@ -3,6 +3,7 @@ require 'time'
 require_relative '../core/environment/identity'
 require_relative '../core/utils'
 require_relative '../core/utils/time'
+require_relative '../core/utils/safe_dup'
 
 require_relative 'event'
 require_relative 'metadata'
@@ -434,19 +435,6 @@ module Datadog
         :parent,
         :span
 
-      if RUBY_VERSION < '2.2' # nil.dup only fails in Ruby 2.1
-        # Ensures #initialize can call nil.dup safely
-        module RefineNil
-          refine NilClass do
-            def dup
-              self
-            end
-          end
-        end
-
-        using RefineNil
-      end
-
       # Create a Span from the operation which represents
       # the finalized measurement. We #dup here to prevent
       # mutation by reference; when this span is returned,
@@ -457,8 +445,8 @@ module Datadog
           duration: duration,
           end_time: @end_time,
           id: @id,
-          meta: meta.dup,
-          metrics: metrics.dup,
+          meta: Core::Utils::SafeDup.frozen_or_dup(meta),
+          metrics: Core::Utils::SafeDup.frozen_or_dup(metrics),
           parent_id: @parent_id,
           resource: @resource,
           service: @service,

data/lib/datadog/tracing/trace_operation.rb

@@ -40,7 +40,9 @@ module Datadog
         :active_span,
         :id,
         :max_length,
-        :parent_span_id
+        :parent_span_id,
+        :trace_state,
+        :trace_state_unknown_fields
 
       attr_writer \
         :name,
@@ -64,8 +66,11 @@ module Datadog
         sampled: nil,
         sampling_priority: nil,
         service: nil,
+        profiling_enabled: nil,
         tags: nil,
-        metrics: nil
+        metrics: nil,
+        trace_state: nil,
+        trace_state_unknown_fields: nil
       )
         # Attributes
         @id = id || Tracing::Utils::TraceId.next_id
@@ -84,6 +89,9 @@ module Datadog
         @sample_rate = sample_rate
         @sampling_priority = sampling_priority
         @service = service
+        @profiling_enabled = profiling_enabled
+        @trace_state = trace_state
+        @trace_state_unknown_fields = trace_state_unknown_fields
 
         # Generic tags
         set_tags(tags) if tags
@@ -288,6 +296,8 @@ module Datadog
           trace_runtime_id: Core::Environment::Identity.id,
           trace_sampling_priority: @sampling_priority,
           trace_service: service,
+          trace_state: @trace_state,
+          trace_state_unknown_fields: @trace_state_unknown_fields,
         ).freeze
       end
 
@@ -310,6 +320,8 @@ module Datadog
           sampled: @sampled,
           sampling_priority: @sampling_priority,
           service: (service && service.dup),
+          trace_state: (@trace_state && @trace_state.dup),
+          trace_state_unknown_fields: (@trace_state_unknown_fields && @trace_state_unknown_fields.dup),
           tags: meta.dup,
           metrics: metrics.dup
         )
@@ -450,7 +462,8 @@ module Datadog
           service: service,
           tags: meta,
           metrics: metrics,
-          root_span_id: !partial ? root_span && root_span.id : nil
+          root_span_id: !partial ? root_span && root_span.id : nil,
+          profiling_enabled: @profiling_enabled,
         )
       end
 

data/lib/datadog/tracing/trace_segment.rb

@@ -31,7 +31,8 @@ module Datadog
         :sample_rate,
         :sampling_decision_maker,
         :sampling_priority,
-        :service
+        :service,
+        :profiling_enabled
 
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity
@@ -54,7 +55,8 @@ module Datadog
         sampling_priority: nil,
         service: nil,
         tags: nil,
-        metrics: nil
+        metrics: nil,
+        profiling_enabled: nil
       )
         @id = id
         @root_span_id = root_span_id
@@ -80,6 +82,7 @@ module Datadog
         @sampling_decision_maker = sampling_decision_maker_tag
         @sampling_priority = sampling_priority || sampling_priority_tag
         @service = Core::Utils::SafeDup.frozen_or_dup(service || service_tag)
+        @profiling_enabled = profiling_enabled
       end
       # rubocop:enable Metrics/PerceivedComplexity
       # rubocop:enable Metrics/CyclomaticComplexity

data/lib/datadog/tracing/tracer.rb

@@ -320,16 +320,20 @@ module Datadog
         if digest
           TraceOperation.new(
             hostname: hostname,
+            profiling_enabled: profiling_enabled,
             id: digest.trace_id,
             origin: digest.trace_origin,
             parent_span_id: digest.span_id,
             sampling_priority: digest.trace_sampling_priority,
             # Distributed tags are just regular trace tags with special meaning to Datadog
             tags: digest.trace_distributed_tags,
+            trace_state: digest.trace_state,
+            trace_state_unknown_fields: digest.trace_state_unknown_fields,
           )
         else
           TraceOperation.new(
-            hostname: hostname
+            hostname: hostname,
+            profiling_enabled: profiling_enabled,
           )
         end
       end
@@ -525,6 +529,11 @@ module Datadog
           span
         end
       end
+
+      def profiling_enabled
+        @profiling_enabled ||=
+          !!(defined?(Datadog::Profiling) && Datadog::Profiling.respond_to?(:enabled?) && Datadog::Profiling.enabled?)
+      end
     end
   end
 end

data/lib/ddtrace/transport/ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Transport
     # @public_api
@@ -5,22 +7,26 @@ module Datadog
       # @public_api
       module HTTP
         ADAPTER = :net_http # DEV: Rename to simply `:http`, as Net::HTTP is an implementation detail.
-        DEFAULT_HOST = '127.0.0.1'.freeze
+        DEFAULT_HOST = '127.0.0.1'
         DEFAULT_PORT = 8126
 
-        HEADER_CONTAINER_ID = 'Datadog-Container-ID'.freeze
-        HEADER_DD_API_KEY = 'DD-API-KEY'.freeze
+        HEADER_CONTAINER_ID = 'Datadog-Container-ID'
+        HEADER_DD_API_KEY = 'DD-API-KEY'
         # Tells agent that `_dd.top_level` metrics have been set by the tracer.
         # The agent will not calculate top-level spans but instead trust the tracer tagging.
         #
         # This prevents partially flushed traces being mistakenly marked as top-level.
         #
         # Setting this header to any non-empty value enables this feature.
-        HEADER_CLIENT_COMPUTED_TOP_LEVEL = 'Datadog-Client-Computed-Top-Level'.freeze
-        HEADER_META_LANG = 'Datadog-Meta-Lang'.freeze
-        HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'.freeze
-        HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'.freeze
-        HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'.freeze
+        HEADER_CLIENT_COMPUTED_TOP_LEVEL = 'Datadog-Client-Computed-Top-Level'
+        HEADER_META_LANG = 'Datadog-Meta-Lang'
+        HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'
+        HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'
+        HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'
+
+        # Header that prevents the Net::HTTP integration from tracing internal trace requests.
+        # Set it to any value to skip tracing.
+        HEADER_DD_INTERNAL_UNTRACED_REQUEST = 'DD-Internal-Untraced-Request'
       end
 
       # @public_api
@@ -31,7 +37,7 @@ module Datadog
       # @public_api
       module UnixSocket
         ADAPTER = :unix
-        DEFAULT_PATH = '/var/run/datadog/apm.socket'.freeze
+        DEFAULT_PATH = '/var/run/datadog/apm.socket'
         DEFAULT_TIMEOUT_SECONDS = 1
       end
     end

data/lib/ddtrace/transport/trace_formatter.rb

@@ -51,6 +51,7 @@ module Datadog
         tag_sampling_decision_maker!
         tag_high_order_trace_id!
         tag_sampling_priority!
+        tag_profiling_enabled!
 
         trace
       end
@@ -175,6 +176,14 @@ module Datadog
         root_span.set_tag(Tracing::Metadata::Ext::Distributed::TAG_TID, high_order_tid)
       end
 
+      def tag_profiling_enabled!
+        return if trace.profiling_enabled.nil?
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::TAG_PROFILING_ENABLED, trace.profiling_enabled ? 1 : 0
+        )
+      end
+
       private
 
       def partial?

data/lib/ddtrace/version.rb

@@ -3,8 +3,8 @@
 module DDTrace
   module VERSION
     MAJOR = 1
-    MINOR = 12
-    PATCH = 1
+    MINOR = 13
+    PATCH = 0
     PRE = nil
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow
@@ -13,17 +13,14 @@ module DDTrace
 
     MINIMUM_RUBY_VERSION = '2.1.0'
 
-    # A maximum version was initially added in https://github.com/DataDog/dd-trace-rb/pull/1495 because we expected
-    # the `ruby2_keywords` method to be removed (see the PR for the discussion).
-    # That is because Ruby 3.x support as implemented using `*args` needs `ruby2_keywords` to continue working,
-    # but if `ruby2_keywords` gets removed we would need to change the code to use `*args, **kwargs`.
+    # Restrict the installation of this gem with untested future versions of Ruby.
     #
-    # Now Ruby 3.2.0-preview1 is out and `ruby2_keywords` are still there, and there's even a recent change for it
-    # in https://github.com/ruby/ruby/pull/5684 that is documented as "ruby2_keywords needed in 3.2+".
+    # This prevents crashes in the native extension code and sends a clear signal to the
+    # user that this version of the gem is untested for the host Ruby version.
     #
-    # So for now let's bump the maximum version to < 3.3 to allow the Ruby 3.2 series to be supported and we can keep
-    # an eye on the Ruby 3.2 test releases to see if anything changes. (Otherwise, once Ruby 3.2.0 stable is out, we
-    # should probably bump this to 3.4, and so on...)
-    MAXIMUM_RUBY_VERSION = '3.3'
+    # To allow testing with the next unreleased version of Ruby, the version check is performed
+    # as `< #{MAXIMUM_RUBY_VERSION}`, meaning prereleases of MAXIMUM_RUBY_VERSION are allowed
+    # but not stable MAXIMUM_RUBY_VERSION releases.
+    MAXIMUM_RUBY_VERSION = '3.4'
   end
 end