sentry-ruby-core 4.1.6 → 4.5.1

data/lib/sentry/background_worker.rb

@@ -1,23 +1,27 @@
 require "concurrent/executor/thread_pool_executor"
 require "concurrent/executor/immediate_executor"
+require "concurrent/configuration"
 
 module Sentry
   class BackgroundWorker
-    attr_reader :max_queue, :number_of_threads
+    include LoggingHelper
+
+    attr_reader :max_queue, :number_of_threads, :logger
 
     def initialize(configuration)
       @max_queue = 30
       @number_of_threads = configuration.background_worker_threads
+      @logger = configuration.logger
 
       @executor =
         if configuration.async
-          configuration.logger.debug(LOGGER_PROGNAME) { "config.async is set, BackgroundWorker is disabled" }
+          log_debug("config.async is set, BackgroundWorker is disabled")
           Concurrent::ImmediateExecutor.new
         elsif @number_of_threads == 0
-          configuration.logger.debug(LOGGER_PROGNAME) { "config.background_worker_threads is set to 0, all events will be sent synchronously" }
+          log_debug("config.background_worker_threads is set to 0, all events will be sent synchronously")
           Concurrent::ImmediateExecutor.new
         else
-          configuration.logger.debug(LOGGER_PROGNAME) { "initialized a background worker with #{@number_of_threads} threads" }
+          log_debug("initialized a background worker with #{@number_of_threads} threads")
 
           Concurrent::ThreadPoolExecutor.new(
             min_threads: 0,

data/lib/sentry/breadcrumb.rb

@@ -2,15 +2,16 @@ module Sentry
   class Breadcrumb
     DATA_SERIALIZATION_ERROR_MESSAGE = "[data were removed due to serialization issues]"
 
-    attr_accessor :category, :data, :message, :level, :timestamp, :type
+    attr_accessor :category, :data, :level, :timestamp, :type
+    attr_reader :message
 
     def initialize(category: nil, data: nil, message: nil, timestamp: nil, level: nil, type: nil)
       @category = category
       @data = data || {}
       @level = level
-      @message = message
       @timestamp = timestamp || Sentry.utc_now.to_i
       @type = type
+      self.message = message
     end
 
     def to_hash
@@ -24,6 +25,10 @@ module Sentry
       }
     end
 
