ddtrace 0.54.2 → 1.18.0

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Workers
+      # Adds looping behavior to workers, with a sleep
+      # interval between each loop.
+      module IntervalLoop
+        BACK_OFF_RATIO = 1.2
+        BACK_OFF_MAX = 5
+        BASE_INTERVAL = 1
+
+        # This single shared mutex is used to avoid concurrency issues during the
+        # initialization of per-instance lazy-initialized mutexes.
+        MUTEX_INIT = Mutex.new
+
+        def self.included(base)
+          base.prepend(PrependedMethods)
+        end
+
+        # Methods that must be prepended
+        module PrependedMethods
+          def perform(*args)
+            perform_loop { super(*args) }
+          end
+        end
+
+        def stop_loop
+          mutex.synchronize do
+            return false unless run_loop?
+
+            @run_loop = false
+            shutdown.signal
+          end
+
+          true
+        end
+
+        def work_pending?
+          run_loop?
+        end
+
+        def run_loop?
+          return false unless instance_variable_defined?(:@run_loop)
+
+          @run_loop == true
+        end
+
+        def loop_base_interval
+          @loop_base_interval ||= BASE_INTERVAL
+        end
+
+        def loop_back_off_ratio
+          @loop_back_off_ratio ||= BACK_OFF_RATIO
+        end
+
+        def loop_back_off_max
+          @loop_back_off_max ||= BACK_OFF_MAX
+        end
+
+        def loop_wait_time
+          @loop_wait_time ||= loop_base_interval
+        end
+
+        def loop_wait_time=(value)
+          @loop_wait_time = value
+        end
+
+        def loop_back_off!
+          self.loop_wait_time = [loop_wait_time * BACK_OFF_RATIO, BACK_OFF_MAX].min
+        end
+
+        # Should perform_loop just straight into work, or start by waiting?
+        #
+        # The use case is if we want to report some information (like profiles) from time to time, we may not want to
+        # report empty/zero/some residual value immediately when the worker starts.
+        def loop_wait_before_first_iteration?
+          false
+        end
+
+        protected
+
+        attr_writer \
+          :loop_back_off_max,
+          :loop_back_off_ratio,
+          :loop_base_interval
+
+        def mutex
+          @mutex || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
+        end
+
+        private
+
+        def perform_loop
+          mutex.synchronize do
+            @run_loop = true
+
+            shutdown.wait(mutex, loop_wait_time) if loop_wait_before_first_iteration?
+          end
+
+          loop do
+            if work_pending?
+              # There's work to do...
+              # Run the task
+              yield
+            end
+
+            # Wait for an interval, unless shutdown has been signaled.
+            mutex.synchronize do
+              return unless run_loop? || work_pending?
+
+              shutdown.wait(mutex, loop_wait_time) if run_loop?
+            end
+          end
+        end
+
+        def shutdown
+          @shutdown ||= ConditionVariable.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require_relative 'async'
+require_relative 'interval_loop'
+
+module Datadog
+  module Core
+    module Workers
+      # Adds polling (async looping) behavior to workers
+      module Polling
+        DEFAULT_SHUTDOWN_TIMEOUT = 1
+
+        def self.included(base)
+          base.include(Workers::IntervalLoop)
+          base.include(Workers::Async::Thread)
+          base.prepend(PrependedMethods)
+        end
+
+        # Methods that must be prepended
+        module PrependedMethods
+          def perform(*args)
+            super if enabled?
+          end
+        end
+
+        def stop(force_stop = false, timeout = DEFAULT_SHUTDOWN_TIMEOUT)
+          if running?
+            # Attempt graceful stop and wait
+            stop_loop
+            graceful = join(timeout)
+
+            if !graceful && force_stop
+              Datadog.logger.debug do
+                "Timeout while waiting for worker to finish gracefully, forcing termination for: #{self}"
+              end
+              terminate
+            else
+              graceful
+            end
+          else
+            false
+          end
+        end
+
+        def enabled?
+          return true unless instance_variable_defined?(:@enabled)
+
+          @enabled
+        end
+
+        # Allow worker to be started
+        def enabled=(value)
+          # Coerce to boolean
+          @enabled = (value == true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Workers
+      # Adds queue behavior to workers, with a buffer
+      # to which items can be queued then dequeued.
+      module Queue
+        def self.included(base)
+          base.prepend(PrependedMethods)
+        end
+
+        # Methods that must be prepended
+        module PrependedMethods
+          def perform(*args)
+            super(*dequeue) if work_pending?
+          end
+        end
+
+        def buffer
+          @buffer ||= []
+        end
+
+        def enqueue(*args)
+          buffer.push(args)
+        end
+
+        def dequeue
+          buffer.shift
+        end
+
+        # Are there more items to be processed next?
+        def work_pending?
+          !buffer.empty?
+        end
+
+        protected
+
+        attr_writer \
+          :buffer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../runtime/metrics'
+
+require_relative '../worker'
+require_relative 'async'
+require_relative 'polling'
+
+module Datadog
+  module Core
+    module Workers
+      # Emits runtime metrics asynchronously on a timed loop
+      class RuntimeMetrics < Worker
+        include Workers::Polling
+
+        # In seconds
+        DEFAULT_FLUSH_INTERVAL = 10
+        DEFAULT_BACK_OFF_MAX = 30
+
+        attr_reader \
+          :metrics
+
+        def initialize(options = {})
+          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new }
+
+          # Workers::Async::Thread settings
+          self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
+
+          # Workers::IntervalLoop settings
+          self.loop_base_interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)
+          self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
+          self.loop_back_off_max = options.fetch(:back_off_max, DEFAULT_BACK_OFF_MAX)
+
+          self.enabled = options.fetch(:enabled, false)
+        end
+
+        def perform
+          metrics.flush
+          true
+        end
+
+        def register_service(service)
+          # Start the worker
+          metrics.register_service(service).tap { perform }
+        end
+
+        # TODO: `close_metrics` is only needed because
+        # Datadog::Core::Configuration::Components directly manipulates
+        # the lifecycle of Runtime::Metrics.statsd instances.
+        # This should be avoided, as it prevents this class from
+        # ensuring correct resource decommission of its internal
+        # dependencies.
+        def stop(*args, close_metrics: true)
+          self.enabled = false
+          result = super(*args)
+          @metrics.close if close_metrics
+          result
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '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
+    class << self
+      # Records the occurrence of a deprecated operation in this library.
+      #
+      # Currently, these operations are logged to `Datadog.logger` at `warn` level.
+      #
+      # `disallowed_next_major` adds a message informing that the deprecated operation
+      # won't be allowed in the next major release.
+      #
+      # @yieldreturn [String] a String with the lazily evaluated deprecation message.
+      # @param [Boolean] disallowed_next_major whether this deprecation will be enforced in the next major release.
+      def log_deprecation(disallowed_next_major: true)
+        Datadog.logger.warn do
+          message = yield
+          message += ' This will be enforced in the next major release.' if disallowed_next_major
+          message
+        end
+        nil
+      end
+    end
+  end
+
+  extend Core::Extensions
+
+  # Add shutdown hook:
+  # Ensures the Datadog components have a chance to gracefully
+  # shut down and cleanup before terminating the process.
+  at_exit do
+    if Interrupt === $! # rubocop:disable Style/SpecialGlobalVars is process terminating due to a ctrl+c or similar?
+      Datadog.send(:handle_interrupt_shutdown!)
+    else
+      Datadog.shutdown!
+    end
+  end
+end

