sentry-raven 2.1.3 → 3.1.2

data/lib/raven/instance.rb

@@ -19,16 +19,15 @@ module Raven
   #     end
   #   end
   class Instance
-    # The client object is responsible for delivering formatted data to the
-    # Sentry server. Must respond to #send. See Raven::Client.
+    # See Raven::Client.
     attr_writer :client
 
-    # A Raven configuration object. Must act like a hash and return sensible
-    # values for all Raven configuration options. See Raven::Configuration.
-    attr_writer :configuration
+    # See Raven::Configuration.
+    attr_accessor :configuration
 
-    def initialize(context = nil)
+    def initialize(context = nil, config = nil)
       @context = @explicit_context = context
+      self.configuration = config || Configuration.new
     end
 
     def context
@@ -40,13 +39,7 @@ module Raven
     end
 
     def logger
-      @logger ||= Logger.new
-    end
-
-    # The configuration object.
-    # @see Raven.configure
-    def configuration
-      @configuration ||= Configuration.new
+      configuration.logger
     end
 
     # The client object is responsible for delivering formatted data to the
@@ -57,11 +50,13 @@ 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
-        logger.info "Raven #{VERSION} configured not to capture errors."
+        logger.info "Raven #{VERSION} configured not to capture errors: #{configuration.error_messages}"
       end
     end
 
@@ -82,10 +77,10 @@ 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)
-      client.send_event(event)
+    def send_event(event, hint = nil)
+      client.send_event(event, hint)
     end
 
     # Capture and process any exceptions from the given block.
@@ -111,30 +106,38 @@ module Raven
 
     def capture_type(obj, options = {})
       unless configuration.capture_allowed?(obj)
-        Raven.logger.debug("#{obj} excluded from capture due to environment or should_capture callback")
+        logger.debug("#{obj} excluded from capture: #{configuration.error_messages}")
         return false
       end
 
       message_or_exc = obj.is_a?(String) ? "message" : "exception"
-      if (evt = Event.send("from_" + message_or_exc, obj, options))
+      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?
           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
-            Raven.logger.error("async event sending failed: #{ex.message}")
-            send_event(evt)
+          rescue => e
+            logger.error("async event sending failed: #{e.message}")
+            send_event(evt, make_hint(obj))
           end
         else
-          send_event(evt)
+          send_event(evt, make_hint(obj))
         end
         Thread.current["sentry_#{object_id}_last_event_id".to_sym] = evt.id
         evt
       end
     end
 
+    alias capture_message capture_type
+    alias capture_exception capture_type
+
     def last_event_id
       Thread.current["sentry_#{object_id}_last_event_id".to_sym]
     end
@@ -160,7 +163,7 @@ module Raven
     #   end
     def annotate_exception(exc, options = {})
       notes = (exc.instance_variable_defined?(:@__raven_context) && exc.instance_variable_get(:@__raven_context)) || {}
-      notes.merge!(options)
+      Raven::Utils::DeepMergeHash.deep_merge!(notes, options)
       exc.instance_variable_set(:@__raven_context, notes)
       exc
     end
@@ -173,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).
@@ -185,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).
@@ -196,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)
@@ -219,5 +241,9 @@ module Raven
         end
       end
     end
+
+    def make_hint(obj)
+      obj.is_a?(String) ? { :exception => nil, :message => obj } : { :exception => obj, :message => nil }
+    end
   end
 end

data/lib/raven/integrations/delayed_job.rb

@@ -1,4 +1,5 @@
 require 'delayed_job'
+require 'raven/utils/context_filter'
 
 module Delayed
   module Plugins
@@ -8,40 +9,39 @@ module Delayed
           begin
             # Forward the call to the next callback in the callback chain
             block.call(job, *args)
-
-          rescue Exception => exception
+          rescue Exception => e
             # Log error to Sentry
             extra = {
               :delayed_job => {
-                :id          => job.id,
-                :priority    => job.priority,
-                :attempts    => job.attempts,
-                :run_at      => job.run_at,
-                :locked_at   => job.locked_at,
-                :locked_by   => job.locked_by,
-                :queue       => job.queue,
-                :created_at  => job.created_at
+                :id => job.id.to_s,
+                :priority => job.priority,
+                :attempts => job.attempts,
+                :run_at => job.run_at,
+                :locked_at => job.locked_at,
+                :locked_by => job.locked_by,
+                :queue => job.queue,
+                :created_at => job.created_at
               }
             }
             # last_error can be nil
