sentry-raven 1.1.0 → 3.1.2

data/lib/raven/event.rb

@@ -1,200 +1,127 @@
 # 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
-
-    attr_reader :id
-    attr_accessor :project, :message, :timestamp, :time_spent, :level, :logger,
-      :culprit, :server_name, :release, :modules, :extra, :tags, :context, :configuration,
-      :checksum, :fingerprint
-
-    def initialize(init = {})
-      @configuration = Raven.configuration
-      @interfaces    = {}
-      @context       = Raven.context
-      @id            = generate_event_id
-      @project       = nil
-      @message       = nil
-      @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          = {}
-      @extra         = {}
-      @tags          = {}
-      @checksum      = nil
-      @fingerprint   = nil
-
-      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
 
-      init.each_pair { |key, val| instance_variable_set('@' + key.to_s, val) }
+      self.configuration = options[:configuration]
+      self.context       = options[:context]
+      self.breadcrumbs   = options[:breadcrumbs]
 
-      @user = @context.user.merge(@user)
-      @extra = @context.extra.merge(@extra)
-      @tags = @configuration.tags.merge(@context.tags).merge(@tags)
+      # 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
 
-    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| (x === exc rescue false) || x == exc.class.name }
-          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
+    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
 
-      def from_message(message, options = {})
-        configuration = options[:configuration] || Raven.configuration
-        new(options) do |evt|
-          evt.configuration = configuration
-          evt.message = message
-          evt.level = options[:level] || :error
-          evt.interface :message do |int|
-            int.message = message
-          end
-          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 message
+      @interfaces[:logentry]&.unformatted_message
+    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
+    def message=(args)
+      if args.is_a?(Array)
+        message, params = args[0], args[0..-1]
+      else
+        message = args
       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
-            if context.include?(exc.object_id)
-              break
-            end
-            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
+      unless message.is_a?(String)
+        configuration.logger.debug("You're passing a non-string message")
+        message = message.to_s
       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)
+      interface(:message) do |int|
+        int.message = message.byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES) # Messages limited to 10kb
+        int.params = params
       end
+    end
 
-      # Because linecache can go to hell
-      def _source_lines(_path, _from, _to)
-      end
+    def timestamp=(time)
+      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : 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 time_spent=(time)
+      @time_spent = time.is_a?(Float) ? (time * 1000).to_i : time
+    end
+
+    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 = Raven.find_interface(name)
-      raise Error.new("Unknown interface: #{name}") unless int
-      @interfaces[int.name] = int.new(value, &block) if value || block
-      @interfaces[int.name]
+      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
 
     def [](key)
@@ -206,62 +133,123 @@ module Raven
     end
 
     def to_hash
-      data = {
-        :event_id => @id,
-        :message => @message,
-        :timestamp => @timestamp,
-        :time_spent => @time_spent,
-        :level => @level,
-        :project => @project,
-        :platform => PLATFORM,
-      }
-      data[:logger] = @logger if @logger
-      data[:culprit] = @culprit if @culprit
-      data[:server_name] = @server_name if @server_name
-      data[:release] = @release if @release
-      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] = @checksum if @checksum
+      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?
+
       @interfaces.each_pair do |name, int_data|
         data[name.to_sym] = int_data.to_hash
       end
       data
     end
 
-    def get_file_context(filename, lineno, context)
-      return nil, nil, nil unless Raven::LineCache.is_valid_file(filename)
-      lines = Array.new(2 * context + 1) do |i|
-        Raven::LineCache.getline(filename, lineno - context + i)
+    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 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
-      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
     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 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
     class << self
-      alias :captureException :from_exception
-      alias :captureMessage :from_message
-      alias :capture_exception :from_exception
-      alias :capture_message :from_message
+      alias captureException from_exception
+      alias captureMessage from_message
+      alias capture_exception from_exception
+      alias capture_message from_message
     end
 
     private
 
-    def generate_event_id
-      # generate a uuid. copy-pasted from SecureRandom, this method is not
-      # available in <1.9.
-      ary = SecureRandom.random_bytes(16).unpack("NnnnnN")
-      ary[2] = (ary[2] & 0x0fff) | 0x4000
-      ary[3] = (ary[3] & 0x3fff) | 0x8000
-      uuid = "%08x-%04x-%04x-%04x-%04x%08x" % ary
-      ::Digest::MD5.hexdigest(uuid)
+    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
+      Utils::RealIp.new(
+        :remote_addr => context.rack_env["REMOTE_ADDR"],
+        :client_ip => context.rack_env["HTTP_CLIENT_IP"],
+        :real_ip => context.rack_env["HTTP_X_REAL_IP"],
+        :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