sentry-ruby 5.18.2 → 5.28.1

data/lib/sentry/configuration.rb

@@ -3,7 +3,8 @@
 require "concurrent/utility/processor_counter"
 
 require "sentry/utils/exception_cause_chain"
-require 'sentry/utils/custom_inspection'
+require "sentry/utils/custom_inspection"
+require "sentry/utils/env_helper"
 require "sentry/dsn"
 require "sentry/release_detector"
 require "sentry/transport/configuration"
@@ -11,6 +12,9 @@ require "sentry/cron/configuration"
 require "sentry/metrics/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
+require "sentry/logger"
+require "sentry/structured_logger"
+require "sentry/log_event_buffer"
 
 module Sentry
   class Configuration
@@ -22,6 +26,8 @@ module Sentry
     # have an `engines` dir at the root of your project, you may want
     # to set this to something like /(app|config|engines|lib)/
     #
+    # The default is value is /(bin|exe|app|config|lib|test|spec)/
+    #
     # @return [Regexp, nil]
     attr_accessor :app_dirs_pattern
 
@@ -96,6 +102,15 @@ module Sentry
     # @return [Proc]
     attr_reader :before_send_transaction
 
+    # Optional Proc, called before sending an event to the server
+    # @example
+    #   config.before_send_log = lambda do |log|
+    #     log.attributes["sentry"] = true
+    #     log
+    #   end
+    # @return [Proc]
+    attr_accessor :before_send_log
+
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :http_logger
@@ -180,13 +195,35 @@ module Sentry
     # Logger used by Sentry. In Rails, this is the Rails logger, otherwise
     # Sentry provides its own Sentry::Logger.
     # @return [Logger]
-    attr_accessor :logger
+    attr_accessor :sdk_logger
+
+    # File path for DebugTransport to log events to. If not set, defaults to a temporary file.
+    # This is useful for debugging and testing purposes.
+    # @return [String, nil]
+    attr_accessor :sdk_debug_transport_log_file
+
+    # @deprecated Use {#sdk_logger=} instead.
+    def logger=(logger)
+      warn "[sentry] `config.logger=` is deprecated. Please use `config.sdk_logger=` instead."
+      self.sdk_logger = logger
+    end
+
+    # @deprecated Use {#sdk_logger} instead.
+    def logger
+      warn "[sentry] `config.logger` is deprecated. Please use `config.sdk_logger` instead."
+      self.sdk_logger
+    end
 
     # Project directory root for in_app detection. Could be Rails root, etc.
     # Set automatically for Rails.
     # @return [String]
     attr_accessor :project_root
 
+    # Whether to strip the load path while constructing the backtrace frame filename.
+    # Defaults to true.
+    # @return [Boolean]
+    attr_accessor :strip_backtrace_load_path
+
     # Insert sentry-trace to outgoing requests' headers
     # @return [Boolean]
     attr_accessor :propagate_traces
@@ -254,8 +291,17 @@ module Sentry
     # @return [Proc]
     attr_accessor :traces_sampler
 
+    # Enable Structured Logging
+    # @return [Boolean]
+    attr_accessor :enable_logs
+
+    # Structured logging configuration.
+    # @return [StructuredLoggingConfiguration]
+    attr_reader :structured_logging
+
     # Easier way to use performance tracing
     # If set to true, will set traces_sample_rate to 1.0
+    # @deprecated It will be removed in the next major release.
     # @return [Boolean, nil]
     attr_reader :enable_tracing
 
@@ -283,6 +329,10 @@ module Sentry
     # @return [Symbol]
     attr_reader :instrumenter
 
+    # The profiler class
+    # @return [Class]
+    attr_reader :profiler_class
+
     # Take a float between 0.0 and 1.0 as the sample rate for capturing profiles.
     # Note that this rate is relative to traces_sample_rate / traces_sampler,
     # i.e. the profile is sampled by this rate after the transaction is sampled.
@@ -294,6 +344,10 @@ module Sentry
     # @return [Array<Symbol>]
     attr_accessor :enabled_patches
 