+    def message=(msg)
+      @message = (msg || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+    end
+
     private
 
     def serialized_data

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -14,6 +14,7 @@ module Sentry
       def add(*args, &block)
         super
         add_breadcrumb(*args, &block)
+        nil
       end
 
       def add_breadcrumb(severity, message = nil, progname = nil)
@@ -49,7 +50,7 @@ module Sentry
           end
         end
 
-        return if ignored_logger?(progname) || message.empty?
+        return if ignored_logger?(progname) || message == ""
 
         # some loggers will add leading/trailing space as they (incorrectly, mind you)
         # think of logging as a shortcut to std{out,err}

data/lib/sentry/breadcrumb_buffer.rb

@@ -2,12 +2,13 @@ require "sentry/breadcrumb"
 
 module Sentry
   class BreadcrumbBuffer
+    DEFAULT_SIZE = 100
     include Enumerable
 
     attr_accessor :buffer
 
-    def initialize(size = 100)
-      @buffer = Array.new(size)
+    def initialize(size = nil)
+      @buffer = Array.new(size || DEFAULT_SIZE)
     end
 
     def record(crumb)

data/lib/sentry/client.rb

@@ -2,10 +2,13 @@ require "sentry/transport"
 
 module Sentry
   class Client
-    attr_reader :transport, :configuration
+    include LoggingHelper
+
+    attr_reader :transport, :configuration, :logger
 
     def initialize(configuration)
       @configuration = configuration
+      @logger = configuration.logger
 
       if transport_class = configuration.transport.transport_class
         @transport = transport_class.new(configuration)
@@ -26,32 +29,17 @@ module Sentry
       scope.apply_to_event(event, hint)
 
       if async_block = configuration.async
-        begin
-          # We have to convert to a JSON-like hash, because background job
-          # processors (esp ActiveJob) may not like weird types in the event hash
-          event_hash = event.to_json_compatible
-
-          if async_block.arity == 2
-            hint = JSON.parse(JSON.generate(hint))
-            async_block.call(event_hash, hint)
-          else
-            async_block.call(event_hash)
-          end
-        rescue => e
-          configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
-          send_event(event, hint)
-        end
+        dispatch_async_event(async_block, event, hint)
+      elsif configuration.background_worker_threads != 0 && hint.fetch(:background, true)
+        dispatch_background_event(event, hint)
       else
-        if hint.fetch(:background, true)
-          Sentry.background_worker.perform do
-            send_event(event, hint)
-          end
-        else
-          send_event(event, hint)
-        end
+        send_event(event, hint)
       end
 
       event
+    rescue => e
+      log_error("Event capturing failed", e, debug: configuration.debug)
+      nil
     end
 
     def event_from_exception(exception, hint = {})
@@ -60,12 +48,15 @@ module Sentry
 
       Event.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
         event.add_exception_interface(exception)
+        event.add_threads_interface(crashed: true)
       end
     end
 
     def event_from_message(message, hint = {})
       integration_meta = Sentry.integrations[hint[:integration]]
-      Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
+      event = Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
+      event.add_threads_interface(backtrace: caller)
+      event
     end
 
     def event_from_transaction(transaction)
@@ -82,16 +73,59 @@ module Sentry
 
     def send_event(event, hint = nil)
       event_type = event.is_a?(Event) ? event.type : event["type"]
-      event = configuration.before_send.call(event, hint) if configuration.before_send && event_type == "event"
 
-      if event.nil?
-        configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
-        return
+      if event_type != TransactionEvent::TYPE && configuration.before_send
+        event = configuration.before_send.call(event, hint)
+
+        if event.nil?
+          log_info("Discarded event because before_send returned nil")
+          return
+        end
       end
 
       transport.send_event(event)
 
       event
+    rescue => e
+      loggable_event_type = (event_type || "event").capitalize
+      log_error("#{loggable_event_type} sending failed", e, debug: configuration.debug)
+
+      event_info = Event.get_log_message(event.to_hash)
+      log_info("Unreported #{loggable_event_type}: #{event_info}")
+      raise
+    end
+
+    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)
+      Sentry.background_worker.perform do
+        send_event(event, hint)
+      end
+    end
+
+    def dispatch_async_event(async_block, event, hint)
+      # We have to convert to a JSON-like hash, because background job
+      # processors (esp ActiveJob) may not like weird types in the event hash
+      event_hash = event.to_json_compatible
+
+      if async_block.arity == 2
+        hint = JSON.parse(JSON.generate(hint))
+        async_block.call(event_hash, hint)
+      else
+        async_block.call(event_hash)
+      end
+    rescue => e
+      loggable_event_type = event_hash["type"] || "event"
+      log_error("Async #{loggable_event_type} sending failed", e, debug: configuration.debug)
+      send_event(event, hint)
     end
   end
 end

data/lib/sentry/configuration.rb

@@ -4,9 +4,11 @@ require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
 require "sentry/linecache"
+require "sentry/interfaces/stacktrace_builder"
 
 module Sentry
   class Configuration
+    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)/
@@ -38,10 +40,19 @@ module Sentry
     #
     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
+    # }
+    attr_reader :before_breadcrumb
+
     # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event| event }
-    # E.g.: lambda { |event| nil }
-    # E.g.: lambda { |event|
+    # E.g.: lambda { |event, hint| event }
+    # E.g.: lambda { |event, hint| nil }
+    # E.g.: lambda { |event, hint|
     #   event[:message] = 'a'
     #   event
     # }
@@ -52,12 +63,19 @@ module Sentry
     # - :active_support_logger
     attr_reader :breadcrumbs_logger
 
+    # Max number of breadcrumbs a breadcrumb buffer can hold
+    attr_accessor :max_breadcrumbs
+
     # Number of lines of code context to capture, or nil for none
     attr_accessor :context_lines
 
     # RACK_ENV by default.
     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
+    attr_accessor :debug
+
     # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
     attr_reader :dsn
 
@@ -88,6 +106,9 @@ module Sentry
     # Set automatically for Rails.
     attr_reader :project_root
 
+    # Insert sentry-trace to outgoing requests' headers
+    attr_accessor :propagate_traces
+
     # Array of rack env parameters to be included in the event sent to sentry.
     attr_accessor :rack_env_whitelist
 
@@ -109,6 +130,12 @@ module Sentry
     # will not be sent to Sentry.
     attr_accessor :send_default_pii
 
