error_radar 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 486749dc9fc6c6e2cc617340f184cf8dbeb4196199c3017eb7bf6f667718fe74
-  data.tar.gz: 13da87d1772c71901b66fb4cd6b4d29a809b539b6fccaee5613defae97c0a04d
+  metadata.gz: bdfb13eb6566d150855376a07e28a5a76a758b23526d7cf31de5a6adc17e5d27
+  data.tar.gz: 713dcf3fa8c7867b971b6e7da6dd7dbf56a6e4057ec284dbadb6a8818b83f6d6
 SHA512:
-  metadata.gz: 6a9fe7aa11d7668ca353e0c6331eac9a339c43263f93bc3650085bd72f2072968376006f7481661037c7d9f80fdca0057b8a28d9779a92050b931fb4eccd441f
-  data.tar.gz: f98150abaa5c7bd7695ddd38ba91d65db73bfe81ce7e739c9f91fac20c596b3303643fc282320b2366f9b1b6bd4da48c2bfca7bd8d182e1162c3a7786770384a
+  metadata.gz: b71979e7ef0ca2737d789f3f047a024c9933d8b2149e83e5d88fc734144213226dfb1a160b4080ee008104dd0c19dd35a1da06ce0fbeb2ae61a0a65455a65d0f
+  data.tar.gz: 1838775fea5865d76bc746c49bc51efb0a557d6f6caf0924bdcd489b081570ff8667715690e3ef1b8a32ca7af219d7a26a1fe312e17304c27e4a9025d0632bf4

data/CHANGELOG.md

@@ -2,6 +2,67 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.6.0] - 2026-07-03
+
+### Added
+- **Async capture** via ActiveJob: set `config.async_capture = true` to enqueue
+  error writes through `CaptureJob` so exceptions don't block the request/job
+  thread. Falls back to synchronous capture if ActiveJob is unavailable.
+  Configure the queue with `config.capture_job_queue` (default `:default`).
+- **Age-based retention**: set `config.retention_days` to automatically prune
+  resolved/ignored records older than N days.
+- **Count-based retention**: set `config.max_records` to cap the table size;
+  oldest resolved/ignored records are deleted first when the limit is exceeded.
+- **`ErrorRadar::Cleanup.run`**: underlying cleanup logic, callable from Ruby or
+  Rake. Supports `older_than_days:` override and `dry_run: true` for previewing
+  without deleting.
+- **Rake tasks**:
+  - `rake error_radar:cleanup` — apply `retention_days` + `max_records`
+  - `rake error_radar:cleanup:dry_run` — preview without deleting
+  - `rake error_radar:cleanup:older_than` — one-off: `DAYS=30 rake …`
+  - `rake error_radar:stats` — print table summary (total, by status, oldest)
+- **Dashboard maintenance panel**: data summary (total / purgeable / open),
+  oldest record date, and an inline "Purge / Dry run" form with adjustable days.
+- **`POST /maintenance/purge`** endpoint: called by the dashboard's Purge button;
+  accepts `days` and `dry_run` params, returns JSON `{ deleted:, dry_run: }`.
+- **Dashboard stat query optimization**: 5 separate COUNT queries replaced by one
+  `group(:status).count` query.
+
+### Notes
+- `async_capture` is `false` by default to avoid surprising behaviour for apps
+  that do not have a queue adapter configured.
+- Cleanup only touches `resolved` and `ignored` records — open/in-progress
+  records are never auto-deleted.
+
+## [0.5.0] - 2026-07-03
+
+### Added
+- **REST API** at `/api/*` for external integrations (CI/CD, dashboards, scripts):
+  - `GET  /api/errors` — paginated list with the same filters as the web UI
+    (`status`, `severity`, `category`, `q`, `from`, `to`, `sort`, `order`, `page`)
+  - `GET  /api/errors/:id` — full detail including context, backtrace, and
+    `github_issue_url` (if column is present)
+  - `PATCH /api/errors/:id` — update status; resolve accepts optional `note`
+    and `resolved_by` params
+  - `GET  /api/stats` — summary counts by status, severity, and category
+- **Bearer-token API auth**: set `config.api_token` to protect all `/api/*`
+  endpoints with `Authorization: Bearer <token>`.
+- **GitHub Issue integration**: "Create GitHub Issue" button on the error detail
+  page opens a pre-filled issue with error class, source, message, backtrace,
+  and a deep-link back to Error Radar. Requires `config.github_token` and
+  `config.github_repo`.
+- **`github_issue_url` column**: stored on the error row so the button becomes
+  "View GitHub Issue" once an issue exists. Requires running the upgrade
+  migration: `bin/rails generate error_radar:upgrade_v050 && bin/rails db:migrate`.
+- **`error_radar:upgrade_v050` generator**: generates the migration that adds
+  `github_issue_url` to `error_radar_error_logs`.
+
+### Notes
+- The GitHub column is optional — the integration is gracefully degraded when the
+  migration has not been run (button appears but URL is not persisted).
+- The API controllers live in `ErrorRadar::Api::*` to avoid polluting the host
+  app's controller namespace.
+
 ## [0.4.0] - 2026-07-03
 
 ### Added

