cw-datadog 2.23.0.2

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../ext'
+
+module Datadog
+  module ErrorTracking
+    module Configuration
+      # Settings
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            # Error Tracking specific configurations.
+            # @public_api
+            settings :error_tracking do
+              # Enable automatic reporting of handled errors and defines the scope
+              # for which to report errors: user code, gems, or both. Possible
+              # values are: all | user | third_party.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors do |o|
+                o.type :string, nilable: true
+                o.default Ext::DEFAULT_HANDLED_ERRORS
+                o.env Ext::ENV_HANDLED_ERRORS
+                o.setter do |value|
+                  next value if Ext::VALID_HANDLED_ERRORS.include?(value)
+
+                  unless value.nil?
+                    Datadog.logger.warn(
+                      "Invalid handled errors scope: #{value}. " \
+                      "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
+                      'Deactivating the feature.'
+                    )
+                  end
+
+                  Ext::DEFAULT_HANDLED_ERRORS
+                end
+              end
+
+              # Enable automatic reporting of handled errors and specify what files should be
+              # instrumented. The value is a list of comma separated paths, filenames or gem names.
+              # The paths can be absolute, starting with '/' or relative to directory in which the program
+              # is launched, starting with './'.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS_MODULES' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors_include do |o|
+                o.type :array
+                o.default []
+                o.env Ext::ENV_HANDLED_ERRORS_INCLUDE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Configuration for ErrorTracking
+    module Configuration
+    end
+  end
+end
+
+require_relative 'configuration/settings'

data/lib/datadog/error_tracking/ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Error Tracking constants
+    module Ext
+      ENV_HANDLED_ERRORS = 'DD_ERROR_TRACKING_HANDLED_ERRORS'
+      ENV_HANDLED_ERRORS_INCLUDE = 'DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE'
+      HANDLED_ERRORS_ALL = 'all'
+      HANDLED_ERRORS_USER = 'user'
+      HANDLED_ERRORS_THIRD_PARTY = 'third_party'
+      DEFAULT_HANDLED_ERRORS = nil
+      VALID_HANDLED_ERRORS = [HANDLED_ERRORS_ALL, HANDLED_ERRORS_USER, HANDLED_ERRORS_THIRD_PARTY].freeze
+      SPAN_EVENTS_HAS_EXCEPTION = '_dd.span_events.has_exception'
+      RUBY_VERSION_WITH_RESCUE_EVENT = '3.3'
+    end
+  end
+end

