sentry-ruby-core 4.4.2 → 5.0.0

data/lib/sentry/client.rb

@@ -1,11 +1,22 @@
+# frozen_string_literal: true
+
 require "sentry/transport"
 
 module Sentry
   class Client
     include LoggingHelper
 
-    attr_reader :transport, :configuration, :logger
+    # The Transport object that'll send events for the client.
+    # @return [Transport]
+    attr_reader :transport
+
+    # @!macro configuration
+    attr_reader :configuration
 
+    # @deprecated Use Sentry.logger to retrieve the current logger instead.
+    attr_reader :logger
+
+    # @param configuration [Configuration]
     def initialize(configuration)
       @configuration = configuration
       @logger = configuration.logger
@@ -23,15 +34,33 @@ module Sentry
       end
     end
 
+    # Applies the given scope's data to the event and sends it to Sentry.
+    # @param event [Event] the event to be sent.
+    # @param scope [Scope] the scope with contextual data that'll be applied to the event before it's sent.
+    # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
+    # @return [Event, nil]
     def capture_event(event, scope, hint = {})
       return unless configuration.sending_allowed?
 
-      scope.apply_to_event(event, hint)
+      unless event.is_a?(TransactionEvent) || configuration.sample_allowed?
+        transport.record_lost_event(:sample_rate, 'event')
+        return
+      end
+
+      event_type = event.is_a?(Event) ? event.type : event["type"]
+      event = scope.apply_to_event(event, hint)
+
+      if event.nil?
+        log_info("Discarded event because one of the event processors returned nil")
+        transport.record_lost_event(:event_processor, event_type)
+        return
+      end
 
       if async_block = configuration.async
         dispatch_async_event(async_block, event, hint)
-      elsif hint.fetch(:background, true)
-        dispatch_background_event(event, hint)
+      elsif configuration.background_worker_threads != 0 && hint.fetch(:background, true)
+        queued = dispatch_background_event(event, hint)
+        transport.record_lost_event(:queue_overflow, event_type) unless queued
       else
         send_event(event, hint)
       end
@@ -42,9 +71,14 @@ module Sentry
       nil
     end
 
+    # Initializes an Event object with the given exception. Returns `nil` if the exception's class is excluded from reporting.
+    # @param exception [Exception] the exception to be reported.
+    # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
+    # @return [Event, nil]
     def event_from_exception(exception, hint = {})
+      return unless @configuration.sending_allowed? && @configuration.exception_class_allowed?(exception)
+
       integration_meta = Sentry.integrations[hint[:integration]]
-      return unless @configuration.exception_class_allowed?(exception)
 
       Event.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
         event.add_exception_interface(exception)
@@ -52,13 +86,22 @@ module Sentry
       end
     end
 
-    def event_from_message(message, hint = {})
+    # Initializes an Event object with the given message.
+    # @param message [String] the message to be reported.
+    # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
+    # @return [Event]
+    def event_from_message(message, hint = {}, backtrace: nil)
+      return unless @configuration.sending_allowed?
+
       integration_meta = Sentry.integrations[hint[:integration]]
       event = Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
-      event.add_threads_interface(backtrace: caller)
+      event.add_threads_interface(backtrace: backtrace || caller)
       event
     end
 
+    # Initializes an Event object with the given Transaction object.
+    # @param transaction [Transaction] the transaction to be recorded.
+    # @return [TransactionEvent]
     def event_from_transaction(transaction)
       TransactionEvent.new(configuration: configuration).tap do |event|
         event.transaction = transaction.name
@@ -71,6 +114,7 @@ module Sentry
       end
     end
 
+    # @!macro send_event
     def send_event(event, hint = nil)
       event_type = event.is_a?(Event) ? event.type : event["type"]
 
@@ -79,6 +123,7 @@ module Sentry
 
         if event.nil?
           log_info("Discarded event because before_send returned nil")
+          transport.record_lost_event(:before_send, 'event')
           return
         end
       end
@@ -92,9 +137,22 @@ module Sentry
 
       event_info = Event.get_log_message(event.to_hash)
       log_info("Unreported #{loggable_event_type}: #{event_info}")
+      transport.record_lost_event(:network_error, event_type)
       raise
     end
 
+    # Generates a Sentry trace for distribted tracing from the given Span.
+    # Returns `nil` if `config.propagate_traces` is `false`.
+    # @param span [Span] the span to generate trace from.
+    # @return [String, nil]
+    def generate_sentry_trace(span)
+      return unless configuration.propagate_traces
+
+      trace = span.to_sentry_trace
+      log_debug("[Tracing] Adding #{SENTRY_TRACE_HEADER_NAME} header to outgoing request: #{trace}")
+      trace
+    end
+
     private
 
     def dispatch_background_event(event, hint)

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,130 +35,179 @@ 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, nil]
     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 false
+    # 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
 
     # You may provide your own LineCache for matching paths with source files.
-    # This may be useful if you need to get source code from places other than
-    # the disk. See Sentry::LineCache for the required interface you must implement.
+    # This may be useful if you need to get source code from places other than the disk.
+    # @see LineCache
+    # @return [LineCache]
     attr_accessor :linecache
 
     # 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
@@ -171,17 +230,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 = []
@@ -190,17 +253,21 @@ module Sentry
       self.linecache = ::Sentry::LineCache.new
       self.logger = ::Sentry::Logger.new(STDOUT)
       self.project_root = Dir.pwd
+      self.propagate_traces = true
 
-      self.release = detect_release
       self.sample_rate = 1.0
       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)
@@ -209,18 +276,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
@@ -239,17 +301,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
@@ -261,18 +319,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)
@@ -296,6 +349,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,
@@ -306,17 +370,39 @@ module Sentry
       )
     end
 
-    private
-
+    # @api private
     def detect_release
-      detect_release_from_env ||
-        detect_release_from_git ||
-        detect_release_from_capistrano ||
-        detect_release_from_heroku
+      return unless sending_allowed?
+
+      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
 
+    # @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)
@@ -346,37 +432,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?
 
@@ -393,36 +448,24 @@ module Sentry
       end
     end
 
-    def sample_allowed?
-      return true if sample_rate == 1.0
-
-      if Random::DEFAULT.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'] || 'default'
+      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']
       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,7 @@
+# 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,5 +1,7 @@
 # frozen_string_literal: true
 
+return if Object.method_defined?(:duplicable?)
+
 #########################################
 #  This file was copied from Rails 5.2  #
 #########################################

data/lib/sentry/dsn.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "uri"
 
 module Sentry
@@ -37,10 +39,13 @@ module Sentry
     def server
       server = "#{scheme}://#{host}"
       server += ":#{port}" unless port == PORT_MAP[scheme]
-      server += path
       server
     end
 
+    def csp_report_uri
+      "#{server}/api/#{project_id}/security/?sentry_key=#{public_key}"
+    end
+
     def envelope_endpoint
       "#{path}/api/#{project_id}/envelope/"
     end