sentry-ruby-core 4.7.2 → 4.8.2

data/lib/sentry/configuration.rb

@@ -1,21 +1,31 @@
+# frozen_string_literal: true
+
 require "concurrent/utility/processor_counter"
 
 require "sentry/utils/exception_cause_chain"
+require 'sentry/utils/custom_inspection'
 require "sentry/dsn"
+require "sentry/release_detector"
 require "sentry/transport/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
 
 module Sentry
   class Configuration
+    include CustomInspection
     include LoggingHelper
     # Directories to be recognized as part of your app. e.g. if you
     # have an `engines` dir at the root of your project, you may want
     # to set this to something like /(app|config|engines|lib)/
+    #
+    # @return [Regexp, nil]
     attr_accessor :app_dirs_pattern
 
     # Provide an object that responds to `call` to send events asynchronously.
     # E.g.: lambda { |event| Thread.new { Sentry.send_event(event) } }
+    #
+    # @deprecated It will be removed in the next major release. Please read https://github.com/getsentry/sentry-ruby/issues/1522 for more information
+    # @return [Proc, nil]
     attr_reader :async
 
     # to send events in a non-blocking way, sentry-ruby has its own background worker
@@ -25,71 +35,94 @@ module Sentry
     #
     # if you want to send events synchronously, set the value to 0
     # E.g.: config.background_worker_threads = 0
+    # @return [Integer]
     attr_accessor :background_worker_threads
 
     # a proc/lambda that takes an array of stack traces
     # it'll be used to silence (reduce) backtrace of the exception
     #
-    # for example:
-    #
-    # ```ruby
-    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
-    #   Rails.backtrace_cleaner.clean(backtrace)
-    # end
-    # ```
+    # @example
+    #   config.backtrace_cleanup_callback = lambda do |backtrace|
+    #     Rails.backtrace_cleaner.clean(backtrace)
+    #   end
     #
+    # @return [Proc]
     attr_accessor :backtrace_cleanup_callback
 
     # Optional Proc, called before adding the breadcrumb to the current scope
-    # E.g.: lambda { |breadcrumb, hint| breadcrumb }
-    # E.g.: lambda { |breadcrumb, hint| nil }
-    # E.g.: lambda { |breadcrumb, hint|
-    #   breadcrumb.message = 'a'
-    #   breadcrumb
-    # }
+    # @example
+    #   config.before = lambda do |breadcrumb, hint|
+    #     breadcrumb.message = 'a'
+    #     breadcrumb
+    #   end
+    # @return [Proc]
     attr_reader :before_breadcrumb
 
-    # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event, hint| event }
-    # E.g.: lambda { |event, hint| nil }
-    # E.g.: lambda { |event, hint|
-    #   event[:message] = 'a'
-    #   event
-    # }
+    # Optional Proc, called before sending an event to the server
+    # @example
+    #   config.before_send = lambda do |event, hint|
+    #     # skip ZeroDivisionError exceptions
+    #     # note: hint[:exception] would be a String if you use async callback
+    #     if hint[:exception].is_a?(ZeroDivisionError)
+    #       nil
+    #     else
+    #       event
+    #     end
+    #   end
+    # @return [Proc]
     attr_reader :before_send
 
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
+    # - :http_logger
+    #
+    # And if you also use sentry-rails:
     # - :active_support_logger
+    # - :monotonic_active_support_logger
+    #
+    # @return [Array<Symbol>]
     attr_reader :breadcrumbs_logger
 
+    # Whether to capture local variables from the raised exception's frame. Default is false.
+    # @return [Boolean]
+    attr_accessor :capture_exception_frame_locals
+
     # Max number of breadcrumbs a breadcrumb buffer can hold
+    # @return [Integer]
     attr_accessor :max_breadcrumbs
 
     # Number of lines of code context to capture, or nil for none
+    # @return [Integer, nil]
     attr_accessor :context_lines
 
     # RACK_ENV by default.
