exception_hunter 0.1.0 → 0.4.1

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,22 @@ 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
+      end
+    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/errors_helper.rb

@@ -0,0 +1,7 @@
+module ExceptionHunter
+  module ErrorsHelper
+    def format_tracked_data(tracked_data)
+      JSON.pretty_generate(tracked_data)
+    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/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

@@ -3,24 +3,37 @@ module ExceptionHunter
     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, unless: -> { error_group.active? }
 
     scope :most_recent, lambda { |error_group_id|
       where(error_group_id: error_group_id).order(occurred_at: :desc)
     }
-
-    def self.in_current_month
-      current_month = Date.today.beginning_of_month..Date.today.end_of_month
-
-      where(occurred_at: current_month)
-    end
+    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)
+    }
 
     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

@@ -4,12 +4,27 @@ module ExceptionHunter
 
     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 }
 
     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,54 @@
+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
+    TABS = [LAST_7_DAYS_TAB, CURRENT_MONTH_TAB, TOTAL_ERRORS_TAB, RESOLVED_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
+        '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
+      }
+    end
+  end
+end

data/app/presenters/exception_hunter/error_group_presenter.rb

@@ -0,0 +1,25 @@
+module ExceptionHunter
+  class ErrorGroupPresenter
+    delegate_missing_to :error_group
+
+    def initialize(error_group)
+      @error_group = error_group
+    end
+
+    def self.wrap_collection(collection)
+      collection.map { |error_group| new(error_group) }
+    end
+
+    def self.format_occurrence_day(day)
+      day.to_date.strftime('%A, %B %d')
+    end
+
+    def show_for_day?(day)
+      last_occurrence.in_time_zone.to_date == day.to_date
+    end
+
+    private
+
+    attr_reader :error_group
+  end
+end

data/app/presenters/exception_hunter/error_presenter.rb

@@ -1,6 +1,7 @@
 module ExceptionHunter
   class ErrorPresenter
     delegate_missing_to :error
+    delegate :tags, to: :error_group
 
     BacktraceLine = Struct.new(:path, :file_name, :line_number, :method_call)
 
@@ -14,6 +15,14 @@ module ExceptionHunter
       end
     end
 
+    def environment_data
+      error.environment_data&.except('params') || {}
+    end
+
+    def tracked_params
+      (error.environment_data || {})['params']
+    end
+
     private
 
     attr_reader :error

data/app/views/exception_hunter/devise/sessions/new.html.erb

@@ -0,0 +1,24 @@
+<div class="login_form_container">
+  <div class="login_left_container">
+    <div class="left_column">Exception Hunter</div>
+  </div>
+  <div class="login_right_container">
+    <%= form_for(resource, as: resource_name, url: exception_hunter_create_session_path) do |f| %>
+    <div class="row">
+      Sign into your account
+    </div>
+    <div class="login_row row"></div>
+    <div class="login_row row">
+      <%= f.email_field :email, autofocus: true, autocomplete: "email", placeholder: 'Email' %>
+    </div>
+    <div class="login_row row">
+      <%= f.password_field :password, autocomplete: "current-password", placeholder: 'Password'%>
+    </div>
+    <div class="login_button row">
+      <div class="column column-50 column-offset-50">
+          <input class="button-log-in" type="submit" value="Log in">
+      </div>
+    </div>
+    <% end %>
+  </div>
+</div>

data/app/views/exception_hunter/errors/_error_row.erb

@@ -0,0 +1,44 @@
+<div class="row error-row">
+  <div class="column column-10 error-cell">
+    <% error.tags.each do |tag| %>
+      <div class="error-cell__tags">
+        <span class="error-tag"><%= tag %></span>
+      </div>
+    <% end %>
+  </div>
+  <div class="column column-40 error-cell error-cell__message">
+    <%= link_to error.message, error_path(error.id), class: %w[error-message] %>
+  </div>
+
+  <div class="column column-15 error-cell">
+    <% if error.first_occurrence.present? %>
+      <%= time_ago_in_words(error.first_occurrence) %> ago
+    <% else %>
+      Never
+    <% end %>
+  </div>
+
+  <div class="column column-15 error-cell">
+    <% if error.last_occurrence.present? %>
+      <%= time_ago_in_words(error.last_occurrence) %> ago
+    <% else %>
+      Never
+    <% end %>
+  </div>
+
+  <div class="column column-10 error-cell">
+    <%= error.total_occurrences %>
+  </div>
+
+  <div class="column column-10 error-cell">
+    <% if error.active? %>
+      <div class="color-green">
+        <%= button_to('Resolve', resolved_errors_path(error_group: { id: error.id }),
+                      method: :post,
+                      class: %w[button button-outline resolve-button],
+                      data: { confirm: 'Are you sure you want to resolve this error?' }) %>
+      </div>
+    <% end %>
+  </div>
+</div>
+