sentry-raven 2.1.3 → 3.1.2

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,234 +1,125 @@
 # frozen_string_literal: true
-require 'rubygems'
+
 require 'socket'
 require 'securerandom'
-require 'digest/md5'
-
-require 'raven/error'
-require 'raven/linecache'
 
 module Raven
   class Event
-    LOG_LEVELS = {
-      "debug" => 10,
-      "info" => 20,
-      "warn" => 30,
-      "warning" => 30,
-      "error" => 40,
-      "fatal" => 50
-    }.freeze
-
-    BACKTRACE_RE = /^(.+?):(\d+)(?::in `(.+?)')?$/
-
-    PLATFORM = "ruby".freeze
-    SDK = { "name" => "sentry-raven", "version" => Raven::VERSION }.freeze
-
-    attr_accessor :id, :timestamp, :time_spent, :level, :logger,
-                  :culprit, :server_name, :release, :modules, :extra, :tags,
-                  :context, :configuration, :checksum, :fingerprint, :environment,
-                  :server_os, :runtime, :breadcrumbs, :user, :backtrace
-
-    def initialize(init = {})
-      @configuration = Raven.configuration
-      @interfaces    = {}
-      @breadcrumbs   = Raven.breadcrumbs
-      @context       = Raven.context
-      @id            = SecureRandom.uuid.delete("-")
-      @timestamp     = Time.now.utc
-      @time_spent    = nil
-      @level         = :error
-      @logger        = ''
-      @culprit       = nil
-      @server_name   = @configuration.server_name
-      @release       = @configuration.release
-      @modules       = list_gem_specs if @configuration.send_modules
-      @user          = {} # TODO: contexts
-      @extra         = {} # TODO: contexts
-      @server_os     = {} # TODO: contexts
-      @runtime       = {} # TODO: contexts
-      @tags          = {} # TODO: contexts
-      @checksum      = nil
-      @fingerprint   = nil
-      @environment   = @configuration.current_environment
-
-      yield self if block_given?
-
-      if !self[:http] && @context.rack_env
-        interface :http do |int|
-          int.from_rack(@context.rack_env)
-        end
+    # 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
+
+    attr_accessor :id, :logger, :transaction, :server_name, :release, :modules,
+                  :extra, :tags, :context, :configuration, :checksum,
+                  :fingerprint, :environment, :server_os, :runtime,
+                  :breadcrumbs, :user, :backtrace, :platform, :sdk
+    alias event_id id
+
+    attr_reader :level, :timestamp, :time_spent
+
+    def initialize(options)
+      # Set some simple default values
+      self.id            = SecureRandom.uuid.delete("-")
+      self.timestamp     = Time.now.utc
+      self.level         = :error
+      self.logger        = :ruby
+      self.platform      = :ruby
+      self.sdk           = SDK
+
+      # Set some attributes with empty hashes to allow merging
+      @interfaces        = {}
+      self.user          = {} # TODO: contexts
+      self.extra         = {} # TODO: contexts
+      self.server_os     = {} # TODO: contexts
+      self.runtime       = {} # TODO: contexts
+      self.tags          = {} # TODO: contexts
+
+      unless REQUIRED_OPTION_KEYS.all? { |key| options.key?(key) }
+        raise "you must provide configuration, context, and breadcrumbs when initializing a Raven::Event"
       end
 
-      if @context.rack_env # TODO: contexts
-        @context.user[:ip_address] = calculate_real_ip_from_rack
-      end
-
-      init.each_pair { |key, val| public_send(key.to_s + "=", val) }
+      self.configuration = options[:configuration]
+      self.context       = options[:context]
+      self.breadcrumbs   = options[:breadcrumbs]
 
-      @user = @context.user.merge(@user) # TODO: contexts
-      @extra = @context.extra.merge(@extra) # TODO: contexts
-      @tags = @configuration.tags.merge(@context.tags).merge(@tags) # TODO: contexts
-      @server_os = @context.server_os # TODO: contexts
-      @runtime = @context.runtime # TODO: contexts
+      # Allow attributes to be set on the event at initialization
+      yield self if block_given?
+      options.each_pair { |key, val| public_send("#{key}=", val) unless val.nil? }
 
-      # Some type coercion
-      @timestamp  = @timestamp.strftime('%Y-%m-%dT%H:%M:%S') if @timestamp.is_a?(Time)
-      @time_spent = (@time_spent * 1000).to_i if @time_spent.is_a?(Float)
-      @level      = LOG_LEVELS[@level.to_s.downcase] if @level.is_a?(String) || @level.is_a?(Symbol)
+      set_core_attributes_from_configuration
+      set_core_attributes_from_context
     end
 
-    def message
-      @interfaces[:logentry] && @interfaces[:logentry].unformatted_message
-    end
-
-    def message=(args)
-      message, params = *args
-      interface(:message) do |int|
-        int.message = message
-        int.params = params
+    def self.from_exception(exc, options = {}, &block)
+      exception_context = if exc.instance_variable_defined?(:@__raven_context)
+                            exc.instance_variable_get(:@__raven_context)
+                          elsif exc.respond_to?(:raven_context)
+                            exc.raven_context
+                          else
+                            {}
+                          end
+      options = Raven::Utils::DeepMergeHash.deep_merge(exception_context, options)
+
+      return unless options[:configuration].exception_class_allowed?(exc)
+
+      new(options) do |evt|
+        evt.add_exception_interface(exc)
+        yield evt if block
       end
     end
 
-    class << self
-      def from_exception(exc, options = {}, &block)
-        exception_context = get_exception_context(exc) || {}
-        options = Raven::Utils::DeepMergeHash.deep_merge(exception_context, options)
-
-        configuration = options[:configuration] || Raven.configuration
-        if exc.is_a?(Raven::Error)
-          # Try to prevent error reporting loops
-          Raven.logger.info "Refusing to capture Raven error: #{exc.inspect}"
-          return nil
-        end
-        if configuration[:excluded_exceptions].any? { |x| get_exception_class(x) === exc }
-          Raven.logger.info "User excluded error: #{exc.inspect}"
-          return nil
-        end
-
-        new(options) do |evt|
-          evt.configuration = configuration
-          evt.message = "#{exc.class}: #{exc.message}"
-          evt.level = options[:level] || :error
-
-          add_exception_interface(evt, exc)
-
-          yield evt if block
-        end
-      end
-
-      def from_message(message, options = {})
-        message = message.byteslice(0...10_000) # Messages limited to 10kb
-        configuration = options[:configuration] || Raven.configuration
-
-        new(options) do |evt|
-          evt.configuration = configuration
-          evt.level = options[:level] || :error
-          evt.message = message, options[:message_params] || []
-          if options[:backtrace]
-            evt.interface(:stacktrace) do |int|
-              stacktrace_interface_from(int, evt, options[:backtrace])
-            end
+    def self.from_message(message, options = {})
+      new(options) do |evt|
+        evt.message = message, options[:message_params] || []
+        if options[:backtrace]
+          evt.interface(:stacktrace) do |int|
+            int.frames = evt.stacktrace_interface_from(options[:backtrace])
           end
         end
       end
+    end
 
-      private
-
-      def get_exception_class(x)
-        x.is_a?(Module) ? x : qualified_const_get(x)
-      end
-
-      # In Ruby <2.0 const_get can't lookup "SomeModule::SomeClass" in one go
-      def qualified_const_get(x)
-        x = x.to_s
-        parts = x.split("::")
-        parts.reject!(&:empty?)
+    def message
+      @interfaces[:logentry]&.unformatted_message
+    end
 
-        if parts.size < 2
-          Object.const_get(x)
-        else
-          parts.inject(Object) { |a, e| a.const_get(e) }
-        end
-      rescue NameError # There's no way to safely ask if a constant exist for an unknown string
-        nil
+    def message=(args)
+      if args.is_a?(Array)
+        message, params = args[0], args[0..-1]
+      else
+        message = args
       end
 
-      def get_exception_context(exc)
-        if exc.instance_variable_defined?(:@__raven_context)
-          exc.instance_variable_get(:@__raven_context)
-        elsif exc.respond_to?(:raven_context)
-          exc.raven_context
-        end
+      unless message.is_a?(String)
+        configuration.logger.debug("You're passing a non-string message")
+        message = message.to_s
       end
 
-      def add_exception_interface(evt, exc)
-        evt.interface(:exception) do |exc_int|
-          exceptions = [exc]
-          context = Set.new [exc.object_id]
-          backtraces = Set.new
-
-          while exc.respond_to?(:cause) && exc.cause
-            exc = exc.cause
-            break if context.include?(exc.object_id)
-            exceptions << exc
-            context.add(exc.object_id)
-          end
-          exceptions.reverse!
-
-          exc_int.values = exceptions.map do |e|
-            SingleExceptionInterface.new do |int|
-              int.type = e.class.to_s
-              int.value = e.to_s
-              int.module = e.class.to_s.split('::')[0...-1].join('::')
-
-              int.stacktrace =
-                if e.backtrace && !backtraces.include?(e.backtrace.object_id)
-                  backtraces << e.backtrace.object_id
-                  StacktraceInterface.new do |stacktrace|
-                    stacktrace_interface_from(stacktrace, evt, e.backtrace)
-                  end
-                end
-            end
-          end
-        end
+      interface(:message) do |int|
+        int.message = message.byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES) # Messages limited to 10kb
+        int.params = params
       end
+    end
 
-      def stacktrace_interface_from(int, evt, backtrace)
-        backtrace = Backtrace.parse(backtrace)
-
-        int.frames = []
-        backtrace.lines.reverse_each do |line|
-          frame = StacktraceInterface::Frame.new
-          frame.abs_path = line.file if line.file
-          frame.function = line.method if line.method
-          frame.lineno = line.number
-          frame.in_app = line.in_app
-          frame.module = line.module_name if line.module_name
-
-          if evt.configuration[:context_lines] && frame.abs_path
-            frame.pre_context, frame.context_line, frame.post_context = \
-              evt.get_file_context(frame.abs_path, frame.lineno, evt.configuration[:context_lines])
-          end
-
-          int.frames << frame if frame.filename
-        end
-
-        evt.culprit = evt.get_culprit(int.frames)
-      end
+    def timestamp=(time)
+      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
+    end
 
-      # Because linecache can go to hell
-      def _source_lines(_path, _from, _to)
-      end
+    def time_spent=(time)
+      @time_spent = time.is_a?(Float) ? (time * 1000).to_i : time
     end
 
-    def list_gem_specs
-      # Older versions of Rubygems don't support iterating over all specs
-      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
+    def level=(new_level) # needed to meet the Sentry spec
+      @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
@@ -242,54 +133,63 @@ module Raven
     end
 
     def to_hash
-      data = {
-        :event_id => @id,
-        :timestamp => @timestamp,
-        :time_spent => @time_spent,
-        :level => @level,
-        :platform => PLATFORM,
-        :sdk => SDK,
-        :contexts => {
-          :server_os => @server_os,
-          :runtime => @runtime
-        }
-      }
-
-      data[:logger] = @logger if @logger
-      data[:culprit] = @culprit if @culprit
-      data[:server_name] = @server_name if @server_name
-      data[:release] = @release if @release
-      data[:environment] = @environment if @environment
-      data[:fingerprint] = @fingerprint if @fingerprint
-      data[:modules] = @modules if @modules
-      data[:extra] = @extra if @extra
-      data[:tags] = @tags if @tags
-      data[:user] = @user if @user
+      data = [:checksum, :environment, :event_id, :extra, :fingerprint, :level,
+              :logger, :message, :modules, :platform, :release, :sdk, :server_name,
+              :tags, :time_spent, :timestamp, :transaction, :user].each_with_object({}) do |att, memo|
+        memo[att] = public_send(att) if public_send(att)
+      end
+
       data[:breadcrumbs] = @breadcrumbs.to_hash unless @breadcrumbs.empty?
-      data[:checksum] = @checksum if @checksum
 
       @interfaces.each_pair do |name, int_data|
         data[name.to_sym] = int_data.to_hash
       end
-      data[:message] = message
       data
     end
 
-    def get_file_context(filename, lineno, context)
-      return nil, nil, nil unless Raven::LineCache.valid_file?(filename)
-      lines = Array.new(2 * context + 1) do |i|
-        Raven::LineCache.getline(filename, lineno - context + i)
-      end
-      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
+    def to_json_compatible
+      cleaned_hash = async_json_processors.reduce(to_hash) { |a, e| e.process(a) }
+      JSON.parse(JSON.generate(cleaned_hash))
     end
 
-    def get_culprit(frames)
-      lastframe = frames.reverse.find(&:in_app) || frames.last
-      "#{lastframe.filename} in #{lastframe.function} at line #{lastframe.lineno}" if lastframe
+    def add_exception_interface(exc)
+      interface(:exception) do |exc_int|
+        exceptions = Raven::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
+        backtraces = Set.new
+        exc_int.values = exceptions.map do |e|
+          SingleExceptionInterface.new do |int|
+            int.type = e.class.to_s
+            int.value = e.to_s
+            int.module = e.class.to_s.split('::')[0...-1].join('::')
+
+            int.stacktrace =
+              if e.backtrace && !backtraces.include?(e.backtrace.object_id)
+                backtraces << e.backtrace.object_id
+                StacktraceInterface.new do |stacktrace|
+                  stacktrace.frames = stacktrace_interface_from(e.backtrace)
+                end
+              end
+          end
+        end
+      end
     end
 
-    def to_json_compatible
-      JSON.parse(JSON.generate(to_hash))
+    def stacktrace_interface_from(backtrace)
+      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
+        frame.lineno = line.number
+        frame.in_app = line.in_app
+        frame.module = line.module_name if line.module_name
+
+        if configuration[:context_lines] && frame.abs_path
+          frame.pre_context, frame.context_line, frame.post_context = \
+            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration[:context_lines])
+        end
+
+        memo << frame if frame.filename
+      end
     end
 
     # For cross-language compat
@@ -302,6 +202,36 @@ module Raven
 
     private
 
+    def set_core_attributes_from_configuration
+      self.server_name ||= configuration.server_name
+      self.release     ||= configuration.release
+      self.modules       = list_gem_specs if configuration.send_modules
+      self.environment ||= configuration.current_environment
+    end
+
+    def set_core_attributes_from_context
+      self.transaction ||= context.transaction.last
+
+      # If this is a Rack event, merge Rack context
+      add_rack_context if !self[:http] && context.rack_env
+
+      # Merge contexts
+      self.user = context.user.merge(user) # TODO: contexts
+      self.extra = context.extra.merge(extra) # TODO: contexts
+      self.tags = configuration.tags.merge(context.tags).merge!(tags) # TODO: contexts
+    end
+
+    def add_rack_context
+      interface :http do |int|
+        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
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack
@@ -312,5 +242,14 @@ module Raven
         :forwarded_for => context.rack_env["HTTP_X_FORWARDED_FOR"]
       ).calculate_ip
     end
+
+    def async_json_processors
+      configuration.processors.map { |v| v.new(self) }
+    end
+
+    def list_gem_specs
+      # Older versions of Rubygems don't support iterating over all specs
+      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
+    end
   end
 end

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