+    # Maximum number of log events to buffer before sending
+    # @return [Integer]
+    attr_accessor :max_log_events
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -302,18 +356,18 @@ module Sentry
     # But they are mostly considered as noise and should be ignored by default
     # Please see https://github.com/getsentry/sentry-ruby/pull/2026 for more information
     PUMA_IGNORE_DEFAULT = [
-      'Puma::MiniSSL::SSLError',
-      'Puma::HttpParserError',
-      'Puma::HttpParserError501'
+      "Puma::MiniSSL::SSLError",
+      "Puma::HttpParserError",
+      "Puma::HttpParserError501"
     ].freeze
 
     # Most of these errors generate 4XX responses. In general, Sentry clients
     # only automatically report 5xx responses.
     IGNORE_DEFAULT = [
-      'Mongoid::Errors::DocumentNotFound',
-      'Rack::QueryParser::InvalidParameterError',
-      'Rack::QueryParser::ParameterTypeError',
-      'Sinatra::NotFound'
+      "Mongoid::Errors::DocumentNotFound",
+      "Rack::QueryParser::InvalidParameterError",
+      "Rack::QueryParser::ParameterTypeError",
+      "Sinatra::NotFound"
     ].freeze
 
     RACK_ENV_WHITELIST_DEFAULT = %w[
@@ -323,18 +377,20 @@ module Sentry
     ].freeze
 
     HEROKU_DYNO_METADATA_MESSAGE = "You are running on Heroku but haven't enabled Dyno Metadata. For Sentry's "\
-    "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`".freeze
+    "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`"
 
-    LOG_PREFIX = "** [Sentry] ".freeze
-    MODULE_SEPARATOR = "::".freeze
+    LOG_PREFIX = "** [Sentry] "
+    MODULE_SEPARATOR = "::"
     SKIP_INSPECTION_ATTRIBUTES = [:@linecache, :@stacktrace_builder]
 
     INSTRUMENTERS = [:sentry, :otel]
 
-    PROPAGATION_TARGETS_MATCH_ALL = /.*/.freeze
+    PROPAGATION_TARGETS_MATCH_ALL = /.*/
 
     DEFAULT_PATCHES = %i[redis puma http].freeze
 
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test|spec)/
+
     class << self
       # Post initialization callbacks are called at the end of initialization process
       # allowing extending the configuration of sentry-ruby by multiple extensions
@@ -344,16 +400,74 @@ module Sentry
 
       # allow extensions to add their hooks to the Configuration class
       def add_post_initialization_callback(&block)
-        post_initialization_callbacks << block
+        callbacks[:initialize][:after] << block
+      end
+
+      def before(event, &block)
+        callbacks[event.to_sym][:before] << block
+      end
+
+      def after(event, &block)
+        callbacks[event.to_sym][:after] << block
+      end
+
+      # @!visibility private
+      def callbacks
+        @callbacks ||= {
+          initialize: { before: [], after: [] },
+          configured: { before: [], after: [] }
+        }
+      end
+
+      def validations
+        @validations ||= {}
+      end
+
+      def validate(attribute, optional: false, type: nil)
+        validations[attribute] = {
+          optional: optional,
+          type: type,
+          proc: build_validation_proc(optional, type)
+        }
+      end
+
+      private
+
+      def build_validation_proc(optional, type)
+        case type
+        when :numeric
+          ->(value) do
+            if optional && value.nil?
+              true
+            else
+              unless value.is_a?(Numeric)
+                message = "must be a Numeric"
+                message += " or nil" if optional
+
+                { error: message, value: value }
+              else
+                true
+              end
+            end
+          end
+        else
+          ->(value) { true }
+        end
       end
     end
 
+    validate :traces_sample_rate, optional: true, type: :numeric
+    validate :profiles_sample_rate, optional: true, type: :numeric
+
     def initialize
-      self.app_dirs_pattern = nil
-      self.debug = false
+      run_callbacks(:before, :initialize)
+
+      self.app_dirs_pattern = APP_DIRS_PATTERN
+      self.debug = Sentry::Utils::EnvHelper.env_to_bool(ENV["SENTRY_DEBUG"])
       self.background_worker_threads = (processor_count / 2.0).ceil
       self.background_worker_max_queue = BackgroundWorker::DEFAULT_MAX_QUEUE
       self.backtrace_cleanup_callback = nil
+      self.strip_backtrace_load_path = true
       self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
