sentry-raven 3.0.2 → 3.1.2

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,34 @@ 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',
+      '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 +234,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 +260,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 +278,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 +322,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 +395,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 +413,10 @@ module Raven
       end
     end
 
+    def enabled_in_current_env?
+      environments.empty? || environments.include?(current_environment)
+    end
+
     private
 
     def detect_project_root
@@ -423,7 +498,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

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