datadog 2.0.0.beta2 → 2.0.0.rc1

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

@@ -6,6 +6,9 @@ module Datadog
       # Checks if a trace conforms to a matching criteria.
       # @abstract
       class Matcher
+        # Pattern that matches any string
+        MATCH_ALL_PATTERN = '*'
+
         # Returns `true` if the trace should conforms to this rule, `false` otherwise
         #
         # @param [TraceOperation] trace
@@ -13,20 +16,49 @@ module Datadog
         def match?(trace)
           raise NotImplementedError
         end
-      end
 
-      # A {Datadog::Sampling::Matcher} that supports matching a trace by
-      # trace name and/or service name.
-      class SimpleMatcher < Matcher
-        # Returns `true` for case equality (===) with any object
+        # Converts a glob pattern String to a case-insensitive String matcher object.
+        # The match object will only return `true` if it matches the complete String.
+        #
+        # The following special characters are supported:
+        # - `?` matches any single character
+        # - `*` matches any substring
+        #
+        # @param glob [String]
+        # @return [#match?(String)]
+        def self.glob_to_regex(glob)
+          # Optimization for match-all case
+          return MATCH_ALL if glob == MATCH_ALL_PATTERN
+
+          # Ensure no undesired characters are treated as regex.
+          glob = Regexp.quote(glob)
+
+          # Our valid special characters, `?` and `*`, were just escaped
+          # by `Regexp.quote` above. We need to unescape them:
+          glob.gsub!('\?', '.') # Any single character
+          glob.gsub!('\*', '.*') # Any substring
+
+          # Patterns have to match the whole input string
+          glob = "\\A#{glob}\\z"
+
+          Regexp.new(glob, Regexp::IGNORECASE)
+        end
+
+        # Returns `true` for any input
         MATCH_ALL = Class.new do
-          # DEV: A class that implements `#===` is ~20% faster than
-          # DEV: a `Proc` that always returns `true`.
-          def ===(other)
+          def match?(_other)
             true
           end
+
+          def inspect
+            "MATCH_ALL:Matcher('*')"
+          end
         end.new
+      end
 
+      # A {Datadog::Sampling::Matcher} that supports matching a trace by
+      # trace name and/or service name.
+      class SimpleMatcher < Matcher
         attr_reader :name, :service, :resource, :tags
 
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name,
@@ -35,16 +67,30 @@ module Datadog
         #                defaults to always match
         # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
         #                defaults to always match
-        def initialize(name: MATCH_ALL, service: MATCH_ALL, resource: MATCH_ALL, tags: {})
+        def initialize(
+          name: MATCH_ALL_PATTERN,
+          service: MATCH_ALL_PATTERN,
+          resource: MATCH_ALL_PATTERN,
+          tags: {}
+        )
           super()
-          @name = name
-          @service = service
-          @resource = resource
+
+          name = Matcher.glob_to_regex(name)
+          service = Matcher.glob_to_regex(service)
+          resource = Matcher.glob_to_regex(resource)
+          tags = tags.transform_values { |matcher| Matcher.glob_to_regex(matcher) }
+
+          @name = name || Datadog::Tracing::Sampling::Matcher::MATCH_ALL
+          @service = service || Datadog::Tracing::Sampling::Matcher::MATCH_ALL
+          @resource = resource || Datadog::Tracing::Sampling::Matcher::MATCH_ALL
           @tags = tags
         end
 
         def match?(trace)
-          name === trace.name && service === trace.service && resource === trace.resource && tags_match?(trace)
+          @name.match?(trace.name) &&
+            @service.match?(trace.service) &&
+            @resource.match?(trace.resource) &&
+            tags_match?(trace)
         end
 
         private
@@ -59,27 +105,10 @@ module Datadog
             # can affect exact string matching (e.g. '400' matching '400.0').
             tag = format('%g', tag) if tag.is_a?(Numeric)
 
-            matcher === tag
+            matcher.match?(tag)
           end
         end
       end
-
-      # A {Datadog::Tracing::Sampling::Matcher} that allows for arbitrary trace matching
-      # based on the return value of a provided block.
-      class ProcMatcher < Matcher
-        attr_reader :block
-
-        # @yield [name, service] Provides trace name and service to the block
-        # @yieldreturn [Boolean] Whether the trace conforms to this matcher
-        def initialize(&block)
-          super()
-          @block = block
-        end
-
-        def match?(trace)
-          block.call(trace.name, trace.service)
-        end
-      end
     end
   end
 end

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

@@ -10,13 +10,18 @@ module Datadog
       # a specific criteria and what sampling strategy to
       # apply in case of a positive match.
       class Rule