@@ -364,7 +478,7 @@ module Sentry
       self.excluded_exceptions = IGNORE_DEFAULT + PUMA_IGNORE_DEFAULT
       self.inspect_exception_causes_for_exclusion = true
       self.linecache = ::Sentry::LineCache.new
-      self.logger = ::Sentry::Logger.new(STDOUT)
+      self.sdk_logger = ::Sentry::Logger.new(STDOUT)
       self.project_root = Dir.pwd
       self.propagate_traces = true
 
@@ -376,8 +490,11 @@ module Sentry
       self.auto_session_tracking = true
       self.enable_backpressure_handling = false
       self.trusted_proxies = []
-      self.dsn = ENV['SENTRY_DSN']
-      self.spotlight = false
+      self.dsn = ENV["SENTRY_DSN"]
+
+      spotlight_env = ENV["SENTRY_SPOTLIGHT"]
+      spotlight_bool = Sentry::Utils::EnvHelper.env_to_bool(spotlight_env, strict: true)
+      self.spotlight = spotlight_bool.nil? ? (spotlight_env || false) : spotlight_bool
       self.server_name = server_name_from_env
       self.instrumenter = :sentry
       self.trace_propagation_targets = [PROPAGATION_TARGETS_MATCH_ALL]
@@ -385,16 +502,45 @@ module Sentry
 
       self.before_send = nil
       self.before_send_transaction = nil
+      self.before_send_log = nil
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
       self.traces_sampler = nil
       self.enable_tracing = nil
+      self.enable_logs = false
+
+      self.profiler_class = Sentry::Profiler
 
       @transport = Transport::Configuration.new
       @cron = Cron::Configuration.new
-      @metrics = Metrics::Configuration.new
+      @metrics = Metrics::Configuration.new(self.sdk_logger)
+      @structured_logging = StructuredLoggingConfiguration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
-      run_post_initialization_callbacks
+      self.max_log_events = LogEventBuffer::DEFAULT_MAX_EVENTS
+
+      run_callbacks(:after, :initialize)
+
+      yield(self) if block_given?
+
+      run_callbacks(:after, :configured)
+    end
+
+    def validate
+      if profiler_class == Sentry::Profiler && profiles_sample_rate && !Sentry.dependency_installed?(:StackProf)
+        log_warn("Please add the 'stackprof' gem to your Gemfile to use the StackProf profiler with Sentry.")
+      end
+
+      if profiler_class == Sentry::Vernier::Profiler && profiles_sample_rate && !Sentry.dependency_installed?(:Vernier)
+        log_warn("Please add the 'vernier' gem to your Gemfile to use the Vernier profiler with Sentry.")
+      end
+
+      self.class.validations.each do |attribute, validation|
+        value = public_send(attribute)
+
+        next if (result = validation[:proc].call(value)) === true
+
+        raise ArgumentError, result[:error]
+      end
     end
 
     def dsn=(value)
@@ -465,25 +611,35 @@ module Sentry
     end
 
     def enable_tracing=(enable_tracing)
+      unless enable_tracing.nil?
+        log_warn <<~MSG
+          `enable_tracing` is now deprecated in favor of `traces_sample_rate = 1.0`.
+        MSG
+      end
+
       @enable_tracing = enable_tracing
       @traces_sample_rate ||= 1.0 if enable_tracing
     end
 
-    def is_numeric_or_nil?(value)
-      value.is_a?(Numeric) || value.nil?
-    end
-
     def traces_sample_rate=(traces_sample_rate)
-      raise ArgumentError, "traces_sample_rate must be a Numeric or nil" unless is_numeric_or_nil?(traces_sample_rate)
       @traces_sample_rate = traces_sample_rate
     end
 
     def profiles_sample_rate=(profiles_sample_rate)
-      raise ArgumentError, "profiles_sample_rate must be a Numeric or nil" unless is_numeric_or_nil?(profiles_sample_rate)
-      log_warn("Please make sure to include the 'stackprof' gem in your Gemfile to use Profiling with Sentry.") unless defined?(StackProf)
       @profiles_sample_rate = profiles_sample_rate
     end
 
+    def profiler_class=(profiler_class)
+      if profiler_class == Sentry::Vernier::Profiler
+        begin
+          require "vernier"
+        rescue LoadError
+        end
+      end
+
+      @profiler_class = profiler_class
+    end
+
     def sending_allowed?
       spotlight || sending_to_dsn_allowed?
     end
