ddtrace 1.0.0 → 1.1.0

data/lib/datadog/appsec/processor.rb

@@ -16,9 +16,40 @@ module Datadog
         end
       end
 
+      # Context manages a sequence of runs
+      class Context
+        attr_reader :time_ns, :time_ext_ns, :timeouts, :events
+
+        def initialize(processor)
+          @context = Datadog::AppSec::WAF::Context.new(processor.send(:handle))
+          @time_ns = 0.0
+          @time_ext_ns = 0.0
+          @timeouts = 0
+          @events = []
+        end
+
+        def run(*args)
+          start_ns = Core::Utils::Time.get_time(:nanosecond)
+
+          ret, res = @context.run(*args)
+
+          stop_ns = Core::Utils::Time.get_time(:nanosecond)
+
+          @time_ns += res.total_runtime
+          @time_ext_ns += (stop_ns - start_ns)
+          @timeouts += 1 if res.timeout
+
+          [ret, res]
+        end
+      end
+
+      attr_reader :ruleset_info, :addresses
+
       def initialize
         @ruleset = nil
         @handle = nil
+        @ruleset_info = nil
+        @addresses = nil
 
         unless load_libddwaf && load_ruleset && create_waf_handle
           Datadog.logger.warn { 'AppSec is disabled, see logged errors above' }
@@ -30,9 +61,13 @@ module Datadog
       end
 
       def new_context
-        Datadog::AppSec::WAF::Context.new(@handle)
+        Context.new(self)
       end
 
+      protected
+
+      attr_reader :handle
+
       private
 
       def load_libddwaf
@@ -70,7 +105,13 @@ module Datadog
         # TODO: this may need to be reset if the main Datadog logging level changes after initialization
         Datadog::AppSec::WAF.logger = Datadog.logger if Datadog.logger.debug? && Datadog::AppSec.settings.waf_debug
 
-        @handle = Datadog::AppSec::WAF::Handle.new(@ruleset)
+        obfuscator_config = {
+          key_regex: Datadog::AppSec.settings.obfuscator_key_regex,
+          value_regex: Datadog::AppSec.settings.obfuscator_value_regex,
+        }
+        @handle = Datadog::AppSec::WAF::Handle.new(@ruleset, obfuscator: obfuscator_config)
+        @ruleset_info = @handle.ruleset_info
+        @addresses = @handle.required_addresses
 
         true
       rescue StandardError => e
@@ -78,6 +119,8 @@ module Datadog
           "libddwaf failed to initialize, error: #{e.inspect}"
         end
 
+        @ruleset_info = e.ruleset_info if e.respond_to?(:ruleset_info)
+
         false
       end
 

data/lib/datadog/appsec/rate_limiter.rb

@@ -35,6 +35,11 @@ module Datadog
           rate_limiter(name).limit(&block)
         end
 
+        # reset a rate limiter: used for testing
+        def reset!(name)
+          Thread.current[:datadog_security_trace_rate_limiter] = nil
+        end
+
         protected
 
         def rate_limiter(name)

data/lib/datadog/appsec/reactive/operation.rb

@@ -1,6 +1,5 @@
 # typed: true
 
-require 'datadog/appsec'
 require 'datadog/appsec/reactive/engine'
 
 module Datadog

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

@@ -379,49 +379,63 @@ module Datadog
             committer_date: Time.at(fields[5].to_i).utc.to_datetime.iso8601
           }
         rescue => e