data/app/controllers/error_radar/api/base_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  module Api
+    class BaseController < ActionController::Base
+      skip_before_action :verify_authenticity_token
+      before_action :authenticate_api!
+
+      private
+
+      def authenticate_api!
+        token = ErrorRadar.config.api_token
+        return if token.nil?
+
+        provided = request.headers['Authorization'].to_s.delete_prefix('Bearer ').strip
+        render json: { error: 'Unauthorized' }, status: :unauthorized unless provided == token
+      end
+    end
+  end
+end

data/app/controllers/error_radar/api/errors_controller.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  module Api
+    class ErrorsController < BaseController
+      PER_PAGE = 50
+
+      # GET /api/errors
+      def index
+        scope  = build_scope
+        total  = scope.count
+        page   = [params[:page].to_i, 1].max
+        total_pages = [(total.to_f / PER_PAGE).ceil, 1].max
+        page   = [page, total_pages].min
+
+        errors = scope.limit(PER_PAGE).offset((page - 1) * PER_PAGE)
+
+        render json: {
+          data: errors.map { |e| serialize(e) },
+          meta: { total: total, page: page, per_page: PER_PAGE, total_pages: total_pages }
+        }
+      end
+
+      # GET /api/errors/:id
+      def show
+        log = ErrorLog.find(params[:id])
+        render json: { data: serialize(log, detail: true) }
+      rescue ActiveRecord::RecordNotFound
+        render json: { error: 'Not found' }, status: :not_found
+      end
+
+      # PATCH /api/errors/:id
+      def update
+        log        = ErrorLog.find(params[:id])
+        new_status = params[:status].to_s
+
+        unless ErrorLog.statuses.key?(new_status)
+          return render json: { error: 'invalid status' }, status: :unprocessable_entity
+        end
+
+        if new_status == 'resolved'
+          log.resolve!(by: params[:resolved_by].presence, note: params[:note].presence)
+        else
+          log.update!(status: new_status, resolved_at: nil)
+        end
+
+        render json: { data: serialize(log) }
+      rescue ActiveRecord::RecordNotFound
+        render json: { error: 'Not found' }, status: :not_found
+      end
+
+      private
+
+      def build_scope
+        scope = ErrorLog.all
+        scope = scope.where(status: params[:status])     if params[:status].present?   && ErrorLog.statuses.key?(params[:status])
+        scope = scope.where(severity: params[:severity]) if params[:severity].present? && ErrorLog.severities.key?(params[:severity])
+        scope = scope.where(category: params[:category]) if params[:category].present? && ErrorLog.categories.key?(params[:category])
+
+        if params[:q].present?
+          q = "%#{params[:q].downcase}%"
+          scope = scope.where('lower(message) LIKE :q OR lower(error_class) LIKE :q OR lower(source) LIKE :q', q: q)
+        end
+
+        from = params[:from].present? ? (Date.parse(params[:from]) rescue nil) : nil
+        to   = params[:to].present?   ? (Date.parse(params[:to])   rescue nil) : nil
+        scope = scope.where('last_seen_at >= ?', from) if from
+        scope = scope.where('last_seen_at <= ?', to.end_of_day) if to
+
+        sort = %w[last_seen_at first_seen_at occurrences].include?(params[:sort]) ? params[:sort] : 'last_seen_at'
+        dir  = params[:order] == 'asc' ? :asc : :desc
+        scope.order(sort => dir)
+      end
+
+      def serialize(log, detail: false)
+        data = {
+          id:            log.id,
+          error_class:   log.error_class,
+          source:        log.source,
+          message:       log.message,
+          category:      log.category,
+          severity:      log.severity,
+          status:        log.status,
+          occurrences:   log.occurrences,
+          first_seen_at: log.first_seen_at&.iso8601,
+          last_seen_at:  log.last_seen_at&.iso8601,
+          resolved_at:   log.resolved_at&.iso8601,
+          resolved_by:   log.resolved_by
+        }
+
+        if detail
+          data.merge!(
+            fingerprint:     log.fingerprint,
+            resolution_note: log.resolution_note,
+            http_status:     log.http_status,
+            request_url:     log.request_url,
+            api_code:        log.api_code,
+            api_subcode:     log.api_subcode,
+            context:         log.context,
+            backtrace:       log.backtrace
+          )
+        end
+
+        if log.class.column_names.include?('github_issue_url')
+          data[:github_issue_url] = log.github_issue_url
+        end
+
+        data
+      end
+    end
+  end
+end

