datadog 2.0.0.beta1 → 2.0.0.beta2

data/lib/datadog/profiling.rb

@@ -65,6 +65,17 @@ module Datadog
       !!(profiler.send(:scheduler).running? if profiler)
     end
 
+    def self.wait_until_running(timeout_seconds: 5)
+      profiler = Datadog.send(:components).profiler
+      if profiler
+        # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+        worker = profiler.send(:worker)
+        worker.wait_until_running(timeout_seconds: timeout_seconds)
+      else
+        raise 'Profiler not enabled or available'
+      end
+    end
+
     private_class_method def self.replace_noop_allocation_count
       def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
         Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count

data/lib/datadog/tracing/contrib/action_pack/integration.rb

@@ -3,7 +3,7 @@
 require_relative 'configuration/settings'
 require_relative 'patcher'
 require_relative '../integration'
-require_relative '../rails/integration'
+require_relative '../rails/ext'
 require_relative '../rails/utils'
 
 module Datadog

data/lib/datadog/tracing/contrib/action_view/integration.rb

@@ -3,7 +3,7 @@
 require_relative 'configuration/settings'
 require_relative 'patcher'
 require_relative '../integration'
-require_relative '../rails/integration'
+require_relative '../rails/ext'
 require_relative '../rails/utils'
 
 module Datadog

data/lib/datadog/tracing/contrib/active_record/integration.rb

@@ -5,7 +5,7 @@ require_relative 'configuration/settings'
 require_relative 'events'
 require_relative 'patcher'
 require_relative '../integration'
-require_relative '../rails/integration'
+require_relative '../rails/ext'
 require_relative '../rails/utils'
 
 module Datadog

data/lib/datadog/tracing/contrib/active_support/integration.rb

@@ -4,7 +4,7 @@ require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'
 require_relative 'cache/redis'
-require_relative '../rails/integration'
+require_relative '../rails/ext'
 require_relative '../rails/utils'
 
 module Datadog

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -92,8 +92,7 @@ module Datadog
                 # Measure service stats
                 Contrib::Analytics.set_measured(span)
 
-                # catch thrown exceptions
-                handle_error(span, payload[:exception_object]) if payload[:exception_object]
+                handle_error_and_status_code(span, endpoint, payload)
 
                 # override the current span with this notification values
                 span.set_tag(Ext::TAG_ROUTE_ENDPOINT, api_view) unless api_view.nil?
@@ -110,6 +109,30 @@ module Datadog
               Datadog.logger.error(e.message)
             end
 
+            # Status code resolution is tied to the exception handling
+            def handle_error_and_status_code(span, endpoint, payload)
+              status = nil
+
+              # Handle exceptions and status code
+              if (exception_object = payload[:exception_object])
+                # If the exception is not an internal Grape error, we won't have a status code at this point.
+                status = exception_object.status if exception_object.respond_to?(:status)
+
+                handle_error(span, exception_object, status)
+              else
+                # Status code is unreliable in `endpoint_run.grape` if there was an exception.
+                # Only after `Grape::Middleware::Error#run_rescue_handler` that the error status code of a request with a
+                # Ruby exception error is resolved. But that handler is called further down the Grape middleware stack.
+                # Rack span will then be the most reliable source for status codes.
+                # DEV: As a corollary, instrumenting Grape without Rack will provide incomplete
+                # DEV: status quote information.
+                status = endpoint.status
+                span.set_error(endpoint) if error_status_codes.include?(status)
+              end
+
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status) if status
+            end
+
             def endpoint_start_render(*)
               return if Thread.current[KEY_RENDER]
               return unless enabled?
@@ -193,9 +216,10 @@ module Datadog
 
             private
 
-            def handle_error(span, exception)
-              if exception.respond_to?('status')
-                span.set_error(exception) if error_status_codes.include?(exception.status)
+            def handle_error(span, exception, status = nil)
+              status ||= (exception.status if exception.respond_to?(:status))
+              if status
+                span.set_error(exception) if error_status_codes.include?(status)
               else
                 on_error.call(span, exception)
               end
@@ -240,6 +264,20 @@ module Datadog
               datadog_configuration[:analytics_sample_rate]
             end
 
