findbug 0.2.0

data/app/models/findbug/error_event.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Findbug
+  # ErrorEvent stores captured exceptions in the database.
+  #
+  # DATABASE SCHEMA
+  # ===============
+  #
+  # This model expects a table created by the install generator:
+  #
+  #   create_table :findbug_error_events do |t|
+  #     t.string :fingerprint, null: false
+  #     t.string :exception_class, null: false
+  #     t.text :message
+  #     t.text :backtrace
+  #     t.jsonb :context, default: {}
+  #     t.jsonb :request_data, default: {}
+  #     t.string :environment
+  #     t.string :release_version
+  #     t.string :severity, default: 'error'
+  #     t.string :source
+  #     t.boolean :handled, default: false
+  #     t.integer :occurrence_count, default: 1
+  #     t.datetime :first_seen_at
+  #     t.datetime :last_seen_at
+  #     t.string :status, default: 'unresolved'
+  #     t.timestamps
+  #   end
+  #
+  # WHY JSONB FOR CONTEXT?
+  # ======================
+  #
+  # Context is semi-structured - different errors have different context.
+  # JSONB (in PostgreSQL) or JSON (in other DBs) lets us store any shape
+  # of data without schema migrations.
+  #
+  # For querying, we create GIN indexes on commonly queried paths.
+  #
+  class ErrorEvent < ActiveRecord::Base
+    self.table_name = "findbug_error_events"
+
+    # Statuses
+    STATUS_UNRESOLVED = "unresolved"
+    STATUS_RESOLVED = "resolved"
+    STATUS_IGNORED = "ignored"
+
+    # Severities
+    SEVERITY_ERROR = "error"
+    SEVERITY_WARNING = "warning"
+    SEVERITY_INFO = "info"
+
+    # Validations
+    validates :fingerprint, presence: true
+    validates :exception_class, presence: true
+    validates :status, inclusion: { in: [STATUS_UNRESOLVED, STATUS_RESOLVED, STATUS_IGNORED] }
+    validates :severity, inclusion: { in: [SEVERITY_ERROR, SEVERITY_WARNING, SEVERITY_INFO] }
+
+    # Scopes
+    scope :unresolved, -> { where(status: STATUS_UNRESOLVED) }
+    scope :resolved, -> { where(status: STATUS_RESOLVED) }
+    scope :ignored, -> { where(status: STATUS_IGNORED) }
+    scope :errors, -> { where(severity: SEVERITY_ERROR) }
+    scope :warnings, -> { where(severity: SEVERITY_WARNING) }
+    scope :recent, -> { order(last_seen_at: :desc) }
+    scope :by_occurrence, -> { order(occurrence_count: :desc) }
+
+    # Time-based scopes
+    scope :last_24_hours, -> { where("last_seen_at >= ?", 24.hours.ago) }
+    scope :last_7_days, -> { where("last_seen_at >= ?", 7.days.ago) }
+    scope :last_30_days, -> { where("last_seen_at >= ?", 30.days.ago) }
+
+    # Find or create an error event, incrementing count if exists
+    #
+    # @param event_data [Hash] the error event data from Redis
+    # @return [ErrorEvent] the created or updated error event
+    #
+    # UPSERT PATTERN
+    # ==============
+    #
+    # We use "upsert" logic: if an error with this fingerprint exists,
+    # we update it (increment count, update last_seen_at). Otherwise,
+    # we create a new record.
+    #
+    # This groups similar errors together instead of creating thousands
+    # of duplicate records.
+    #
+    def self.upsert_from_event(event_data)
+      fingerprint = event_data[:fingerprint]
+
+      # Use database-level locking to prevent race conditions
+      transaction do
+        existing = find_by(fingerprint: fingerprint)
+
+        if existing
+          # Update existing error
+          existing.occurrence_count += 1
+          existing.last_seen_at = Time.current
+
+          # Update context with latest (might have new info)
+          existing.context = merge_contexts(existing.context, event_data[:context])
+
+          # If it was resolved but happened again, reopen it
+          if existing.status == STATUS_RESOLVED
+            existing.status = STATUS_UNRESOLVED
+          end
+
+          existing.save!
+          existing
+        else
+          # Create new error
+          create!(
+            fingerprint: fingerprint,
+            exception_class: event_data[:exception_class],
+            message: event_data[:message],
+            backtrace: serialize_backtrace(event_data[:backtrace]),
+            context: event_data[:context] || {},
+            request_data: event_data[:context]&.dig(:request) || {},
+            environment: event_data[:environment],
+            release_version: event_data[:release],
+            severity: event_data[:severity] || SEVERITY_ERROR,
+            source: event_data[:source],
+            handled: event_data[:handled] || false,
+            occurrence_count: 1,
+            first_seen_at: Time.current,
+            last_seen_at: Time.current,
+            status: STATUS_UNRESOLVED
+          )
+        end
+      end
+    end
+
+    # Mark this error as resolved
+    def resolve!
+      update!(status: STATUS_RESOLVED)
+    end
+
+    # Mark this error as ignored
+    def ignore!
+      update!(status: STATUS_IGNORED)
+    end
+
+    # Reopen a resolved/ignored error
+    def reopen!
+      update!(status: STATUS_UNRESOLVED)
+    end
+
+    # Get parsed backtrace as array
+    def backtrace_lines
+      return [] unless backtrace
+
+      backtrace.is_a?(Array) ? backtrace : JSON.parse(backtrace)
+    rescue JSON::ParserError
+      backtrace.to_s.split("\n")
+    end
+
+    # Get user info from context
+    def user
+      context&.dig("user") || context&.dig(:user)
+    end
+
+    # Get request info from context
+    def request
+      context&.dig("request") || context&.dig(:request)
+    end
+
+    # Get breadcrumbs from context
+    def breadcrumbs
+      context&.dig("breadcrumbs") || context&.dig(:breadcrumbs) || []
+    end
+
+    # Get tags from context
+    def tags
+      context&.dig("tags") || context&.dig(:tags) || {}
+    end
+
+    # Short summary for lists
+    def summary
+      "#{exception_class}: #{message&.truncate(100)}"
+    end
+
+    private
+
+    def self.merge_contexts(old_context, new_context)
+      return new_context if old_context.blank?
+      return old_context if new_context.blank?
+
+      # Deep merge, preferring new values
+      old_context.deep_merge(new_context)
+    end
+
+    def self.serialize_backtrace(backtrace)
+      return nil unless backtrace
+
+      backtrace.is_a?(Array) ? backtrace.to_json : backtrace
+    end
+  end
+end