@@ -555,7 +711,8 @@ module Sentry
         app_dirs_pattern: @app_dirs_pattern,
         linecache: @linecache,
         context_lines: @context_lines,
-        backtrace_cleanup_callback: @backtrace_cleanup_callback
+        backtrace_cleanup_callback: @backtrace_cleanup_callback,
+        strip_backtrace_load_path: @strip_backtrace_load_path
       )
     end
 
@@ -632,12 +789,12 @@ module Sentry
     end
 
     def environment_from_env
-      ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      ENV["SENTRY_CURRENT_ENV"] || ENV["SENTRY_ENVIRONMENT"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
     end
 
     def server_name_from_env
       if running_on_heroku?
-        ENV['DYNO']
+        ENV["DYNO"]
       else
         # Try to resolve the hostname to an FQDN, but fall back to whatever
         # the load name is.
@@ -649,18 +806,30 @@ module Sentry
       File.directory?("/etc/heroku") && !ENV["CI"]
     end
 
-    def run_post_initialization_callbacks
-      self.class.post_initialization_callbacks.each do |hook|
+    def run_callbacks(hook, event)
+      self.class.callbacks[event][hook].each do |hook|
         instance_eval(&hook)
       end
     end
 
     def processor_count
-      if Concurrent.respond_to?(:usable_processor_count)
-        Concurrent.usable_processor_count
-      else
-        Concurrent.processor_count
-      end
+      available_processor_count = Concurrent.available_processor_count if Concurrent.respond_to?(:available_processor_count)
+      available_processor_count || Concurrent.processor_count
+    end
+  end
+
+  class StructuredLoggingConfiguration
+    # File path for DebugStructuredLogger to log events to
+    # @return [String, Pathname, nil]
+    attr_accessor :file_path
+
+    # The class to use as a structured logger.
+    # @return [Class]
+    attr_accessor :logger_class
+
+    def initialize
+      @file_path = nil
+      @logger_class = Sentry::StructuredLogger
     end
   end
 end

data/lib/sentry/core_ext/object/deep_dup.rb

@@ -2,7 +2,7 @@
 
 return if Object.method_defined?(:deep_dup)
 
-require 'sentry/core_ext/object/duplicable'
+require "sentry/core_ext/object/duplicable"
 
 #########################################
 #  This file was copied from Rails 5.2  #

data/lib/sentry/cron/monitor_check_ins.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Cron
     module MonitorCheckIns
@@ -12,12 +14,12 @@ module Sentry
                                                 :in_progress,
                                                 monitor_config: monitor_config)
 
-          start = Sentry.utc_now.to_i
+          start = Metrics::Timing.duration_start
 
           begin
             # need to do this on ruby <= 2.6 sadly
             ret = method(:perform).super_method.arity == 0 ? super() : super