-          Datadog.logger.debug("Unable to read git commit users: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git commit users: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 
         def git_repository_url
           exec_git_command('git ls-remote --get-url')
         rescue => e
-          Datadog.logger.debug("Unable to read git repository url: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git repository url: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 
         def git_commit_message
           exec_git_command('git show -s --format=%s')
         rescue => e
-          Datadog.logger.debug("Unable to read git commit message: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git commit message: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 
         def git_branch
           exec_git_command('git rev-parse --abbrev-ref HEAD')
         rescue => e
-          Datadog.logger.debug("Unable to read git branch: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git branch: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 
         def git_commit_sha
           exec_git_command('git rev-parse HEAD')
         rescue => e
-          Datadog.logger.debug("Unable to read git commit SHA: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git commit SHA: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 
         def git_tag
           exec_git_command('git tag --points-at HEAD')
         rescue => e
-          Datadog.logger.debug("Unable to read git tag: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git tag: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 
         def git_base_directory
           exec_git_command('git rev-parse --show-toplevel')
         rescue => e
-          Datadog.logger.debug("Unable to read git base directory: #{e.message} at #{Array(e.backtrace).first}")
+          Datadog.logger.debug(
+            "Unable to read git base directory: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
           nil
         end
 

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

@@ -303,7 +303,7 @@ module Datadog
               if logger
                 logger.debug do
                   'Could not extract configuration from transport_options proc. ' \
-                  "Cause: #{e.message} Source: #{Array(e.backtrace).first}"
+                  "Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
                 end
               end
 

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

@@ -11,8 +11,6 @@ require 'datadog/tracing/tracer'
 require 'datadog/tracing/flush'
 require 'datadog/tracing/sync_writer'
 
-require 'datadog/profiling'
-
 module Datadog
   module Core
     module Configuration
@@ -181,7 +179,27 @@ module Datadog
           end
 
           def build_profiler(settings, agent_settings, tracer)
-            return unless Profiling.supported? && settings.profiling.enabled
+            return unless settings.profiling.enabled
+
+            # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
+            # dependency on individual products, in this case the Profiler.
+            # (Note "currently": in the future we want to change this so core classes don't depend on specific products)
+            #
+            # If the current file included a `require 'datadog/profiler'` at its beginning, we would generate circular
+            # requires when used from profiling:
+            #
+            # datadog/profiling
+            #     └─requires─> datadog/core
+            #                      └─requires─> datadog/core/configuration/components
+            #                                       └─requires─> datadog/profiling       # Loop!
+            #
+            # ...thus in #1998 we removed such a require.
+            #
+            # On the other hand, if datadog/core is loaded by a different product and no general `require 'ddtrace'` is
+            # done, then profiling may not be loaded, and thus to avoid this issue we do a require here (which is a
+            # no-op if profiling is already loaded).
+            require 'datadog/profiling'
+            return unless Profiling.supported?
 
             unless defined?(Profiling::Tasks::Setup)
               # In #1545 a user reported a NameError due to this constant being uninitialized
@@ -278,7 +296,7 @@ module Datadog
 
           def build_profiler_collectors(settings, recorder, trace_identifiers_helper)
             [
-              Profiling::Collectors::Stack.new(
+              Profiling::Collectors::OldStack.new(
                 recorder,
                 trace_identifiers_helper: trace_identifiers_helper,
                 max_frames: settings.profiling.advanced.max_frames

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

@@ -305,7 +305,7 @@ module Datadog
             tags = {}
 
             # Parse tags from environment
-            env_to_list(Core::Environment::Ext::ENV_TAGS).each do |tag|
+            env_to_list(Core::Environment::Ext::ENV_TAGS, comma_separated_only: false).each do |tag|
               pair = tag.split(':')
               tags[pair.first] = pair.last if pair.length == 2
             end
@@ -412,7 +412,7 @@ module Datadog
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3,
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
-                  ]
+                  ], comma_separated_only: true
                 )
               end
 
@@ -430,7 +430,7 @@ module Datadog
               o.default do
                 env_to_list(
                   Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT,
-                  [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG] # Only inject Datadog headers by default
+                  [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG], comma_separated_only: true # Only inject Datadog headers by default
                 )
               end
 

data/lib/datadog/core/configuration.rb

@@ -1,6 +1,5 @@
 # typed: true
 
-require 'forwardable'
 require 'datadog/core/configuration/components'
 require 'datadog/core/configuration/settings'
 require 'datadog/core/logger'
@@ -11,7 +10,6 @@ module Datadog
     # Configuration provides a unique access point for configurations
     module Configuration # rubocop:disable Metrics/ModuleLength
       include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-      extend Forwardable
 
       # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
       #
@@ -154,9 +152,13 @@ module Datadog
         pin[option] if pin
       end
 
-      def_delegators \
-        :components,
-        :health_metrics
+      # Internal {Datadog::Statsd} metrics collection.
+      #
+      # The list of metrics collected can be found in {Datadog::Core::Diagnostics::Ext::Health::Metrics}.
+      # @public_api
+      def health_metrics
+        components.health_metrics
+      end
 
       def logger
         # avoid initializing components if they didn't already exist

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

@@ -35,7 +35,9 @@ module Datadog
                 end
               end
             rescue StandardError => e
-              Datadog.logger.error("Error while parsing cgroup. Cause: #{e.message} Location: #{Array(e.backtrace).first}")
+              Datadog.logger.error(
+                "Error while parsing cgroup. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+              )
             end
           end
         end

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

@@ -81,7 +81,8 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(
-                "Error while parsing container info. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
+                "Error while parsing container info. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
               )
             end
           end

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

@@ -24,10 +24,34 @@ module Datadog
           var && ENV.key?(var) ? ENV[var].to_f : default
         end
 
-        def env_to_list(var, default = [])
+        # Parses comma- or space-separated lists.
+        #
+        # If a comma is present, then the list is considered comma-separated.
+        # Otherwise, it is considered space-separated.
+        #
+        # After the entries are separated, commas and whitespaces that are
+        # either trailing or leading are trimmed.
+        #
+        # Empty entries, after trimmed, are also removed from the result.
+        def env_to_list(var, default = [], comma_separated_only:)
           var = decode_array(var)
           if var && ENV.key?(var)
-            ENV[var].split(',').map(&:strip)
+            value = ENV[var]
+
+            values = if value.include?(',') || comma_separated_only
+                       value.split(',')
+                     else
+                       value.split(' ') # rubocop:disable Style/RedundantArgument
+                     end
+
+            values.map! do |v|
+              v.gsub!(/\A[\s,]*|[\s,]*\Z/, '')
+
+              v.empty? ? nil : v
+            end
+
+            values.compact!
+            values
           else
             default
           end

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

@@ -0,0 +1,11 @@
+module Datadog
+  module Core
+    module Logging
+      module Ext
+        # The technology from which the log originated.
+        # @see https://docs.datadoghq.com/api/latest/logs/#send-logs
+        DD_SOURCE = 'ruby'.freeze
+      end
+    end
+  end
+end

data/lib/datadog/core/metrics/client.rb

@@ -96,7 +96,9 @@ module Datadog
 
           statsd.count(stat, value, metric_options(options))
         rescue StandardError => e
-          Datadog.logger.error("Failed to send count stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+          Datadog.logger.error(
+            "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          )
         end
 
         def distribution(stat, value = nil, options = nil, &block)
@@ -107,7 +109,9 @@ module Datadog
 
           statsd.distribution(stat, value, metric_options(options))
         rescue StandardError => e
-          Datadog.logger.error("Failed to send distribution stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+          Datadog.logger.error(
+            "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          )
         end
 
         def increment(stat, options = nil)
@@ -117,7 +121,9 @@ module Datadog
 
           statsd.increment(stat, metric_options(options))
         rescue StandardError => e
-          Datadog.logger.error("Failed to send increment stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+          Datadog.logger.error(
+            "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          )
         end
 
         def gauge(stat, value = nil, options = nil, &block)
@@ -128,7 +134,9 @@ module Datadog
 
           statsd.gauge(stat, value, metric_options(options))
         rescue StandardError => e
-          Datadog.logger.error("Failed to send gauge stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+          Datadog.logger.error(
+            "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+          )
         end
 
         def time(stat, options = nil)
@@ -144,7 +152,9 @@ module Datadog
               distribution(stat, ((finished - start) * 1000), options)
             end
           rescue StandardError => e
-            Datadog.logger.error("Failed to send time stat. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+            Datadog.logger.error(
+              "Failed to send time stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            )
           end
         end
 

data/lib/datadog/core/runtime/metrics.rb

@@ -79,7 +79,7 @@ module Datadog
         def try_flush
           yield
         rescue StandardError => e
-          Datadog.logger.error("Error while sending runtime metric. Cause: #{e.message}")
+          Datadog.logger.error("Error while sending runtime metric. Cause: #{e.class.name} #{e.message}")
         end
 
         def default_metric_options

data/lib/datadog/core/workers/async.rb

@@ -138,7 +138,9 @@ module Datadog
               # rubocop:disable Lint/RescueException
               rescue Exception => e
                 @error = e
-                Datadog.logger.debug("Worker thread error. Cause #{e.message} Location: #{Array(e.backtrace).first}")
+                Datadog.logger.debug(
+                  "Worker thread error. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                )
                 raise
               end
               # rubocop:enable Lint/RescueException

data/lib/datadog/core/workers/runtime_metrics.rb

@@ -1,7 +1,5 @@
 # typed: false
 
-require 'forwardable'
-
 require 'datadog/core/runtime/metrics'
 
 require 'datadog/core/worker'
@@ -13,7 +11,6 @@ module Datadog
     module Workers
       # Emits runtime metrics asynchronously on a timed loop
       class RuntimeMetrics < Worker
-        extend Forwardable
         include Workers::Polling
 
         # In seconds

data/lib/datadog/core.rb

@@ -59,6 +59,12 @@ require 'datadog/core/extensions'
 # We must load core extensions to make certain global APIs
 # accessible: both for Datadog features and the core itself.
 module Datadog
+  # Common, lower level, internal code used (or usable) by two or more
+  # products. It is a dependency of each product. Contrast with Datadog::Kit
+  # for higher-level features.
+  module Core
+  end
+
   extend Core::Extensions
 
   # Add shutdown hook:

data/lib/datadog/kit/enable_core_dumps.rb

@@ -0,0 +1,50 @@
+# typed: ignore
+
+module Datadog
+  module Kit
+    # This helper is used to enable core dumps for the current Ruby app. This is useful when debugging native-level
+    # crashes.
+    #
+    # It can be enabled simply by adding `require 'datadog/kit/enable_core_dumps'` to start of the app.
+    module EnableCoreDumps
+      def self.call
+        current_size, maximum_size = Process.getrlimit(:CORE)
+        core_pattern =
+          begin
+            File.read('/proc/sys/kernel/core_pattern').strip
+          rescue
+            '(Could not open /proc/sys/kernel/core_pattern)'
+          end
+
+        if maximum_size <= 0
+          Kernel.warn("[DDTRACE] Could not enable core dumps on crash, maximum size is #{maximum_size} (disabled).")
+          return
+        elsif maximum_size == current_size
+          Kernel.warn('[DDTRACE] Core dumps already enabled, nothing to do!')
+          return
+        end
+
+        begin
+          Process.setrlimit(:CORE, maximum_size)
+        rescue => e
+          Kernel.warn(
+            "[DDTRACE] Failed to enable core dumps. Cause: #{e.class.name} #{e.message} " \
+            "Location: #{Array(e.backtrace).first}"
+          )
+          return
+        end
+
+        if current_size == 0
+          Kernel.warn("[DDTRACE] Enabled core dumps. Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'")
+        else
+          Kernel.warn(
+            "[DDTRACE] Raised core dump limit. Old size: #{current_size} " \
+            "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
+          )
+        end
+      end
+    end
+  end
+end
+
+Datadog::Kit::EnableCoreDumps.call

data/lib/datadog/kit/identity.rb

@@ -0,0 +1,63 @@
+# typed: false
+
+module Datadog
+  module Kit
+    # Tracking identity via traces
+    module Identity
+      # Attach user information to the trace
+      #
+      # @param trace [TraceOperation] Trace to attach data to.
+      # @param id [String] Mandatory. Username or client id extracted
+      #   from the access token or Authorization header in the inbound request
+      #   from outside the system.
+      # @param email [String] Email of the authenticated user associated
+      #   to the trace.
+      # @param name [String] User-friendly name. To be displayed in the
+      #   UI if set.
+      # @param session_id [String] Session ID of the authenticated user.
+      # @param role [String] Actual/assumed role the client is making
+      #   the request under extracted from token or application security
+      #   context.
+      # @param scope [String] Scopes or granted authorities the client
+      #   currently possesses extracted from token or application security
+      #   context. The value would come from the scope associated with an OAuth
+      #   2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
+      # @param others [Hash<String || Symbol, String>] Additional free-form
+      #   user information to attach to the trace.
+      #
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.set_user(trace, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others)
+        raise ArgumentError, 'missing required key: :id' if id.nil?
+
+        # enforce types
+
+        raise TypeError, 'id must be a String'         unless id.is_a?(String)
+        raise TypeError, 'email must be a String'      unless email.nil? || email.is_a?(String)
+        raise TypeError, 'name must be a String'       unless name.nil? || name.is_a?(String)
+        raise TypeError, 'session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
+        raise TypeError, 'role must be a String'       unless role.nil? || role.is_a?(String)
+        raise TypeError, 'scope must be a String'      unless scope.nil? || scope.is_a?(String)
+
+        others.each do |k, v|
+          raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
+        end
+
+        # set tags once data is known consistent
+
+        trace.set_tag('usr.id', id)
+        trace.set_tag('usr.email', email)           unless email.nil?
+        trace.set_tag('usr.name', name)             unless name.nil?
+        trace.set_tag('usr.session_id', session_id) unless session_id.nil?
+        trace.set_tag('usr.role', role)             unless role.nil?
+        trace.set_tag('usr.scope', scope)           unless scope.nil?
+
+        others.each do |k, v|
+          trace.set_tag("usr.#{k}", v) unless v.nil?
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end

data/lib/datadog/kit.rb

@@ -0,0 +1,11 @@
+# typed: false
+
+module Datadog
+  # Datadog::Kit holds public-facing APIs for higher level user-facing
+  # features, these features not belonging to a specific product. Contrary to
+  # Datadog::Core, Kit depends on products.
+  module Kit
+  end
+end
+
+require 'datadog/kit/identity'

data/lib/datadog/opentracer/tracer.rb

@@ -10,8 +10,6 @@ module Datadog
     # OpenTracing adapter for Datadog::Tracer
     # @public_api
     class Tracer < ::OpenTracing::Tracer
-      extend Forwardable
-
       # (see Datadog::Tracer)
       # @return [Datadog::Tracer]
       attr_reader \