alec-gem 2.7.2

data/lib/raven/integrations/delayed_job.rb

@@ -0,0 +1,58 @@
+require 'delayed_job'
+
+module Delayed
+  module Plugins
+    class Raven < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          begin
+            # Forward the call to the next callback in the callback chain
+            block.call(job, *args)
+
+          rescue Exception => exception
+            # 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
+              }
+            }
+            # last_error can be nil
+            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...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
+            end
+            ::Raven.capture_exception(exception,
+                                      :logger  => 'delayed_job',
+                                      :tags    => {
+                                        :delayed_job_queue => job.queue,
+                                        :delayed_job_id => job.id
+                                      },
+                                      :extra => extra)
+
+            # Make sure we propagate the failure!
+            raise exception
+          ensure
+            ::Raven::Context.clear!
+            ::Raven::BreadcrumbBuffer.clear!
+          end
+        end
+      end
+    end
+  end
+end
+
+##
+# Register DelayedJob Raven plugin
+#
+Delayed::Worker.plugins << Delayed::Plugins::Raven

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

@@ -0,0 +1,19 @@
+# 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.
+    { :fingerprint => ["{{ default }}", env["REQUEST_URI"]] } if defined?(env)
+  end
+end
+
+# Include is private in Ruby 1.9
+Rack::Timeout::Error.__send__(:include, RackTimeoutExtensions)
+Rack::Timeout::RequestTimeoutException.__send__(:include, RackTimeoutExtensions)

data/lib/raven/integrations/rack.rb

@@ -0,0 +1,139 @@
+require 'time'
+require 'rack'
+
+module Raven
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Sentry and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'raven'
+  #
+  #   Raven.configure do |config|
+  #     config.server = 'http://my_dsn'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     use Raven::Rack
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  # Use a standard Raven.configure call to configure your server credentials.
+  class Rack
+    def self.capture_type(exception, env, options = {})
+      if env['raven.requested_at']
+        options[:time_spent] = Time.now - env['raven.requested_at']
+      end
+      Raven.capture_type(exception, options) do |evt|
+        evt.interface :http do |int|
+          int.from_rack(env)
+        end
+      end
+    end
+    class << self
+      alias capture_message capture_type
+      alias capture_exception capture_type
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # 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::Rack.capture_exception(e, env)
+        raise
+      end
+
+      error = env['rack.exception'] || env['sinatra.error']
+      Raven::Rack.capture_exception(error, env) if error
+
+      response
+    ensure
+      Context.clear!
+      BreadcrumbBuffer.clear!
+    end
+  end
+
+  module RackInterface
+    def from_rack(env_hash)
+      req = ::Rack::Request.new(env_hash)
+
+      self.url = req.scheme && req.url.split('?').first
+      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)
+    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(4096 * 4) # Sentry server limit
+        request.body.rewind
+        data
+      end
+    rescue IOError => ex
+      ex.message
+    end
+
+    def format_headers_for_sentry(env_hash)
+      env_hash.each_with_object({}) do |(key, value), memo|
+        begin
+          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_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.gsub("HTTP_", "")
+          key = key.split('_').map(&:capitalize).join('-')
+          memo[key] = value
+        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)
+      env_hash.select do |k, _v|
+        %w(REMOTE_ADDR SERVER_NAME SERVER_PORT).include? k.to_s
+      end
+    end
+  end
+
+  class HttpInterface
+    include RackInterface
+  end
+end

data/lib/raven/integrations/rails.rb

@@ -0,0 +1,79 @@
+require 'rails'
+
+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
+    end
+
+    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",
+            :from => Raven::Rails::Overrides,
+            :to => ActionController::Live
+          )
+        end
+      end
+    end
+
+    initializer 'raven.action_view' do
+      ActiveSupport.on_load :action_view do
+        Raven.safely_prepend(
+          "StreamingReporter",
+          :from => Raven::Rails::Overrides,
+          :to => ActionView::StreamingTemplateRenderer::Body
+        )
+      end
+    end
+
+    config.before_initialize do
+      Raven.configuration.logger = ::Rails.logger
+    end
+
+    config.after_initialize do
+      if Raven.configuration.rails_activesupport_breadcrumbs
+        require 'raven/breadcrumbs/activesupport'
+        Raven::ActiveSupportBreadcrumbs.inject
+      end
+
+      if Raven.configuration.rails_report_rescued_exceptions
+        require 'raven/integrations/rails/overrides/debug_exceptions_catcher'
+        if defined?(::ActionDispatch::DebugExceptions)
+          exceptions_class = ::ActionDispatch::DebugExceptions
+        elsif defined?(::ActionDispatch::ShowExceptions)
+          exceptions_class = ::ActionDispatch::ShowExceptions
+        end
+
+        Raven.safely_prepend(
+          "DebugExceptionsCatcher",
+          :from => Raven::Rails::Overrides,
+          :to => exceptions_class
+        )
+      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
+
+    if defined?(runner)
+      runner do
+        Raven.capture
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Raven
+  class Rails
+    module ActiveJobExtensions
+      ALREADY_SUPPORTED_SENTRY_ADAPTERS = %w(
+        ActiveJob::QueueAdapters::SidekiqAdapter
+        ActiveJob::QueueAdapters::DelayedJobAdapter
+      ).freeze
+
+      def self.included(base)
+        base.class_eval do
+          around_perform do |job, block|
+            capture_and_reraise_with_sentry(job, block)
+          end
+        end
+      end
+
+      def capture_and_reraise_with_sentry(job, block)
+        block.call
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        return if rescue_with_handler(exception)
+        unless already_supported_by_specific_integration?(job)
+          Raven.capture_exception(exception, :extra => raven_context(job))
+        end
+        raise exception
+      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/controller_methods.rb

@@ -0,0 +1,13 @@
+module Raven
+  class Rails
+    module ControllerMethods
+      def capture_message(message, options = {})
+        Raven::Rack.capture_message(message, request.env, options)
+      end
+
+      def capture_exception(exception, options = {})
+        Raven::Rack.capture_exception(exception, request.env, options)
+      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.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

@@ -0,0 +1,31 @@
+module Raven
+  class Rails
+    module Overrides
+      module DebugExceptionsCatcher
+        def render_exception(env_or_request, exception)
+          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
+          end
+          super
+        end
+      end
+
+      module OldDebugExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :raven)
+        end
+
+        def render_exception_with_raven(env_or_request, exception)
+          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
+          end
+          render_exception_without_raven(env_or_request, exception)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Raven
+  class Rails
+    module Overrides
+      module StreamingReporter
+        def log_error(exception)
+          Raven.capture_exception(exception)
+          super
+        end
+      end
+
+      module OldStreamingReporter
+        def self.included(base)
+          base.send(:alias_method_chain, :log_error, :raven)
+        end
+
+        def log_error_with_raven(exception)
+          Raven.capture_exception(exception)
+          log_error_without_raven(exception)
+        end
+      end
+    end
+  end
+end

data/lib/raven/integrations/railties.rb

@@ -0,0 +1 @@
+require 'raven/integrations/rails'