data/app/controllers/error_radar/api/stats_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  module Api
+    # GET /api/stats — summary counts for dashboards, CI gates, uptime monitors.
+    class StatsController < BaseController
+      def show
+        render json: {
+          total:       ErrorLog.count,
+          open:        ErrorLog.status_open.count,
+          in_progress: ErrorLog.status_in_progress.count,
+          resolved:    ErrorLog.status_resolved.count,
+          ignored:     ErrorLog.status_ignored.count,
+          unresolved:  ErrorLog.unresolved.count,
+          by_severity: ErrorLog.group(:severity).count,
+          by_category: ErrorLog.group(:category).count,
+          generated_at: Time.current.iso8601
+        }
+      end
+    end
+  end
+end

data/app/controllers/error_radar/dashboard_controller.rb

@@ -10,13 +10,18 @@ module ErrorRadar
     SEVERITY_ORDER = { 'critical' => 0, 'error' => 1, 'warning' => 2, 'info' => 3 }.freeze
 
     def index
-      @total          = ErrorLog.count
-      @open_count     = ErrorLog.status_open.count
-      @in_progress    = ErrorLog.status_in_progress.count
-      @resolved_count = ErrorLog.status_resolved.count
-      @ignored_count  = ErrorLog.status_ignored.count
+      counts_by_status = ErrorLog.group(:status).count
+      # statuses returns {"open"=>0, "in_progress"=>1, "resolved"=>2, "ignored"=>3}
+      inv = ErrorLog.statuses.invert
+      @open_count     = counts_by_status[ErrorLog.statuses['open']] || 0
+      @in_progress    = counts_by_status[ErrorLog.statuses['in_progress']] || 0
+      @resolved_count = counts_by_status[ErrorLog.statuses['resolved']] || 0
+      @ignored_count  = counts_by_status[ErrorLog.statuses['ignored']] || 0
+      @total          = counts_by_status.values.sum
       @unresolved     = @open_count + @in_progress
 
+      @oldest_record  = ErrorLog.minimum(:first_seen_at)
+
       @by_category = ErrorLog.unresolved.group(:category).count
       @by_severity = ErrorLog.unresolved.group(:severity).count
 
@@ -46,6 +51,28 @@ module ErrorRadar
       @external_links = build_external_links
     end
 
+    def purge
+      days    = params[:days].presence&.to_i
+      dry_run = params[:dry_run] == '1'
+
+      result = ErrorRadar::Cleanup.run(
+        older_than_days: (days if days&.positive?),
+        dry_run: dry_run
+      )
+
+      respond_to do |format|
+        format.json { render json: result }
+        format.html do
+          msg = if dry_run
+                  "Dry run: would delete #{result[:deleted]} record(s)."
+                else
+                  "Purged #{result[:deleted]} record(s)."
+                end
+          redirect_to root_path, notice: msg
+        end
+      end
+    end
+
     private
 
     def build_external_links

data/app/controllers/error_radar/errors_controller.rb

@@ -3,7 +3,7 @@
 module ErrorRadar
   class ErrorsController < ApplicationController
     before_action :authenticate_request!
-    before_action :set_error, only: %i[show update_status destroy]
+    before_action :set_error, only: %i[show update_status destroy create_github_issue]
 
     rescue_from ActiveRecord::RecordNotFound do
       redirect_to errors_path, alert: 'Error not found.'
@@ -44,6 +44,35 @@ module ErrorRadar
       render json: { ok: true }
     end
 
+    def create_github_issue
+      unless github_configured?
+        return render json: { ok: false, error: 'GitHub not configured (set config.github_token and config.github_repo)' },
+                      status: :unprocessable_entity
+      end
+
+      if ErrorLog.column_names.include?('github_issue_url') && @error.github_issue_url.present?
+        return render json: { ok: false, error: 'Issue already created', url: @error.github_issue_url },
+                      status: :unprocessable_entity
+      end
+
+      require 'error_radar/integrations/github'
+      result = ErrorRadar::Integrations::Github.create_issue(
+        @error,
+        token: ErrorRadar.config.github_token,
+        repo:  ErrorRadar.config.github_repo
+      )
+
+      if result['html_url']
+        @error.update!(github_issue_url: result['html_url']) if ErrorLog.column_names.include?('github_issue_url')
+        render json: { ok: true, url: result['html_url'], number: result['number'] }
+      else
+        render json: { ok: false, error: result['message'] || 'GitHub API error' },
+               status: :unprocessable_entity
+      end
+    rescue StandardError => e
+      render json: { ok: false, error: e.message }, status: :internal_server_error
+    end
+
     def bulk
       ids = Array(params[:ids]).map(&:to_i).select(&:positive?)
       action = params[:bulk_action].to_s
@@ -115,6 +144,10 @@ module ErrorRadar
       ids.size
     end
 
+    def github_configured?
+      ErrorRadar.config.github_token.present? && ErrorRadar.config.github_repo.present?
+    end
+
     def active_filter_params
       params.permit(:q, :status, :severity, :category, :from, :to, :sort, :order).to_h
     end

