exception_hunter 0.1.0 → 0.4.1

data/config/routes.rb

@@ -1,3 +1,21 @@
 ExceptionHunter::Engine.routes.draw do
-  resources :errors, only: %i[index show]
+  resources :errors, only: %i[index show] do
+    delete 'purge', on: :collection, to: 'errors#destroy', as: :purge
+  end
+
+  resources :resolved_errors, only: %i[create]
+
+  get '/', to: redirect('/exception_hunter/errors')
+
+  if ExceptionHunter::Config.auth_enabled?
+    admin_user_class = ExceptionHunter::Config.admin_user_class.underscore.to_sym
+
+    devise_scope admin_user_class do
+      get '/login', to: 'devise/sessions#new', as: :exception_hunter_login
+      post '/login', to: 'devise/sessions#create', as: :exception_hunter_create_session
+      get '/logout', to: 'devise/sessions#destroy', as: :exception_hunter_logout
+    end
+
+    devise_for admin_user_class, only: []
+  end
 end

data/lib/exception_hunter.rb

@@ -1,15 +1,25 @@
+require 'pagy'
+
 require 'exception_hunter/engine'
-require 'exception_hunter/railtie'
+require 'exception_hunter/middleware/request_hunter'
 require 'exception_hunter/config'
+require 'exception_hunter/error_creator'
+require 'exception_hunter/error_reaper'
+require 'exception_hunter/tracking'
 require 'exception_hunter/user_attributes_collector'
-require 'pagy'
 
 module ExceptionHunter
+  autoload :Devise, 'exception_hunter/devise'
+
+  extend ::ExceptionHunter::Tracking
+
   def self.setup(&block)
     block.call(Config)
   end
 
   def self.routes(router)
+    return unless Config.enabled
+
     router.mount(ExceptionHunter::Engine, at: 'exception_hunter')
   end
 end

data/lib/exception_hunter/config.rb

@@ -1,5 +1,12 @@
 module ExceptionHunter
   class Config
-    cattr_accessor :current_user_method, :user_attributes
+    cattr_accessor :admin_user_class,
+                   :current_user_method, :user_attributes
+    cattr_accessor :enabled, default: true
+    cattr_accessor :errors_stale_time, default: 45.days
+
+    def self.auth_enabled?
+      admin_user_class.present? && admin_user_class.try(:underscore)
+    end
   end
 end

data/lib/exception_hunter/devise.rb

@@ -0,0 +1,17 @@
+module ExceptionHunter
+  module Devise
+    class SessionsController < ::Devise::SessionsController
+      skip_before_action :verify_authenticity_token
+
+      layout 'exception_hunter/exception_hunter_logged_out'
+
+      def after_sign_out_path_for(*)
+        '/exception_hunter/login'
+      end
+
+      def after_sign_in_path_for(*)
+        '/exception_hunter'
+      end
+    end
+  end
+end

data/lib/exception_hunter/engine.rb

@@ -12,5 +12,10 @@ module ExceptionHunter
       app.config.assets.precompile << 'exception_hunter/application.css'
       app.config.assets.precompile << 'exception_hunter/logo.png'
     end
+
+    initializer 'exception_hunter.load_middleware', group: :all do
+      require 'exception_hunter/middleware/sidekiq_hunter' if defined?(Sidekiq)
+      require 'exception_hunter/middleware/delayed_job_hunter' if defined?(Delayed)
+    end
   end
 end

data/{app/services → lib}/exception_hunter/error_creator.rb

@@ -1,12 +1,18 @@
 module ExceptionHunter
   class ErrorCreator
+    HTTP_TAG = 'HTTP'.freeze
+    WORKER_TAG = 'Worker'.freeze
+    MANUAL_TAG = 'Manual'.freeze
+
     class << self
-      def call(**error_attrs)
+      def call(tag: nil, **error_attrs)
+        return unless should_create?
+
         ActiveRecord::Base.transaction do
           error_attrs = extract_user_data(error_attrs)
           error = Error.new(error_attrs)
           error_group = ErrorGroup.find_matching_group(error) || ErrorGroup.new
-          update_error_group(error_group, error)
+          update_error_group(error_group, error, tag)
           error.error_group = error_group
           error.save!
           error
@@ -17,9 +23,15 @@ module ExceptionHunter
 
       private
 
-      def update_error_group(error_group, error)
+      def should_create?
+        Config.enabled
+      end
+
+      def update_error_group(error_group, error, tag)
         error_group.error_class_name = error.class_name
         error_group.message = error.message
+        error_group.tags << tag unless tag.nil?
+        error_group.tags.uniq!
 
         error_group.save!
       end

data/lib/exception_hunter/error_reaper.rb

@@ -0,0 +1,12 @@
+module ExceptionHunter
+  class ErrorReaper
+    class << self
+      def purge(stale_time: Config.errors_stale_time)
+        ActiveRecord::Base.transaction do
+          Error.with_occurrences_before(Date.today - stale_time).destroy_all
+          ErrorGroup.without_errors.destroy_all
+        end
+      end
+    end
+  end
+end

