exception_hunter 0.2.0 → 1.0.0

data/app/assets/stylesheets/exception_hunter/navigation.css

@@ -1,8 +1,7 @@
 .nav {
-    background: var(--secondary-color);
-    border-bottom: .1rem solid var(--border-color);
+    background: #000;
     display: block;
-    height: 5.2rem;
+    height: 4.2rem;
     left: 0;
     max-width: 100%;
     position: fixed;
@@ -16,6 +15,22 @@
     height: 100%;
 }
 
-.nav__logo img {
-    height: 100%;
+.nav__title {
+    line-height: 4.2rem;
+    font-style: normal;
+    font-weight: 600;
+    font-size: 16px;
+    color: #FFF;
+}
+
+.footer {
+    text-align: center;
+    padding-top: 4rem;
+    padding-bottom: 1rem;
+}
+
+.logout {
+  line-height: 4.2rem;
+  color: #FFF;
+  text-align: right;
 }

data/app/assets/stylesheets/exception_hunter/sessions.css

@@ -0,0 +1,71 @@
+.login_form_container {
+  margin: 0rem auto auto;
+  display: flex;
+  max-width: 75%;
+  margin-top: 20rem;
+  width: 910px;
+  height: 356px;
+  font-family: 'Inter', sans-serif;
+  background-color: white;
+}
+
+.login_left_container {
+  width: 455px;
+  text-align: center;
+  width: 38rem;
+  background-color: black;
+
+}
+
+.left_column {
+  max-width: 50%;
+  padding-top: 15%;
+  padding-left: 10%;
+  line-height: 130%;
+  color: white;
+  text-align: left;
+  font-size: 30px;
+  font-weight: 600;
+}
+
+.login_right_container {
+  width: 350px;
+  margin: 3rem 3.5rem 1rem;
+  font-size: 24px;
+  font-weight: 400;
+  text-align: left;
+  line-height: 29px;
+  line-height: 100%;
+  color: black;
+}
+
+.login_row {
+  margin: 2rem 0rem 0rem;
+  width: 100%;
+  align-items: center;
+}
+
+.login_button{
+  margin: 3rem 3rem 0rem;
+  align-items: right;
+}
+
+.button-log-in {
+  background-color: #2CBB85!important;
+  border-color: #2CBB85!important;
+}
+
+.field{
+  border: 0.1rem solid black;
+  border-radius: .4rem;
+}
+
+input[type='password'],
+input[type='email'],
+textarea:focus,
+select:focus {
+  border-color: black!important;
+  outline: 0;
+  font-size: 1.2rem!important;
+  color: black!important;
+}

data/app/controllers/concerns/exception_hunter/authorization.rb

@@ -0,0 +1,23 @@
+module ExceptionHunter
+  module Authorization
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :authenticate_admin_user_class
+    end
+
+    def authenticate_admin_user_class
+      return unless ExceptionHunter::Config.auth_enabled? && !send("current_#{underscored_admin_user_class}")
+
+      redirect_to '/exception_hunter/login'
+    end
+
+    def redirect_to_login
+      render 'exception_hunter/devise/sessions/new'
+    end
+
+    def underscored_admin_user_class
+      ExceptionHunter::Config.admin_user_class.underscore
+    end
+  end
+end

data/app/controllers/exception_hunter/application_controller.rb

@@ -1,5 +1,7 @@
 module ExceptionHunter
   class ApplicationController < ActionController::Base
+    include ExceptionHunter::Authorization
+
     protect_from_forgery with: :exception
   end
 end

data/app/controllers/exception_hunter/errors_controller.rb

@@ -5,14 +5,20 @@ module ExceptionHunter
     include Pagy::Backend
 
     def index
-      @errors = ErrorGroup.all.order(created_at: :desc)
-      @errors_count = Error.count
-      @month_errors = Error.in_current_month.count
+      @dashboard = DashboardPresenter.new(current_tab)
+      shown_errors = errors_for_tab(@dashboard).order(updated_at: :desc).distinct
+      @errors = ErrorGroupPresenter.wrap_collection(shown_errors)
     end
 
     def show
       @pagy, errors = pagy(most_recent_errors, items: 1)
-      @error = ErrorPresenter.new(errors.first)
+      @error = ErrorPresenter.new(errors.first!)
+    end
+
+    def destroy
+      ErrorReaper.purge
+
+      redirect_back fallback_location: errors_path, notice: 'Errors purged successfully'
     end
 
     private
@@ -20,5 +26,24 @@ module ExceptionHunter
     def most_recent_errors
       Error.most_recent(params[:id])
     end
+
+    def current_tab
+      params[:tab]
+    end
+
+    def errors_for_tab(dashboard)
+      case dashboard.current_tab
+      when DashboardPresenter::LAST_7_DAYS_TAB
+        ErrorGroup.with_errors_in_last_7_days.active
+      when DashboardPresenter::CURRENT_MONTH_TAB
+        ErrorGroup.with_errors_in_current_month.active
+      when DashboardPresenter::TOTAL_ERRORS_TAB
+        ErrorGroup.active
+      when DashboardPresenter::RESOLVED_ERRORS_TAB
+        ErrorGroup.resolved
+      when DashboardPresenter::IGNORED_ERRORS_TAB
+        ErrorGroup.ignored
+      end
+    end
   end
 end

data/app/controllers/exception_hunter/ignored_errors_controller.rb

@@ -0,0 +1,25 @@
+require_dependency 'exception_hunter/application_controller'
+
+module ExceptionHunter
+  class IgnoredErrorsController < ApplicationController
+    def create
+      error_group.ignored!
+      redirect_to errors_path, notice: 'Error ignored successfully'
+    end
+
+    def reopen
+      error_group.active!
+      redirect_to errors_path, notice: 'Error re-opened successfully'
+    end
+
+    private
+
+    def error_group
+      @error_group ||= ErrorGroup.find(error_group_params[:id])
+    end
+
+    def error_group_params
+      params.require(:error_group).permit(:id)
+    end
+  end
+end

data/app/controllers/exception_hunter/resolved_errors_controller.rb

@@ -0,0 +1,11 @@
+require_dependency 'exception_hunter/application_controller'
+
+module ExceptionHunter
+  class ResolvedErrorsController < ApplicationController
+    def create
+      ErrorGroup.find(params[:error_group][:id]).resolved!
+
+      redirect_to errors_path, notice: 'Error resolved successfully'
+    end
+  end
+end

data/app/helpers/exception_hunter/application_helper.rb

@@ -1,5 +1,27 @@
 module ExceptionHunter
   module ApplicationHelper
     include Pagy::Frontend
+
+    def application_name
+      if defined? Rails.application.class.module_parent_name
+        Rails.application.class.module_parent_name
+      else
+        Rails.application.class.parent_name
+      end
+    end
+
+    def display_action_button(title, error)
+      button_to(title.to_s, route_for_button(title, error),
+                class: "button button-outline #{title}-button",
+                data: { confirm: "Are you sure you want to #{title} this error?" }).to_s
+    end
+
+    def route_for_button(title, error)
+      if title.eql?('ignore')
+        ignored_errors_path(error_group: { id: error.id })
+      else
+        resolved_errors_path(error_group: { id: error.id })
+      end
+    end
   end
 end

data/app/helpers/exception_hunter/sessions_helper.rb

@@ -0,0 +1,16 @@
+module ExceptionHunter
+  module SessionsHelper
+    def current_admin_user?
+      underscored_admin_user_class &&
+        current_admin_class_name(underscored_admin_user_class)
+    end
+
+    def underscored_admin_user_class
+      ExceptionHunter::Config.admin_user_class.try(:underscore)
+    end
+
+    def current_admin_class_name(class_name)
+      send("current_#{class_name.underscore}")
+    end
+  end
+end

data/app/jobs/exception_hunter/send_notification_job.rb

@@ -0,0 +1,15 @@
+module ExceptionHunter
+  class SendNotificationJob < ApplicationJob
+    queue_as :default
+
+    def perform(serialized_notifier)
+      # Use SlackNotifierSerializer as it's the only one for now.
+      serializer = ExceptionHunter::Notifiers::SlackNotifierSerializer
+      deserialized_notifier = serializer.deserialize(serialized_notifier)
+      deserialized_notifier.notify
+    rescue Exception # rubocop:disable Lint/RescueException
+      # Suppress all exceptions to avoid loop as this would create a new error in EH.
+      false
+    end
+  end
+end

data/app/models/exception_hunter/application_record.rb

@@ -1,5 +1,13 @@
 module ExceptionHunter
   class ApplicationRecord < ActiveRecord::Base
     self.abstract_class = true
+
+    class << self
+      delegate :[], to: :arel_table
+
+      def sql_similarity(attr, value)
+        Arel::Nodes::NamedFunction.new('similarity', [attr, Arel::Nodes.build_quoted(value)])
+      end
+    end
   end
 end

data/app/models/exception_hunter/error.rb

@@ -1,26 +1,43 @@
 module ExceptionHunter
-  class Error < ApplicationRecord
+  class Error < ::ExceptionHunter::ApplicationRecord
     validates :class_name, presence: true
     validates :occurred_at, presence: true
 
-    belongs_to :error_group
+    belongs_to :error_group, touch: true
 
     before_validation :set_occurred_at, on: :create
+    after_create :unresolve_error_group, if: -> { error_group.resolved? }
 
     scope :most_recent, lambda { |error_group_id|
       where(error_group_id: error_group_id).order(occurred_at: :desc)
     }
+    scope :with_occurrences_before, lambda { |max_occurrence_date|
+      where(Error[:occurred_at].lteq(max_occurrence_date))
+    }
+    scope :in_period, ->(period) { where(occurred_at: period) }
+    scope :in_last_7_days, -> { in_period(7.days.ago.beginning_of_day..Time.now) }
+    scope :in_current_month, lambda {
+      in_period(Date.current.beginning_of_month.beginning_of_day..Date.current.end_of_month.end_of_day)
+    }
+    scope :from_active_error_groups, lambda {
+      joins(:error_group).where(error_group: ErrorGroup.active)
+    }
+    scope :from_resolved_error_groups, lambda {
+      joins(:error_group).where(error_group: ErrorGroup.resolved)
+    }
 
-    def self.in_current_month
-      current_month = Date.today.beginning_of_month..Date.today.end_of_month
-
-      where(occurred_at: current_month)
-    end
+    scope :from_ignored_error_groups, lambda {
+      joins(:error_group).where(error_group: ErrorGroup.ignored)
+    }
 
     private
 
     def set_occurred_at
       self.occurred_at ||= Time.now
     end
+
+    def unresolve_error_group
+      error_group.active!
+    end
   end
 end

data/app/models/exception_hunter/error_group.rb

@@ -1,15 +1,30 @@
 module ExceptionHunter
-  class ErrorGroup < ApplicationRecord
+  class ErrorGroup < ::ExceptionHunter::ApplicationRecord
     SIMILARITY_THRESHOLD = 0.75
 
     validates :error_class_name, presence: true
 
-    has_many :grouped_errors, class_name: 'ExceptionHunter::Error'
+    has_many :grouped_errors, class_name: 'ExceptionHunter::Error', dependent: :destroy
+
+    enum status: { active: 0, resolved: 1, ignored: 2 }
 
     scope :most_similar, lambda { |message|
-      quoted_message = ActiveRecord::Base.connection.quote_string(message)
-      where("similarity(exception_hunter_error_groups.message, :message) >= #{SIMILARITY_THRESHOLD}", message: message)
-        .order(Arel.sql("similarity(exception_hunter_error_groups.message, '#{quoted_message}') DESC"))
+      message_similarity = sql_similarity(ErrorGroup[:message], message)
+      where(message_similarity.gteq(SIMILARITY_THRESHOLD))
+        .order(message_similarity.desc)
+    }
+
+    scope :without_errors, lambda {
+      is_associated_error = Error[:error_group_id].eq(ErrorGroup[:id])
+      where.not(Error.where(is_associated_error).arel.exists)
+    }
+    scope :with_errors_in_last_7_days, lambda {
+      joins(:grouped_errors)
+        .where(Error.in_last_7_days.where(Error[:error_group_id].eq(ErrorGroup[:id])).arel.exists)
+    }
+    scope :with_errors_in_current_month, lambda {
+      joins(:grouped_errors)
+        .where(Error.in_current_month.where(Error[:error_group_id].eq(ErrorGroup[:id])).arel.exists)
     }
 
     def self.find_matching_group(error)
@@ -18,6 +33,10 @@ module ExceptionHunter
         .first
     end
 
+    def first_occurrence
+      @first_occurrence ||= grouped_errors.minimum(:occurred_at)
+    end
+
     def last_occurrence
       @last_occurrence ||= grouped_errors.maximum(:occurred_at)
     end

data/app/presenters/exception_hunter/dashboard_presenter.rb

@@ -0,0 +1,56 @@
+module ExceptionHunter
+  class DashboardPresenter
+    LAST_7_DAYS_TAB = 'last_7_days'.freeze
+    CURRENT_MONTH_TAB = 'current_month'.freeze
+    TOTAL_ERRORS_TAB = 'total_errors'.freeze
+    RESOLVED_ERRORS_TAB = 'resolved'.freeze
+    IGNORED_ERRORS_TAB = 'ignored'.freeze
+    TABS = [LAST_7_DAYS_TAB, CURRENT_MONTH_TAB, TOTAL_ERRORS_TAB, RESOLVED_ERRORS_TAB, IGNORED_ERRORS_TAB].freeze
+    DEFAULT_TAB = LAST_7_DAYS_TAB
+
+    attr_reader :current_tab
+
+    def initialize(current_tab)
+      assign_tab(current_tab)
+      calculate_tabs_counts
+    end
+
+    def tab_active?(tab)
+      tab == current_tab
+    end
+
+    def partial_for_tab
+      case current_tab
+      when LAST_7_DAYS_TAB
+        'exception_hunter/errors/last_7_days_errors_table'
+      when CURRENT_MONTH_TAB, TOTAL_ERRORS_TAB, RESOLVED_ERRORS_TAB, IGNORED_ERRORS_TAB
+        'exception_hunter/errors/errors_table'
+      end
+    end
+
+    def errors_count(tab)
+      @tabs_counts[tab]
+    end
+
+    private
+
+    def assign_tab(tab)
+      @current_tab = if TABS.include?(tab)
+                       tab
+                     else
+                       DEFAULT_TAB
+                     end
+    end
+
+    def calculate_tabs_counts
+      active_errors = Error.from_active_error_groups
+      @tabs_counts = {
+        LAST_7_DAYS_TAB => active_errors.in_last_7_days.count,
+        CURRENT_MONTH_TAB => active_errors.in_current_month.count,
+        TOTAL_ERRORS_TAB => active_errors.count,
+        RESOLVED_ERRORS_TAB => Error.from_resolved_error_groups.count,
+        IGNORED_ERRORS_TAB => Error.from_ignored_error_groups.count
+      }
+    end
+  end
+end