data/lib/datadog/kit/appsec/events.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative '../identity'
+
+module Datadog
+  module Kit
+    module AppSec
+      # Tracking events
+      module Events
+        LOGIN_SUCCESS_EVENT = 'users.login.success'
+        LOGIN_FAILURE_EVENT = 'users.login.failure'
+        SIGNUP_EVENT = 'users.signup'
+
+        class << self
+          # Attach login success event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user [Hash<Symbol, String>] User information to pass to
+          #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_login_success(trace = nil, span = nil, user:, **others)
+            set_trace_and_span_context('track_login_success', trace, span) do |active_trace, active_span|
+              user_options = user.dup
+              user_id = user_options.delete(:id)
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
+
+              Kit::Identity.set_user(active_trace, active_span, id: user_id, **user_options)
+            end
+          end
+
+          # Attach login failure event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user_id [String] User id that attempted login
+          # @param user_exists [bool] Whether the user id that did a login attempt exists.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_login_failure(trace = nil, span = nil, user_id:, user_exists:, **others)
+            set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
+              raise ArgumentError, 'user_id cannot be nil' if user_id.nil?
+
+              track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
+
+              active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id)
+              active_span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
+            end
+          end
+
+          # Attach signup event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user [Hash<Symbol, String>] User information to pass to
+          #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_signup(trace = nil, span = nil, user:, **others)
+            set_trace_and_span_context('track_signup', trace, span) do |active_trace, active_span|
+              user_options = user.dup
+              user_id = user_options.delete(:id)
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              track(SIGNUP_EVENT, active_trace, active_span, **others)
+
+              Kit::Identity.set_user(trace, id: user_id, **user_options)
+            end
+          end
+
+          # Attach custom event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param event [String] Mandatory. Event code.
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param others [Hash<Symbol, String>] Additional free-form
+          #   event information to attach to the trace. Key must not
+          #   be :track.
+          def track(event, trace = nil, span = nil, **others)
+            if trace && span
+              check_trace_span_integrity(trace, span)
+
+              span.set_tag("appsec.events.#{event}.track", 'true')
+              span.set_tag("_dd.appsec.events.#{event}.sdk", 'true')
+
+              others.each do |k, v|
+                raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
+
+                span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+              end
+
+              trace.keep!
+            else
+              set_trace_and_span_context('track', trace, span) do |active_trace, active_span|
+                active_span.set_tag("appsec.events.#{event}.track", 'true')
+                active_span.set_tag("_dd.appsec.events.#{event}.sdk", 'true')
+
+                others.each do |k, v|
+                  raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
+
+                  active_span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+                end
+
+                active_trace.keep!
+              end
+            end
+          end
+
+          private
+
+          def set_trace_and_span_context(method, trace = nil, span = nil)
+            if (appsec_scope = Datadog::AppSec.active_scope)
+              trace = appsec_scope.trace
+              span = appsec_scope.service_entry_span
+            end
+
+            trace ||= Datadog::Tracing.active_trace
+            span ||=  trace && trace.active_span || Datadog::Tracing.active_span
+
+            unless trace && span
+              Datadog.logger.debug(
+                "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+                ' to track this events'
+              )
+              return
+            end
+
+            check_trace_span_integrity(trace, span)
+
+            yield(trace, span)
+          end
+
+          def check_trace_span_integrity(trace, span)
+            raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/kit/enable_core_dumps.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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
+
+        enabled_status = "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
+
+        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. #{enabled_status}")
+          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. #{enabled_status}")
+        else
+          Kernel.warn("[ddtrace] Raised core dump limit. Old size: #{current_size} #{enabled_status}")
+        end
+      end
+    end
+  end
+end
+
+Datadog::Kit::EnableCoreDumps.call