-            extra[:last_error] = job.last_error[0...100] if job.last_error
+            extra[:last_error] = job.last_error[0...1000] if job.last_error
             # handlers are YAML objects in strings, we definitely can't
             # report all of that or the event will get truncated randomly
-            extra[:handler] = job.handler[0...100] if job.handler
+            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] = ::Raven::Utils::ContextFilter.filter_context(job.payload_object.job_data)
             end
-            ::Raven.capture_exception(exception,
-                                      :logger  => 'delayed_job',
-                                      :tags    => {
+            ::Raven.capture_exception(e,
+                                      :logger => 'delayed_job',
+                                      :tags => {
                                         :delayed_job_queue => job.queue,
-                                        :delayed_job_id => job.id
+                                        :delayed_job_id => job.id.to_s
                                       },
                                       :extra => extra)
 
             # Make sure we propagate the failure!
-            raise exception
+            raise e
           ensure
             ::Raven::Context.clear!
             ::Raven::BreadcrumbBuffer.clear!

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

@@ -1,6 +1,5 @@
-# rubocop:disable Style/FileName
 # We need to do this because of the way integration loading works
-require "rack/timeout/base"
+require "rack/timeout/base" unless defined?(Rack::Timeout)
 
 # This integration is a good example of how to change how exceptions
 # get grouped by Sentry's UI. Simply override #raven_context in
@@ -8,9 +7,16 @@ require "rack/timeout/base"
 # that will distinguish exceptions in the way you desire.
 module RackTimeoutExtensions
   def raven_context
-    { :fingerprint => ["{{ default }}", env["REQUEST_URI"]] }
+    # 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.
+    if defined?(env)
+      { :fingerprint => ["{{ default }}", env["REQUEST_URI"]] }
+    else
+      {}
+    end
   end
 end
 
-Rack::Timeout::Error.include RackTimeoutExtensions
-Rack::Timeout::RequestTimeoutException.include RackTimeoutExtensions
+Rack::Timeout::Error.include(RackTimeoutExtensions)
+Rack::Timeout::RequestTimeoutException.include(RackTimeoutExtensions)

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)
@@ -73,47 +74,63 @@ module Raven
       self.method = req.request_method
       self.query_string = req.query_string
       self.data = read_data_from(req)
+      self.cookies = req.cookies
 
       self.headers = format_headers_for_sentry(env_hash)
-      self.env = format_env_for_sentry(env_hash)
+      self.env     = format_env_for_sentry(env_hash)
     end
 
     private
 
+    # See Sentry server default limits at
+    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     def read_data_from(request)
       if request.form_data?
         request.POST
       elsif request.body # JSON requests, etc
-        data = request.body.read(2048) # Sentry server limit
+        data = request.body.read(4096 * 4) # Sentry server limit
         request.body.rewind
         data
       end
+    rescue IOError => e
+      e.message
     end
 
     def format_headers_for_sentry(env_hash)
       env_hash.each_with_object({}) do |(key, value), memo|
-        key = key.to_s # rack env can contain symbols
-        value = value.to_s
-        next unless key.upcase == key # Non-upper case stuff isn't either
-
-        # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
-        # to think this is a Version header. Instead, this is mapped to
-        # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
-        # if the request has legitimately sent a Version header themselves.
-        # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
-        next if key == 'HTTP_VERSION' && value == ENV['SERVER_PROTOCOL']
-
-        next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(key)
-        # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
-        key = key.gsub("HTTP_", "")
-        key = key.split('_').map(&:capitalize).join('-')
-        memo[key] = value
+        begin
+          key = key.to_s # rack env can contain symbols
+          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env_hash) if Utils::RequestId::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
+          # to think this is a Version header. Instead, this is mapped to
+          # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
+          # if the request has legitimately sent a Version header themselves.
+          # 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
+          key = key.sub(/^HTTP_/, "")
+          key = key.split('_').map(&:capitalize).join('-')
+          memo[key] = value.to_s
+        rescue StandardError => e
+          # Rails adds objects to the Rack env that can sometimes raise exceptions
+          # when `to_s` is called.
+          # See: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb#L134
+          Raven.logger.warn("Error raised while formatting headers: #{e.message}")
+          next
+        end
       end
     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

data/lib/raven/integrations/rails/active_job.rb

@@ -1,31 +1,63 @@
 module Raven
   class Rails