-        attr_reader :matcher, :sampler
+        PROVENANCE_LOCAL = :local
+        PROVENANCE_REMOTE_USER = :customer
+        PROVENANCE_REMOTE_DYNAMIC = :dynamic
+
+        attr_reader :matcher, :sampler, :provenance
 
         # @param [Matcher] matcher A matcher to verify trace conformity against
         # @param [Sampler] sampler A sampler to be consulted on a positive match
-        def initialize(matcher, sampler)
+        def initialize(matcher, sampler, provenance)
           @matcher = matcher
           @sampler = sampler
+          @provenance = provenance
         end
 
         # Evaluates if the provided `trace` conforms to the `matcher`.
@@ -55,8 +60,10 @@ module Datadog
         #                defaults to always match
         # @param sample_rate [Float] Sampling rate between +[0,1]+
         def initialize(
-          name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL,
-          resource: SimpleMatcher::MATCH_ALL, tags: {}, sample_rate: 1.0
+          name: SimpleMatcher::MATCH_ALL_PATTERN, service: SimpleMatcher::MATCH_ALL_PATTERN,
+          resource: SimpleMatcher::MATCH_ALL_PATTERN, tags: {},
+          provenance: Rule::PROVENANCE_LOCAL,
+          sample_rate: 1.0
         )
           # We want to allow 0.0 to drop all traces, but {Datadog::Tracing::Sampling::RateSampler}
           # considers 0.0 an invalid rate and falls back to 100% sampling.
@@ -69,7 +76,7 @@ module Datadog
           sampler = RateSampler.new
           sampler.sample_rate = sample_rate
 
-          super(SimpleMatcher.new(name: name, service: service, resource: resource, tags: tags), sampler)
+          super(SimpleMatcher.new(name: name, service: service, resource: resource, tags: tags), sampler, provenance)
         end
       end
     end

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

@@ -65,6 +65,12 @@ module Datadog
               resource: rule['resource'],
               tags: rule['tags'],
               sample_rate: sample_rate,
+              provenance: if (provenance = rule['provenance'])
+                            # `Rule::PROVENANCE_*` values are symbols, so convert strings to match
+                            provenance.to_sym
+                          else
+                            Rule::PROVENANCE_LOCAL
+                          end,
             }
 
             kwargs.compact!
@@ -118,7 +124,17 @@ module Datadog
           rate_limiter.allow?(1).tap do |allowed|
             set_priority(trace, allowed)
             set_limiter_metrics(trace, rate_limiter.effective_rate)