data/app/models/findbug/performance_event.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Findbug
+  # PerformanceEvent stores captured performance data in the database.
+  #
+  # DATABASE SCHEMA
+  # ===============
+  #
+  #   create_table :findbug_performance_events do |t|
+  #     t.string :transaction_name, null: false
+  #     t.string :transaction_type, default: 'request'
+  #     t.string :request_method
+  #     t.string :request_path
+  #     t.string :format
+  #     t.integer :status
+  #     t.float :duration_ms, null: false
+  #     t.float :db_time_ms, default: 0
+  #     t.float :view_time_ms, default: 0
+  #     t.integer :query_count, default: 0
+  #     t.jsonb :slow_queries, default: []
+  #     t.jsonb :n_plus_one_queries, default: []
+  #     t.boolean :has_n_plus_one, default: false
+  #     t.integer :view_count, default: 0
+  #     t.jsonb :context, default: {}
+  #     t.string :environment
+  #     t.string :release_version
+  #     t.datetime :captured_at
+  #     t.timestamps
+  #   end
+  #
+  # AGGREGATION STRATEGY
+  # ====================
+  #
+  # Unlike errors (which we group by fingerprint), we store every
+  # performance event individually. This allows:
+  #
+  # - Percentile calculations (p50, p95, p99)
+  # - Trend analysis over time
+  # - Individual slow request investigation
+  #
+  # For dashboards, we aggregate on read using SQL GROUP BY.
+  #
+  class PerformanceEvent < ActiveRecord::Base
+    self.table_name = "findbug_performance_events"
+
+    # Transaction types
+    TYPE_REQUEST = "request"
+    TYPE_CUSTOM = "custom"
+    TYPE_JOB = "job"
+
+    # Validations
+    validates :transaction_name, presence: true
+    validates :duration_ms, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    # Scopes
+    scope :requests, -> { where(transaction_type: TYPE_REQUEST) }
+    scope :custom, -> { where(transaction_type: TYPE_CUSTOM) }
+    scope :jobs, -> { where(transaction_type: TYPE_JOB) }
+    scope :slow, -> { where("duration_ms >= ?", Findbug.config.slow_request_threshold_ms) }
+    scope :with_n_plus_one, -> { where(has_n_plus_one: true) }
+    scope :recent, -> { order(captured_at: :desc) }
+
+    # Time-based scopes
+    scope :last_hour, -> { where("captured_at >= ?", 1.hour.ago) }
+    scope :last_24_hours, -> { where("captured_at >= ?", 24.hours.ago) }
+    scope :last_7_days, -> { where("captured_at >= ?", 7.days.ago) }
+
+    # Create a performance event from Redis data
+    #
+    # @param event_data [Hash] the performance event data
+    # @return [PerformanceEvent] the created event
+    #
+    def self.create_from_event(event_data)
+      create!(
+        transaction_name: event_data[:transaction_name],
+        transaction_type: event_data[:transaction_type] || TYPE_REQUEST,
+        request_method: event_data[:request_method],
+        request_path: event_data[:request_path],
+        format: event_data[:format],
+        status: event_data[:status],
+        duration_ms: event_data[:duration_ms],
+        db_time_ms: event_data[:db_time_ms] || 0,
+        view_time_ms: event_data[:view_time_ms] || 0,
+        query_count: event_data[:query_count] || 0,
+        slow_queries: event_data[:slow_queries] || [],
+        n_plus_one_queries: event_data[:n_plus_one_queries] || [],
+        has_n_plus_one: event_data[:has_n_plus_one] || false,
+        view_count: event_data[:view_count] || 0,
+        context: event_data[:context] || {},
+        environment: event_data[:environment],
+        release_version: event_data[:release],
+        captured_at: parse_captured_at(event_data[:captured_at])
+      )
+    end
+
+    # Aggregate stats for a transaction
+    #
+    # @param transaction_name [String] the transaction to aggregate
+    # @param since [Time] start time for aggregation
+    # @return [Hash] aggregated statistics
+    #
+    def self.aggregate_for(transaction_name, since: 24.hours.ago)
+      events = where(transaction_name: transaction_name)
+               .where("captured_at >= ?", since)
+
+      return nil if events.empty?
+
+      durations = events.pluck(:duration_ms).sort
+
+      {
+        transaction_name: transaction_name,
+        count: events.count,
+        avg_duration_ms: durations.sum / durations.size.to_f,
+        min_duration_ms: durations.first,
+        max_duration_ms: durations.last,
+        p50_duration_ms: percentile(durations, 50),
+        p95_duration_ms: percentile(durations, 95),
+        p99_duration_ms: percentile(durations, 99),
+        avg_query_count: events.average(:query_count).to_f.round(1),
+        n_plus_one_count: events.where(has_n_plus_one: true).count
+      }
+    end
+
+    # Get slowest transactions
+    #
+    # @param since [Time] start time
+    # @param limit [Integer] max results
+    # @return [Array<Hash>] slowest transactions with stats
+    #
+    def self.slowest_transactions(since: 24.hours.ago, limit: 10)
+      where("captured_at >= ?", since)
+        .group(:transaction_name)
+        .select(
+          "transaction_name",
+          "AVG(duration_ms) as avg_duration",
+          "MAX(duration_ms) as max_duration",
+          "COUNT(*) as request_count"
+        )
+        .order("avg_duration DESC")
+        .limit(limit)
+        .map do |row|
+          {
+            transaction_name: row.transaction_name,
+            avg_duration_ms: row.avg_duration.round(2),
+            max_duration_ms: row.max_duration.round(2),
+            count: row.request_count
+          }
+        end
+    end
+
+    # Get transactions with most N+1 issues
+    #
+    # @param since [Time] start time
+    # @param limit [Integer] max results
+    # @return [Array<Hash>] transactions with N+1 stats
+    #
+    def self.n_plus_one_hotspots(since: 24.hours.ago, limit: 10)
+      with_n_plus_one
+        .where("captured_at >= ?", since)
+        .group(:transaction_name)
+        .select(
+          "transaction_name",
+          "COUNT(*) as occurrence_count",
+          "AVG(query_count) as avg_queries"
+        )
+        .order("occurrence_count DESC")
+        .limit(limit)
+        .map do |row|
+          {
+            transaction_name: row.transaction_name,
+            n_plus_one_count: row.occurrence_count,
+            avg_queries: row.avg_queries.round(1)
+          }
+        end
+    end
+
+    # Get throughput over time (requests per minute)
+    #
+    # @param since [Time] start time
+    # @param interval [String] grouping interval ('minute', 'hour', 'day')
+    # @return [Array<Hash>] time series data
+    #
+    def self.throughput_over_time(since: 24.hours.ago, interval: "hour")
+      # This uses database-specific date truncation
+      # Works with PostgreSQL; adjust for other databases
+      time_column = case interval
+                    when "minute" then "date_trunc('minute', captured_at)"
+                    when "hour" then "date_trunc('hour', captured_at)"
+                    when "day" then "date_trunc('day', captured_at)"
+                    else "date_trunc('hour', captured_at)"
+                    end
+
+      where("captured_at >= ?", since)
+        .group(Arel.sql(time_column))
+        .select(
+          Arel.sql("#{time_column} as time_bucket"),
+          "COUNT(*) as request_count",
+          "AVG(duration_ms) as avg_duration"
+        )
+        .order(Arel.sql(time_column))
+        .map do |row|
+          {
+            time: row.time_bucket,
+            count: row.request_count,
+            avg_duration_ms: row.avg_duration.round(2)
+          }
+        end
+    end
+
+    private
+
+    def self.percentile(sorted_array, percentile)
+      return 0 if sorted_array.empty?
+
+      k = (percentile / 100.0) * (sorted_array.length - 1)
+      f = k.floor
+      c = k.ceil
+
+      if f == c
+        sorted_array[f]
+      else
+        sorted_array[f] + (k - f) * (sorted_array[c] - sorted_array[f])
+      end
+    end
+
+    def self.parse_captured_at(value)
+      case value
+      when Time, DateTime
+        value
+      when String
+        Time.parse(value)
+      else
+        Time.current
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+<h1>Dashboard</h1>
+<p class="page-description">Monitor errors and performance across your application.</p>
+
+<%# Redis connection warning %>
+<% if @stats[:buffer][:circuit_breaker_state] != :closed || @stats[:buffer][:error].present? %>
+  <div class="flash flash-error" style="margin-bottom: 1.5rem;">
+    <svg width="14" height="14" viewBox="0 0 16 16" fill="currentColor"><path d="M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16zM5.22 5.22a.75.75 0 0 1 1.06 0L8 6.94l1.72-1.72a.75.75 0 1 1 1.06 1.06L9.06 8l1.72 1.72a.75.75 0 1 1-1.06 1.06L8 9.06l-1.72 1.72a.75.75 0 0 1-1.06-1.06L6.94 8 5.22 6.28a.75.75 0 0 1 0-1.06z"/></svg>
+    <div>
+      <strong>Redis connection failed.</strong> Errors are not being captured.
+      <% if @stats[:buffer][:error].present? %>
+        <br><span class="text-muted text-xs"><%= @stats[:buffer][:error] %></span>
+      <% end %>
+      <br><span class="text-muted text-xs">Configured URL: <code style="background: hsl(var(--muted)); padding: 0.125rem 0.375rem; border-radius: 0.25rem;"><%= Findbug.config.redis_url %></code></span>
+    </div>
+  </div>
+<% end %>
+
+<%# Stats overview %>
+<div class="stats-grid">
+  <div class="stat-card">
+    <div class="stat-label">Unresolved Errors</div>
+    <div class="stat-value <%= @stats[:errors][:unresolved] > 0 ? 'error' : '' %>">
+      <%= @stats[:errors][:unresolved] %>
+    </div>
+    <div class="stat-change">Total: <%= @stats[:errors][:total] %></div>
+  </div>
+
+  <div class="stat-card">
+    <div class="stat-label">Errors (24h)</div>
+    <div class="stat-value"><%= @stats[:errors][:last_24h] %></div>
+    <div class="stat-change">Last 7d: <%= @stats[:errors][:last_7d] %></div>
+  </div>
+
+  <div class="stat-card">
+    <div class="stat-label">Avg Response Time</div>
+    <div class="stat-value"><%= @stats[:performance][:avg_duration] %><span class="text-muted text-sm">ms</span></div>
+    <div class="stat-change"><%= @stats[:performance][:last_24h] %> requests (24h)</div>
+  </div>
+
+  <div class="stat-card">
+    <div class="stat-label">N+1 Issues (24h)</div>
+    <div class="stat-value <%= @stats[:performance][:n_plus_one_count] > 0 ? 'warning' : '' %>">
+      <%= @stats[:performance][:n_plus_one_count] %>
+    </div>
+    <div class="stat-change">Performance issues detected</div>
+  </div>
+</div>
+
+<div class="grid-2">
+  <%# Recent Errors %>
+  <div class="card">
+    <div class="card-header">
+      <div>
+        <h2 class="card-title">Recent Errors</h2>
+        <p class="card-description">Unresolved errors from your application</p>
+      </div>
+      <a href="<%= findbug.errors_path %>" class="btn btn-outline btn-sm">View All</a>
+    </div>
+
+    <% if @recent_errors.any? %>
+      <table class="table">
+        <thead>
+          <tr>
+            <th>Error</th>
+            <th>Count</th>
+            <th>Last Seen</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @recent_errors.each do |error| %>
+            <tr>
+              <td>
+                <a href="<%= findbug.error_path(error) %>">
+                  <strong class="font-mono"><%= error.exception_class %></strong>
+                </a>
+                <br>
+                <span class="text-muted text-sm"><%= truncate(error.message, length: 60) %></span>
+              </td>
+              <td>
+                <span class="badge badge-<%= error.occurrence_count > 10 ? 'error' : 'muted' %>">
+                  <%= error.occurrence_count %>
+                </span>
+              </td>
+              <td class="text-muted text-sm">
+                <%= time_ago_in_words(error.last_seen_at) %> ago
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    <% else %>
+      <div class="empty-state">
+        <div class="empty-state-icon">
+          <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>
+            <polyline points="22 4 12 14.01 9 11.01"/>
+          </svg>
+        </div>
+        <p>No unresolved errors</p>
+      </div>
+    <% end %>
+  </div>
+
+  <%# Slowest Endpoints %>
+  <div class="card">
+    <div class="card-header">
+      <div>
+        <h2 class="card-title">Slowest Endpoints</h2>
+        <p class="card-description">Performance data from the last 24 hours</p>
+      </div>
+      <a href="<%= findbug.performance_index_path %>" class="btn btn-outline btn-sm">View All</a>
+    </div>
+
+    <% if @slowest_endpoints.any? %>
+      <table class="table">
+        <thead>
+          <tr>
+            <th>Endpoint</th>
+            <th>Avg</th>
+            <th>Max</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @slowest_endpoints.each do |endpoint| %>
+            <tr>
+              <td>
+                <a href="<%= findbug.performance_path(endpoint[:transaction_name]) %>" class="font-mono text-sm">
+                  <%= truncate(endpoint[:transaction_name], length: 35) %>
+                </a>
+              </td>
+              <td>
+                <span class="badge badge-<%= endpoint[:avg_duration_ms] > 500 ? 'warning' : 'muted' %>">
+                  <%= endpoint[:avg_duration_ms].round %>ms
+                </span>
+              </td>
+              <td class="text-muted text-sm">
+                <%= endpoint[:max_duration_ms].round %>ms
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    <% else %>
+      <div class="empty-state">
+        <div class="empty-state-icon">
+          <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+            <line x1="12" y1="20" x2="12" y2="10"/>
+            <line x1="18" y1="20" x2="18" y2="4"/>
+            <line x1="6" y1="20" x2="6" y2="16"/>
+          </svg>
+        </div>
+        <p>No performance data yet</p>
+      </div>
+    <% end %>
+  </div>
+</div>
+
+<%# System Status %>
+<div class="card">
+  <div class="card-header">
+    <div>
+      <h2 class="card-title">System Status</h2>
+      <p class="card-description">Buffer and system health information</p>
+    </div>
+  </div>
+  <div class="card-content">
+    <div class="stats-grid">
+      <div>
+        <div class="stat-label">Error Buffer</div>
+        <div class="stat-value" style="font-size: 1.5rem;">
+          <%= @stats[:buffer][:error_queue_length] || 0 %>
+        </div>
+        <div class="stat-change">events pending</div>
+      </div>
+      <div>
+        <div class="stat-label">Perf Buffer</div>
+        <div class="stat-value" style="font-size: 1.5rem;">
+          <%= @stats[:buffer][:performance_queue_length] || 0 %>
+        </div>
+        <div class="stat-change">events pending</div>
+      </div>
+      <div>
+        <div class="stat-label">Circuit Breaker</div>
+        <div style="margin-top: 0.5rem;">
+          <span class="status-dot <%= @stats[:buffer][:circuit_breaker_state] == :closed ? 'success' : 'error' %>"></span>
+          <span class="text-sm"><%= @stats[:buffer][:circuit_breaker_state] %></span>
+        </div>
+        <div class="stat-change">Redis connection status</div>
+      </div>
+      <div>
+        <div class="stat-label">Total Events</div>
+        <div class="stat-value" style="font-size: 1.5rem;">
+          <%= @stats[:errors][:total] + @stats[:performance][:total] %>
+        </div>
+        <div class="stat-change">all time</div>
+      </div>
+    </div>
+  </div>
+</div>