+    # Allow to skip Sentry emails within rake tasks
+    attr_accessor :skip_rake_integration
+
+    # IP ranges for trusted proxies that will be skipped when calculating IP address.
+    attr_accessor :trusted_proxies
+
     attr_accessor :server_name
 
     # Return a Transport::Configuration object for transport-related configurations.
@@ -151,25 +178,32 @@ module Sentry
     LOG_PREFIX = "** [Sentry] ".freeze
     MODULE_SEPARATOR = "::".freeze
 
-    AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
+    # 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.debug = false
       self.background_worker_threads = Concurrent.processor_count
+      self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
       self.environment = environment_from_env
       self.enabled_environments = []
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT.dup
-      self.inspect_exception_causes_for_exclusion = false
+      self.inspect_exception_causes_for_exclusion = true
       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.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
 
@@ -178,7 +212,8 @@ module Sentry
 
       @transport = Transport::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-      post_initialization_callback
+
+      run_post_initialization_callbacks
     end
 
     def dsn=(value)
@@ -203,10 +238,6 @@ module Sentry
         if logger.is_a?(Array)
           logger
         else
-          unless AVAILABLE_BREADCRUMBS_LOGGERS.include?(logger)
-            raise Sentry::Error, "Unsupported breadcrumbs logger. Supported loggers: #{AVAILABLE_BREADCRUMBS_LOGGERS}"
-          end
-
           Array(logger)
         end
 
@@ -223,6 +254,14 @@ module Sentry
       @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
+
+      @before_breadcrumb = value
+    end
+
     def environment=(environment)
       @environment = environment.to_s
     end
@@ -247,10 +286,10 @@ module Sentry
     def exception_class_allowed?(exc)
       if exc.is_a?(Sentry::Error)
         # Try to prevent error reporting loops
-        logger.debug(LOGGER_PROGNAME) { "Refusing to capture Sentry error: #{exc.inspect}" }
+        log_debug("Refusing to capture Sentry error: #{exc.inspect}")
         false
       elsif excluded_exception?(exc)
-        logger.debug(LOGGER_PROGNAME) { "User excluded error: #{exc.inspect}" }
+        log_debug("User excluded error: #{exc.inspect}")
         false
       else
         true
@@ -262,7 +301,17 @@ module Sentry
     end
 
     def tracing_enabled?
-      !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
+      !!((@traces_sample_rate && @traces_sample_rate >= 0.0 && @traces_sample_rate <= 1.0) || @traces_sampler) && sending_allowed?
+    end
+
+    def stacktrace_builder
+      @stacktrace_builder ||= StacktraceBuilder.new(
+        project_root: @project_root.to_s,
+        app_dirs_pattern: @app_dirs_pattern,
+        linecache: @linecache,
+        context_lines: @context_lines,
+        backtrace_cleanup_callback: @backtrace_cleanup_callback
+      )
     end
 
     private
@@ -273,7 +322,7 @@ module Sentry
         detect_release_from_capistrano ||
         detect_release_from_heroku
     rescue => e
-      logger.error(LOGGER_PROGNAME) { "Error detecting release: #{e.message}" }
+      log_error("Error detecting release", e, debug: debug)
     end
 
     def excluded_exception?(incoming_exception)
@@ -308,7 +357,7 @@ module Sentry
     def detect_release_from_heroku
       return unless running_on_heroku?
       return if ENV['CI']
-      logger.warn(LOGGER_PROGNAME) { HEROKU_DYNO_METADATA_MESSAGE } && return unless ENV['HEROKU_SLUG_COMMIT']
+      log_warn(HEROKU_DYNO_METADATA_MESSAGE) && return unless ENV['HEROKU_SLUG_COMMIT']
 
       ENV['HEROKU_SLUG_COMMIT']
     end
@@ -382,7 +431,21 @@ module Sentry
       end
     end
 
-    # allow extensions to extend the Configuration class
-    def post_initialization_callback; end
+    def run_post_initialization_callbacks
+      self.class.post_initialization_callbacks.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+
+    # allow extensions to add their hooks to the Configuration class
+    def self.add_post_initialization_callback(&block)
+      self.post_initialization_callbacks << block
+    end
+
+    protected
+
+    def self.post_initialization_callbacks
+      @@post_initialization_callbacks
+    end
   end
 end