sentry-raven 2.9.0 → 3.1.2

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

data/lib/raven/event.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'socket'
 require 'securerandom'
 
@@ -7,6 +8,7 @@ module Raven
     # See Sentry server default limits at
     # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
+    REQUIRED_OPTION_KEYS = [:configuration, :context, :breadcrumbs].freeze
 
     SDK = { "name" => "raven-ruby", "version" => Raven::VERSION }.freeze
 
@@ -18,7 +20,7 @@ module Raven
 
     attr_reader :level, :timestamp, :time_spent
 
-    def initialize(init = {})
+    def initialize(options)
       # Set some simple default values
       self.id            = SecureRandom.uuid.delete("-")
       self.timestamp     = Time.now.utc
@@ -35,11 +37,17 @@ module Raven
       self.runtime       = {} # TODO: contexts
       self.tags          = {} # TODO: contexts
 
-      copy_initial_state
+      unless REQUIRED_OPTION_KEYS.all? { |key| options.key?(key) }
+        raise "you must provide configuration, context, and breadcrumbs when initializing a Raven::Event"
+      end
+
+      self.configuration = options[:configuration]
+      self.context       = options[:context]
+      self.breadcrumbs   = options[:breadcrumbs]
 
       # Allow attributes to be set on the event at initialization
       yield self if block_given?
-      init.each_pair { |key, val| public_send("#{key}=", val) unless val.nil? }
+      options.each_pair { |key, val| public_send("#{key}=", val) unless val.nil? }
 
       set_core_attributes_from_configuration
       set_core_attributes_from_context
@@ -55,14 +63,10 @@ module Raven
                           end
       options = Raven::Utils::DeepMergeHash.deep_merge(exception_context, options)
 
-      configuration = options[:configuration] || Raven.configuration
-      return unless configuration.exception_class_allowed?(exc)
+      return unless options[:configuration].exception_class_allowed?(exc)
 
       new(options) do |evt|
-        evt.message = "#{exc.class}: #{exc.message}"
-
         evt.add_exception_interface(exc)
-
         yield evt if block
       end
     end
@@ -79,11 +83,21 @@ module Raven
     end
 
     def message
-      @interfaces[:logentry] && @interfaces[:logentry].unformatted_message
+      @interfaces[:logentry]&.unformatted_message
     end
 
     def message=(args)
-      message, params = *args
+      if args.is_a?(Array)
+        message, params = args[0], args[0..-1]
+      else
+        message = args
+      end
+
+      unless message.is_a?(String)
+        configuration.logger.debug("You're passing a non-string message")
+        message = message.to_s
+      end
+
       interface(:message) do |int|
         int.message = message.byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES) # Messages limited to 10kb
         int.params = params
@@ -99,12 +113,13 @@ module Raven
     end
 
     def level=(new_level) # needed to meet the Sentry spec
-      @level = new_level == "warn" || new_level == :warn ? :warning : new_level
+      @level = new_level.to_s == "warn" ? :warning : new_level
     end
 
     def interface(name, value = nil, &block)
       int = Interface.registered[name]
       raise(Error, "Unknown interface: #{name}") unless int
+
       @interfaces[int.sentry_alias] = int.new(value, &block) if value || block
       @interfaces[int.sentry_alias]
     end
@@ -160,7 +175,7 @@ module Raven
     end
 
     def stacktrace_interface_from(backtrace)
-      Backtrace.parse(backtrace).lines.reverse.each_with_object([]) do |line, memo|
+      Backtrace.parse(backtrace, { configuration: configuration }).lines.reverse.each_with_object([]) do |line, memo|
         frame = StacktraceInterface::Frame.new
         frame.abs_path = line.file if line.file
         frame.function = line.method if line.method
@@ -187,12 +202,6 @@ module Raven
 
     private
 
-    def copy_initial_state
-      self.configuration = Raven.configuration
-      self.breadcrumbs   = Raven.breadcrumbs
-      self.context       = Raven.context
-    end
-
     def set_core_attributes_from_configuration
       self.server_name ||= configuration.server_name
       self.release     ||= configuration.release
@@ -217,6 +226,10 @@ module Raven
         int.from_rack(context.rack_env)
       end
       context.user[:ip_address] = calculate_real_ip_from_rack
