sentry-raven 2.6.3 → 2.7.1

data/lib/raven/context.rb

@@ -10,7 +10,7 @@ module Raven
       Thread.current[:sentry_context] = nil
     end
 
-    attr_accessor :extra, :server_os, :rack_env, :runtime, :tags, :user
+    attr_accessor :transaction, :extra, :server_os, :rack_env, :runtime, :tags, :user
 
     def initialize
       self.server_os = self.class.os_context
@@ -19,6 +19,7 @@ module Raven
       self.rack_env = nil
       self.tags = {}
       self.user = {}
+      self.transaction = []
     end
 
     class << self

data/lib/raven/event.rb

@@ -1,227 +1,117 @@
 # 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 `(.+?)')?$/
     # 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
 
-    PLATFORM = "ruby".freeze
     SDK = { "name" => "raven-ruby", "version" => Raven::VERSION }.freeze
 
     attr_accessor :id, :timestamp, :time_spent, :level, :logger,
-                  :culprit, :server_name, :release, :modules, :extra, :tags,
+                  :transaction, :server_name, :release, :modules, :extra, :tags,
                   :context, :configuration, :checksum, :fingerprint, :environment,
-                  :server_os, :runtime, :breadcrumbs, :user, :backtrace, :linecache
+                  :server_os, :runtime, :breadcrumbs, :user, :backtrace, :platform,
+                  :sdk
+    alias event_id id
 
     def initialize(init = {})
-      @configuration = init[:configuration] || Raven.configuration
-      @interfaces    = {}
-      @breadcrumbs   = init[:breadcrumbs] || Raven.breadcrumbs
-      @context       = init[:context] || Raven.context
-      @linecache     = @configuration.linecache
-      @id            = SecureRandom.uuid.delete("-")
-      @timestamp     = Time.now.utc
-      @time_spent    = nil
-      @level         = :error
-      @logger        = 'ruby'
-      @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
+      self.configuration = Raven.configuration
+      self.breadcrumbs   = Raven.breadcrumbs
+      self.context       = Raven.context
+      self.id            = SecureRandom.uuid.delete("-")
+      self.timestamp     = Time.now.utc
+      self.level         = :error
+      self.logger        = :ruby
+      self.platform      = :ruby
+      self.sdk           = SDK
+      @interfaces        = {}
+      self.user          = {} # TODO: contexts
+      self.extra         = {} # TODO: contexts
+      self.server_os     = {} # TODO: contexts
+      self.runtime       = {} # TODO: contexts
+      self.tags          = {} # TODO: contexts
 
       yield self if block_given?
 
-      if !self[:http] && @context.rack_env
+      init.each_pair { |key, val| public_send("#{key}=", val) }
+
+      self.transaction ||= context.transaction.last
+      self.server_name ||= configuration.server_name
+      self.release     ||= configuration.release
+      self.modules       = list_gem_specs if configuration.send_modules
+      self.environment ||= configuration.current_environment
+
+      if !self[:http] && context.rack_env
         interface :http do |int|
-          int.from_rack(@context.rack_env)
+          int.from_rack(context.rack_env)
         end
-      end
 
-      if @context.rack_env # TODO: contexts
-        @context.user[:ip_address] = calculate_real_ip_from_rack
+        context.user[:ip_address] = calculate_real_ip_from_rack
       end
 
-      init.each_pair { |key, val| public_send(key.to_s + "=", val) }
-
-      @user = @context.user.merge(@user) # TODO: contexts
-      @extra = @context.extra.merge(@extra) # TODO: contexts
-      @tags = @configuration.tags.merge(@context.tags).merge(@tags) # TODO: contexts
-
-      # 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)
+      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 message
-      @interfaces[:logentry] && @interfaces[:logentry].unformatted_message
-    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)
 
-    def message=(args)
-      message, params = *args
-      interface(:message) do |int|
-        int.message = message
-        int.params = params
-      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
-          configuration.logger.debug "Refusing to capture Raven error: #{exc.inspect}"
-          return nil
-        end
-        if configuration[:excluded_exceptions].any? { |x| get_exception_class(x) === exc }
-          configuration.logger.debug "User excluded error: #{exc.inspect}"
-          return nil
-        end
+      configuration = options[:configuration] || Raven.configuration
+      return unless configuration.exception_class_allowed?(exc)
 
-        new(options) do |evt|
-          evt.configuration = configuration
-          evt.message = "#{exc.class}: #{exc.message}".byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES) # Messages limited to 10kb
-          evt.level = options[:level] || :error
+      new(options) do |evt|
+        evt.message = "#{exc.class}: #{exc.message}"
 
-          add_exception_interface(evt, exc)
+        evt.add_exception_interface(exc)
 
-          yield evt if block
-        end
+        yield evt if block
       end
+    end
 
-      def from_message(message, options = {})
-        message = message.byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES)
-        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?)
-
-        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
-      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
-      end
+    def message
+      @interfaces[:logentry] && @interfaces[:logentry].unformatted_message
+    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
+    def message=(args)
+      message, params = *args
+      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
+    def timestamp=(time)
+      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
+    end
 
-        evt.culprit = evt.get_culprit(int.frames)
-      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 == "warn" || new_level == :warn ? :warning : new_level
     end
 
     def interface(name, value = nil, &block)
@@ -240,47 +130,63 @@ module Raven
     end
 
     def to_hash
-      data = {
-        :event_id => @id,
-        :timestamp => @timestamp,
-        :time_spent => @time_spent,
-        :level => @level,
-        :platform => PLATFORM,
-        :sdk => SDK
-      }
-
-      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)
-      linecache.get_file_context(filename, lineno, context)
+    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 = exception_chain_to_array(exc)
+        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
-      cleaned_hash = async_json_processors.reduce(to_hash) { |a, e| e.process(a) }
-      JSON.parse(JSON.generate(cleaned_hash))
+    def stacktrace_interface_from(backtrace)
+      Backtrace.parse(backtrace).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
@@ -310,5 +216,24 @@ module Raven
         Raven::Processor::UTF8Conversion
       ].map { |v| v.new(self) }
     end
+
+    def exception_chain_to_array(exc)
+      if exc.respond_to?(:cause) && exc.cause
+        exceptions = [exc]
+        while exc.cause
+          exc = exc.cause
+          break if exceptions.any? { |e| e.object_id == exc.object_id }
+          exceptions << exc
+        end
+        exceptions.reverse!
+      else
+        [exc]
+      end
+    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/integrations/rack.rb

@@ -45,6 +45,7 @@ module Raven
       # callers
       env['raven.requested_at'] = Time.now
       Raven.rack_context(env)
+      Raven.context.transaction.push(env["PATH_INFO"]) if env["PATH_INFO"]
 
       begin
         response = @app.call(env)

data/lib/raven/integrations/rails.rb

@@ -4,6 +4,7 @@ module Raven
   class Rails < ::Rails::Railtie
     require 'raven/integrations/rails/overrides/streaming_reporter'
     require 'raven/integrations/rails/controller_methods'
+    require 'raven/integrations/rails/controller_transaction'
 
     initializer "raven.use_rack_middleware" do |app|
       app.config.middleware.insert 0, Raven::Rack
@@ -12,6 +13,7 @@ module Raven
     initializer 'raven.action_controller' do
       ActiveSupport.on_load :action_controller do
         include Raven::Rails::ControllerMethods
+        include Raven::Rails::ControllerTransaction
         if ::Rails::VERSION::STRING >= "4.0.0"
           Raven.safely_prepend(
             "StreamingReporter",