+            def exception_is_error?(exception)
+              return false unless exception
+              return true unless exception.respond_to?(:status)
+
+              error_status?(status.exception)
+            end
+
+            def error_status?(status)
+              matcher = datadog_configuration[:error_statuses]
+              return true unless matcher
+
+              matcher.include?(status) if matcher
+            end
+
             def enabled?
               Datadog.configuration.tracing.enabled && \
                 datadog_configuration[:enabled] == true

data/lib/datadog/tracing/correlation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'utils'
-require_relative 'metadata/ext'
 require_relative '../core/logging/ext'
 
 module Datadog
@@ -36,11 +35,11 @@ module Datadog
           version: nil
         )
           # Dup and freeze strings so they aren't modified by reference.
-          @env = Core::Utils::SafeDup.frozen_dup(env || Datadog.configuration.env)
-          @service = Core::Utils::SafeDup.frozen_dup(service || Datadog.configuration.service)
+          @env = env || Datadog.configuration.env
+          @service = service || Datadog.configuration.service
           @span_id = (span_id || 0).to_s
           @trace_id = trace_id || 0
-          @version = Core::Utils::SafeDup.frozen_dup(version || Datadog.configuration.version)
+          @version = version || Datadog.configuration.version
         end
 
         def to_h

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

@@ -27,20 +27,40 @@ module Datadog
           end
         end.new
 
-        attr_reader :name, :service
+        attr_reader :name, :service, :resource, :tags
 
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name,
         #             defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
-        def initialize(name: MATCH_ALL, service: MATCH_ALL)
+        # @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: {})
           super()
           @name = name
           @service = service
+          @resource = resource
+          @tags = tags
         end
 
         def match?(trace)
-          name === trace.name && service === trace.service
+          name === trace.name && service === trace.service && resource === trace.resource && tags_match?(trace)
+        end
+
+        private
+
+        # Match against the trace tags and metrics.
+        def tags_match?(trace)
+          @tags.all? do |name, matcher|
+            tag = trace.get_tag(name)
+
+            # Format metrics as strings, to allow for partial number matching (/4.*/ matching '400', '404', etc.).
+            # Because metrics are floats, we use the '%g' format specifier to avoid trailing zeros, which
+            # can affect exact string matching (e.g. '400' matching '400.0').
+            tag = format('%g', tag) if tag.is_a?(Numeric)
+
+            matcher === tag
+          end
         end
       end
 

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

@@ -51,9 +51,25 @@ module Datadog
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name, defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
+        # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
+        #                defaults to always match
         # @param sample_rate [Float] Sampling rate between +[0,1]+
-        def initialize(name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL, sample_rate: 1.0)
-          super(SimpleMatcher.new(name: name, service: service), RateSampler.new(sample_rate))
+        def initialize(
+          name: SimpleMatcher::MATCH_ALL, service: SimpleMatcher::MATCH_ALL,
+          resource: SimpleMatcher::MATCH_ALL, tags: {}, 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.
+          #
+          # We address that here by not setting the rate in the constructor,
+          # but using the setter method.
+          #
+          # We don't want to make this change directly to {Datadog::Tracing::Sampling::RateSampler}
+          # because it breaks its current contract to existing users.
+          sampler = RateSampler.new
+          sampler.sample_rate = sample_rate
+
+          super(SimpleMatcher.new(name: name, service: service, resource: resource, tags: tags), sampler)
         end
       end
     end

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

@@ -62,6 +62,8 @@ module Datadog
             kwargs = {
               name: rule['name'],
               service: rule['service'],
+              resource: rule['resource'],
+              tags: rule['tags'],
               sample_rate: sample_rate,
             }
 

data/lib/datadog/tracing/span.rb

@@ -26,6 +26,7 @@ module Datadog
         :parent_id,
         :resource,
         :service,
+        :links,
         :type,
         :start_time,
         :status,
@@ -58,7 +59,8 @@ module Datadog
         status: 0,
         type: nil,
         trace_id: nil,
-        service_entry: nil
+        service_entry: nil,
+        links: nil
       )
         @name = Core::Utils::SafeDup.frozen_or_dup(name)
         @service = Core::Utils::SafeDup.frozen_or_dup(service)
@@ -86,6 +88,8 @@ module Datadog
 
         @service_entry = service_entry
 
+        @links = links || []
+
         # Mark with the service entry span metric, if applicable
         set_metric(Metadata::Ext::TAG_TOP_LEVEL, 1.0) if service_entry
       end
