sentry-raven 3.0.0 → 3.1.0

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
 
@@ -29,31 +29,20 @@ module Raven
 
       begin
         1 / 0
-      rescue ZeroDivisionError => exception
-        evt = instance.capture_exception(exception)
+      rescue ZeroDivisionError => e
+        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

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
+
 require 'base64'
 require 'json'
 require 'zlib'
 
+require "raven/transports"
+
 module Raven
   # Encodes events and sends them to the Sentry server.
   class Client
-    PROTOCOL_VERSION = '5'.freeze
-    USER_AGENT = "raven-ruby/#{Raven::VERSION}".freeze
-    CONTENT_TYPE = 'application/json'.freeze
+    PROTOCOL_VERSION = '5'
+    USER_AGENT = "raven-ruby/#{Raven::VERSION}"
+    CONTENT_TYPE = 'application/json'
 
     attr_accessor :configuration
 
@@ -120,7 +123,9 @@ module Raven
         configuration.logger.warn "Not sending event due to previous failure(s)."
       end
       configuration.logger.warn("Failed to submit event: #{get_log_message(event)}")
-      configuration.transport_failure_callback.call(event) if configuration.transport_failure_callback
+
+      # configuration.transport_failure_callback can be false & nil
+      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,32 @@ 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
+
+    # 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
@@ -201,8 +235,11 @@ module Raven
     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 +252,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
@@ -236,6 +274,9 @@ module Raven
 
     def server=(value)
       return if value.nil?
+
+      @dsn = value
+
       uri = URI.parse(value)
       uri_path = uri.path.split('/')
 
@@ -253,13 +294,14 @@ module Raven
 
       # For anyone who wants to read the base server string
       @server = "#{scheme}://#{host}"
-      @server << ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
-      @server << path
+      @server += ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
+      @server += path
     end
     alias dsn= server=
 
     def encoding=(encoding)
       raise(Error, 'Unsupported encoding') unless %w(gzip json).include? encoding
+
       @encoding = encoding
     end
 
@@ -267,13 +309,32 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise(ArgumentError, "async must be callable (or false to disable)")
       end
+
       @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)")
       end
+
       @transport_failure_callback = value
     end
 
@@ -281,6 +342,7 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise ArgumentError, "should_capture must be callable (or false to disable)"
       end
+
       @should_capture = value
     end
 
@@ -288,6 +350,7 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise ArgumentError, "before_send must be callable (or false to disable)"
       end
+
       @before_send = value
     end
 
@@ -323,6 +386,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
@@ -336,6 +404,10 @@ module Raven
       end
     end
 
+    def enabled_in_current_env?
+      environments.empty? || environments.include?(current_environment)
+    end
+
     private
 
     def detect_project_root
@@ -351,8 +423,8 @@ module Raven
         detect_release_from_git ||
         detect_release_from_capistrano ||
         detect_release_from_heroku
-    rescue => ex
-      logger.error "Error detecting release: #{ex.message}"
+    rescue => e
+      logger.error "Error detecting release: #{e.message}"
     end
 
     def excluded_exception?(incoming_exception)
@@ -417,19 +489,22 @@ 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
     end
 
     def capture_allowed_by_callback?(message_or_exc)
-      return true if !should_capture || message_or_exc.nil? || should_capture.call(*[message_or_exc])
+      return true if !should_capture || message_or_exc.nil? || should_capture.call(message_or_exc)
+
       @errors << "should_capture returned false"
       false
     end
 
     def valid?
       return true if %w(server host path public_key project_id).all? { |k| public_send(k) }
+
       if server
         %w(server host path public_key project_id).map do |key|
           @errors << "No #{key} specified" unless public_send(key)
@@ -442,6 +517,7 @@ module Raven
 
     def sample_allowed?
       return true if sample_rate == 1.0
+
       if Random::DEFAULT.rand >= sample_rate
         @errors << "Excluded by random sample"
         false

data/lib/raven/context.rb

@@ -1,4 +1,5 @@
 require 'rbconfig'
+require 'etc'
 
 module Raven
   class Context
@@ -24,18 +25,22 @@ module Raven
 
     class << self
       def os_context
-        @os_context ||= {
-          :name => Raven.sys_command("uname -s") || RbConfig::CONFIG["host_os"],
-          :version => Raven.sys_command("uname -v"),
-          :build => Raven.sys_command("uname -r"),
-          :kernel_version => Raven.sys_command("uname -a") || Raven.sys_command("ver") # windows
-        }
+        @os_context ||=
+          begin
+            uname = Etc.uname
+            {
+              name: uname[:sysname] || RbConfig::CONFIG["host_os"],
+              version: uname[:version],
+              build: uname[:release],
+              kernel_version: uname[:version]
+            }
+          end
       end
 
       def runtime_context
         @runtime_context ||= {
-          :name => RbConfig::CONFIG["ruby_install_name"],
-          :version => Raven.sys_command("ruby -v")
+          name: RbConfig::CONFIG["ruby_install_name"],
+          version: RUBY_DESCRIPTION || Raven.sys_command("ruby -v")
         }
       end
     end

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

@@ -0,0 +1,57 @@
+require 'raven/core_ext/object/duplicable'
+
+#########################################
+#  This file was copied from Rails 5.2  #
+#########################################
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def deep_dup
+    map(&:deep_dup)
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def deep_dup
+    hash = dup
+    each_pair do |key, value|
+      if key.frozen? && ::String === key
+        hash[key] = value.deep_dup
+      else
+        hash.delete(key)
+        hash[key.deep_dup] = value.deep_dup
+      end
+    end
+    hash
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+#########################################
+#  This file was copied from Rails 5.2  #
+#########################################
+
+#--
+# Most objects are cloneable, but not all. For example you can't dup methods:
+#
+#   method(:puts).dup # => TypeError: allocator undefined for Method
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for method objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  begin
+    nil.dup
+  rescue TypeError
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class FalseClass
+  begin
+    false.dup
+  rescue TypeError
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class TrueClass
+  begin
+    true.dup
+  rescue TypeError
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Symbol
+  begin
+    :symbol.dup # Ruby 2.4.x.
+    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+  rescue TypeError
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Numeric
+  begin
+    1.dup
+  rescue TypeError
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Integer
+    def duplicable?
+      false
+    end
+  end
+end
+
+require "bigdecimal"
+class BigDecimal
+  # BigDecimals are duplicable:
+  #
+  #   BigDecimal("1.2").duplicable? # => true
+  #   BigDecimal("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
+  def duplicable?
+    true
+  end
+end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end
+
+class Complex
+  begin
+    Complex(1).dup
+  rescue TypeError
+    # Complexes are not duplicable:
+    #
+    #   Complex(1).duplicable? # => false
+    #   Complex(1).dup         # => TypeError: can't copy Complex
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Rational
+  begin
+    Rational(1).dup
+  rescue TypeError
+    # Rationals are not duplicable:
+    #
+    #   Rational(1).duplicable? # => false
+    #   Rational(1).dup         # => TypeError: can't copy Rational
+    def duplicable?
+      false
+    end
+  end
+end