sentry-raven 3.0.1 → 3.1.1

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

@@ -8,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
 
@@ -19,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
@@ -36,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 much 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
@@ -56,8 +63,7 @@ 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.add_exception_interface(exc)
@@ -81,7 +87,17 @@ module Raven
     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
@@ -159,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
@@ -186,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

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,6 +50,7 @@ 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?
@@ -76,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)
@@ -110,8 +111,11 @@ module Raven
       end
 
       message_or_exc = obj.is_a?(String) ? "message" : "exception"
+      options = options.deep_dup
       options[:configuration] = configuration
       options[:context] = context
+      options[:breadcrumbs] = breadcrumbs
+
       if evt = Event.send("from_" + message_or_exc, obj, options)
         yield evt if block_given?
         if configuration.async?
@@ -172,7 +176,12 @@ module Raven
     # @example
     #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
     def user_context(options = nil)
+      original_user_context = context.user
       context.user = options || {}
+      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).

data/lib/raven/integrations/delayed_job.rb

@@ -1,4 +1,5 @@
 require 'delayed_job'
+require 'raven/utils/context_filter'
 
 module Delayed
   module Plugins
@@ -29,7 +30,7 @@ module Delayed
             extra[:handler] = job.handler[0...1000] if job.handler
 
             if job.respond_to?('payload_object') && job.payload_object.respond_to?('job_data')
-              extra[:active_job] = job.payload_object.job_data
+              extra[:active_job] = Utils::ContextFilter.filter_context(job.payload_object.job_data)
             end
             ::Raven.capture_exception(e,
                                       :logger => 'delayed_job',

data/lib/raven/integrations/rack-timeout.rb

@@ -10,7 +10,11 @@ module RackTimeoutExtensions
     # Only rack-timeout 0.3.0+ provides the request environment, but we can't
     # gate this based on a gem version constant because rack-timeout does
     # not provide one.
-    { :fingerprint => ["{{ default }}", env["REQUEST_URI"]] } if defined?(env)
+    if defined?(env)
+      { :fingerprint => ["{{ default }}", env["REQUEST_URI"]] }
+    else
+      {}
+    end
   end
 end
 

data/lib/raven/integrations/rack.rb

@@ -67,6 +67,8 @@ module Raven
   end
 
   module RackInterface
+    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+
     def from_rack(env_hash)
       req = ::Rack::Request.new(env_hash)
 
@@ -82,6 +84,15 @@ module Raven
 
     private
 
+    # Request ID based on ActionDispatch::RequestId
+    def read_request_id_from(env_hash)
+      REQUEST_ID_HEADERS.each do |key|
+        request_id = env_hash[key]
+        return request_id if request_id
+      end
+      nil
+    end
+
     # See Sentry server default limits at
     # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     def read_data_from(request)
@@ -101,6 +112,7 @@ module Raven
         begin
           key = key.to_s # rack env can contain symbols
           value = value.to_s
+          next memo['X-Request-Id'] ||= read_request_id_from(env_hash) if REQUEST_ID_HEADERS.include?(key)
           next unless key.upcase == key # Non-upper case stuff isn't either
 
           # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
@@ -110,7 +122,6 @@ module Raven
           # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
           next if key == 'HTTP_VERSION' && value == env_hash['SERVER_PROTOCOL']
           next if key == 'HTTP_COOKIE' # Cookies don't go here, they go somewhere else
-
           next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(key)
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
@@ -128,8 +139,10 @@ module Raven
     end
 
     def format_env_for_sentry(env_hash)
+      return env_hash if Raven.configuration.rack_env_whitelist.empty?
+
       env_hash.select do |k, _v|
-        %w(REMOTE_ADDR SERVER_NAME SERVER_PORT).include? k.to_s
+        Raven.configuration.rack_env_whitelist.include? k.to_s
       end
     end
   end