@@ -136,7 +140,8 @@ module Datadog
           service: @service,
           span_id: @id,
           trace_id: @trace_id,
-          type: @type
+          type: @type,
+          span_links: @links.map(&:to_hash)
         }
 
         if stopped?

data/lib/datadog/tracing/span_link.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    # SpanLink represents a causal link between two spans.
+    # @public_api
+    class SpanLink
+      # @!attribute [r] span_id
+      #   Datadog id for the currently active span.
+      #   @return [Integer]
+      attr_reader :span_id
+
+      # @!attribute [r] trace_id
+      #   Datadog id for the currently active trace.
+      #   @return [Integer]
+      attr_reader :trace_id
+
+      # @!attribute [r] attributes
+      #   Datadog-specific tags that support richer distributed tracing association.
+      #   @return [Hash<String,String>]
+      attr_reader :attributes
+
+      # @!attribute [r] trace_flags
+      #   The W3C "trace-flags" extracted from a distributed context. This field is an 8-bit unsigned integer.
+      #   @return [Integer]
+      #   @see https://www.w3.org/TR/trace-context/#trace-flags
+      attr_reader :trace_flags
+
+      # @!attribute [r] trace_state
+      #   The W3C "tracestate" extracted from a distributed context.
+      #   This field is a string representing vendor-specific distribution data.
+      #   The `dd=` entry is removed from `trace_state` as its value is dynamically calculated
+      #   on every propagation injection.
+      #   @return [String]
+      #   @see https://www.w3.org/TR/trace-context/#tracestate-header
+      attr_reader :trace_state
+
+      # @!attribute [r] dropped_attributes
+      #   The number of attributes that were discarded due to serialization limits.
+      #   @return [Integer]
+      attr_reader :dropped_attributes
+
+      def initialize(
+        attributes: nil,
+        digest: 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
+        @dropped_attributes = 0
+        @attributes = (attributes && attributes.dup) || {}
+      end
+
+      def to_hash
+        h = {
+          span_id: @span_id || 0,
+          trace_id: Tracing::Utils::TraceId.to_low_order(@trace_id) || 0,
+        }
+        # Optimization: Hash non empty attributes
+        if @trace_id.to_i > Tracing::Utils::EXTERNAL_MAX_ID
+          h[:trace_id_high] =
+            Tracing::Utils::TraceId.to_high_order(@trace_id)
+        end
+        unless @attributes&.empty?
+          h[:attributes] = {}
+          @attributes.each do |k1, v1|
+            Tracing::Utils.serialize_attribute(k1, v1).each do |new_k1, value|
+              h[:attributes][new_k1] = value.to_s
+            end
+          end
+        end
+        h[:dropped_attributes_count] = @dropped_attributes if @dropped_attributes > 0
+        h[:tracestate] = @trace_state if @trace_state
+        # If traceflags set, the high bit (bit 31) should be set to 1 (uint32).
+        # This helps us distinguish between when the sample decision is zero or not set
+        h[:flags] = if @trace_flags.nil?
+                      0
+                    else
+                      @trace_flags | (1 << 31)
+                    end
+        h
+      end
+    end
+  end
+end

data/lib/datadog/tracing/trace_operation.rb

@@ -8,6 +8,7 @@ require_relative 'metadata/tagging'
 require_relative 'sampling/ext'
 require_relative 'span_operation'
 require_relative 'trace_digest'
+require_relative 'correlation'
 require_relative 'trace_segment'
 require_relative 'utils'
 
@@ -306,6 +307,17 @@ module Datadog
         ).freeze
       end
 
+      def to_correlation
+        # Resolve current span ID
+        span_id = @active_span && @active_span.id
+        span_id ||= @parent_span_id unless finished?
+
+        Correlation::Identifier.new(
+          trace_id: @id,
+          span_id: span_id
+        )
+      end
+
       # Returns a copy of this trace suitable for forks (w/o spans.)
       # Used for continuation of traces across forks.
       def fork_clone

data/lib/datadog/tracing/tracer.rb

@@ -224,9 +224,10 @@ module Datadog
       # @return [Datadog::Tracing::Correlation::Identifier] correlation object
       def active_correlation(key = nil)
         trace = active_trace(key)
