rails_exception_log 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f74b304353846663f7ce71910b4551a2ff998add94dcbfc1ec367cf8fd6a0cc1
+  data.tar.gz: f8f6dc75de6d73b215d47aa4dad59c07d0f91a2613b54c7f3d3bf050633b10fb
+SHA512:
+  metadata.gz: ac73adab5b4b0f3bd6000c0054e468081bd305f9543f36e00d2047e1d051af1312c1f4dbc7d61b33c47d8a2da3a32ab0e7d894ec8bf23d182d495e8779b1bdfd
+  data.tar.gz: 6ce8da2534567b8a8308af48eb6fe4db59777a02f702417fafba96f6ac61c85ff565ded94e0e141b3f26abdb0c6133aca5931afe5143bb2fd40e93ea0066b12b

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+# Rails Exception Log
+
+A modern exception logging gem for Rails 7 and 8 with Tailwind UI, inspired by Honeybadger.
+
+## Features
+
+- **Error Grouping**: Automatically groups similar exceptions using fingerprinting
+- **Status Tracking**: Open, Resolved, Reopened, Ignored states
+- **Occurrence Count**: Track how many times each error occurs
+- **User Tracking**: Link exceptions to affected users
+- **Comments**: Add notes to exceptions for team collaboration
+- **Rate Limiting**: Prevent database flooding from repeated errors
+- **Modern UI**: Beautiful Tailwind-styled dashboard
+- **Stimulus JS**: Lightweight JavaScript interactions
+
+## Requirements
+
+- Ruby >= 3.0
+- Rails >= 7.0, < 9.0
+- Bun (for CSS bundling)
+- Tailwind CSS via css-bundling-rails
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "rails_exception_log"
+```
+
+Run the install generator:
+
+```bash
+rails generate rails_exception_log:install
+```
+
+This will:
+- Copy migrations to your app
+- Add route to config/routes.rb
+
+Then run migrations:
+
+```bash
+rails db:migrate
+```
+
+## Configuration
+
+### Application Controller
+
+```ruby
+class ApplicationController < ActionController::Base
+  include RailsExceptionLog::ExceptionLoggable
+  rescue_from Exception, with: :log_exception_handler
+end
+```
+
+### Routes
+
+The generator adds this route:
+
+```ruby
+mount RailsExceptionLog::Engine => "/exceptions"
+```
+
+### Optional Configuration
+
+Create an initializer `config/initializers/rails_exception_log.rb`:
+
+```ruby
+RailsExceptionLog.configure do |config|
+  config.application_name = "My App"
+  config.max_requests_per_minute = 100
+  config.enable_user_tracking = true
+  config.before_log_exception = ->(controller) {
+    # Add custom authentication
+    true
+  }
+  config.after_log_exception = ->(exception) {
+    # Send notifications, etc.
+  }
+end
+```
+
+### Custom Exception Data
+
+```ruby
+class ApplicationController < ActionController::Base
+  # Add custom data to exceptions
+  self.exception_data = Proc.new { |controller|
+    { user_id: controller.current_user&.id }
+  }
+  
+  # Or use a method
+  self.exception_data = :extra_exception_data
+  
+  def extra_exception_data
+    { version: "1.0", environment: Rails.env }
+  end
+end
+```
+
+### Authentication
+
+In your environment config:
+
+```ruby
+config.after_initialize do
+  RailsExceptionLog::LoggedExceptionsController.class_eval do
+    before_action :authenticate_admin!
+  end
+end
+```
+
+## Usage
+
+### Dashboard
+
+Visit `/exceptions` to view the exception dashboard.
+
+### Actions
+
+- **View**: Click on an exception to see details
+- **Resolve**: Mark an exception as resolved
+- **Reopen**: Reopen a resolved exception
+- **Ignore**: Ignore an exception
+- **Delete**: Delete an exception
+- **Export**: Export exceptions as CSV
+
+### Filtering
+
+- By date range (Today, 7 days, 30 days)
+- By status (Open, Resolved, Reopened, Ignored)
+- By exception type
+- By controller
+
+## JavaScript Setup
+
+Ensure your app has Stimulus configured. The gem includes a dropdown controller.
+
+In your application layout, include the bundled assets:
+
+```erb
+<%= stylesheet_link_tag "rails_exception_log/application" %>
+<%= javascript_include_tag "rails_exception_log/application" %>
+```
+
+## Rake Tasks
+
+```bash
+# Cleanup exceptions older than 30 days
+rails rails_exception_log:cleanup
+
+# Cleanup with custom days
+rails rails_exception_log:cleanup[60]
+```
+
+## Development
+
+```bash
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rake test
+
+# Build
+bundle exec rake build
+```
+
+## License
+
+MIT License

data/app/assets/config/tailwind.config.js

@@ -0,0 +1,34 @@
+const defaultTheme = require("tailwindcss/defaultTheme");
+
+module.exports = {
+  content: [
+    "./app/views/**/*.{erb,haml,html}",
+    "./app/helpers/**/*.rb",
+    "./app/controllers/**/*.rb",
+  ],
+  theme: {
+    extend: {
+      fontFamily: {
+        sans: ["Inter", ...defaultTheme.fontFamily.sans],
+      },
+      colors: {
+        primary: {
+          50: "#EEF2FF",
+          100: "#E0E7FF",
+          200: "#C7D2FE",
+          300: "#A5B4FC",
+          400: "#818CF8",
+          500: "#6366F1",
+          600: "#4F46E5",
+          700: "#4338CA",
+          800: "#3730A3",
+          900: "#312E81",
+        },
+      },
+    },
+  },
+  plugins: [],
+  corePlugins: {
+    container: false,
+  },
+};

data/app/assets/stylesheets/rails_exception_log/application.css

@@ -0,0 +1,12 @@
+@import "tailwindcss/base";
+@import "tailwindcss/components";
+@import "tailwindcss/utilities";
+
+/* Custom styles */
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+}
+
+.font-mono {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}

data/app/controllers/rails_exception_log/application_controller.rb

@@ -0,0 +1,17 @@
+module RailsExceptionLog
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    before_action :ensure_exception_log_enabled
+
+    private
+
+    def ensure_exception_log_enabled
+      return if Rails.env.development? || Rails.env.test?
+
+      return if RailsExceptionLog.before_log_exception.call(self)
+
+      render plain: 'Unauthorized', status: 401
+    end
+  end
+end

data/app/controllers/rails_exception_log/logged_exceptions_controller.rb

@@ -0,0 +1,158 @@
+require 'csv'
+
+module RailsExceptionLog
+  class LoggedExceptionsController < ApplicationController
+    before_action :load_exception, only: %i[show destroy resolve reopen ignore add_comment]
+
+    def index
+      @exceptions = filtered_exceptions
+                    .select(:id, :exception_class, :message, :controller_name,
+                            :action_name, :request_method, :request_path,
+                            :environment, :created_at, :status, :occurrence_count,
+                            :last_occurred_at, :resolved_at)
+                    .order(last_occurred_at: :desc)
+                    .page(params[:page])
+
+      @exception_classes = RailsExceptionLog::LoggedException
+                           .select(:exception_class)
+                           .distinct
+                           .pluck(:exception_class)
+                           .sort
+
+      @controllers = RailsExceptionLog::LoggedException
+                     .select(:controller_name)
+                     .distinct
+                     .pluck(:controller_name)
+                     .compact
+                     .sort
+
+      @status_counts = {
+        open: RailsExceptionLog::LoggedException.status_open.count,
+        resolved: RailsExceptionLog::LoggedException.status_resolved.count,
+        reopened: RailsExceptionLog::LoggedException.status_reopened.count,
+        ignored: RailsExceptionLog::LoggedException.status_ignored.count
+      }
+
+      @stats = {
+        total: RailsExceptionLog::LoggedException.count,
+        unresolved: RailsExceptionLog::LoggedException.unresolved.count,
+        last_24h: RailsExceptionLog::LoggedException.where('created_at >= ?', 24.hours.ago).count
+      }
+
+      respond_to do |format|
+        format.html
+        format.json { render json: @exceptions }
+      end
+    end
+
+    def show
+      @exception_data = @exception.request_params_display
+      @session_data = @exception.session_data_display
+      @headers = @exception.request_headers || {}
+      @comments = @exception.comments.present? ? JSON.parse(@exception.comments) : []
+    end
+
+    def destroy
+      @exception.destroy
+      redirect_to railsexceptionlog_exceptions_path,
+                  notice: 'Exception deleted successfully'
+    end
+
+    def resolve
+      @exception.mark_resolved!
+      redirect_to railsexceptionlog_exception_path(@exception),
+                  notice: 'Exception marked as resolved'
+    end
+
+    def reopen
+      @exception.mark_open!
+      redirect_to railsexceptionlog_exception_path(@exception),
+                  notice: 'Exception reopened'
+    end
+
+    def ignore
+      @exception.update!(status: :ignored)
+      redirect_to railsexceptionlog_exception_path(@exception),
+                  notice: 'Exception ignored'
+    end
+
+    def add_comment
+      @exception.add_comment!(params[:comment], author: current_user_email)
+      redirect_to railsexceptionlog_exception_path(@exception),
+                  notice: 'Comment added'
+    end
+
+    def destroy_all
+      if params[:status].present?
+        filtered_exceptions.destroy_all
+      else
+        RailsExceptionLog::LoggedException.delete_all
+      end
+      redirect_to railsexceptionlog_exceptions_path,
+                  notice: 'Exceptions cleared'
+    end
+
+    def export
+      @exceptions = filtered_exceptions.order(last_occurred_at: :desc)
+      respond_to do |format|
+        format.csv { send_data export_to_csv(@exceptions), filename: "exceptions-#{Date.today}.csv" }
+        format.json { render json: @exceptions }
+      end
+    end
+
+    private
+
+    def load_exception
+      @exception = RailsExceptionLog::LoggedException.find(params[:id])
+    end
+
+    def filtered_exceptions
+      exceptions = RailsExceptionLog::LoggedException.all
+
+      exceptions = exceptions.filter_by_date(params[:date_range]) if params[:date_range].present?
+
+      exceptions = exceptions.by_class(params[:exception_class]) if params[:exception_class].present?
+
+      exceptions = exceptions.by_controller(params[:controller]) if params[:controller].present?
+
+      exceptions = exceptions.by_status(params[:status]) if params[:status].present?
+
+      if params[:search].present?
+        search_term = "%#{params[:search]}%"
+        exceptions = exceptions.where(
+          'exception_class LIKE ? OR message LIKE ?',
+          search_term, search_term
+        )
+      end
+
+      exceptions
+    end
+
+    def export_to_csv(exceptions)
+      CSV.generate(headers: true) do |csv|
+        csv << ['ID', 'Exception Class', 'Message', 'Controller', 'Action', 'Path', 'Method', 'Environment', 'Status',
+                'Occurrences', 'Created At']
+        exceptions.each do |exc|
+          csv << [
+            exc.id,
+            exc.exception_class,
+            exc.message,
+            exc.controller_name,
+            exc.action_name,
+            exc.request_path,
+            exc.request_method,
+            exc.environment,
+            exc.status_label,
+            exc.occurrence_count,
+            exc.created_at
+          ]
+        end
+      end
+    end
+
+    def current_user_email
+      # Override this method to return the current user's email
+      'anonymous'
+    end
+  end
+end

data/app/helpers/rails_exception_log/application_helper.rb

@@ -0,0 +1,52 @@
+module RailsExceptionLog
+  module ApplicationHelper
+    def exception_status_class(exception)
+      case exception.environment
+      when 'production' then 'bg-red-100 text-red-800'
+      when 'staging' then 'bg-amber-100 text-amber-800'
+      else 'bg-slate-100 text-slate-800'
+      end
+    end
+
+    def exception_status_badge(exception)
+      case exception.status.to_s
+      when 'open' then 'bg-red-100 text-red-800'
+      when 'resolved' then 'bg-green-100 text-green-800'
+      when 'reopened' then 'bg-orange-100 text-orange-800'
+      when 'ignored' then 'bg-slate-100 text-slate-600'
+      else 'bg-slate-100 text-slate-800'
+      end
+    end
+
+    def severity_badge(severity)
+      case severity.to_i
+      when 3 then 'bg-red-600 text-white'
+      when 2 then 'bg-orange-500 text-white'
+      when 1 then 'bg-yellow-500 text-white'
+      else 'bg-blue-500 text-white'
+      end
+    end
+
+    def format_datetime(datetime)
+      return '-' unless datetime
+
+      datetime.strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+    def format_datetime_relative(datetime)
+      return '-' unless datetime
+
+      time_ago_in_words(datetime)
+    end
+
+    def request_method_class(method)
+      case method&.upcase
+      when 'GET' then 'bg-green-100 text-green-800'
+      when 'POST' then 'bg-blue-100 text-blue-800'
+      when 'PUT', 'PATCH' then 'bg-amber-100 text-amber-800'
+      when 'DELETE' then 'bg-red-100 text-red-800'
+      else 'bg-slate-100 text-slate-800'
+      end
+    end
+  end
+end

data/app/javascript/controllers/dropdown_controller.js

@@ -0,0 +1,22 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class DropdownController extends Controller {
+  static targets = ["menu"]
+
+  connect() {
+    this.isOpen = false
+  }
+
+  toggle(event) {
+    event.preventDefault()
+    this.isOpen = !this.isOpen
+    this.menuTarget.classList.toggle("hidden", !this.isOpen)
+  }
+
+  close(event) {
+    if (!this.element.contains(event.target)) {
+      this.isOpen = false
+      this.menuTarget.classList.add("hidden")
+    }
+  }
+}

data/app/javascript/index.js

@@ -0,0 +1,4 @@
+import "@hotwired/stimulus"
+import DropdownController from "./controllers/dropdown_controller"
+
+application.register("dropdown", DropdownController)

data/app/models/rails_exception_log/logged_exception.rb

@@ -0,0 +1,149 @@
+module RailsExceptionLog
+  class LoggedException < ::ActiveRecord::Base
+    self.table_name = 'rails_exception_log_logged_exceptions'
+
+    enum :status, { open: 0, resolved: 1, reopened: 2, ignored: 3 }, prefix: true
+    enum :severity, { info: 0, warning: 1, error: 2, critical: 3 }, prefix: true
+
+    validates :exception_class, presence: true
+
+    scope :recent, -> { order(last_occurred_at: :desc) }
+    scope :today, -> { where('created_at >= ?', Date.today) }
+    scope :last_days, ->(days) { where('created_at >= ?', days.days.ago) }
+    scope :by_class, ->(klass) { where(exception_class: klass) }
+    scope :by_controller, ->(controller) { where(controller_name: controller) }
+    scope :by_status, ->(status) { where(status: statuses[status]) }
+    scope :unresolved, -> { where(status: [statuses[:open], statuses[:reopened]]) }
+    scope :high_severity, -> { where('severity >= ?', severities[:error]) }
+
+    def self.filter_by_date(range)
+      case range
+      when 'today'
+        today
+      when '7days'
+        last_days(7)
+      when '30days'
+        last_days(30)
+      else
+        all
+      end
+    end
+
+    def self.generate_fingerprint(exception, request = nil)
+      fingerprint_parts = [
+        exception.class.name,
+        exception.message.to_s.split("\n").first[0..200],
+        request&.path
+      ].compact
+
+      Digest::SHA256.hexdigest(fingerprint_parts.join('|'))
+    end
+
+    def self.create_or_update_with_fingerprint!(exception, request = nil, user: nil)
+      fp = generate_fingerprint(exception, request)
+      existing = where(fingerprint: fp, status: [statuses[:open], statuses[:reopened]]).first
+
+      if existing
+        updates = {
+          occurrence_count: existing.occurrence_count + 1,
+          last_occurred_at: Time.current
+        }
+        updates[:backtrace] = exception.backtrace.join("\n") if exception.backtrace
+        existing.update!(updates)
+        existing
+      else
+        create!(
+          exception_class: exception.class.name,
+          message: exception.message,
+          backtrace: exception.backtrace&.join("\n"),
+          controller_name: request&.controller_name,
+          action_name: request&.action_name,
+          request_method: request&.method&.to_s,
+          request_path: request&.path,
+          request_params: request&.params,
+          request_headers: request_headers(request),
+          session_data: session_data(request),
+          environment: Rails.env,
+          fingerprint: fp,
+          user_id: user&.id,
+          user_email: user&.email,
+          last_occurred_at: Time.current
+        )
+      end
+    end
+
+    def self.request_headers(request)
+      return {} unless request&.headers
+
+      {
+        'HTTP_HOST' => request.headers['HTTP_HOST'],
+        'HTTP_USER_AGENT' => request.headers['HTTP_USER_AGENT'],
+        'REMOTE_ADDR' => request.remote_ip
+      }.compact
+    end
+
+    def self.session_data(request)
+      return {} unless request&.session
+
+      begin
+        request.session.to_hash
+      rescue StandardError
+        {}
+      end
+    end
+
+    def formatted_backtrace
+      return [] unless backtrace
+
+      backtrace.split("\n").reject(&:blank?)
+    end
+
+    def request_params_display
+      return {} unless request_params
+
+      request_params.with_indifferent_access
+    end
+
+    def session_data_display
+      return {} unless session_data
+
+      session_data.with_indifferent_access
+    end
+
+    def mark_resolved!
+      update!(status: :resolved, resolved_at: Time.current)
+    end
+
+    def mark_open!
+      update!(status: :reopened, resolved_at: nil)
+    end
+
+    def add_comment!(comment, author: nil)
+      comment_data = {
+        body: comment,
+        author: author || 'System',
+        created_at: Time.current.iso8601
+      }
+
+      existing_comments = comments.present? ? JSON.parse(comments) : []
+      existing_comments << comment_data
+      update!(comments: existing_comments.to_json)
+    end
+
+    def reopen_if_needed!
+      return unless resolved? && last_occurred_at && last_occurred_at > resolved_at
+
+      update!(status: :reopened, resolved_at: nil)
+    end
+
+    def status_label
+      case status
+      when 'open' then 'Open'
+      when 'resolved' then 'Resolved'
+      when 'reopened' then 'Reopened'
+      when 'ignored' then 'Ignored'
+      else 'Unknown'
+      end
+    end
+  end
+end