-    module ActiveJob
+    module ActiveJobExtensions
+      ALREADY_SUPPORTED_SENTRY_ADAPTERS = %w(
+        ActiveJob::QueueAdapters::SidekiqAdapter
+        ActiveJob::QueueAdapters::DelayedJobAdapter
+      ).freeze
+
       def self.included(base)
         base.class_eval do
-          rescue_from(Exception) do |exception|
-            # Do not capture exceptions when using Sidekiq so we don't capture
-            # The same exception twice.
-            unless self.class.queue_adapter.to_s == 'ActiveJob::QueueAdapters::SidekiqAdapter'
-              active_job_details = {
-                :active_job => self.class.name,
-                :arguments => arguments,
-                :scheduled_at => scheduled_at,
-                :job_id => job_id,
-                :locale => locale
-              }
-
-              # Add provider_job_id details if Rails 5
-              if defined?(provider_job_id)
-                active_job_details[:provider_job_id] = provider_job_id
-              end
-
-              Raven.capture_exception(exception, :extra => active_job_details)
-              raise exception
+          around_perform do |job, block|
+            if already_supported_by_specific_integration?(job)
+              block.call
+            else
+              capture_and_reraise_with_sentry(job, block)
             end
           end
         end
       end
+
+      def capture_and_reraise_with_sentry(job, block)
+        block.call
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        rescue_handler_result = rescue_with_handler(e)
+        return rescue_handler_result if rescue_handler_result
+
+        Raven.capture_exception(e, :extra => raven_context(job))
+        raise e
+      ensure
+        Context.clear!
+        BreadcrumbBuffer.clear!
+      end
+
+      def already_supported_by_specific_integration?(job)
+        if ::Rails.version.to_f < 5.0
+          ALREADY_SUPPORTED_SENTRY_ADAPTERS.include?(job.class.queue_adapter.to_s)
+        else
+          ALREADY_SUPPORTED_SENTRY_ADAPTERS.include?(job.class.queue_adapter.class.to_s)
+        end
+      end
+
+      def raven_context(job)
+        ctx = {
+          :active_job => job.class.name,
+          :arguments => job.arguments,
+          :scheduled_at => job.scheduled_at,
+          :job_id => job.job_id,
+          :locale => job.locale
+        }
+        # Add provider_job_id details if Rails 5
+        if job.respond_to?(:provider_job_id)
+          ctx[:provider_job_id] = job.provider_job_id
+        end
+
+        ctx
+      end
     end
   end
 end
+
+class ActiveJob::Base
+  include Raven::Rails::ActiveJobExtensions
+end

data/lib/raven/integrations/rails/backtrace_cleaner.rb