+    # @return [String]
     attr_reader :environment
 
     # Whether the SDK should run in the debugging mode. Default is false.
     # If set to true, SDK errors will be logged with backtrace
+    # @return [Boolean]
     attr_accessor :debug
 
     # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
+    # @return [String]
     attr_reader :dsn
 
     # Whitelist of enabled_environments that will send notifications to Sentry. Array of Strings.
+    # @return [Array<String>]
     attr_accessor :enabled_environments
 
     # Logger 'progname's to exclude from breadcrumbs
+    # @return [Array<String>]
     attr_accessor :exclude_loggers
 
     # Array of exception classes that should never be sent. See IGNORE_DEFAULT.
     # You should probably append to this rather than overwrite it.
+    # @return [Array<String>]
     attr_accessor :excluded_exceptions
 
     # Boolean to check nested exceptions when deciding if to exclude. Defaults to true
+    # @return [Boolean]
     attr_accessor :inspect_exception_causes_for_exclusion
     alias inspect_exception_causes_for_exclusion? inspect_exception_causes_for_exclusion
 
@@ -100,61 +133,80 @@ 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
 
     # Project directory root for in_app detection. Could be Rails root, etc.
     # Set automatically for Rails.
-    attr_reader :project_root
+    # @return [String]
+    attr_accessor :project_root
 
     # Insert sentry-trace to outgoing requests' headers
+    # @return [Boolean]
     attr_accessor :propagate_traces
 
     # Array of rack env parameters to be included in the event sent to sentry.
+    # @return [Array<String>]
     attr_accessor :rack_env_whitelist
 
     # Release tag to be passed with every event sent to Sentry.
     # We automatically try to set this to a git SHA or Capistrano release.
+    # @return [String]
     attr_accessor :release
 
     # The sampling factor to apply to events. A value of 0.0 will not send
     # any events, and a value of 1.0 will send 100% of events.
+    # @return [Float]
     attr_accessor :sample_rate
 
     # Include module versions in reports - boolean.
+    # @return [Boolean]
     attr_accessor :send_modules
 
     # When send_default_pii's value is false (default), sensitive information like
     # - user ip
     # - user cookie
     # - request body
+    # - query string
     # will not be sent to Sentry.
+    # @return [Boolean]
     attr_accessor :send_default_pii
 
     # Allow to skip Sentry emails within rake tasks
+    # @return [Boolean]
     attr_accessor :skip_rake_integration
 
     # IP ranges for trusted proxies that will be skipped when calculating IP address.
     attr_accessor :trusted_proxies
 
+    # @return [String]
     attr_accessor :server_name
 
     # Return a Transport::Configuration object for transport-related configurations.
+    # @return [Transport]
     attr_reader :transport
 
     # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
+    # @return [Float]
     attr_accessor :traces_sample_rate
 
     # Take a Proc that controls the sample rate for every tracing event, e.g.
-    # ```
-    # lambda do |tracing_context|
-    #   # tracing_context[:transaction_context] contains the information about the transaction
-    #   # tracing_context[:parent_sampled] contains the transaction's parent's sample decision
-    #   true # return value can be a boolean or a float between 0.0 and 1.0
-    # end
-    # ```
+    # @example
+    #   config.traces_sampler =  lambda do |tracing_context|
+    #     # tracing_context[:transaction_context] contains the information about the transaction
+    #     # tracing_context[:parent_sampled] contains the transaction's parent's sample decision
+    #     true # return value can be a boolean or a float between 0.0 and 1.0
+    #   end
+    # @return [Proc]
     attr_accessor :traces_sampler
 
+    # Send diagnostic client reports about dropped events, true by default
+    # tries to attach to an existing envelope max once every 30s
+    # @return [Boolean]
+    attr_accessor :send_client_reports
+
     # these are not config options
+    # @!visibility private
     attr_reader :errors, :gem_specs
 
     # Most of these errors generate 4XX responses. In general, Sentry clients
@@ -177,17 +229,21 @@ module Sentry
 
     LOG_PREFIX = "** [Sentry] ".freeze
     MODULE_SEPARATOR = "::".freeze
