sentry-raven 3.0.1 → 3.1.1

data/Gemfile

@@ -2,9 +2,10 @@ source "https://rubygems.org/"
 
 gemspec
 
-rails_version = ENV["RAILS_VERSION"].to_f
+rails_version = ENV["RAILS_VERSION"]
+rails_version = "5.2" if rails_version.nil?
 
-if rails_version != 0
+if rails_version.to_f != 0
   gem "rails", "~> #{rails_version}"
   gem "rspec-rails", "~> 4.0"
 end
@@ -16,7 +17,9 @@ gem "rack-timeout"
 
 gem "pry"
 gem "benchmark-ips"
+gem "benchmark_driver"
 gem "benchmark-ipsa"
+gem "benchmark-memory"
 gem "ruby-prof", platform: :mri
 gem "rake", "> 12"
 gem "rubocop", "~> 0.81.0"

data/README.md

@@ -7,6 +7,11 @@
 
 # Raven-Ruby, the Ruby Client for Sentry
 
+### 🚧 We're restructuring this SDK for the [version 4.0](https://github.com/getsentry/raven-ruby/issues/1029) 🚧 
+
+---
+
+
 [![Gem Version](https://img.shields.io/gem/v/sentry-raven.svg)](https://rubygems.org/gems/sentry-raven)
 ![Build Status](https://github.com/getsentry/raven-ruby/workflows/Test/badge.svg)
 [![Coverage Status](https://img.shields.io/codecov/c/github/getsentry/raven-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/raven-ruby/branch/master)
@@ -18,6 +23,7 @@
 
 The official Ruby-language client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
 
+
 ## Requirements
 
 We test on Ruby 2.3, 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny version. We also support JRuby 9.0. Our Rails integration works with Rails 4.2+, including Rails 5 and Rails 6.
@@ -30,7 +36,7 @@ We test on Ruby 2.3, 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny versio
 gem "sentry-raven"
 ```
 
-### Raven only runs when SENTRY_DSN is set
+### Raven only runs when Sentry DSN is set
 
 Raven will capture and send exceptions to the Sentry server whenever its DSN is set. This makes environment-based configuration easy - if you don't want to send errors in a certain environment, just don't set the DSN in that environment!
 
@@ -39,7 +45,7 @@ Raven will capture and send exceptions to the Sentry server whenever its DSN is
 export SENTRY_DSN=http://public@example.com/project-id
 ```
 ```ruby
-# Or you can configure the client in the code (not recommended - keep your DSN secret!)
+# Or you can configure the client in the code.
 Raven.configure do |config|
   config.dsn = 'http://public@example.com/project-id'
 end
@@ -49,11 +55,11 @@ end
 
 **Raven ignores some exceptions by default** - most of these are related to 404s or controller actions not being found. [For a complete list, see the `IGNORE_DEFAULT` constant](https://github.com/getsentry/raven-ruby/blob/master/lib/raven/configuration.rb).
 
-Raven doesn't report POST data or cookies by default. In addition, it will attempt to remove any obviously sensitive data, such as credit card or Social Security numbers. For more information about how Sentry processes your data, [check out the documentation on the `processors` config setting.](https://docs.getsentry.com/hosted/clients/ruby/config/)
+Raven doesn't report POST data or cookies by default. In addition, it will attempt to remove any obviously sensitive data, such as credit card or Social Security numbers. For more information about how Sentry processes your data, [check out the documentation on the `processors` config setting.](https://docs.sentry.io/platforms/ruby/config/)
 
 ### Usage
 
-**If you use Rails, you're already done - no more configuration required!** Check [Integrations](https://docs.getsentry.com/hosted/clients/ruby/integrations/) for more details on other gems Sentry integrates with automatically.
+**If you use Rails, you're already done - no more configuration required!** Check [Integrations](https://docs.sentry.io/platforms/ruby/integrations/) for more details on other gems Sentry integrates with automatically.
 
 Otherwise, Raven supports two methods of capturing exceptions:
 
@@ -105,26 +111,35 @@ end
 If Raven fails to send an event to Sentry for any reason (either the Sentry server has returned a 4XX or 5XX response), this Proc or lambda will be called.
 
 ```ruby
-config.transport_failure_callback = lambda { |event|
-  AdminMailer.email_admins("Oh god, it's on fire!", event).deliver_later
+config.transport_failure_callback = lambda { |event, error|
+  AdminMailer.email_admins("Oh god, it's on fire because #{error.message}!", event).deliver_later
 }
 ```
 
 #### Context
 
-Much of the usefulness of Sentry comes from additional context data with the events. Raven makes this very convenient by providing methods to set thread local context data that is then submitted automatically with all events.
-
-There are three primary methods for providing request context:
+Much of the usefulness of Sentry comes from additional context data with the events. Raven makes this very convenient by providing methods to set thread local context data that is then submitted automatically with all events:
 
 ```ruby
-# bind the logged in user
 Raven.user_context email: 'foo@example.com'
 
-# tag the request with something interesting
-Raven.tags_context interesting: 'yes'
+Raven.tags.merge!(interesting: 'yes')
+
+Raven.extra.merge!(additional_info: 'foo')
+```
+
+You can also use `tags_context` and `extra_context` to provide scoped information:
 
-# provide a bit of additional context
-Raven.extra_context happiness: 'very'
+```ruby
+Raven.tags_context(interesting: 'yes') do
+  # the `interesting: 'yes'` tag will only present in the requests sent inside the block
+  Raven.capture_exception(exception)
+end
+
+Raven.extra_context(additional_info: 'foo') do
+  # same as above, the `additional_info` will only present in this request
+  Raven.capture_exception(exception)
+end
 ```
 
 For more information, see [Context](https://docs.sentry.io/clients/ruby/context/).

data/lib/raven/backtrace.rb

@@ -94,6 +94,8 @@ module Raven
     def self.parse(backtrace, opts = {})
       ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
 
+      ruby_lines = opts[:configuration].backtrace_cleanup_callback.call(ruby_lines) if opts[:configuration]&.backtrace_cleanup_callback
+
       filters = opts[:filters] || []
       filtered_lines = ruby_lines.to_a.map do |line|
         filters.reduce(line) do |nested_line, proc|

data/lib/raven/base.rb

@@ -1,4 +1,6 @@
 require 'raven/version'
+require "raven/helpers/deprecation_helper"
+require 'raven/core_ext/object/deep_dup'
 require 'raven/backtrace'
 require 'raven/breadcrumbs'
 require 'raven/processor'

data/lib/raven/breadcrumbs/active_support_logger.rb

@@ -0,0 +1,25 @@
+module Raven
+  module Breadcrumbs
+    module ActiveSupportLogger
+      class << self
+        def add(name, started, _finished, _unique_id, data)
+          Raven.breadcrumbs.record do |crumb|
+            crumb.data = data
+            crumb.category = name
+            crumb.timestamp = started.to_i
+          end
+        end
+
+        def inject
+          @subscriber = ::ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
+            add(name, started, finished, unique_id, data)
+          end
+        end
+
+        def detach
+          ::ActiveSupport::Notifications.unsubscribe(@subscriber)
+        end
+      end
+    end
+  end
+end

data/lib/raven/breadcrumbs/logger.rb

@@ -1,93 +1,3 @@
-require 'logger'
+DeprecationHelper.deprecate_old_breadcrumbs_configuration(:sentry_logger)
 
-module Raven
-  module BreadcrumbLogger
-    LEVELS = {
-      ::Logger::DEBUG => 'debug',
-      ::Logger::INFO => 'info',
-      ::Logger::WARN => 'warn',
-      ::Logger::ERROR => 'error',
-      ::Logger::FATAL => 'fatal'
-    }.freeze
-
-    EXC_FORMAT = /^([a-zA-Z0-9]+)\:\s(.*)$/.freeze
-
-    def self.parse_exception(message)
-      lines = message.split(/\n\s*/)
-      # TODO: wat
-      return nil unless lines.length > 2
-
-      match = lines[0].match(EXC_FORMAT)
-      return nil unless match
-
-      _, type, value = match.to_a
-      [type, value]
-    end
-
-    def add(*args)
-      add_breadcrumb(*args)
-      super
-    end
-
-    def add_breadcrumb(severity, message = nil, progname = nil)
-      message = progname if message.nil? # see Ruby's Logger docs for why
-      return if ignored_logger?(progname)
-      return if message.nil? || message == ""
-
-      # some loggers will add leading/trailing space as they (incorrectly, mind you)
-      # think of logging as a shortcut to std{out,err}
-      message = message.to_s.strip
-
-      last_crumb = Raven.breadcrumbs.peek
-      # try to avoid dupes from logger broadcasts
-      if last_crumb.nil? || last_crumb.message != message
-        error = Raven::BreadcrumbLogger.parse_exception(message)
-        # TODO(dcramer): we need to filter out the "currently captured error"
-        if error
-          Raven.breadcrumbs.record do |crumb|
-            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
-            crumb.category = progname || 'error'
-            crumb.type = 'error'
-            crumb.data = {
-              :type => error[0],
-              :value => error[1]
-            }
-          end
-        else
-          Raven.breadcrumbs.record do |crumb|
-            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
-            crumb.category = progname || 'logger'
-            crumb.message = message
-          end
-        end
-      end
-    end
-
-    private
-
-    def ignored_logger?(progname)
-      progname == "sentry" ||
-        Raven.configuration.exclude_loggers.include?(progname)
-    end
-  end
-  module OldBreadcrumbLogger
-    def self.included(base)
-      base.class_eval do
-        include Raven::BreadcrumbLogger
-        alias_method :add_without_raven, :add
-        alias_method :add, :add_with_raven
-      end
-    end
-
-    def add_with_raven(*args)
-      add_breadcrumb(*args)
-      add_without_raven(*args)
-    end
-  end
-end
-
-Raven.safely_prepend(
-  "BreadcrumbLogger",
-  :from => Raven,
-  :to => ::Logger
-)
+require "raven/breadcrumbs/sentry_logger"

data/lib/raven/breadcrumbs/sentry_logger.rb

@@ -0,0 +1,73 @@
+require 'logger'
+
+module Raven
+  module Breadcrumbs
+    module SentryLogger
+      LEVELS = {
+        ::Logger::DEBUG => 'debug',
+        ::Logger::INFO => 'info',
+        ::Logger::WARN => 'warn',
+        ::Logger::ERROR => 'error',
+        ::Logger::FATAL => 'fatal'
+      }.freeze
+
+      def add(*args)
+        add_breadcrumb(*args)
+        super
+      end
+
+      def add_breadcrumb(severity, message = nil, progname = nil)
+        message = progname if message.nil? # see Ruby's Logger docs for why
+        return if ignored_logger?(progname)
+        return if message.nil? || message == ""
+
+        # some loggers will add leading/trailing space as they (incorrectly, mind you)
+        # think of logging as a shortcut to std{out,err}
+        message = message.to_s.strip
+
+        last_crumb = Raven.breadcrumbs.peek
+        # try to avoid dupes from logger broadcasts
+        if last_crumb.nil? || last_crumb.message != message
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::Breadcrumbs::SentryLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'logger'
+            crumb.message = message
+            crumb.type =
+              if severity >= 3
+                "error"
+              else
+                crumb.level
+              end
+          end
+        end
+      end
+
+      private
+
+      def ignored_logger?(progname)
+        progname == "sentry" ||
+          Raven.configuration.exclude_loggers.include?(progname)
+      end
+    end
+    module OldBreadcrumbsSentryLogger
+      def self.included(base)
+        base.class_eval do
+          include Raven::Breadcrumbs::SentryLogger
+          alias_method :add_without_raven, :add
+          alias_method :add, :add_with_raven
+        end
+      end
+
+      def add_with_raven(*args)
+        add_breadcrumb(*args)
+        add_without_raven(*args)
+      end
+    end
+  end
+end
+
+Raven.safely_prepend(
+  "Breadcrumbs::SentryLogger",
+  :from => Raven,
+  :to => ::Logger
+)

data/lib/raven/cli.rb

@@ -1,6 +1,6 @@
 module Raven
   class CLI
-    def self.test(dsn = nil, silent = false, config = nil) # rubocop:disable all
+    def self.test(dsn = nil, silent = false, config = nil)
       config ||= Raven.configuration
 
       config.logger = if silent
@@ -18,7 +18,7 @@ module Raven
 
       # wipe out env settings to ensure we send the event
       unless config.capture_allowed?
-        env_name = config.environments.pop || 'production'
+        env_name = config.environments.last || 'production'
         config.current_environment = env_name
       end
 
@@ -33,27 +33,16 @@ module Raven
         evt = instance.capture_exception(e)
       end
 
-      if evt && !(evt.is_a? Thread)
-        if evt.is_a? Hash
-          instance.logger.debug "-> event ID: #{evt[:event_id]}"
-        else
-          instance.logger.debug "-> event ID: #{evt.id}"
-        end
-      elsif evt # async configuration
-        if evt.value.is_a? Hash
-          instance.logger.debug "-> event ID: #{evt.value[:event_id]}"
-        else
-          instance.logger.debug "-> event ID: #{evt.value.id}"
-        end
+      if evt
+        instance.logger.debug "-> event ID: #{evt.id}"
+        instance.logger.debug ""
+        instance.logger.debug "Done!"
+        evt
       else
         instance.logger.debug ""
         instance.logger.debug "An error occurred while attempting to send the event."
-        exit 1
+        false
       end
-
-      instance.logger.debug ""
-      instance.logger.debug "Done!"
-      evt
     end
   end
 end

data/lib/raven/client.rb

@@ -125,7 +125,7 @@ module Raven
       configuration.logger.warn("Failed to submit event: #{get_log_message(event)}")
 
       # configuration.transport_failure_callback can be false & nil
-      configuration.transport_failure_callback.call(event) if configuration.transport_failure_callback # rubocop:disable Style/SafeNavigation
+      configuration.transport_failure_callback.call(event, e) if configuration.transport_failure_callback # rubocop:disable Style/SafeNavigation
     end
   end
 

data/lib/raven/configuration.rb

@@ -12,6 +12,11 @@ module Raven
     attr_reader :async
     alias async? async
 
+    # An array of breadcrumbs loggers to be used. Available options are:
+    # - :sentry_logger
+    # - :active_support_logger
+    attr_reader :breadcrumbs_logger
+
     # Number of lines of code context to capture, or nil for none
     attr_accessor :context_lines
 
@@ -83,7 +88,7 @@ module Raven
     attr_accessor :public_key
 
     # Turns on ActiveSupport breadcrumbs integration
-    attr_accessor :rails_activesupport_breadcrumbs
+    attr_reader :rails_activesupport_breadcrumbs
 
     # Rails catches exceptions in the ActionDispatch::ShowExceptions or
     # ActionDispatch::DebugExceptions middlewares, depending on the environment.
@@ -118,6 +123,19 @@ module Raven
     # Otherwise, can be one of "http", "https", or "dummy"
     attr_accessor :scheme
 
+    # a proc/lambda that takes an array of stack traces
+    # it'll be used to silence (reduce) backtrace of the exception
+    #
+    # for example:
+    #
+    # ```ruby
+    # Raven.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+    #   Rails.backtrace_cleaner.clean(backtrace)
+    # end
+    # ```
+    #
+    attr_accessor :backtrace_cleanup_callback
+
     # Secret key for authentication with the Sentry server
     # If you provide a DSN, this will be set automatically.
     #
@@ -172,16 +190,35 @@ module Raven
     # Errors object - an Array that contains error messages. See #
     attr_reader :errors
 
+    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
+    attr_reader :dsn
+
+    # Array of rack env parameters to be included in the event sent to sentry.
+    attr_accessor :rack_env_whitelist
+
+    # Most of these errors generate 4XX responses. In general, Sentry clients
+    # only automatically report 5xx responses.
     IGNORE_DEFAULT = [
       'AbstractController::ActionNotFound',
+      'ActionController::BadRequest',
       'ActionController::InvalidAuthenticityToken',
+      'ActionController::InvalidCrossOriginRequest',
+      'ActionController::MethodNotAllowed',
+      'ActionController::NotImplemented',
+      'ActionController::ParameterMissing',
       'ActionController::RoutingError',
       'ActionController::UnknownAction',
+      'ActionController::UnknownFormat',
+      'ActionController::UnknownHttpMethod',
+      'ActionDispatch::Http::Parameters::ParseError',
+      'ActionView::MissingTemplate',
+      'ActiveJob::DeserializationError', # Can cause infinite loops
       'ActiveRecord::RecordNotFound',
       'CGI::Session::CookieStore::TamperedWithCookie',
       'Mongoid::Errors::DocumentNotFound',
-      'Sinatra::NotFound',
-      'ActiveJob::DeserializationError'
+      'Rack::QueryParser::InvalidParameterError',
+      'Rack::QueryParser::ParameterTypeError',
+      'Sinatra::NotFound'
     ].freeze
 
     # Note the order - we have to remove circular references and bad characters
@@ -198,11 +235,20 @@ module Raven
     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
 
+    RACK_ENV_WHITELIST_DEFAULT = %w(
+      REMOTE_ADDR
+      SERVER_NAME
+      SERVER_PORT
+    ).freeze
+
     LOG_PREFIX = "** [Raven] ".freeze
     MODULE_SEPARATOR = "::".freeze
 
+    AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
+
     def initialize
       self.async = false
+      self.breadcrumbs_logger = []
       self.context_lines = 3
       self.current_environment = current_environment_from_env
       self.encoding = 'gzip'
@@ -215,7 +261,8 @@ module Raven
       self.open_timeout = 1
       self.processors = DEFAULT_PROCESSORS.dup
       self.project_root = detect_project_root
-      self.rails_activesupport_breadcrumbs = false
+      @rails_activesupport_breadcrumbs = false
+
       self.rails_report_rescued_exceptions = true
       self.release = detect_release
       self.sample_rate = 1.0
@@ -232,11 +279,14 @@ module Raven
       self.timeout = 2
       self.transport_failure_callback = false
       self.before_send = false
+      self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
     end
 
     def server=(value)
       return if value.nil?
 
+      @dsn = value
+
       uri = URI.parse(value)
       uri_path = uri.path.split('/')
 
@@ -273,6 +323,23 @@ module Raven
       @async = value
     end
 
+    def breadcrumbs_logger=(logger)
+      loggers =
+        if logger.is_a?(Array)
+          logger
+        else
+          unless AVAILABLE_BREADCRUMBS_LOGGERS.include?(logger)
+            raise Raven::Error, "Unsupported breadcrumbs logger. Supported loggers: #{AVAILABLE_BREADCRUMBS_LOGGERS}"
+          end
+
+          Array(logger)
+        end
+
+      require "raven/breadcrumbs/sentry_logger" if loggers.include?(:sentry_logger)
+
+      @breadcrumbs_logger = logger
+    end
+
     def transport_failure_callback=(value)
       unless value == false || value.respond_to?(:call)
         raise(ArgumentError, "transport_failure_callback must be callable (or false to disable)")
@@ -329,6 +396,11 @@ module Raven
       Backtrace::Line.instance_variable_set(:@in_app_pattern, nil) # blow away cache
     end
 
+    def rails_activesupport_breadcrumbs=(val)
+      DeprecationHelper.deprecate_old_breadcrumbs_configuration(:active_support_logger)
+      @rails_activesupport_breadcrumbs = val
+    end
+
     def exception_class_allowed?(exc)
       if exc.is_a?(Raven::Error)
         # Try to prevent error reporting loops
@@ -342,6 +414,10 @@ module Raven
       end
     end
 
+    def enabled_in_current_env?
+      environments.empty? || environments.include?(current_environment)
+    end
+
     private
 
     def detect_project_root
@@ -423,7 +499,7 @@ module Raven
     end
 
     def capture_in_current_environment?
-      return true unless environments.any? && !environments.include?(current_environment)
+      return true if enabled_in_current_env?
 
       @errors << "Not configured to send/capture in environment '#{current_environment}'"
       false