-            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, Ext::Decision::TRACE_SAMPLING_RULE)
+
+            provenance = case rule.provenance
+                         when Rule::PROVENANCE_REMOTE_USER
+                           Ext::Decision::REMOTE_USER_RULE
+                         when Rule::PROVENANCE_REMOTE_DYNAMIC
+                           Ext::Decision::REMOTE_DYNAMIC_RULE
+                         else
+                           Ext::Decision::TRACE_SAMPLING_RULE
+                         end
+
+            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance)
           end
         rescue StandardError => e
           Datadog.logger.error(

data/lib/datadog/tracing/sampling/span/matcher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../matcher'
+
 module Datadog
   module Tracing
     module Sampling
@@ -31,29 +33,19 @@ module Datadog
           # @param name_pattern [String] a pattern to be matched against {SpanOperation#name}
           # @param service_pattern [String] a pattern to be matched against {SpanOperation#service}
           def initialize(name_pattern: MATCH_ALL_PATTERN, service_pattern: MATCH_ALL_PATTERN)
-            @name = pattern_to_regex(name_pattern)
-            @service = pattern_to_regex(service_pattern)
+            @name = Sampling::Matcher.glob_to_regex(name_pattern)
+            @service = Sampling::Matcher.glob_to_regex(service_pattern)
           end
 
-          # {Regexp#match?} was added in Ruby 2.4, and it's measurably
-          # the least costly way to get a boolean result for a Regexp match.
-          # @see https://www.ruby-lang.org/en/news/2016/12/25/ruby-2-4-0-released/
-          if Regexp.method_defined?(:match?)
-            # Returns `true` if the span conforms to the configured patterns,
-            # `false` otherwise
-            #
-            # @param [SpanOperation] span
-            # @return [Boolean]
-            def match?(span)
-              # Matching is performed at the end of the lifecycle of a Span,
-              # thus both `name` and `service` are guaranteed to be not `nil`.
-              @name.match?(span.name) && @service.match?(span.service)
-            end
-          else
-            # DEV: Remove when support for Ruby 2.3 and older is removed.
-            def match?(span)
-              @name === span.name && @service === span.service
-            end
+          # Returns `true` if the span conforms to the configured patterns,
+          # `false` otherwise
+          #
+          # @param [SpanOperation] span
+          # @return [Boolean]
+          def match?(span)
+            # Matching is performed at the end of the lifecycle of a Span,
+            # thus both `name` and `service` are guaranteed to be not `nil`.
+            @name.match?(span.name) && @service.match?(span.service)
           end
 
           def ==(other)
@@ -62,26 +54,6 @@ module Datadog
             name == other.name &&
               service == other.service
           end
-
-          private
-
-          # @param pattern [String]
-          # @return [Regexp]
-          def pattern_to_regex(pattern)
-            # Ensure no undesired characters are treated as regex.
-            # Our valid special characters, `?` and `*`,
-            # will be escaped so...
-            pattern = Regexp.quote(pattern)
-
-            # ...we account for that here:
-            pattern.gsub!('\?', '.') # Any single character
-            pattern.gsub!('\*', '.*') # Any substring
-
-            # Patterns have to match the whole input string
-            pattern = "\\A#{pattern}\\z"
-
-            Regexp.new(pattern)
-          end
         end
       end
     end

data/lib/datadog/tracing/span_link.rb

@@ -41,13 +41,19 @@ module Datadog
       attr_reader :dropped_attributes
 
       def initialize(
-        attributes: nil,
-        digest: nil
+        digest,
+        attributes: nil
       )
-        @span_id = digest&.span_id
-        @trace_id = digest&.trace_id
-        @trace_flags = digest&.trace_flags
-        @trace_state = digest&.trace_state && digest&.trace_state.dup
+        @span_id = digest.span_id
+        @trace_id = digest.trace_id
+        @trace_flags = if digest.trace_sampling_priority.nil?
+                         nil
+                       elsif digest.trace_sampling_priority > 0
+                         1
+                       else
+                         0
+                       end
+        @trace_state = digest.trace_state && digest.trace_state.dup
         @dropped_attributes = 0
         @attributes = (attributes && attributes.dup) || {}
       end

data/lib/datadog/tracing/span_operation.rb

@@ -35,9 +35,7 @@ module Datadog
         :start_time,
         :trace_id,
         :type
-
-      attr_accessor \
-        :status
+      attr_accessor :links, :status
 
       def initialize(
         name,
@@ -49,7 +47,8 @@ module Datadog
         start_time: nil,
         tags: nil,
         trace_id: nil,
-        type: nil
+        type: nil,
+        links: nil
       )
         # Ensure dynamically created strings are UTF-8 encoded.
         #
@@ -66,6 +65,8 @@ module Datadog
         @trace_id = trace_id || Tracing::Utils::TraceId.next_id
 
         @status = 0
+        # stores array of span links
+        @links = links || []
 
         # start_time and end_time track wall clock. In Ruby, wall clock
         # has less accuracy than monotonic clock, so if possible we look to only use wall clock
@@ -452,6 +453,7 @@ module Datadog
           status: @status,
           type: @type,
           trace_id: @trace_id,
+          links: @links,
           service_entry: parent.nil? || (service && parent.service != service)
         )
       end

data/lib/datadog/version.rb

@@ -5,7 +5,7 @@ module Datadog
     MAJOR = 2
     MINOR = 0
     PATCH = 0
-    PRE = 'beta2'
+    PRE = 'rc1'
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-18 00:00:00.000000000 Z
+date: 2024-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0.1.0
+        version: 9.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0.1.0
+        version: 9.0.0.1.0
 description: |
   datadog is Datadog's client library for Ruby. It includes a suite of tools
   which provide visibility into the performance and security of Ruby applications,
@@ -106,6 +106,7 @@ files:
 - ext/datadog_profiling_native_extension/collectors_stack.h
 - ext/datadog_profiling_native_extension/collectors_thread_context.c
 - ext/datadog_profiling_native_extension/collectors_thread_context.h
+- ext/datadog_profiling_native_extension/crashtracker.c
 - ext/datadog_profiling_native_extension/extconf.rb
 - ext/datadog_profiling_native_extension/heap_recorder.c
 - ext/datadog_profiling_native_extension/heap_recorder.h
@@ -351,6 +352,7 @@ files:
 - lib/datadog/profiling/collectors/stack.rb
 - lib/datadog/profiling/collectors/thread_context.rb
 - lib/datadog/profiling/component.rb
+- lib/datadog/profiling/crashtracker.rb
 - lib/datadog/profiling/exporter.rb
 - lib/datadog/profiling/ext.rb
 - lib/datadog/profiling/ext/forking.rb
@@ -856,7 +858,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications