findbug 0.2.0

data/app/controllers/findbug/errors_controller.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Findbug
+  # ErrorsController handles error listing and detail views.
+  #
+  class ErrorsController < ApplicationController
+    before_action :set_error, only: [:show, :resolve, :ignore, :reopen]
+
+    # GET /findbug/errors
+    #
+    # List all errors with filtering.
+    #
+    def index
+      @errors = Findbug::ErrorEvent.all
+
+      # Apply filters
+      @errors = apply_filters(@errors)
+
+      # Pagination
+      @page = (params[:page] || 1).to_i
+      @per_page = 25
+      @total_count = @errors.count
+      @errors = @errors.offset((@page - 1) * @per_page).limit(@per_page)
+
+      render template: "findbug/errors/index", layout: "findbug/application"
+    end
+
+    # GET /findbug/errors/:id
+    #
+    # Show error details.
+    #
+    def show
+      @similar_errors = Findbug::ErrorEvent.where(exception_class: @error.exception_class)
+                                  .where.not(id: @error.id)
+                                  .recent
+                                  .limit(5)
+
+      render template: "findbug/errors/show", layout: "findbug/application"
+    end
+
+    # POST /findbug/errors/:id/resolve
+    #
+    # Mark error as resolved.
+    #
+    def resolve
+      @error.resolve!
+      flash_success "Error marked as resolved"
+      redirect_back(fallback_location: findbug.errors_path)
+    end
+
+    # POST /findbug/errors/:id/ignore
+    #
+    # Mark error as ignored.
+    #
+    def ignore
+      @error.ignore!
+      flash_success "Error marked as ignored"
+      redirect_back(fallback_location: findbug.errors_path)
+    end
+
+    # POST /findbug/errors/:id/reopen
+    #
+    # Reopen a resolved/ignored error.
+    #
+    def reopen
+      @error.reopen!
+      flash_success "Error reopened"
+      redirect_back(fallback_location: findbug.errors_path)
+    end
+
+    private
+
+    def set_error
+      @error = Findbug::ErrorEvent.find(params[:id])
+    end
+
+    def apply_filters(scope)
+      # Status filter
+      # Note: empty string means "All Statuses" was selected
+      if params[:status].present?
+        scope = scope.where(status: params[:status])
+      elsif !params.key?(:status)
+        # Default to unresolved only on initial page load (no filter submitted)
+        scope = scope.unresolved
+      end
+      # If params[:status] is "" (All Statuses), don't filter by status
+
+      # Severity filter
+      if params[:severity].present?
+        scope = scope.where(severity: params[:severity])
+      end
+
+      # Search filter
+      if params[:search].present?
+        search = "%#{params[:search]}%"
+        scope = scope.where(
+          "exception_class ILIKE :search OR message ILIKE :search",
+          search: search
+        )
+      end
+
+      # Date range filter
+      if params[:since].present?
+        since = parse_since(params[:since])
+        scope = scope.where("last_seen_at >= ?", since)
+      end
+
+      # Sort
+      case params[:sort]
+      when "oldest"
+        scope.order(last_seen_at: :asc)
+      when "occurrences"
+        scope.order(occurrence_count: :desc)
+      else
+        scope.recent # Default: most recent
+      end
+    end
+
+    def parse_since(value)
+      case value
+      when "1h" then 1.hour.ago
+      when "24h" then 24.hours.ago
+      when "7d" then 7.days.ago
+      when "30d" then 30.days.ago
+      else 24.hours.ago
+      end
+    end
+  end
+end

data/app/controllers/findbug/performance_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Findbug
+  # PerformanceController handles performance metrics views.
+  #
+  class PerformanceController < ApplicationController
+    # GET /findbug/performance
+    #
+    # Performance overview with slowest endpoints.
+    #
+    def index
+      @since = parse_since(params[:since] || "24h")
+
+      @slowest = Findbug::PerformanceEvent.slowest_transactions(since: @since, limit: 20)
+      @n_plus_one = Findbug::PerformanceEvent.n_plus_one_hotspots(since: @since, limit: 10)
+      @throughput = Findbug::PerformanceEvent.throughput_over_time(since: @since)
+      @stats = calculate_stats(@since)
+
+      render template: "findbug/performance/index", layout: "findbug/application"
+    end
+
+    # GET /findbug/performance/:id
+    #
+    # Show details for a specific transaction type.
+    #
+    def show
+      @transaction_name = params[:id]
+      @since = parse_since(params[:since] || "24h")
+
+      # Get events for this transaction
+      @events = Findbug::PerformanceEvent.where(transaction_name: @transaction_name)
+                                .where("captured_at >= ?", @since)
+                                .recent
+                                .limit(100)
+
+      # Calculate aggregates
+      @stats = Findbug::PerformanceEvent.aggregate_for(@transaction_name, since: @since)
+
+      # Get slowest individual requests
+      @slowest_requests = @events.order(duration_ms: :desc).limit(10)
+
+      # Get requests with N+1 issues
+      @n_plus_one_requests = @events.where(has_n_plus_one: true).limit(10)
+
+      render template: "findbug/performance/show", layout: "findbug/application"
+    end
+
+    private
+
+    def calculate_stats(since)
+      events = Findbug::PerformanceEvent.where("captured_at >= ?", since)
+
+      {
+        total_requests: events.count,
+        avg_duration: events.average(:duration_ms)&.round(2) || 0,
+        max_duration: events.maximum(:duration_ms)&.round(2) || 0,
+        avg_queries: events.average(:query_count)&.round(1) || 0,
+        n_plus_one_percentage: calculate_n_plus_one_percentage(events)
+      }
+    end
+
+    def calculate_n_plus_one_percentage(events)
+      total = events.count
+      return 0 if total.zero?
+
+      n_plus_one = events.where(has_n_plus_one: true).count
+      ((n_plus_one.to_f / total) * 100).round(1)
+    end
+
+    def parse_since(value)
+      case value
+      when "1h" then 1.hour.ago
+      when "24h" then 24.hours.ago
+      when "7d" then 7.days.ago
+      when "30d" then 30.days.ago
+      else 24.hours.ago
+      end
+    end
+  end
+end

data/app/jobs/findbug/alert_job.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Findbug
+  # AlertJob sends alerts asynchronously.
+  #
+  # WHY ASYNC ALERTS?
+  # =================
+  #
+  # Alert sending involves:
+  # - HTTP requests to Slack/Discord webhooks
+  # - Email delivery (SMTP)
+  # - Potential network latency
+  #
+  # If we did this synchronously during error capture:
+  # 1. Slow alerts would slow down error persistence
+  # 2. Failed alerts would block other alerts
+  # 3. Network issues would impact the persist job
+  #
+  # By using a separate job:
+  # 1. PersistJob stays fast
+  # 2. Alerts can retry independently
+  # 3. Network issues are isolated
+  #
+  class AlertJob < ActiveJob::Base
+    queue_as { Findbug.config.queue_name }
+
+    # Retry on network failures
+    retry_on StandardError, attempts: 3, wait: :polynomially_longer
+
+    def perform(error_event_id)
+      error_event = Findbug::ErrorEvent.find_by(id: error_event_id)
+      return unless error_event
+
+      Findbug::Alerts::Dispatcher.send_alerts(error_event)
+    rescue ActiveRecord::RecordNotFound
+      # Event was deleted, skip alerting
+      Findbug.logger.debug("[Findbug] Alert skipped: error event #{error_event_id} not found")
+    end
+  end
+end