data/lib/exception_hunter/middleware/delayed_job_hunter.rb

@@ -0,0 +1,69 @@
+require 'delayed_job'
+
+module ExceptionHunter
+  module Middleware
+    class DelayedJobHunter < ::Delayed::Plugin
+      TRACK_AT_RETRY = [0, 3, 6, 10].freeze
+      JOB_TRACKED_DATA = %w[
+        attempts
+      ].freeze
+      ARGS_TRACKED_DATA = %w[
+        queue_name
+        job_class
+        job_id
+        arguments
+        enqueued_at
+      ].freeze
+
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          block.call(job, *args)
+
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          track_exception(exception, job)
+
+          raise exception
+        end
+      end
+
+      def self.track_exception(exception, job)
+        return unless should_track?(job.attempts)
+
+        ErrorCreator.call(
+          tag: ErrorCreator::WORKER_TAG,
+          class_name: exception.class.to_s,
+          message: exception.message,
+          environment_data: environment_data(job),
+          backtrace: exception.backtrace
+        )
+      end
+
+      def self.environment_data(job)
+        job_data =
+          JOB_TRACKED_DATA.each_with_object({}) do |data_param, dict|
+            dict.merge(data_param => job.try(data_param))
+          end
+
+        job_class = if job.payload_object.class.name == 'ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper'
+                      # support for Rails 4.2 ActiveJob
+                      job.payload_object.job_data['job_class']
+                    elsif job.payload_object.object.is_a?(Class)
+                      job.payload_object.object.name
+                    else
+                      job.payload_object.object.class.name
+                    end
+        args_data = (job.payload_object.try(:job_data) || {}).select { |key, _value| ARGS_TRACKED_DATA.include?(key) }
+
+        args_data['job_class'] = job_class || job.payload_object.class.name if args_data['job_class'].nil?
+
+        job_data.merge(args_data)
+      end
+
+      def self.should_track?(attempts)
+        TRACK_AT_RETRY.include?(attempts)
+      end
+    end
+  end
+end
+
+Delayed::Worker.plugins << ExceptionHunter::Middleware::DelayedJobHunter

data/lib/exception_hunter/middleware/request_hunter.rb

@@ -0,0 +1,71 @@
+module ExceptionHunter
+  module Middleware
+    class RequestHunter
+      ENVIRONMENT_KEYS =
+        %w[PATH_INFO
+           QUERY_STRING
+           REMOTE_HOST
+           REQUEST_METHOD
+           REQUEST_URI
+           SERVER_PROTOCOL
+           HTTP_HOST
+           CONTENT_TYPE
+           HTTP_USER_AGENT].freeze
+
+      FILTERED_PARAMS = [/password/].freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        catch_prey(env, exception)
+        raise exception
+      end
+
+      private
+
+      def catch_prey(env, exception)
+        user = user_from_env(env)
+        ErrorCreator.call(
+          tag: ErrorCreator::HTTP_TAG,
+          class_name: exception.class.to_s,
+          message: exception.message,
+          environment_data: environment_data(env),
+          backtrace: exception.backtrace,
+          user: user
+        )
+      end
+
+      def environment_data(env)
+        env
+          .select { |key, _value| ENVIRONMENT_KEYS.include?(key) }
+          .merge(params: filtered_sensitive_params(env))
+      end
+
+      def user_from_env(env)
+        current_user_method = Config.current_user_method
+        controller = env['action_controller.instance']
+        controller.try(current_user_method)
+      end
+
+      def filtered_sensitive_params(env)
+        params = env['action_dispatch.request.parameters']
+        parameter_filter = ::ActiveSupport::ParameterFilter.new(FILTERED_PARAMS)
+        parameter_filter.filter(params || {})
+      end
+    end
+  end
+end
+
+module ExceptionHunter
+  class Railtie < Rails::Railtie
+    initializer 'exception_hunter.add_middleware', after: :load_config_initializers do |app|
+      app.config.middleware.insert_after(
+        ActionDispatch::DebugExceptions, ExceptionHunter::Middleware::RequestHunter
+      )
+    end
+  end
+end

data/lib/exception_hunter/middleware/sidekiq_hunter.rb