data/app/views/error_radar/dashboard/index.html.erb

@@ -101,6 +101,52 @@
   </div>
 </div>
 
+<div class="panel" style="margin-bottom:20px" id="maintenance-panel">
+  <h2>Maintenance &amp; Data Retention</h2>
+  <div style="display:grid;grid-template-columns:1fr 1fr 1fr 1fr;gap:12px;margin-bottom:16px">
+    <div style="background:#f9fafb;border-radius:8px;padding:12px;text-align:center">
+      <div style="font-size:22px;font-weight:700;color:#111827"><%= @total %></div>
+      <div style="font-size:11px;color:#6b7280">Total records</div>
+    </div>
+    <div style="background:#f9fafb;border-radius:8px;padding:12px;text-align:center">
+      <div style="font-size:22px;font-weight:700;color:#28a745"><%= @resolved_count + @ignored_count %></div>
+      <div style="font-size:11px;color:#6b7280">Resolved / Ignored (purgeable)</div>
+    </div>
+    <div style="background:#f9fafb;border-radius:8px;padding:12px;text-align:center">
+      <div style="font-size:22px;font-weight:700;color:#fd7e14"><%= @unresolved %></div>
+      <div style="font-size:11px;color:#6b7280">Open / In progress</div>
+    </div>
+    <div style="background:#f9fafb;border-radius:8px;padding:12px;text-align:center">
+      <div style="font-size:13px;font-weight:600;color:#111827">
+        <%= @oldest_record ? @oldest_record.strftime('%Y-%m-%d') : '—' %>
+      </div>
+      <div style="font-size:11px;color:#6b7280">Oldest record</div>
+    </div>
+  </div>
+  <div style="display:flex;align-items:center;gap:12px;flex-wrap:wrap">
+    <label style="font-size:13px;font-weight:500">Delete resolved/ignored older than</label>
+    <input id="purge-days" type="number" min="1" placeholder="days" value="90"
+           style="width:80px;padding:5px 8px;border:1px solid #d1d5db;border-radius:6px;font-size:13px">
+    <span style="font-size:13px;color:#6b7280">days</span>
+    <button onclick="doPurge(false)"
+            style="padding:6px 14px;background:#dc3545;color:#fff;border:none;border-radius:6px;font-size:13px;cursor:pointer">
+      Purge
+    </button>
+    <button onclick="doPurge(true)"
+            style="padding:6px 14px;background:#6c757d;color:#fff;border:none;border-radius:6px;font-size:13px;cursor:pointer">
+      Dry run
+    </button>
+    <span id="purge-result" style="font-size:13px;color:#16a34a"></span>
+  </div>
+  <% if ErrorRadar.config.retention_days || ErrorRadar.config.max_records %>
+    <div style="margin-top:10px;font-size:12px;color:#6b7280">
+      Config: retention_days=<strong><%= ErrorRadar.config.retention_days || '—' %></strong>,
+      max_records=<strong><%= ErrorRadar.config.max_records || '—' %></strong>
+      (applies automatically when you run <code>rake error_radar:cleanup</code>)
+    </div>
+  <% end %>
+</div>
+
 <div class="panel" style="margin-bottom:20px">
   <h2>Kanban — drag a card to change status</h2>
   <div class="kanban">
@@ -127,6 +173,28 @@
 </div>
 
 <script>