+    SKIP_INSPECTION_ATTRIBUTES = [:@linecache, :@stacktrace_builder]
 
     # Post initialization callbacks are called at the end of initialization process
     # allowing extending the configuration of sentry-ruby by multiple extensions
     @@post_initialization_callbacks = []
 
     def initialize
+      self.app_dirs_pattern = nil
       self.debug = false
       self.background_worker_threads = Concurrent.processor_count
+      self.backtrace_cleanup_callback = nil
       self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
+      self.capture_exception_frame_locals = false
       self.environment = environment_from_env
       self.enabled_environments = []
       self.exclude_loggers = []
@@ -202,12 +258,15 @@ module Sentry
       self.send_modules = true
       self.send_default_pii = false
       self.skip_rake_integration = false
+      self.send_client_reports = true
       self.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
 
-      self.before_send = false
+      self.before_send = nil
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
+      self.traces_sample_rate = nil
+      self.traces_sampler = nil
 
       @transport = Transport::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
@@ -216,18 +275,13 @@ module Sentry
     end
 
     def dsn=(value)
-      return if value.nil? || value.empty?
-
-      @dsn = DSN.new(value)
+      @dsn = init_dsn(value)
     end
 
     alias server= dsn=
 
-
     def async=(value)
-      if value && !value.respond_to?(:call)
-        raise(ArgumentError, "async must be callable")
-      end
+      check_callable!("async", value)
 
       @async = value
     end
@@ -246,17 +300,13 @@ module Sentry
     end
 
     def before_send=(value)
-      unless value == false || value.respond_to?(:call)
-        raise ArgumentError, "before_send must be callable (or false to disable)"
-      end
+      check_callable!("before_send", value)
 
       @before_send = value
     end
 
     def before_breadcrumb=(value)
-      unless value.nil? || value.respond_to?(:call)
-        raise ArgumentError, "before_breadcrumb must be callable (or nil to disable)"
-      end
+      check_callable!("before_breadcrumb", value)
 
       @before_breadcrumb = value
     end
@@ -268,18 +318,13 @@ module Sentry
     def sending_allowed?
       @errors = []
 
-      valid? &&
-        capture_in_environment? &&
-        sample_allowed?
+      valid? && capture_in_environment?
     end
 
-    def error_messages
-      @errors = [@errors[0]] + @errors[1..-1].map(&:downcase) # fix case of all but first
-      @errors.join(", ")
-    end
+    def sample_allowed?
+      return true if sample_rate == 1.0
 
-    def project_root=(root_dir)
-      @project_root = root_dir
+      Random.rand < sample_rate
     end
 
     def exception_class_allowed?(exc)
@@ -303,6 +348,17 @@ module Sentry
       !!((@traces_sample_rate && @traces_sample_rate >= 0.0 && @traces_sample_rate <= 1.0) || @traces_sampler) && sending_allowed?
     end
 
+    # @return [String, nil]
+    def csp_report_uri
+      if dsn && dsn.valid?
+        uri = dsn.csp_report_uri
+        uri += "&sentry_release=#{CGI.escape(release)}" if release && !release.empty?
+        uri += "&sentry_environment=#{CGI.escape(environment)}" if environment && !environment.empty?
+        uri
+      end
+    end
+
+    # @api private
     def stacktrace_builder
       @stacktrace_builder ||= StacktraceBuilder.new(
         project_root: @project_root.to_s,
@@ -313,28 +369,39 @@ module Sentry
       )
     end
 
+    # @api private
     def detect_release
       return unless sending_allowed?
 
-      self.release ||= detect_release_from_env ||
-        detect_release_from_git ||
-        detect_release_from_capistrano ||
-        detect_release_from_heroku
+      self.release ||= ReleaseDetector.detect_release(project_root: project_root, running_on_heroku: running_on_heroku?)
+
+      if running_on_heroku? && release.nil?
+        log_warn(HEROKU_DYNO_METADATA_MESSAGE)
+      end
     rescue => e
       log_error("Error detecting release", e, debug: debug)
     end
 