data/lib/datadog/kit/identity.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../appsec/instrumentation/gateway/argument'
+
+module Datadog
+  module Kit
+    # Tracking identity via traces
+    module Identity
+      class << self
+        # Attach user information to the trace
+        #
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
+        # @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<Symbol, String>] Additional free-form
+        #   user information to attach to the trace.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def set_user(
+          trace = nil, span = nil, 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_trace_and_span_context('set_user', trace, span) do |_active_trace, active_span|
+            # set tags once data is known consistent
+            active_span.set_tag('usr.id', id)
+            active_span.set_tag('usr.email', email)           unless email.nil?
+            active_span.set_tag('usr.name', name)             unless name.nil?
+            active_span.set_tag('usr.session_id', session_id) unless session_id.nil?
+            active_span.set_tag('usr.role', role)             unless role.nil?
+            active_span.set_tag('usr.scope', scope)           unless scope.nil?
+
+            others.each do |k, v|
+              active_span.set_tag("usr.#{k}", v) unless v.nil?
+            end
+
+            if Datadog::AppSec.active_scope
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+          end
+        end
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        private
+
+        def set_trace_and_span_context(method, trace = nil, span = nil)
+          if (appsec_scope = Datadog::AppSec.active_scope)
+            trace = appsec_scope.trace
+            span = appsec_scope.service_entry_span
+          end
+
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace && trace.active_span || Datadog::Tracing.active_span
+
+          unless trace && span
+            Datadog.logger.debug(
+              "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+              ' to track this events'
+            )
+            return
+          end
+
+          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+
+          yield(trace, span)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/kit.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+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_relative 'kit/identity'