@@ -0,0 +1,59 @@
+module ExceptionHunter
+  module Middleware
+    # Middleware to report errors
+    # when a Sidekiq worker fails
+    #
+    class SidekiqHunter
+      TRACK_AT_RETRY = [0, 3, 6, 10].freeze
+      JOB_TRACKED_DATA = %w[
+        queue
+        retry_count
+      ].freeze
+      ARGS_TRACKED_DATA = %w[
+        job_class
+        job_id
+        arguments
+        enqueued_at
+      ].freeze
+
+      def call(_worker, context, _queue)
+        yield
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        track_exception(exception, context)
+        raise exception
+      end
+
+      private
+
+      def track_exception(exception, context)
+        return unless should_track?(context)
+
+        ErrorCreator.call(
+          tag: ErrorCreator::WORKER_TAG,
+          class_name: exception.class.to_s,
+          message: exception.message,
+          environment_data: environment_data(context),
+          backtrace: exception.backtrace
+        )
+      end
+
+      def environment_data(context)
+        job_data = context.select { |key, _value| JOB_TRACKED_DATA.include?(key) }
+        args_data = (context['args']&.first || {}).select { |key, _value| ARGS_TRACKED_DATA.include?(key) }
+
+        job_data.merge(args_data)
+      end
+
+      def should_track?(context)
+        TRACK_AT_RETRY.include?(context['retry_count'].to_i)
+      end
+    end
+  end
+end
+
+# As seen in https://github.com/mperham/sidekiq/wiki/Error-Handling
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add(ExceptionHunter::Middleware::SidekiqHunter)
+  end
+end

data/lib/exception_hunter/tracking.rb

@@ -0,0 +1,16 @@
+module ExceptionHunter
+  module Tracking
+    def track(exception, custom_data: {}, user: nil)
+      ErrorCreator.call(
+        tag: ErrorCreator::MANUAL_TAG,
+        class_name: exception.class.to_s,
+        message: exception.message,
+        backtrace: exception.backtrace,
+        custom_data: custom_data,
+        user: user
+      )
+
+      nil
+    end
+  end
+end

data/lib/exception_hunter/user_attributes_collector.rb

@@ -3,11 +3,15 @@ module ExceptionHunter
     extend self
 
     def collect_attributes(user)
+      return unless user
+
       attributes.reduce({}) do |data, attribute|
         data.merge(attribute => user.try(attribute))
       end
     end
 
+    private
+
     def attributes
       Config.user_attributes
     end

data/lib/exception_hunter/version.rb

@@ -1,3 +1,3 @@
 module ExceptionHunter
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.4.1'.freeze
 end

data/lib/generators/exception_hunter/create_users/create_users_generator.rb

@@ -22,7 +22,14 @@ module ExceptionHunter
     end
 
     def create_admin_user
-      invoke 'devise', [name]
+      invoke 'devise', [name], routes: false
+    end
+
+    def remove_registerable_from_model
+      return if options[:registerable]
+
+      model_file = File.join(destination_root, 'app', 'models', "#{file_path}.rb")
+      gsub_file model_file, /\:registerable([.]*,)?/, ''
     end
   end
 end

data/lib/generators/exception_hunter/install/install_generator.rb

@@ -15,7 +15,9 @@ module ExceptionHunter
 
     def setup_routes
       if options[:users]
-        inject_into_file 'config/routes.rb', "\n  ExceptionHunter.routes(self)", after: /devise_for .*/
+        gsub_file 'config/routes.rb',
+                  "\n  devise_for :#{plural_table_name}, skip: :all",
+                  "\n  ExceptionHunter.routes(self)"
       else
         route 'ExceptionHunter.routes(self)'
       end

data/lib/generators/exception_hunter/install/templates/create_exception_hunter_error_groups.rb.erb

@@ -5,10 +5,13 @@ class CreateExceptionHunterErrorGroups < ActiveRecord::Migration[<%= ActiveRecor
     create_table :exception_hunter_error_groups do |t|
       t.string :error_class_name, null: false
       t.string :message
+      t.integer :status, default: 0
+      t.text :tags, array: true, default: []
 
       t.timestamps
 
       t.index :message, opclass: :gin_trgm_ops, using: :gin
+      t.index :status
     end
   end
 end

data/lib/generators/exception_hunter/install/templates/exception_hunter.rb.erb

@@ -1,4 +1,19 @@
 ExceptionHunter.setup do |config|
+  # == Enabling
+  #
+  # This flag allows disabling error tracking, it's set to track in
+  # any environment but development or test by default
+  #
+  config.enabled = !(Rails.env.development? || Rails.env.test?)
+
+  # == Dashboard User
+  # Exception Hunter allows you to restrict users who can see the dashboard
+  # to the ones included in the database. You can change the table name in
+  # case you are not satisfied with the default one. You can also remove the
+  # configuration if you wish to have no access restrictions for the dashboard.
+  #
+  <%= @use_authentication_method ? "config.admin_user_class = '#{name}'" : "# config.admin_user_class = '#{name}'" %>
+
   # == Current User
   #
   # Exception Hunter will include the user as part of the environment
@@ -15,4 +30,12 @@ ExceptionHunter.setup do |config|
   # as part of the user information that is kept from the request.
   #
   config.user_attributes = [:id, :email]
+
+  # == Stale errors
+  #
+  # You can configure how long it takes for errors to go stale. This is
+  # taken into account when purging old error messages but nothing will
+  # happen automatically.
+  #
+  # config.errors_stale_time = 45.days
 end