data/app/jobs/findbug/cleanup_job.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Findbug
+  # CleanupJob removes old data based on retention policy.
+  #
+  # WHY CLEANUP?
+  # ============
+  #
+  # Without cleanup, your database would grow forever:
+  # - 1000 errors/day x 30 days = 30,000 records
+  # - 10000 perf events/day x 30 days = 300,000 records
+  #
+  # Cleanup enforces retention policy:
+  # - Default: 30 days
+  # - Configurable via config.retention_days
+  #
+  # WHAT GETS CLEANED
+  # =================
+  #
+  # 1. Error events older than retention_days
+  #    - Except: unresolved errors (you probably want to fix these!)
+  #
+  # 2. Performance events older than retention_days
+  #    - All performance data is cleaned (it's meant for trends, not forever)
+  #
+  # 3. Resolved/ignored errors older than retention_days
+  #
+  # SCHEDULING
+  # ==========
+  #
+  # Run this daily (not too often, not too rare):
+  #
+  #   findbug_cleanup:
+  #     cron: "0 3 * * *"  # 3 AM daily
+  #     class: Findbug::CleanupJob
+  #
+  class CleanupJob < ActiveJob::Base
+    queue_as { Findbug.config.queue_name }
+
+    # Delete in batches to avoid long-running transactions
+    BATCH_SIZE = 1000
+
+    def perform
+      return unless Findbug.enabled?
+
+      cleanup_errors
+      cleanup_performance
+
+      Findbug.logger.info("[Findbug] Cleanup completed")
+    rescue StandardError => e
+      Findbug.logger.error("[Findbug] CleanupJob failed: #{e.message}")
+      raise
+    end
+
+    private
+
+    def cleanup_errors
+      cutoff_date = retention_days.days.ago
+
+      # Delete resolved and ignored errors older than retention
+      deleted_count = delete_in_batches(
+        Findbug::ErrorEvent.where(status: [Findbug::ErrorEvent::STATUS_RESOLVED, Findbug::ErrorEvent::STATUS_IGNORED])
+                  .where("last_seen_at < ?", cutoff_date)
+      )
+
+      # Optionally delete very old unresolved errors (e.g., 3x retention)
+      # This prevents truly ancient errors from accumulating
+      very_old_cutoff = (retention_days * 3).days.ago
+      old_unresolved_count = delete_in_batches(
+        Findbug::ErrorEvent.unresolved.where("last_seen_at < ?", very_old_cutoff)
+      )
+
+      total = deleted_count + old_unresolved_count
+      if total.positive?
+        Findbug.logger.info("[Findbug] Cleaned up #{total} error events")
+      end
+    end
+
+    def cleanup_performance
+      cutoff_date = retention_days.days.ago
+
+      # Delete all performance events older than retention
+      deleted_count = delete_in_batches(
+        Findbug::PerformanceEvent.where("captured_at < ?", cutoff_date)
+      )
+
+      if deleted_count.positive?
+        Findbug.logger.info("[Findbug] Cleaned up #{deleted_count} performance events")
+      end
+    end
+
+    # Delete records in batches to avoid long transactions
+    #
+    # WHY BATCHING?
+    # =============
+    #
+    # Deleting 100,000 records in one query:
+    # 1. Locks the table for a long time
+    # 2. Can cause deadlocks with other queries
+    # 3. Uses lots of memory for transaction log
+    # 4. Might timeout
+    #
+    # Batching (1000 at a time):
+    # 1. Short locks between batches
+    # 2. Other queries can interleave
+    # 3. Steady memory usage
+    # 4. Can be interrupted and resumed
+    #
+    def delete_in_batches(scope)
+      total_deleted = 0
+
+      loop do
+        # Get IDs of records to delete
+        ids = scope.limit(BATCH_SIZE).pluck(:id)
+        break if ids.empty?
+
+        # Delete this batch
+        deleted = scope.where(id: ids).delete_all
+        total_deleted += deleted
+
+        # Give other queries a chance
+        sleep(0.01)
+      end
+
+      total_deleted
+    end
+
+    def retention_days
+      Findbug.config.retention_days
+    end
+  end
+end