-    def csp_report_uri
-      if dsn && dsn.valid?
-        uri = dsn.csp_report_uri
-        uri += "&sentry_release=#{CGI.escape(release)}" if release && !release.empty?
-        uri += "&sentry_environment=#{CGI.escape(environment)}" if environment && !environment.empty?
-        uri
-      end
+    # @api private
+    def error_messages
+      @errors = [@errors[0]] + @errors[1..-1].map(&:downcase) # fix case of all but first
+      @errors.join(", ")
     end
 
     private
 
+    def check_callable!(name, value)
+      unless value == nil || value.respond_to?(:call)
+        raise ArgumentError, "#{name} must be callable (or nil to disable)"
+      end
+    end
+
+    def init_dsn(dsn_string)
+      return if dsn_string.nil? || dsn_string.empty?
+
+      DSN.new(dsn_string)
+    end
+
     def excluded_exception?(incoming_exception)
       excluded_exception_classes.any? do |excluded_exception|
         matches_exception?(excluded_exception, incoming_exception)
@@ -364,37 +431,6 @@ module Sentry
       nil
     end
 
-    def detect_release_from_heroku
-      return unless running_on_heroku?
-      return if ENV['CI']
-      log_warn(HEROKU_DYNO_METADATA_MESSAGE) && return unless ENV['HEROKU_SLUG_COMMIT']
-
-      ENV['HEROKU_SLUG_COMMIT']
-    end
-
-    def running_on_heroku?
-      File.directory?("/etc/heroku")
-    end
-
-    def detect_release_from_capistrano
-      revision_file = File.join(project_root, 'REVISION')
-      revision_log = File.join(project_root, '..', 'revisions.log')
-
-      if File.exist?(revision_file)
-        File.read(revision_file).strip
-      elsif File.exist?(revision_log)
-        File.open(revision_log).to_a.last.strip.sub(/.*as release ([0-9]+).*/, '\1')
-      end
-    end
-
-    def detect_release_from_git
-      Sentry.sys_command("git rev-parse --short HEAD") if File.directory?(".git")
-    end
-
-    def detect_release_from_env
-      ENV['SENTRY_RELEASE']
-    end
-
     def capture_in_environment?
       return true if enabled_in_current_env?
 
@@ -411,24 +447,6 @@ module Sentry
       end
     end
 
-    def sample_allowed?
-      return true if sample_rate == 1.0
-
-      if Random.rand >= sample_rate
-        @errors << "Excluded by random sample"
-        false
-      else
-        true
-      end
-    end
-
-    # Try to resolve the hostname to an FQDN, but fall back to whatever
-    # the load name is.
-    def resolve_hostname
-      Socket.gethostname ||
-        Socket.gethostbyname(hostname).first rescue server_name
-    end
-
     def environment_from_env
       ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     end
@@ -437,10 +455,16 @@ module Sentry
       if running_on_heroku?
         ENV['DYNO']
       else
-        resolve_hostname
+        # Try to resolve the hostname to an FQDN, but fall back to whatever
+        # the load name is.
+        Socket.gethostname || Socket.gethostbyname(hostname).first rescue server_name
       end
     end
 
+    def running_on_heroku?
+      File.directory?("/etc/heroku") && !ENV["CI"]
+    end
+
     def run_post_initialization_callbacks
       self.class.post_initialization_callbacks.each do |hook|
         instance_eval(&hook)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 return if Object.method_defined?(:deep_dup)
 
 require 'sentry/core_ext/object/duplicable'

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 return if Object.method_defined?(:duplicable?)
 
 #########################################

data/lib/sentry/dsn.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "uri"
 
 module Sentry