data/lib/datadog/error_tracking/extensions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'configuration'
+require_relative '../core/configuration'
+
+module Datadog
+  module ErrorTracking
+    # Extends Datadog tracing with ErrorTracking features
+    module Extensions
+      # Inject Error Tracking into global objects.
+      def self.activate!
+        Core::Configuration::Settings.extend(Configuration::Settings)
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/filters.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Based on configuration, the TracePoint listening to :rescue or :raise
+    # may report more handled errors than we want to report. Therefore we need
+    # a function to filter the events. As the filter function both depends
+    # on configuration and is called numerous time, we generate it during
+    # during the initialization of the feature to have the best performance
+    # possible.
+    #
+    # @api private
+    module Filters
+      module_function
+
+      def get_gem_name(file_path)
+        regex = %r{gems/([^/]+)-\d}
+        regex_match = regex.match(file_path)
+        return unless regex_match
+
+        gem_name = regex_match[1]
+
+        begin
+          Gem::Specification.find_by_name(gem_name) # steep:ignore
+        rescue Gem::MissingSpecError
+          nil
+        end
+      end
+
+      def user_code?(file_path)
+        !get_gem_name(file_path)
+      end
+
+      def datadog_code?(file_path)
+        file_path.include?('lib/datadog/')
+      end
+
+      def third_party_code?(file_path)
+        gem_name = get_gem_name(file_path)
+        gem_name && gem_name != "datadog"
+      end
+
+      def file_included?(file_path, instrumented_files)
+        instrumented_files.include?(file_path)
+      end
+
+      # Generate the proc used in the TracePoint
+      def generate_filter(to_instrument_scope, handled_errors_include = nil)
+        case to_instrument_scope
+        # If DD_ERROR_TRACKING_HANDLED_ERRORS is set
+        when 'all'
+          proc { |file_path| !datadog_code?(file_path) }
+        when 'user'
+          # If DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
+          if handled_errors_include
+            proc { |file_path|
+              user_code?(file_path) || file_included?(file_path, handled_errors_include)
+            }
+          else
+            proc { |file_path| user_code?(file_path) }
+          end
+        when 'third_party'
+          if handled_errors_include
+            proc { |file_path|
+              third_party_code?(file_path) || file_included?(file_path, handled_errors_include)
+            }
+          else
+            proc { |file_path| third_party_code?(file_path) }
+          end
+        else
+          # If only DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
+          proc { |file_path| file_included?(file_path, handled_errors_include) }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'error_tracking/collector'
+require_relative 'error_tracking/component'
+require_relative 'error_tracking/configuration'
+require_relative 'error_tracking/ext'
+require_relative 'error_tracking/extensions'
+require_relative 'error_tracking/filters'
+
+module Datadog
+  # Namespace for Datadog ErrorTracking.
+  #
+  # @api private
+  module ErrorTracking
+    # Expose ErrorTracking to global shared objects
+    Extensions.activate!
+  end
+end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative '../../identity'
+require_relative '../../../appsec/trace_keeper'
+
+module Datadog
+  module Kit
+    module AppSec
+      module Events
+        # The second version of Business Logic Events SDK
+        module V2
+          LOGIN_SUCCESS_EVENT = 'users.login.success'
+          LOGIN_FAILURE_EVENT = 'users.login.failure'
+          TELEMETRY_METRICS_NAMESPACE = 'appsec'
+          TELEMETRY_METRICS_SDK_EVENT = 'sdk.event'
+          TELEMETRY_METRICS_SDK_VERSION = 'v2'
+          TELEMETRY_METRICS_EVENTS_INTO_TYPES = {
+            LOGIN_SUCCESS_EVENT => 'login_success',
+            LOGIN_FAILURE_EVENT => 'login_failure'
+          }.freeze
+
+          class << self
+            # Attach user login success information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_or_id [String, Hash<Symbol, String>] (optional) If a
+            #   String, considered as a user ID, if a Hash, considered as a user
+            #   attributes. The Hash must include `:id` as a key.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success('alice@example.com')
+            #
+            # @example Login and user attributes
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success(
+            #     'alice@example.com',
+            #     { id: 'user-123', email: 'alice@example.com', name: 'Alice' },
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_success(login, user_or_id = nil, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              user_attributes = build_user_attributes(user_or_id, login)
+
+              set_span_tags(span, metadata, namespace: LOGIN_SUCCESS_EVENT)
+              set_span_tags(span, user_attributes, namespace: "#{LOGIN_SUCCESS_EVENT}.usr")
+              span.set_tag('appsec.events.users.login.success.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.success.sdk', 'true')
+
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
+
+              record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_SUCCESS_EVENT)
+
+              # NOTE: Guard-clause will not work with Steep typechecking
+              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id) # steep:ignore
+
+              # NOTE: This is a fallback for the case when we don't have an ID,
+              #       but need to trigger WAF.
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            # Attach user login failure information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_exists [Boolean] Whether the user exists in the system.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure('alice@example.com')
+            #
+            # @example With user existence and metadata
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure(
+            #     'alice@example.com',
+            #     true,
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_failure(login, user_exists = false, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              unless user_exists.is_a?(TrueClass) || user_exists.is_a?(FalseClass)
+                raise TypeError, '`user_exists` argument must be a boolean'
+              end
+
+              set_span_tags(span, metadata, namespace: LOGIN_FAILURE_EVENT)
+              span.set_tag('appsec.events.users.login.failure.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.failure.sdk', 'true')
+              span.set_tag('appsec.events.users.login.failure.usr.login', login)
+              span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists.to_s)
+
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
+
+              record_event_telemetry_metric(LOGIN_FAILURE_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_FAILURE_EVENT)
+
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            private
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_trace
+              return Datadog::Tracing.active_trace unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.trace
+            end
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_span
+              return Datadog::Tracing.active_span unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.span
+            end
+
+            def build_user_attributes(user_or_id, login)
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+
+              case user_or_id
+              when nil
+                {login: login}
+              when String
+                {login: login, id: user_or_id}
+              when Hash
+                raise ArgumentError, 'missing required user key `:id`' unless user_or_id.key?(:id)
+                raise TypeError, 'user key `:id` must be a String' unless user_or_id[:id].is_a?(String)
+
+                user_or_id.merge(login: login)
+              else
+                raise TypeError, '`user_or_id` argument must be either String or Hash'
+              end
+            end
+
+            def set_span_tags(span, tags, namespace:)
+              tags.each do |name, value|
+                next if value.nil?
+
+                span.set_tag("appsec.events.#{namespace}.#{name}", value)
+              end
+            end
+
+            # TODO: In case if we need to introduce telemetry metrics to the SDK v1
+            #       or highly increase the number of metrics, this method should be
+            #       extracted into a proper module.
+            def record_event_telemetry_metric(event)
+              telemetry = ::Datadog.send(:components, allow_initialization: false)&.telemetry
+
+              if telemetry.nil?
+                return Datadog.logger.debug(
+                  'Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics'
+                )
+              end
+
+              tags = {
+                event_type: TELEMETRY_METRICS_EVENTS_INTO_TYPES[event],
+                sdk_version: TELEMETRY_METRICS_SDK_VERSION
+              }
+              telemetry.inc(TELEMETRY_METRICS_NAMESPACE, TELEMETRY_METRICS_SDK_EVENT, 1, tags: tags)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative '../identity'
+require_relative '../../appsec/trace_keeper'
+
+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'
+        USER_LOGIN_KEYS = ['usr.login', :"usr.login"].freeze
+
+        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)
+              user_login = user_options[:login] || others[:"usr.login"] || others['usr.login'] || user_id
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              others = others.reject { |key, _| USER_LOGIN_KEYS.include?(key) }
+              others[:"usr.login"] = user_login
+              track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
+
+              user_options[:login] = user_login
+              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_exists:, user_id: nil, **others)
+            set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
+              others[:"usr.login"] = user_id if user_id && !others.key?(:"usr.login") && !others.key?('usr.login')
+              track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
+
+              active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id) if 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)
+              user_login = user_options[:login] || others[:"usr.login"] || others['usr.login'] || user_id
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              others = others.reject { |key, _| USER_LOGIN_KEYS.include?(key) }
+              others[:"usr.login"] = user_login
+              track(SIGNUP_EVENT, active_trace, active_span, **others)
+
+              user_options[:login] = user_login
+              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
+
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
+            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
+
+                ::Datadog::AppSec::TraceKeeper.keep!(active_trace)
+              end
+            end
+
+            ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', event)
+          end
+
+          private
+
+          def set_trace_and_span_context(method, trace = nil, span = nil)
+            if (appsec_context = Datadog::AppSec.active_context)
+              trace = appsec_context.trace
+              span = appsec_context.span
+            end
+
+            trace ||= Datadog::Tracing.active_trace
+            span ||= 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.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("[datadog] Could not enable core dumps on crash, maximum size is #{maximum_size} (disabled).")
+          return
+        elsif maximum_size == current_size
+          Kernel.warn("[datadog] Core dumps already enabled, nothing to do. #{enabled_status}")
+          return
+        end
+
+        begin
+          Process.setrlimit(:CORE, maximum_size)
+        rescue => e
+          Kernel.warn(
+            "[datadog] Failed to enable core dumps. Cause: #{e.class.name} #{e.message} " \
+            "Location: #{Array(e.backtrace).first}"
+          )
+          return
+        end
+
+        if current_size == 0
+          Kernel.warn("[datadog] Enabled core dumps. #{enabled_status}")
+        else
+          Kernel.warn("[datadog] Raised core dump limit. Old size: #{current_size} #{enabled_status}")
+        end
+      end
+    end
+  end
+end
+
+Datadog::Kit::EnableCoreDumps.call