data/app/jobs/findbug/persist_job.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Findbug
+  # PersistJob moves data from Redis buffer to the database.
+  #
+  # THE TWO-PHASE STORAGE PATTERN
+  # =============================
+  #
+  # Phase 1: Real-time capture (Redis)
+  # - Happens in your request thread
+  # - Must be FAST (1-2ms)
+  # - Non-blocking
+  # - Data is temporary (24h TTL)
+  #
+  # Phase 2: Persistence (Database)
+  # - Happens in background job
+  # - Can be slow (50-100ms per batch)
+  # - Doesn't affect user requests
+  # - Data is permanent
+  #
+  # WHY THIS PATTERN?
+  # =================
+  #
+  # Direct database writes in the request cycle would:
+  # 1. Add 50-100ms latency to every error
+  # 2. Risk database connection exhaustion under high error rates
+  # 3. Create contention with app's own database traffic
+  #
+  # By buffering in Redis first:
+  # 1. Capture is instant (Redis LPUSH is ~1ms)
+  # 2. Database writes are batched (more efficient)
+  # 3. Load is smoothed out over time
+  #
+  # SCHEDULING
+  # ==========
+  #
+  # This job should run periodically (every 30 seconds is a good default).
+  # You can set this up with:
+  #
+  # 1. Sidekiq-scheduler / sidekiq-cron:
+  #
+  #    findbug_persist:
+  #      cron: "*/30 * * * * *"  # Every 30 seconds
+  #      class: Findbug::PersistJob
+  #
+  # 2. Whenever gem (cron):
+  #
+  #    every 30.seconds do
+  #      runner "Findbug::PersistJob.perform_now"
+  #    end
+  #
+  # 3. Solid Queue (Rails 8):
+  #
+  #    Findbug::PersistJob.set(wait: 30.seconds).perform_later
+  #    (then reschedule itself at the end)
+  #
+  class PersistJob < ActiveJob::Base
+    queue_as { Findbug.config.queue_name }
+
+    # Maximum number of events to process in one job run
+    # This prevents the job from running too long
+    MAX_EVENTS_PER_RUN = 1000
+
+    def perform
+      return unless Findbug.enabled?
+
+      persist_errors
+      persist_performance
+    rescue StandardError => e
+      Findbug.logger.error("[Findbug] PersistJob failed: #{e.message}")
+      raise # Re-raise to trigger job retry
+    end
+
+    # Persist error events from Redis to database
+    def persist_errors
+      batch_size = Findbug.config.persist_batch_size
+      total_persisted = 0
+
+      loop do
+        # Pop a batch from Redis
+        events = Findbug::Storage::RedisBuffer.pop_errors(batch_size)
+        break if events.empty?
+
+        # Process the batch
+        self.class.persist_errors_batch(events)
+        total_persisted += events.size
+
+        # Safety limit to prevent infinite loops
+        break if total_persisted >= MAX_EVENTS_PER_RUN
+
+        # Small sleep to avoid hammering the database
+        sleep(0.01)
+      end
+
+      if total_persisted.positive?
+        Findbug.logger.info("[Findbug] Persisted #{total_persisted} error events")
+      end
+    end
+
+    # Persist performance events from Redis to database
+    def persist_performance
+      batch_size = Findbug.config.persist_batch_size
+      total_persisted = 0
+
+      loop do
+        events = Findbug::Storage::RedisBuffer.pop_performance(batch_size)
+        break if events.empty?
+
+        self.class.persist_performance_batch(events)
+        total_persisted += events.size
+
+        break if total_persisted >= MAX_EVENTS_PER_RUN
+
+        sleep(0.01)
+      end
+
+      if total_persisted.positive?
+        Findbug.logger.info("[Findbug] Persisted #{total_persisted} performance events")
+      end
+    end
+
+    class << self
+      # Persist a batch of error events
+      #
+      # @param events [Array<Hash>] error event data
+      #
+      def persist_errors_batch(events)
+        events.each do |event_data|
+          # Scrub sensitive data before persisting
+          scrubbed = Findbug::Processing::DataScrubber.scrub(event_data)
+
+          # Upsert to database
+          Findbug::ErrorEvent.upsert_from_event(scrubbed)
+        rescue StandardError => e
+          Findbug.logger.error(
+            "[Findbug] Failed to persist error event: #{e.message}"
+          )
+          # Continue with other events
+        end
+      end
+
+      # Persist a batch of performance events
+      #
+      # @param events [Array<Hash>] performance event data
+      #
+      def persist_performance_batch(events)
+        events.each do |event_data|
+          scrubbed = Findbug::Processing::DataScrubber.scrub(event_data)
+          Findbug::PerformanceEvent.create_from_event(scrubbed)
+        rescue StandardError => e
+          Findbug.logger.error(
+            "[Findbug] Failed to persist performance event: #{e.message}"
+          )
+        end
+      end
+    end
+  end
+end