+
+      if request_id = Utils::RequestId.read_from(context.rack_env)
+        context.tags[:request_id] = request_id
+      end
     end
 
     # When behind a proxy (or if the user is using a proxy), we can't use
@@ -231,10 +244,7 @@ module Raven
     end
 
     def async_json_processors
-      [
-        Raven::Processor::RemoveCircularReferences,
-        Raven::Processor::UTF8Conversion
-      ].map { |v| v.new(self) }
+      configuration.processors.map { |v| v.new(self) }
     end
 
     def list_gem_specs

data/lib/raven/helpers/deprecation_helper.rb

@@ -0,0 +1,17 @@
+module DeprecationHelper
+  def self.deprecate_dasherized_filename(correct_filename)
+    warn "[Deprecation Warning] Dasherized filename \"#{correct_filename.gsub('_', '-')}\" is deprecated and will be removed in 4.0; use \"#{correct_filename}\" instead" # rubocop:disable Style/LineLength
+  end
+
+  def self.deprecate_old_breadcrumbs_configuration(logger)
+    deprecated_usage =
+      if logger == :sentry_logger
+        "require \"raven/breadcrumbs/logger\""
+      else
+        "Raven.configuration.rails_activesupport_breadcrumbs = true"
+      end
+    recommended_usage = "Raven.configuration.breadcrumbs_logger = :#{logger}"
+
+    warn "[Deprecation Warning] The way you enable breadcrumbs logger (#{deprecated_usage}) is deprecated and will be removed in 4.0; use '#{recommended_usage}' instead" # rubocop:disable Style/LineLength
+  end
+end

data/lib/raven/instance.rb

@@ -50,7 +50,9 @@ module Raven
 
     # Tell the log that the client is good to go
     def report_status
+      return unless configuration.enabled_in_current_env?
       return if configuration.silence_ready
+
       if configuration.capture_allowed?
         logger.info "Raven #{VERSION} ready to catch errors"
       else
@@ -75,7 +77,7 @@ module Raven
     # Send an event to the configured Sentry server
     #
     # @example
-    #   evt = Raven::Event.new(:message => "An error")
+    #   evt = Raven::Event.new(:message => "An errore)
     #   Raven.send_event(evt)
     def send_event(event, hint = nil)
       client.send_event(event, hint)
@@ -109,17 +111,20 @@ module Raven
       end
 
       message_or_exc = obj.is_a?(String) ? "message" : "exception"
+      options = options.deep_dup
       options[:configuration] = configuration
       options[:context] = context
-      if (evt = Event.send("from_" + message_or_exc, obj, options))
+      options[:breadcrumbs] = breadcrumbs
+
+      if evt = Event.send("from_" + message_or_exc, obj, options)
         yield evt if block_given?
         if 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
             configuration.async.call(evt.to_json_compatible)
-          rescue => ex
-            logger.error("async event sending failed: #{ex.message}")
+          rescue => e
+            logger.error("async event sending failed: #{e.message}")
             send_event(evt, make_hint(obj))
           end
         else
@@ -171,7 +176,18 @@ module Raven
     # @example
     #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
     def user_context(options = nil)
-      context.user = options || {}
+      original_user_context = context.user
+
+      if options
+        context.user.merge!(options)
+      else
+        context.user = {}
+      end
+
+      yield if block_given?
+      context.user
+    ensure
+      context.user = original_user_context if block_given?
     end
 
     # Bind tags context. Merges with existing context (if any).
@@ -183,6 +199,10 @@ module Raven
     #   Raven.tags_context('my_custom_tag' => 'tag_value')
     def tags_context(options = nil)
       context.tags.merge!(options || {})
+      yield if block_given?
+      context.tags
+    ensure
+      context.tags.delete_if { |k, _| options.keys.include? k } if block_given?
     end
 
     # Bind extra context. Merges with existing context (if any).
@@ -194,6 +214,10 @@ module Raven
     #   Raven.extra_context('my_custom_data' => 'value')
     def extra_context(options = nil)
       context.extra.merge!(options || {})
+      yield if block_given?
+      context.extra
+    ensure
+      context.extra.delete_if { |k, _| options.keys.include? k } if block_given?
     end
 
     def rack_context(env)