sentry-raven 1.1.0 → 3.1.2

data/lib/raven/instance.rb

@@ -0,0 +1,249 @@
+module Raven
+  # A copy of Raven's base module class methods, minus some of the integration
+  # and global hooks since it's meant to be used explicitly. Useful for
+  # sending errors to multiple sentry projects in a large application.
+  #
+  # @example
+  #   class Foo
+  #     def initialize
+  #       @other_raven = Raven::Instance.new
+  #       @other_raven.configure do |config|
+  #         config.server = 'http://...'
+  #       end
+  #     end
+  #
+  #     def foo
+  #       # ...
+  #     rescue => e
+  #       @other_raven.capture_exception(e)
+  #     end
+  #   end
+  class Instance
+    # See Raven::Client.
+    attr_writer :client
+
+    # See Raven::Configuration.
+    attr_accessor :configuration
+
+    def initialize(context = nil, config = nil)
+      @context = @explicit_context = context
+      self.configuration = config || Configuration.new
+    end
+
+    def context
+      if @explicit_context
+        @context ||= Context.new
+      else
+        Context.current
+      end
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    # The client object is responsible for delivering formatted data to the
+    # Sentry server.
+    def client
+      @client ||= Client.new(configuration)
+    end
+
+    # 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: #{configuration.error_messages}"
+      end
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Raven.configure do |config|
+    #     config.server = 'http://...'
+    #   end
+    def configure
+      yield(configuration) if block_given?
+
+      self.client = Client.new(configuration)
+      report_status
+      client
+    end
+
+    # Send an event to the configured Sentry server
+    #
+    # @example
+    #   evt = Raven::Event.new(:message => "An errore)
+    #   Raven.send_event(evt)
+    def send_event(event, hint = nil)
+      client.send_event(event, hint)
+    end
+
+    # Capture and process any exceptions from the given block.
+    #
+    # @example
+    #   Raven.capture do
+    #     MyApp.run
+    #   end
+    def capture(options = {})
+      if block_given?
+        begin
+          yield
+        rescue Error
+          raise # Don't capture Raven errors
+        rescue Exception => e
+          capture_type(e, options)
+          raise
+        end
+      else
+        install_at_exit_hook(options)
+      end
+    end
+
+    def capture_type(obj, options = {})
+      unless configuration.capture_allowed?(obj)
+        logger.debug("#{obj} excluded from capture: #{configuration.error_messages}")
+        return false
+      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?
+          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 => e
+            logger.error("async event sending failed: #{e.message}")
+            send_event(evt, make_hint(obj))
+          end
+        else
+          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
+
+    # Provides extra context to the exception prior to it being handled by
+    # Raven. An exception can have multiple annotations, which are merged
+    # together.
+    #
+    # The options (annotation) is treated the same as the ``options``
+    # parameter to ``capture_exception`` or ``Event.from_exception``, and
+    # can contain the same ``:user``, ``:tags``, etc. options as these
+    # methods.
+    #
+    # These will be merged with the ``options`` parameter to
+    # ``Event.from_exception`` at the top of execution.
+    #
+    # @example
+    #   begin
+    #     raise "Hello"
+    #   rescue => exc
+    #     Raven.annotate_exception(exc, :user => { 'id' => 1,
+    #                              'email' => 'foo@example.com' })
+    #   end
+    def annotate_exception(exc, options = {})
+      notes = (exc.instance_variable_defined?(:@__raven_context) && exc.instance_variable_get(:@__raven_context)) || {}
+      Raven::Utils::DeepMergeHash.deep_merge!(notes, options)
+      exc.instance_variable_set(:@__raven_context, notes)
+      exc
+    end
+
+    # Bind user context. Merges with existing context (if any).
+    #
+    # It is recommending that you send at least the ``id`` and ``email``
+    # values. All other values are arbitrary.
+    #
+    # @example
+    #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
+    def user_context(options = nil)
+      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).
+    #
+    # Tags are key / value pairs which generally represent things like
+    # application version, environment, role, and server names.
+    #
+    # @example
+    #   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).
+    #
+    # Extra context shows up as Additional Data within Sentry, and is
+    # completely arbitrary.
+    #
+    # @example
+    #   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)
+      env = nil if env.empty?
+
+      context.rack_env = env
+    end
+
+    def breadcrumbs
+      BreadcrumbBuffer.current
+    end
+
+    private
+
+    def install_at_exit_hook(options)
+      at_exit do
+        exception = $ERROR_INFO
+        if exception
+          logger.debug "Caught a post-mortem exception: #{exception.inspect}"
+          capture_type(exception, options)
+        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,45 +9,46 @@ 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    => {
-                 :delayed_job_queue => job.queue,
-                 :delayed_job_id => job.id
-              },
-              :extra => extra)
+            ::Raven.capture_exception(e,
+                                      :logger => 'delayed_job',
+                                      :tags => {
+                                        :delayed_job_queue => job.queue,
+                                        :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!
           end
         end
       end
     end
-
   end
 end
 

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

@@ -0,0 +1,22 @@
+# We need to do this because of the way integration loading works
+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
+# the exception class, and append something to the fingerprint
+# that will distinguish exceptions in the way you desire.
+module RackTimeoutExtensions
+  def raven_context
+    # 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)

data/lib/raven/integrations/rack.rb

@@ -41,20 +41,17 @@ module Raven
     end
 
     def call(env)
-      # clear context at the beginning of the request to ensure a clean slate
-      Context.clear!
-
       # store the current environment in our local context for arbitrary
       # 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)
       rescue Error
         raise # Don't capture Raven errors
       rescue Exception => e
-        Raven.logger.debug "Collecting %p: %s" % [ e.class, e.message ]
         Raven::Rack.capture_exception(e, env)
         raise
       end
@@ -63,6 +60,9 @@ module Raven
       Raven::Rack.capture_exception(error, env) if error
 
       response
+    ensure
+      Context.clear!
+      BreadcrumbBuffer.clear!
     end
   end
 
@@ -74,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
-        data = request.body.read
+      elsif request.body # JSON requests, etc
+        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