-            duration = Sentry.utc_now.to_i - start
+            duration = Metrics::Timing.duration_end(start)
 
             Sentry.capture_check_in(slug,
                                     :ok,
@@ -27,7 +29,7 @@ module Sentry
 
             ret
           rescue Exception
-            duration = Sentry.utc_now.to_i - start
+            duration = Metrics::Timing.duration_end(start)
 
             Sentry.capture_check_in(slug,
                                     :error,
@@ -57,7 +59,7 @@ module Sentry
 
         def sentry_monitor_slug(name: self.name)
           @sentry_monitor_slug ||= begin
-            slug = name.gsub('::', '-').downcase
+            slug = name.gsub("::", "-").downcase
             slug[-MAX_SLUG_LENGTH..-1] || slug
           end
         end

data/lib/sentry/cron/monitor_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'sentry/cron/monitor_schedule'
+require "sentry/cron/monitor_schedule"
 
 module Sentry
   module Cron

data/lib/sentry/debug_structured_logger.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "pathname"
+require "delegate"
+
+module Sentry
+  # DebugStructuredLogger is a logger that captures structured log events to a file for debugging purposes.
+  #
+  # It can optionally also send log events to Sentry via the normal structured logger if logging
+  # is enabled.
+  class DebugStructuredLogger < SimpleDelegator
+    DEFAULT_LOG_FILE_PATH = File.join("log", "sentry_debug_logs.log")
+
+    attr_reader :log_file, :backend
+
+    def initialize(configuration)
+      @log_file = initialize_log_file(
+        configuration.structured_logging.file_path || DEFAULT_LOG_FILE_PATH
+      )
+      @backend = initialize_backend(configuration)
+
+      super(@backend)
+    end
+
+    # Override all log level methods to capture events
+    %i[trace debug info warn error fatal].each do |level|
+      define_method(level) do |message, parameters = [], **attributes|
+        log_event = capture_log_event(level, message, parameters, **attributes)
+        backend.public_send(level, message, parameters, **attributes)
+        log_event
+      end
+    end
+
+    def log(level, message, parameters:, **attributes)
+      log_event = capture_log_event(level, message, parameters, **attributes)
+      backend.log(level, message, parameters: parameters, **attributes)
+      log_event
+    end
+
+    def capture_log_event(level, message, parameters, **attributes)
+      log_event_json = {
+        timestamp: Time.now.utc.iso8601,
+        level: level.to_s,
+        message: message,
+        parameters: parameters,
+        attributes: attributes
+      }
+
+      File.open(log_file, "a") { |file| file << JSON.dump(log_event_json) << "\n" }
+      log_event_json
+    end
+
+    def logged_events
+      File.readlines(log_file).map do |line|
+        JSON.parse(line)
+      end
+    end
+
+    def clear
+      File.write(log_file, "")
+      if backend.respond_to?(:config)
+        backend.config.sdk_logger.debug("DebugStructuredLogger: Cleared events from #{log_file}")
+      end
+    end
+
+    private
+
+    def initialize_backend(configuration)
+      if configuration.enable_logs
+        StructuredLogger.new(configuration)
+      else
+        # Create a no-op logger if logging is disabled
+        NoOpLogger.new
+      end
+    end
+
+    def initialize_log_file(log_file_path)
+      log_file = Pathname(log_file_path)
+
+      FileUtils.mkdir_p(log_file.dirname) unless log_file.dirname.exist?
+
+      log_file
+    end
+
+    # No-op logger for when structured logging is disabled
+    class NoOpLogger
+      %i[trace debug info warn error fatal log].each do |method|
+        define_method(method) { |*args, **kwargs| nil }
+      end
+    end
+  end
+end

data/lib/sentry/dsn.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 require "uri"
+require "ipaddr"
+require "resolv"
 
 module Sentry
   class DSN
-    PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
+    PORT_MAP = { "http" => 80, "https" => 443 }.freeze
     REQUIRED_ATTRIBUTES = %w[host path public_key project_id].freeze
+    LOCALHOST_NAMES = %w[localhost 127.0.0.1 ::1 [::1]].freeze
+    LOCALHOST_PATTERN = /\.local(host|domain)?$/i
 
     attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 
@@ -13,7 +17,7 @@ module Sentry
       @raw_value = dsn_string
 
       uri = URI.parse(dsn_string)
-      uri_path = uri.path.split('/')
+      uri_path = uri.path.split("/")
 
       if uri.user
         # DSN-style string
@@ -25,7 +29,7 @@ module Sentry
       @scheme = uri.scheme
       @host = uri.host
       @port = uri.port if uri.port
-      @path = uri_path.join('/')
+      @path = uri_path.join("/")
     end
 
     def valid?
@@ -49,5 +53,33 @@ module Sentry
     def envelope_endpoint
       "#{path}/api/#{project_id}/envelope/"
     end
+
+    def local?
+      @local ||= (localhost? || private_ip? || resolved_ips_private?)
+    end
+
+    def localhost?
+      LOCALHOST_NAMES.include?(host.downcase) || LOCALHOST_PATTERN.match?(host)
+    end
+
+    def private_ip?
+      @private_ip ||= begin
+        begin
+          IPAddr.new(host).private?
+        rescue IPAddr::InvalidAddressError
+          false
+        end
+      end
+    end
+
+    def resolved_ips_private?
+      @resolved_ips_private ||= begin
+        begin
+          Resolv.getaddresses(host).any? { |ip| IPAddr.new(ip).private? }
+        rescue Resolv::ResolvError, IPAddr::InvalidAddressError
+          false
+        end
+      end
+    end
   end
 end