@@ -0,0 +1,29 @@
+require "active_support/backtrace_cleaner"
+require "active_support/core_ext/string/access"
+
+module Raven
+  class Rails
+    class BacktraceCleaner < ActiveSupport::BacktraceCleaner
+      APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/.freeze
+      RENDER_TEMPLATE_PATTERN = /:in `.*_\w+_{2,3}\d+_\d+'/.freeze
+
+      def initialize
+        super
+        # we don't want any default silencers because they're too aggressive
+        remove_silencers!
+
+        @root = "#{Raven.configuration.project_root}/"
+        add_filter do |line|
+          line.start_with?(@root) ? line.from(@root.size) : line
+        end
+        add_filter do |line|
+          if line =~ RENDER_TEMPLATE_PATTERN
+            line.sub(RENDER_TEMPLATE_PATTERN, "")
+          else
+            line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/raven/integrations/rails/controller_transaction.rb

@@ -0,0 +1,13 @@
+module Raven
+  class Rails
+    module ControllerTransaction
+      def self.included(base)
+        base.prepend_around_action do |controller, block|
+          Raven.context.transaction.push "#{controller.class}##{controller.action_name}"
+          block.call
+          Raven.context.transaction.pop
+        end
+      end
+    end
+  end
+end

data/lib/raven/integrations/rails/overrides/debug_exceptions_catcher.rb

@@ -6,7 +6,7 @@ module Raven
           begin
             env = env_or_request.respond_to?(:env) ? env_or_request.env : env_or_request
             Raven::Rack.capture_exception(exception, env)
-          rescue # rubocop:disable Lint/HandleExceptions
+          rescue
           end
           super
         end
@@ -21,7 +21,7 @@ module Raven
           begin
             env = env_or_request.respond_to?(:env) ? env_or_request.env : env_or_request
             Raven::Rack.capture_exception(exception, env)
-          rescue # rubocop:disable Lint/HandleExceptions
+          rescue
           end
           render_exception_without_raven(env_or_request, exception)
         end

data/lib/raven/integrations/rails.rb

@@ -4,6 +4,9 @@ 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'
+    require 'raven/integrations/rails/backtrace_cleaner'
+    require 'raven/integrations/rack'
 
     initializer "raven.use_rack_middleware" do |app|
       app.config.middleware.insert 0, Raven::Rack
@@ -12,6 +15,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",
@@ -32,16 +36,22 @@ module Raven
       end
     end
 
-    config.after_initialize do
-      Raven.configure do |config|
-        config.logger ||= ::Rails.logger
-        config.project_root ||= ::Rails.root
-        config.release ||= config.detect_release # if project_root has changed, need to re-check
+    config.before_initialize do
+      Raven.configuration.logger = ::Rails.logger
+
+      backtrace_cleaner = Raven::Rails::BacktraceCleaner.new
+
+      Raven.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+        backtrace_cleaner.clean(backtrace)
       end
+    end
 
-      if Raven.configuration.rails_activesupport_breadcrumbs
-        require 'raven/breadcrumbs/activesupport'
-        Raven::ActiveSupportBreadcrumbs.inject
+    config.after_initialize do
+      if Raven.configuration.breadcrumbs_logger.include?(:active_support_logger) ||
+         Raven.configuration.rails_activesupport_breadcrumbs
+
+        require 'raven/breadcrumbs/active_support_logger'
+        Raven::Breadcrumbs::ActiveSupportLogger.inject
       end
 
       if Raven.configuration.rails_report_rescued_exceptions
@@ -60,6 +70,12 @@ module Raven
       end
     end
 
+    initializer 'raven.active_job' do
+      ActiveSupport.on_load :active_job do
+        require 'raven/integrations/rails/active_job'
+      end
+    end
+
     rake_tasks do
       require 'raven/integrations/tasks'
     end

data/lib/raven/integrations/rake.rb

@@ -6,7 +6,12 @@ module Rake
   class Application
     alias orig_display_error_messsage display_error_message
     def display_error_message(ex)
-      Raven.capture_exception ex, :logger => 'rake', :tags => { 'rake_task' => @name }
+      Raven.capture_exception(
+        ex,
+        :transaction => top_level_tasks.join(' '),
+        :logger => 'rake',
+        :tags => { 'rake_task' => top_level_tasks.join(' ') }
+      )
       orig_display_error_messsage(ex)
     end
   end

data/lib/raven/integrations/sidekiq/cleanup_middleware.rb

@@ -0,0 +1,13 @@
+module Raven
+  module Sidekiq
+    class CleanupMiddleware
+      def call(_worker, job, queue)
+        Raven.context.transaction.push "Sidekiq/#{job['class']}"
+        Raven.extra_context(:sidekiq => job.merge("queue" => queue))
+        yield
+        Context.clear!
+        BreadcrumbBuffer.clear!
+      end
+    end
+  end
+end

data/lib/raven/integrations/sidekiq/error_handler.rb

@@ -0,0 +1,38 @@
+require 'raven/utils/context_filter'
+
+module Raven
+  module Sidekiq
+    class ErrorHandler
+      SIDEKIQ_NAME = "Sidekiq".freeze
+
+      def call(ex, context)
+        context = Utils::ContextFilter.filter_context(context)
+        Raven.context.transaction.push transaction_from_context(context)
+        Raven.capture_exception(
+          ex,
+          :message => ex.message,
+          :extra => { :sidekiq => context }
+        )
+        Context.clear!
+        BreadcrumbBuffer.clear!
+      end
+
+      private
+
+      # this will change in the future:
+      # https://github.com/mperham/sidekiq/pull/3161
+      def transaction_from_context(context)
+        classname = (context["wrapped"] || context["class"] ||
+                      (context[:job] && (context[:job]["wrapped"] || context[:job]["class"]))
+                    )
+        if classname
+          "#{SIDEKIQ_NAME}/#{classname}"
+        elsif context[:event]
+          "#{SIDEKIQ_NAME}/#{context[:event]}"
+        else
+          SIDEKIQ_NAME
+        end
+      end
+    end
+  end
+end