data/lib/sentry/envelope.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Envelope
+    def initialize(headers)
+      @headers = headers
+      @items = []
+    end
+
+    def add_item(headers, payload)
+      @items << [headers, payload]
+    end
+
+    def to_s
+      payload = @items.map do |item_headers, item_payload|
+        <<~ENVELOPE
+          #{JSON.generate(item_headers)}
+          #{JSON.generate(item_payload)}
+        ENVELOPE
+      end.join("\n")
+
+      "#{JSON.generate(@headers)}\n#{payload}"
+    end
+  end
+end

data/lib/sentry/event.rb

@@ -6,6 +6,7 @@ require 'sentry/interface'
 require 'sentry/backtrace'
 require 'sentry/utils/real_ip'
 require 'sentry/utils/request_id'
+require 'sentry/utils/custom_inspection'
 
 module Sentry
   class Event
@@ -21,6 +22,10 @@ module Sentry
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
+    SKIP_INSPECTION_ATTRIBUTES = [:@configuration, :@modules, :@backtrace]
+
+    include CustomInspection
+
     attr_writer(*WRITER_ATTRIBUTES)
     attr_reader(*SERIALIZEABLE_ATTRIBUTES)
 

data/lib/sentry/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class Error < StandardError
   end

data/lib/sentry/hub.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/scope"
 require "sentry/client"
 
@@ -90,10 +92,10 @@ module Sentry
     end
 
     def capture_exception(exception, **options, &block)
-      return unless current_client
-
       check_argument_type!(exception, ::Exception)
 
+      return unless current_client
+
       options[:hint] ||= {}
       options[:hint][:exception] = exception
       event = current_client.event_from_exception(exception, options[:hint])
@@ -104,6 +106,8 @@ module Sentry
     end
 
     def capture_message(message, **options, &block)
+      check_argument_type!(message, ::String)
+
       return unless current_client
 
       options[:hint] ||= {}
@@ -114,10 +118,10 @@ module Sentry
     end
 
     def capture_event(event, **options, &block)
-      return unless current_client
-
       check_argument_type!(event, Sentry::Event)
 
+      return unless current_client
+
       hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
@@ -131,6 +135,11 @@ module Sentry
 
       event = current_client.capture_event(event, scope, hint)
 
+
+      if event && configuration.debug
+        configuration.log_debug(event.to_json_compatible)
+      end
+
       @last_event_id = event&.event_id
       event
     end

data/lib/sentry/integrable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Integrable
     def register_integration(name:, version:)

data/lib/sentry/interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class Interface
     def self.inherited(klass)

data/lib/sentry/interfaces/exception.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class ExceptionInterface < Interface
     def initialize(values:)

data/lib/sentry/interfaces/single_exception.rb

@@ -1,5 +1,16 @@
+# frozen_string_literal: true
+
+require "sentry/utils/exception_cause_chain"
+
 module Sentry
   class SingleExceptionInterface < Interface
+    include CustomInspection
+
+    SKIP_INSPECTION_ATTRIBUTES = [:@stacktrace]
+    PROBLEMATIC_LOCAL_VALUE_REPLACEMENT = "[ignored due to error]".freeze
+    OMISSION_MARK = "...".freeze
+    MAX_LOCAL_BYTES = 1024
+
     attr_reader :type, :value, :module, :thread_id, :stacktrace
 
     def initialize(exception:, stacktrace: nil)
@@ -20,6 +31,26 @@ module Sentry
     # also see `StacktraceBuilder.build`.
     def self.build_with_stacktrace(exception:, stacktrace_builder:)
       stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
+
+      if locals = exception.instance_variable_get(:@sentry_locals)
+        locals.each do |k, v|
+          locals[k] =
+            begin
+              v = v.inspect unless v.is_a?(String)
+
+              if v.length >= MAX_LOCAL_BYTES
+                v = v.byteslice(0..MAX_LOCAL_BYTES - 1) + OMISSION_MARK
+              end
+
+              v
+            rescue StandardError
+              PROBLEMATIC_LOCAL_VALUE_REPLACEMENT
+            end
+        end
+
+        stacktrace.frames.last.vars = locals
+      end
+
       new(exception: exception, stacktrace: stacktrace)
     end
   end