+  function doPurge(dryRun) {
+    var days = document.getElementById('purge-days').value;
+    var result = document.getElementById('purge-result');
+    var token = document.querySelector('meta[name="csrf-token"]').content;
+    result.textContent = 'Running…';
+    result.style.color = '#6b7280';
+    fetch('<%= maintenance_purge_path %>', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': token, 'Accept': 'application/json' },
+      body: JSON.stringify({ days: days, dry_run: dryRun ? '1' : '0' })
+    }).then(function(r) { return r.json(); })
+      .then(function(d) {
+        var label = dryRun ? 'Would delete' : 'Deleted';
+        result.textContent = label + ' ' + d.deleted + ' record(s).';
+        result.style.color = dryRun ? '#fd7e14' : '#16a34a';
+      })
+      .catch(function() {
+        result.textContent = 'Request failed.';
+        result.style.color = '#dc3545';
+      });
+  }
+
   (function () {
     var token = document.querySelector('meta[name="csrf-token"]').content;
 

data/app/views/error_radar/errors/show.html.erb

@@ -104,11 +104,37 @@
   </div>
 </div>
 
+<%# ── GitHub Issue ── %>
+<% if ErrorRadar.config.github_token.present? && ErrorRadar.config.github_repo.present? %>
+  <div class="panel" style="margin-top:16px">
+    <h2>GitHub</h2>
+    <% has_col = @error.class.column_names.include?('github_issue_url') %>
+    <% if has_col && @error.github_issue_url.present? %>
+      <a href="<%= @error.github_issue_url %>" target="_blank" rel="noopener"
+         class="er-btn" style="background:#24292e;display:inline-block;text-decoration:none">
+        &#9651; View GitHub Issue
+      </a>
+    <% else %>
+      <button id="github-btn" class="er-btn" style="background:#24292e" onclick="createGithubIssue()">
+        &#9651; Create GitHub Issue
+      </button>
+      <span id="github-status" style="font-size:13px;color:#6b7280;margin-left:10px"></span>
+      <% unless has_col %>
+        <p style="font-size:12px;color:#9ca3af;margin:10px 0 0">
+          Run <code style="background:#f3f4f6;padding:2px 6px;border-radius:4px">bin/rails generate error_radar:upgrade_v050 &amp;&amp; bin/rails db:migrate</code>
+          to enable issue tracking.
+        </p>
+      <% end %>
+    <% end %>
+  </div>
+<% end %>
+
 <script>
 (function () {
   var CSRF       = document.querySelector('meta[name="csrf-token"]').content;
   var STATUS_URL = '<%= error_status_path(@error) %>';
   var DELETE_URL = '<%= error_path(@error) %>';
+  var GITHUB_URL = '<%= error_github_issue_path(@error) %>';
 
   document.querySelectorAll('.status-btn').forEach(function (btn) {
     btn.addEventListener('click', function () { changeStatus(btn.dataset.status, null); });
@@ -154,6 +180,35 @@
     });
   };
 
+  window.createGithubIssue = function () {
+    var btn    = document.getElementById('github-btn');
+    var status = document.getElementById('github-status');
+    if (!btn) return;
+    btn.disabled    = true;
+    status.textContent = 'Creating issue…';
+
+    fetch(GITHUB_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': CSRF }
+    })
+    .then(function (r) { return r.json(); })
+    .then(function (d) {
+      if (d.ok) {
+        status.innerHTML = '✓ Created: <a href="' + d.url + '" target="_blank">#' + d.number + '</a>';
+        btn.style.display = 'none';
+        showToast('GitHub issue #' + d.number + ' created', true);
+      } else {
+        status.textContent = 'Error: ' + (d.error || 'failed');
+        btn.disabled = false;
+        showToast(d.error || 'GitHub error', false);
+      }
+    })
+    .catch(function () {
+      status.textContent = 'Network error';
+      btn.disabled = false;
+    });
+  };
+
   function showToast(msg, ok) {
     var t = document.getElementById('toast');
     t.textContent = msg;

data/config/routes.rb

@@ -3,9 +3,19 @@
 ErrorRadar::Engine.routes.draw do
   root to: 'dashboard#index'
 
-  get    'errors',            to: 'errors#index',         as: :errors
-  post   'errors/bulk',       to: 'errors#bulk',          as: :errors_bulk
-  get    'errors/:id',        to: 'errors#show',          as: :error
-  patch  'errors/:id/status', to: 'errors#update_status', as: :error_status
-  delete 'errors/:id',        to: 'errors#destroy'
+  # REST API — JSON endpoints for CI/CD, external dashboards, scripts
+  namespace :api, defaults: { format: :json } do
+    resources :errors, only: %i[index show update]
+    resource  :stats,  only: [:show]
+  end
+
+  # Web UI
+  get    'errors',                  to: 'errors#index',               as: :errors
+  post   'errors/bulk',             to: 'errors#bulk',                as: :errors_bulk
+  post   'errors/:id/github_issue', to: 'errors#create_github_issue', as: :error_github_issue
+  get    'errors/:id',              to: 'errors#show',                as: :error
+  patch  'errors/:id/status',       to: 'errors#update_status',       as: :error_status
+  delete 'errors/:id',              to: 'errors#destroy'
+
+  post 'maintenance/purge', to: 'dashboard#purge', as: :maintenance_purge
 end

data/lib/error_radar/capture_job.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  # Background job for async exception capture. Used when config.async_capture
+  # is true. Failures are logged to Rails.logger and swallowed — a broken
+  # capture job must not cause retry storms or affect the application.
+  class CaptureJob < ActiveJob::Base
+    queue_as { ErrorRadar.config.capture_job_queue }
+
+    def perform(attrs_json)
+      attrs = JSON.parse(attrs_json, symbolize_names: true)
+      log   = ErrorLog.record(**attrs)
+      Notifier.dispatch(log) if log
+    rescue StandardError => e
+      ErrorRadar::Tracking.warn_internal("CaptureJob failed: #{e.class}: #{e.message}")
+    end
+  end
+end

data/lib/error_radar/cleanup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  # Prunes stale ErrorLog records. Two independent strategies run in sequence:
+  #
+  #   1. Age-based: deletes resolved/ignored records whose last_seen_at is
+  #      older than `older_than_days` (or config.retention_days).
+  #   2. Count-based: when the total exceeds config.max_records, deletes the
+  #      oldest resolved/ignored records until the limit is satisfied.
+  #
+  # Open and in_progress records are never deleted automatically.
+  module Cleanup
+    def self.run(older_than_days: nil, dry_run: false)
+      deleted = 0
+
+      # ── Age-based pruning ───────────────────────────────────────────────
+      days = (older_than_days || ErrorRadar.config.retention_days)&.to_i
+      if days && days > 0
+        cutoff = days.days.ago
+        scope  = stale_scope.where('last_seen_at < ?', cutoff)
+        deleted += dry_run ? scope.count : scope.delete_all
+      end
+
+      # ── Count-based pruning ────────────────────────────────────────────
+      max = ErrorRadar.config.max_records&.to_i
+      if max && max > 0
+        total = ErrorLog.count
+        if total > max
+          excess = total - max
+          ids    = stale_scope.order(last_seen_at: :asc).limit(excess).pluck(:id)
+          deleted += dry_run ? ids.size : ErrorLog.where(id: ids).delete_all
+        end
+      end
+
+      { deleted: deleted, dry_run: dry_run }
+    end
+
+    def self.stale_scope
+      ErrorLog.where(status: [ErrorLog.statuses[:resolved], ErrorLog.statuses[:ignored]])
+    end
+    private_class_method :stale_scope
+  end
+end

data/lib/error_radar/configuration.rb

@@ -69,6 +69,29 @@ module ErrorRadar
       @error_callbacks << block
     end
 
+    # Performance ─────────────────────────────────────────────────────────────
+    # When true, ErrorLog.record is enqueued via ActiveJob (non-blocking).
+    # Requires ActiveJob to be configured. Falls back to sync if ActiveJob is absent.
+    attr_accessor :async_capture
+    # Queue name for CaptureJob when async_capture is enabled.
+    attr_accessor :capture_job_queue
+
+    # Retention ───────────────────────────────────────────────────────────────
+    # Auto-delete resolved/ignored records older than this many days (nil = keep forever).
+    attr_accessor :retention_days
+    # Keep at most this many total records; deletes oldest resolved/ignored first (nil = unlimited).
+    attr_accessor :max_records
+
+    # REST API ────────────────────────────────────────────────────────────────
+    # Bearer token for /api/* endpoints. nil = unauthenticated (not for prod).
+    attr_accessor :api_token
+
+    # GitHub integration ──────────────────────────────────────────────────────
+    # Personal access token with repo scope.
+    attr_accessor :github_token
+    # "owner/repo" string, e.g. "myorg/myapp".
+    attr_accessor :github_repo
+
     # Custom classification rules. Each is a callable `->(exception) { :category | nil }`.
     # The first rule that returns a non-nil category wins; built-in rules run after.
     attr_accessor :categorizers
@@ -124,6 +147,15 @@ module ErrorRadar
       @app_name             = nil
       @app_host             = nil
       @error_callbacks      = []
+
+      @async_capture     = false
+      @capture_job_queue = :default
+      @retention_days    = nil
+      @max_records       = nil
+
+      @api_token    = nil
+      @github_token = nil
+      @github_repo  = nil
       @categorizers       = []
       @detail_extractors  = []
       @expected_servers   = []

data/lib/error_radar/engine.rb

@@ -52,5 +52,9 @@ module ErrorRadar
         ErrorRadar::Integrations::RailsAdmin.install!
       end
     end
+
+    rake_tasks do
+      load File.expand_path('../tasks/error_radar.rake', __dir__)
+    end
   end
 end

data/lib/error_radar/integrations/github.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module ErrorRadar
+  module Integrations
+    # Creates GitHub issues from ErrorLog records via the GitHub REST API.
+    # Requires a personal access token with the `repo` scope and a repo in
+    # "owner/repo" format.
+    module Github
+      API_BASE = 'https://api.github.com'
+
+      # Returns the parsed JSON response from GitHub.
+      # Raises StandardError on network/API failure.
+      def self.create_issue(error_log, token:, repo:)
+        owner, repo_name = repo.split('/', 2)
+        uri  = URI("#{API_BASE}/repos/#{owner}/#{repo_name}/issues")
+
+        http              = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = true
+        http.open_timeout = 10
+        http.read_timeout = 10
+
+        req = Net::HTTP::Post.new(uri)
+        req['Authorization']        = "Bearer #{token}"
+        req['Content-Type']         = 'application/json'
+        req['Accept']               = 'application/vnd.github+json'
+        req['X-GitHub-Api-Version'] = '2022-11-28'
+        req.body = {
+          title:  issue_title(error_log),
+          body:   issue_body(error_log),
+          labels: ['bug', 'error-radar']
+        }.to_json
+
+        response = http.request(req)
+        JSON.parse(response.body)
+      end
+
+      def self.issue_title(log)
+        short_msg = log.message.to_s.truncate(80).gsub(/\n/, ' ')
+        "[Error Radar] #{log.error_class}: #{short_msg}"
+      end
+
+      def self.issue_body(log)
+        url       = ErrorRadar::Notifier.error_url(log)
+        backtrace = log.backtrace.to_s.split("\n").first(20).join("\n")
+
+        parts = []
+        parts << "## Error Details\n"
+        parts << "| Field | Value |"
+        parts << "|-------|-------|"
+        parts << "| **Error Class** | `#{log.error_class}` |"
+        parts << "| **Source** | #{log.source || 'unknown'} |"
+        parts << "| **Category** | #{log.category} |"
+        parts << "| **Severity** | #{log.severity} |"
+        parts << "| **Occurrences** | #{log.occurrences} |"
+        parts << "| **First seen** | #{log.first_seen_at&.strftime('%Y-%m-%d %H:%M UTC')} |"
+        parts << "| **Last seen** | #{log.last_seen_at&.strftime('%Y-%m-%d %H:%M UTC')} |"
+        parts << "\n## Message\n\n```\n#{log.message.to_s.truncate(1000)}\n```"
+
+        unless backtrace.empty?
+          parts << "\n## Backtrace\n\n```\n#{backtrace}\n```"
+        end
+
+        parts << "\n## Link\n\n[View in Error Radar](#{url})" if url
+
+        parts << "\n---\n*Created automatically by [Error Radar](https://github.com/chienbn9x/error_radar)*"
+        parts.join("\n")
+      end
+    end
+  end
+end

data/lib/error_radar/tracking.rb

@@ -27,6 +27,17 @@ module ErrorRadar
         attrs.merge!(extra.compact) if extra.is_a?(Hash)
       end
 
+      if ErrorRadar.config.async_capture && defined?(::ActiveJob::Base)
+        require 'error_radar/capture_job'
+        job_attrs = attrs.merge(
+          category: attrs[:category].to_s,
+          severity: attrs[:severity].to_s,
+          context:  safe_json(attrs[:context])
+        )
+        ErrorRadar::CaptureJob.perform_later(job_attrs.to_json)
+        return nil
+      end
+
       log = ErrorRadar::ErrorLog.record(**attrs)
       ErrorRadar::Notifier.dispatch(log) if log
       log
@@ -112,6 +123,12 @@ module ErrorRadar
       nil
     end
 
+    def safe_json(value)
+      JSON.parse(value.to_json)
+    rescue StandardError
+      {}
+    end
+
     def warn_internal(message)
       logger = defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : nil
       logger ? logger.error("[ErrorRadar] #{message}") : warn("[ErrorRadar] #{message}")

data/lib/error_radar/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ErrorRadar
-  VERSION = '0.4.0'
+  VERSION = '0.6.0'
 end

data/lib/error_radar.rb

@@ -4,6 +4,7 @@ require 'error_radar/version'
 require 'error_radar/configuration'
 require 'error_radar/tracking'
 require 'error_radar/notifier'
+require 'error_radar/cleanup'
 require 'error_radar/middleware'
 require 'error_radar/server_monitor'
 require 'error_radar/engine'

data/lib/generators/error_radar/install/templates/initializer.rb

@@ -72,6 +72,36 @@ ErrorRadar.configure do |config|
   # config.expected_servers = [
   #   { key: 'web', name: 'Web', tag: 'sidekiq_web', host: 'web', queue_hint: 'low' }
   # ]
+
+  # --- REST API ---
+  # Protect /api/* endpoints with a Bearer token.
+  # config.api_token = ENV['ERROR_RADAR_API_TOKEN']
+  # curl -H "Authorization: Bearer $TOKEN" https://myapp.com/error_radar/api/stats
+
+  # --- GitHub Integration ---
+  # Creates GitHub issues directly from the error detail page.
+  # Requires running: bin/rails generate error_radar:upgrade_v050 && bin/rails db:migrate
+  # config.github_token = ENV['GITHUB_TOKEN']   # PAT with repo scope
+  # config.github_repo  = 'myorg/myapp'         # "owner/repo" format
+
+  # --- Performance & Async Capture ---
+  # Write ErrorLog records via ActiveJob so exceptions don't block the request.
+  # Requires ActiveJob + a queue adapter (Sidekiq, Solid Queue, etc.).
+  # Falls back to synchronous capture if ActiveJob is unavailable.
+  # config.async_capture     = true
+  # config.capture_job_queue = :default   # queue name for CaptureJob
+
+  # --- Retention / Cleanup ---
+  # Auto-prune old resolved/ignored records to keep the table lean.
+  # Run `rake error_radar:cleanup` from a cron job or Heroku Scheduler.
+  # config.retention_days = 90    # delete resolved/ignored records older than 90 days
+  # config.max_records    = 50000 # hard cap; oldest resolved/ignored purged first
+  #
+  # Rake tasks available:
+  #   rake error_radar:cleanup              # apply retention_days + max_records
+  #   rake error_radar:cleanup:dry_run      # preview without deleting
+  #   rake error_radar:cleanup:older_than   # DAYS=30 rake error_radar:cleanup:older_than
+  #   rake error_radar:stats                # print table summary
 end
 
 # ActiveJob is now captured automatically via install_active_job = true above.

data/lib/generators/error_radar/upgrade_v050/templates/add_github_issue_to_error_radar_error_logs.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddGithubIssueToErrorRadarErrorLogs < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    add_column :error_radar_error_logs, :github_issue_url, :string, limit: 500
+  end
+end

data/lib/generators/error_radar/upgrade_v050/upgrade_v050_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module ErrorRadar
+  module Generators
+    class UpgradeV050Generator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Generates the migration for Error Radar v0.5.0 (adds github_issue_url column).'
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration_file
+        migration_template(
+          'add_github_issue_to_error_radar_error_logs.rb.tt',
+          'db/migrate/add_github_issue_to_error_radar_error_logs.rb'
+        )
+      end
+    end
+  end
+end

data/lib/tasks/error_radar.rake

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+namespace :error_radar do
+  desc 'Delete old resolved/ignored ErrorLogs per config.retention_days and config.max_records'
+  task cleanup: :environment do
+    result = ErrorRadar::Cleanup.run
+    puts "[ErrorRadar] Cleanup complete — #{result[:deleted]} record(s) deleted."
+  end
+
+  namespace :cleanup do
+    desc 'Preview what error_radar:cleanup would delete without actually deleting'
+    task dry_run: :environment do
+      result = ErrorRadar::Cleanup.run(dry_run: true)
+      puts "[ErrorRadar] Dry run — would delete #{result[:deleted]} record(s)."
+    end
+
+    desc 'Delete resolved/ignored ErrorLogs older than DAYS (e.g. DAYS=30 rake error_radar:cleanup:older_than)'
+    task older_than: :environment do
+      days = ENV.fetch('DAYS', nil)&.to_i
+      abort '[ErrorRadar] Set DAYS env var (e.g. DAYS=30)' unless days&.positive?
+
+      result = ErrorRadar::Cleanup.run(older_than_days: days)
+      puts "[ErrorRadar] Deleted #{result[:deleted]} record(s) older than #{days} days."
+    end
+  end
+
+  desc 'Print a summary of ErrorLog table stats'
+  task stats: :environment do
+    counts = ErrorRadar::ErrorLog.group(:status).count
+                                 .transform_keys { |k| ErrorRadar::ErrorLog.statuses.key(k) || k }
+    total  = counts.values.sum
+
+    puts "\n[ErrorRadar] Error log summary"
+    puts "  Total      : #{total}"
+    puts "  Open       : #{counts['open'] || 0}"
+    puts "  In progress: #{counts['in_progress'] || 0}"
+    puts "  Resolved   : #{counts['resolved'] || 0}"
+    puts "  Ignored    : #{counts['ignored'] || 0}"
+
+    oldest = ErrorRadar::ErrorLog.minimum(:first_seen_at)
+    puts "  Oldest     : #{oldest&.strftime('%Y-%m-%d') || '—'}"
+    puts ''
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: error_radar
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - chienbn9x
@@ -57,6 +57,9 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/controllers/error_radar/api/base_controller.rb
+- app/controllers/error_radar/api/errors_controller.rb
+- app/controllers/error_radar/api/stats_controller.rb
 - app/controllers/error_radar/application_controller.rb
 - app/controllers/error_radar/dashboard_controller.rb
 - app/controllers/error_radar/errors_controller.rb
@@ -72,9 +75,12 @@ files:
 - app/views/layouts/error_radar/application.html.erb
 - config/routes.rb
 - lib/error_radar.rb
+- lib/error_radar/capture_job.rb
+- lib/error_radar/cleanup.rb
 - lib/error_radar/configuration.rb
 - lib/error_radar/engine.rb
 - lib/error_radar/integrations/active_job.rb
+- lib/error_radar/integrations/github.rb
 - lib/error_radar/integrations/rails_admin.rb
 - lib/error_radar/integrations/rake.rb
 - lib/error_radar/integrations/sidekiq.rb
@@ -90,6 +96,9 @@ files:
 - lib/generators/error_radar/install/install_generator.rb
 - lib/generators/error_radar/install/templates/create_error_radar_error_logs.rb.tt
 - lib/generators/error_radar/install/templates/initializer.rb
+- lib/generators/error_radar/upgrade_v050/templates/add_github_issue_to_error_radar_error_logs.rb.tt
+- lib/generators/error_radar/upgrade_v050/upgrade_v050_generator.rb
+- lib/tasks/error_radar.rake
 homepage: https://github.com/chienbn9x/error_radar
 licenses:
 - MIT