-        Correlation.identifier_from_digest(
-          trace && trace.to_digest
-        )
+
+        return Datadog::Tracing::Correlation::Identifier.new unless trace
+
+        trace.to_correlation
       end
 
       # Setup a new trace to continue from where another

data/lib/datadog/tracing/transport/serializable_trace.rb

@@ -58,7 +58,7 @@ module Datadog
         def to_msgpack(packer = nil)
           packer ||= MessagePack::Packer.new
 
-          number_of_elements_to_write = 10
+          number_of_elements_to_write = 11
 
           if span.stopped?
             packer.write_map_header(number_of_elements_to_write + 2) # Set header with how many elements in the map
@@ -93,6 +93,8 @@ module Datadog
           packer.write(span.meta)
           packer.write('metrics')
           packer.write(span.metrics)
+          packer.write('span_links')
+          packer.write(span.links.map(&:to_hash))
           packer.write('error')
           packer.write(span.status)
           packer

data/lib/datadog/tracing/utils.rb

@@ -45,6 +45,22 @@ module Datadog
         @id_rng = Random.new
       end
 
+      # Serialize values into Datadog span tags and metrics.
+      # Notably, arrays are exploded into many keys, each with
+      # a numeric suffix representing the array index, for example:
+      # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+      def self.serialize_attribute(key, value)
+        if value.is_a?(Array)
+          value.flat_map.with_index do |v, idx|
+            serialize_attribute("#{key}.#{idx}", v)
+          end
+        elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          [[key, value.to_s]]
+        else
+          [[key, value]]
+        end
+      end
+
       private_class_method :id_rng, :reset!
 
       # The module handles bitwise operation for trace id

data/lib/datadog/version.rb

@@ -5,7 +5,7 @@ module Datadog
     MAJOR = 2
     MINOR = 0
     PATCH = 0
-    PRE = 'beta1'
+    PRE = 'beta2'
     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.beta1
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-22 00:00:00.000000000 Z
+date: 2024-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: base64
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: debase-ruby_core_source
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0.2.0
+        version: 7.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.0.2.0
+        version: 7.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,
@@ -295,7 +281,6 @@ files:
 - lib/datadog/core/runtime/ext.rb
 - lib/datadog/core/runtime/metrics.rb
 - lib/datadog/core/telemetry/client.rb
-- lib/datadog/core/telemetry/collector.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
 - lib/datadog/core/telemetry/ext.rb
@@ -305,17 +290,7 @@ files:
 - lib/datadog/core/telemetry/http/ext.rb
 - lib/datadog/core/telemetry/http/response.rb
 - lib/datadog/core/telemetry/http/transport.rb
-- lib/datadog/core/telemetry/v1/app_event.rb
-- lib/datadog/core/telemetry/v1/application.rb
-- lib/datadog/core/telemetry/v1/configuration.rb
-- lib/datadog/core/telemetry/v1/dependency.rb
-- lib/datadog/core/telemetry/v1/host.rb
-- lib/datadog/core/telemetry/v1/install_signature.rb
-- lib/datadog/core/telemetry/v1/integration.rb
-- lib/datadog/core/telemetry/v1/product.rb
-- lib/datadog/core/telemetry/v1/telemetry_request.rb
-- lib/datadog/core/telemetry/v2/app_client_configuration_change.rb
-- lib/datadog/core/telemetry/v2/request.rb
+- lib/datadog/core/telemetry/request.rb
 - lib/datadog/core/transport/ext.rb
 - lib/datadog/core/transport/http/adapters/net.rb
 - lib/datadog/core/transport/http/adapters/registry.rb
@@ -330,6 +305,7 @@ files:
 - lib/datadog/core/transport/request.rb
 - lib/datadog/core/transport/response.rb
 - lib/datadog/core/utils.rb
+- lib/datadog/core/utils/base64.rb
 - lib/datadog/core/utils/duration.rb
 - lib/datadog/core/utils/forking.rb
 - lib/datadog/core/utils/hash.rb
@@ -828,6 +804,7 @@ files:
 - lib/datadog/tracing/sampling/span/rule_parser.rb
 - lib/datadog/tracing/sampling/span/sampler.rb
 - lib/datadog/tracing/span.rb
+- lib/datadog/tracing/span_link.rb
 - lib/datadog/tracing/span_operation.rb
 - lib/datadog/tracing/sync_writer.rb
 - lib/datadog/tracing/trace_digest.rb