rails_error_dashboard 0.8.0 → 0.8.2

data/lib/rails_error_dashboard/commands/flush_storm_counts.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Reconcile counted-not-stored storm events onto ErrorLog rows
+    # and maintain the storm_events episode record.
+    #
+    # Runs in a background job (DB allowed). For each counted fingerprint:
+    #   1. Recompute the canonical error_hash from the stored identity parts
+    #      (the gate's key deliberately omits application_id — resolved here)
+    #   2. Unresolved match  → single UPDATE: occurrence_count += N
+    #   3. Resolved match    → reopen (mirrors FindOrIncrementError semantics)
+    #   4. No match          → create a minimal ErrorLog from the exemplar
+    #
+    # Counts are exact. Notifications are NOT dispatched from here — during a
+    # storm they're suppressed by design; the storm notification covers it.
+    class FlushStormCounts
+      def self.call(entries:, overflow: 0, episode: nil)
+        new(entries: entries, overflow: overflow, episode: episode).call
+      end
+
+      def initialize(entries:, overflow: 0, episode: nil)
+        @entries = Array(entries)
+        @overflow = overflow.to_i
+        @episode = episode
+      end
+
+      def call
+        application = resolve_application
+        counted = 0
+
+        @entries.each do |entry|
+          entry = entry.with_indifferent_access if entry.respond_to?(:with_indifferent_access)
+          counted += reconcile_entry(entry, application)
+        rescue => e
+          # A corrupt (non-Hash) entry must not abort the whole batch — and the
+          # log line itself must not assume `entry` is subscriptable (an Integer
+          # from a broken serializer would raise again here, escaping this rescue).
+          error_class = entry.is_a?(Hash) ? entry["error_class"] : entry.class
+          RailsErrorDashboard::Logger.error(
+            "[RailsErrorDashboard] Storm count reconcile failed for #{error_class}: #{e.class} - #{e.message}"
+          )
+        end
+
+        upsert_storm_event(counted)
+        { success: true, reconciled: counted, overflow: @overflow }
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] FlushStormCounts failed: #{e.class} - #{e.message}"
+        )
+        { success: false, error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def reconcile_entry(entry, application)
+        count = entry["count"].to_i
+        return 0 if count <= 0
+
+        error_hash = canonical_hash(entry, application)
+        last_seen = parse_time(entry["last_seen_at"]) || Time.current
+
+        # Priority 1: unresolved match — one UPDATE, no row instantiation
+        updated = ErrorLog.unresolved
+          .where(error_hash: error_hash, application_id: application.id)
+          .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
+        return count if updated.positive?
+
+        # Priority 2: resolved/wont_fix match — reopen, mirroring
+        # FindOrIncrementError so storm recurrences don't stay buried
+        resolved = ErrorLog
+          .where(error_hash: error_hash, application_id: application.id)
+          .where(status: %w[resolved wont_fix])
+          .order(last_seen_at: :desc)
+          .first
+        if resolved
+          attrs = {
+            resolved: false,
+            status: "new",
+            resolved_at: nil,
+            occurrence_count: resolved.occurrence_count + count,
+            last_seen_at: last_seen
+          }
+          attrs[:reopened_at] = Time.current if ErrorLog.column_names.include?("reopened_at")
+          resolved.update!(attrs)
+          return count
+        end
+
+        # Priority 3: first seen during count-only mode — minimal ErrorLog
+        # from the exemplar (no backtrace/context was captured; the next
+        # occurrence after the storm fills in detail via the normal path)
+        ErrorLog.create!(
+          application_id: application.id,
+          error_type: entry["error_class"],
+          message: entry["message"],
+          backtrace: entry["first_app_frame"],
+          controller_name: entry["controller_name"],
+          action_name: entry["action_name"],
+          occurred_at: parse_time(entry["first_seen_at"]) || Time.current,
+          last_seen_at: last_seen,
+          occurrence_count: count,
+          error_hash: error_hash,
+          resolved: false
+        )
+        count
+      end
+
+      # Mirrors ErrorHashGenerator.call exactly: same fields, same order,
+      # same normalization — so counts land on the same ErrorLog the full
+      # capture path would have used.
+      def canonical_hash(entry, application)
+        return entry["custom_hash"] if entry["custom_hash"].present?
+
+        digest_input = [
+          entry["error_class"],
+          Services::ErrorHashGenerator.normalize_message(entry["message"]),
+          entry["first_app_frame"],
+          entry["controller_name"],
+          entry["action_name"],
+          application.id.to_s
+        ].compact.join("|")
+
+        Digest::SHA256.hexdigest(digest_input)[0..15]
+      end
+
+      def resolve_application
+        # Same chain LogError uses — app name is process-global
+        app_name = RailsErrorDashboard.configuration.application_name ||
+                   ENV["APPLICATION_NAME"] ||
+                   (defined?(Rails) && Rails.application.class.module_parent_name) ||
+                   "Rails Application"
+        Application.find_or_create_by_name(app_name)
+      end
+
+      def upsert_storm_event(counted)
+        return unless @episode.is_a?(Hash)
+        return unless StormEvent.table_exists?
+
+        started_at = parse_time(@episode["started_at"])
+        return unless started_at
+
+        event = StormEvent.active.recent_first.first || StormEvent.create!(started_at: started_at)
+
+        event.events_counted_only = event.events_counted_only.to_i + counted
+        event.events_overflow = event.events_overflow.to_i + @overflow
+        # events_total is the count-only total: in-map reconciled + overflow.
+        # It deliberately excludes :lite/:full admissions (those became real
+        # ErrorLog rows on the hot path and are never counted here), so it is
+        # always events_counted_only + events_overflow. Derive it rather than
+        # accumulate so it can't drift from its two components.
+        event.events_total = event.events_counted_only.to_i + event.events_overflow.to_i
+        event.fingerprints_affected = [ event.fingerprints_affected.to_i, @entries.size ].max
+        event.peak_rate_per_minute = [ event.peak_rate_per_minute.to_i, @episode["peak_rate_per_minute"].to_i ].max
+        event.reached_open ||= @episode["reached_open"] == true
+        event.top_fingerprints = top_fingerprints_json(event)
+        event.ended_at = parse_time(@episode["ended_at"]) if @episode["ended_at"]
+        event.save!
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] Storm event upsert failed: #{e.class} - #{e.message}"
+        )
+      end
+
+      def top_fingerprints_json(event)
+        existing = event.top_fingerprints_list
+        fresh = @entries.map { |e|
+          e = e.with_indifferent_access if e.respond_to?(:with_indifferent_access)
+          { "class" => e["error_class"], "message" => e["message"].to_s[0, 120], "count" => e["count"].to_i }
+        }
+
+        merged = (existing + fresh)
+          .group_by { |f| [ f["class"], f["message"] ] }
+          .map { |_k, group| group.first.merge("count" => group.sum { |f| f["count"].to_i }) }
+
+        merged.sort_by { |f| -f["count"].to_i }.first(5).to_json
+      end
+
+      def parse_time(value)
+        return value if value.is_a?(Time) || value.is_a?(ActiveSupport::TimeWithZone)
+        return nil if value.blank?
+
+        Time.zone.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/link_existing_issue.rb

@@ -14,7 +14,9 @@ module RailsErrorDashboard
       PROVIDER_PATTERNS = {
         github: %r{github\.com/([^/]+/[^/]+)/issues/(\d+)}i,
         gitlab: %r{gitlab\.com/([^/]+/[^/]+)/-/issues/(\d+)}i,
-        codeberg: %r{codeberg\.org/([^/]+/[^/]+)/issues/(\d+)}i
+        codeberg: %r{codeberg\.org/([^/]+/[^/]+)/issues/(\d+)}i,
+        # https://linear.app/<workspace>/issue/ENG-123/<slug> — capture team key + number
+        linear: %r{linear\.app/[^/]+/issue/([A-Za-z][A-Za-z0-9]*)-(\d+)}i
       }.freeze
 
       def self.call(error_id, issue_url:)

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -6,15 +6,59 @@ module RailsErrorDashboard
     # This is a write operation that creates an ErrorLog record
     class LogError
       def self.call(exception, context = {})
-        # Check if async logging is enabled
+        # Filter FIRST (ignore list + static sampling) so ignored exceptions
+        # never count toward storm state. _pre_filtered prevents the sync path
+        # from re-rolling the sampling dice (rate would square otherwise).
+        # The filter + gate run inside this method's rescue: nothing in the
+        # capture path may ever raise into the host app.
+        begin
+          unless Services::ExceptionFilter.should_log?(exception)
+            # Preserve the OTel contract: filtered captures still emit a span
+            # tagged filtered=true (no-op when OTel export is disabled).
+            Integrations::Tracer.in_span(
+              "capture_error",
+              kind: :capture,
+              attributes: build_capture_span_attributes(exception, was_async: false)
+            ) do |span|
+              span&.set_attribute("rails_error_dashboard.filtered", true)
+            end
+            return nil
+          end
+          context = context.merge(_pre_filtered: true)
+
+          # Storm protection gate — BEFORE the async branch, because with
+          # SolidQueue the enqueue itself is a DB write. :count_only events are
+          # tallied in memory and reconciled by StormFlushJob; nothing else
+          # happens for them (that's the point).
+          storm_decision = Services::StormProtection::Gate.admit!(exception, context)
+          return nil if storm_decision == :count_only
+          context = context.merge(_storm_decision: storm_decision) if storm_decision == :lite
+        rescue => e
+          RailsErrorDashboard::Logger.error(
+            "[RailsErrorDashboard] Capture pre-checks failed: #{e.class} - #{e.message}"
+          )
+          # Fall through and attempt full capture — fail open, never raise
+        end
+
         if RailsErrorDashboard.configuration.async_logging
           # For async logging, just enqueue the job
-          # All filtering happens when the job runs
           call_async(exception, context)
         else
           # For sync logging, execute immediately
           new(exception, context).call
         end
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] LogError.call failed: #{e.class} - #{e.message}"
+        )
+        nil
+      end
+
+      # :lite captures shed context (breadcrumbs/health/locals/ivars) — the
+      # storm shedding ladder's first economy. Symbol or string key: the
+      # async job round-trips context through the queue serializer.
+      def self.storm_lite?(context)
+        context[:_storm_decision].to_s == "lite"
       end
 
       # Build the base OTel span attributes available before any work happens.
@@ -42,18 +86,22 @@ module RailsErrorDashboard
           cause_chain: serialize_cause_chain(exception)
         }
 
+        # Storm shedding: :lite captures skip ALL pre-enqueue context harvest —
+        # this is request-thread CPU, the most valuable thing to shed.
+        lite = storm_lite?(context)
+
         # Harvest breadcrumbs NOW (before job dispatch — different thread won't have them)
-        if RailsErrorDashboard.configuration.enable_breadcrumbs
+        if !lite && RailsErrorDashboard.configuration.enable_breadcrumbs
           context = context.merge(_serialized_breadcrumbs: Services::BreadcrumbCollector.harvest)
         end
 
         # Capture system health NOW (metrics are time-sensitive, different thread = different state)
-        if RailsErrorDashboard.configuration.enable_system_health
+        if !lite && RailsErrorDashboard.configuration.enable_system_health
           context = context.merge(_serialized_system_health: Services::SystemHealthSnapshot.capture)
         end
 
         # Capture local variables NOW (TracePoint attaches to exception, must extract before job dispatch)
-        if RailsErrorDashboard.configuration.enable_local_variables
+        if !lite && RailsErrorDashboard.configuration.enable_local_variables
           begin
             raw_locals = Services::LocalVariableCapturer.extract(exception)
             if raw_locals.is_a?(Hash) && raw_locals.any?
@@ -65,7 +113,7 @@ module RailsErrorDashboard
         end
 
         # Capture instance variables NOW (same reason — attached to exception object)
-        if RailsErrorDashboard.configuration.enable_instance_variables
+        if !lite && RailsErrorDashboard.configuration.enable_instance_variables
           begin
             raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(exception)
             if raw_ivars.is_a?(Hash) && raw_ivars.any?
@@ -157,12 +205,19 @@ module RailsErrorDashboard
           kind: :capture,
           attributes: self.class.build_capture_span_attributes(@exception, was_async: false)
         ) do |span|
-        # Check if this exception should be logged (ignore list + sampling)
-        if !Services::ExceptionFilter.should_log?(@exception)
+        # Check if this exception should be logged (ignore list + sampling).
+        # Skipped when self.call already filtered (re-rolling the sampling
+        # dice here would square the effective rate).
+        if !@context[:_pre_filtered] && !Services::ExceptionFilter.should_log?(@exception)
           span&.set_attribute("rails_error_dashboard.filtered", true)
           next nil
         end
 
+        # Storm shedding: :lite captures keep the error + occurrence row but
+        # shed context payloads (breadcrumbs/health/locals/ivars).
+        storm_lite = self.class.storm_lite?(@context)
+        span&.set_attribute("rails_error_dashboard.storm_degraded", true) if storm_lite
+
         error_context = ValueObjects::ErrorContext.new(@context, @context[:source])
 
         # Find or create application (cached lookup)
@@ -239,7 +294,7 @@ module RailsErrorDashboard
         attributes = Services::SensitiveDataFilter.filter_attributes(attributes)
 
         # Harvest breadcrumbs (if enabled and column exists)
-        if ErrorLog.column_names.include?("breadcrumbs") && RailsErrorDashboard.configuration.enable_breadcrumbs
+        if !storm_lite && ErrorLog.column_names.include?("breadcrumbs") && RailsErrorDashboard.configuration.enable_breadcrumbs
           # Sync path: harvest from current thread
           raw_breadcrumbs = Services::BreadcrumbCollector.harvest
 
@@ -256,13 +311,13 @@ module RailsErrorDashboard
         end
 
         # Capture system health snapshot (if enabled and column exists)
-        if ErrorLog.column_names.include?("system_health") && RailsErrorDashboard.configuration.enable_system_health
+        if !storm_lite && ErrorLog.column_names.include?("system_health") && RailsErrorDashboard.configuration.enable_system_health
           health_data = @context[:_serialized_system_health] || Services::SystemHealthSnapshot.capture
           attributes[:system_health] = health_data.to_json
         end
 
         # Capture local variables (if enabled and column exists)
-        if ErrorLog.column_names.include?("local_variables") && RailsErrorDashboard.configuration.enable_local_variables
+        if !storm_lite && ErrorLog.column_names.include?("local_variables") && RailsErrorDashboard.configuration.enable_local_variables
           begin
             # Sync path: extract from exception ivar
             raw_locals = Services::LocalVariableCapturer.extract(@exception)
@@ -278,7 +333,7 @@ module RailsErrorDashboard
         end
 
         # Capture instance variables (if enabled and column exists)
-        if ErrorLog.column_names.include?("instance_variables") && RailsErrorDashboard.configuration.enable_instance_variables
+        if !storm_lite && ErrorLog.column_names.include?("instance_variables") && RailsErrorDashboard.configuration.enable_instance_variables
           begin
             # Sync path: extract from exception ivar
             raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(@exception)
@@ -364,8 +419,11 @@ module RailsErrorDashboard
 
       # Dispatch notification if error is not muted and the throttle check passes.
       # Muted errors skip notifications but still fire plugin events/callbacks.
+      # During a storm (breaker not closed) per-error notifications are
+      # suppressed — a single storm notification replaces them.
       def maybe_notify(error_log)
         return if error_log.muted?
+        return if Services::StormProtection::Gate.notifications_suppressed?
         return unless yield
 
         Services::ErrorNotificationDispatcher.call(error_log)

data/lib/rails_error_dashboard/configuration.rb

@@ -67,6 +67,25 @@ module RailsErrorDashboard
     # Sampling rate for non-critical errors (0.0 to 1.0, default 1.0 = 100%)
     attr_accessor :sampling_rate
 
+    # Storm protection — circuit breaker + adaptive sampling for error floods.
+    # Protects the HOST APP from the gem's own writes during an error storm
+    # (bad deploy throwing thousands of errors/minute). Default ON: this is
+    # the feature that makes the gem quieter, so ON is the conservative choice.
+    # All thresholds are PER PROCESS (no cross-process coordination by design).
+    attr_accessor :enable_storm_protection            # Master switch (default: true)
+    attr_accessor :storm_fingerprint_full_per_minute  # Full-fidelity captures per fingerprint per minute (default: 30)
+    attr_accessor :storm_occurrence_sample_keep_every # Past the cap, keep every Nth occurrence (default: 10)
+    attr_accessor :storm_shedding_threshold_per_second # Global rate that enters shedding state (default: 10)
+    attr_accessor :storm_open_threshold_per_second    # Global rate that opens the breaker = count-only (default: 50)
+    attr_accessor :storm_cooldown_seconds             # Open → half-open probe delay (default: 60)
+    attr_accessor :storm_max_tracked_fingerprints     # Bounded in-memory map size; beyond = overflow bucket (default: 1000)
+    attr_accessor :storm_flush_interval_seconds       # Count-buffer flush cadence (default: 30)
+    attr_accessor :storm_notification                 # Single "storm in progress" notification per episode (default: true)
+    attr_accessor :auto_issue_rate_limit_count        # Max auto-created issues per window — applies always (default: 5)
+    attr_accessor :auto_issue_rate_limit_window_minutes # Window for the above (default: 10)
+    attr_accessor :context_sampling_threshold_per_day # Full-context captures per fingerprint per day before sampling (default: 25)
+    attr_accessor :context_sampling_keep_every        # After threshold, keep full context every Nth (default: 10)
+
     # Async logging configuration
     attr_accessor :async_logging
     attr_accessor :async_adapter # :sidekiq, :solid_queue, or :async
@@ -92,8 +111,8 @@ module RailsErrorDashboard
     # issue_webhook_secret is set.
     attr_accessor :enable_issue_tracking         # Master switch (default: false) — enables all platform integration
     attr_accessor :issue_tracker_token            # String or lambda/proc for Rails credentials
-    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url)
-    attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url)
+    attr_accessor :issue_tracker_provider         # :github, :gitlab, :codeberg (auto-detected from git_repository_url), or :linear (explicit only)
+    attr_accessor :issue_tracker_repo             # "owner/repo" (auto-extracted from git_repository_url), or Linear team key like "ENG"
     attr_accessor :issue_tracker_labels           # Array of label strings (default: ["bug"])
     attr_accessor :issue_tracker_api_url          # Custom API base URL for self-hosted instances
     attr_accessor :issue_tracker_auto_create_severities  # Auto-create for these severities (default: [:critical, :high])
@@ -268,6 +287,21 @@ module RailsErrorDashboard
       @ignored_exceptions = []
       @custom_fingerprint = nil # Lambda: ->(exception, context) { "custom_key" }
       @sampling_rate = 1.0 # 100% by default
+
+      # Storm protection defaults (thresholds tuned via chaos Phase G — see ROADMAP)
+      @enable_storm_protection = true
+      @storm_fingerprint_full_per_minute = 30
+      @storm_occurrence_sample_keep_every = 10
+      @storm_shedding_threshold_per_second = 10
+      @storm_open_threshold_per_second = 50
+      @storm_cooldown_seconds = 60
+      @storm_max_tracked_fingerprints = 1000
+      @storm_flush_interval_seconds = 30
+      @storm_notification = true
+      @auto_issue_rate_limit_count = 5
+      @auto_issue_rate_limit_window_minutes = 10
+      @context_sampling_threshold_per_day = 25
+      @context_sampling_keep_every = 10
       @async_logging = false
       @async_adapter = :sidekiq # Battle-tested default
       @max_backtrace_lines = 100 # Matches industry standard (Rollbar, Airbrake)
@@ -604,7 +638,8 @@ module RailsErrorDashboard
 
         if enable_issue_tracking && effective_issue_tracker_provider.nil?
           warnings << "enable_issue_tracking is true but provider could not be detected. " \
-                      "Set issue_tracker_provider or git_repository_url."
+                      "Set issue_tracker_provider (:github, :gitlab, :codeberg, :linear) or git_repository_url. " \
+                      "Note: :linear is never auto-detected — set it explicitly with issue_tracker_repo as the team key."
         end
       end
 
@@ -682,6 +717,32 @@ module RailsErrorDashboard
         end
       end
 
+      # Validate storm protection thresholds (all must be positive when protection is on)
+      if enable_storm_protection
+        {
+          storm_fingerprint_full_per_minute: storm_fingerprint_full_per_minute,
+          storm_occurrence_sample_keep_every: storm_occurrence_sample_keep_every,
+          storm_shedding_threshold_per_second: storm_shedding_threshold_per_second,
+          storm_open_threshold_per_second: storm_open_threshold_per_second,
+          storm_cooldown_seconds: storm_cooldown_seconds,
+          storm_max_tracked_fingerprints: storm_max_tracked_fingerprints,
+          storm_flush_interval_seconds: storm_flush_interval_seconds,
+          auto_issue_rate_limit_count: auto_issue_rate_limit_count,
+          auto_issue_rate_limit_window_minutes: auto_issue_rate_limit_window_minutes,
+          context_sampling_threshold_per_day: context_sampling_threshold_per_day,
+          context_sampling_keep_every: context_sampling_keep_every
+        }.each do |name, value|
+          if value.nil? || value.to_i < 1
+            errors << "#{name} must be a positive integer (got: #{value.inspect})"
+          end
+        end
+
+        if storm_open_threshold_per_second.to_i < storm_shedding_threshold_per_second.to_i
+          errors << "storm_open_threshold_per_second (#{storm_open_threshold_per_second}) must be >= " \
+                    "storm_shedding_threshold_per_second (#{storm_shedding_threshold_per_second})"
+        end
+      end
+
       # Validate total_users_for_impact (must be positive if set)
       if total_users_for_impact && total_users_for_impact < 1
         errors << "total_users_for_impact must be at least 1 (got: #{total_users_for_impact})"
@@ -736,9 +797,11 @@ module RailsErrorDashboard
       default || blank
     end
 
-    # Resolve the effective issue tracker provider (auto-detect from git_repository_url)
+    # Resolve the effective issue tracker provider (auto-detect from git_repository_url).
+    # Linear is never auto-detected (it is not a git forge) — set issue_tracker_provider
+    # explicitly.
     #
-    # @return [Symbol, nil] :github, :gitlab, :codeberg, or nil
+    # @return [Symbol, nil] :github, :gitlab, :codeberg, :linear, or nil
     def effective_issue_tracker_provider
       return issue_tracker_provider&.to_sym if issue_tracker_provider.present?
       return nil if git_repository_url.blank?
@@ -751,11 +814,13 @@ module RailsErrorDashboard
       end
     end
 
-    # Resolve the effective issue tracker repository ("owner/repo")
+    # Resolve the effective issue tracker repository ("owner/repo", or Linear team key)
     #
-    # @return [String, nil] "owner/repo" or nil
+    # @return [String, nil] "owner/repo", Linear team key, or nil
     def effective_issue_tracker_repo
       return issue_tracker_repo if issue_tracker_repo.present?
+      # A git URL can never yield a Linear team key — require explicit config
+      return nil if effective_issue_tracker_provider == :linear
       return nil if git_repository_url.blank?
 
       # Extract owner/repo from URL: https://github.com/owner/repo(.git)
@@ -783,6 +848,7 @@ module RailsErrorDashboard
       when :github then "https://api.github.com"
       when :gitlab then "https://gitlab.com/api/v4"
       when :codeberg then "https://codeberg.org/api/v1"
+      when :linear then "https://api.linear.app/graphql"
       end
     end
 

data/lib/rails_error_dashboard/queries/storm_history.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Storm protection episode history + active-storm lookup.
+    #
+    # Read-only. Powers the /errors/storms page and the layout banner.
+    class StormHistory
+      RECENT_BANNER_WINDOW = 24.hours
+
+      def self.call(limit: 50)
+        return { active: nil, recent: nil, events: [] } unless StormEvent.table_exists?
+
+        {
+          active: StormEvent.active.recent_first.first,
+          recent: StormEvent.ended_within(RECENT_BANNER_WINDOW).recent_first.first,
+          events: StormEvent.recent_first.limit(limit).to_a
+        }
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] StormHistory query failed: #{e.message}"
+        )
+        { active: nil, recent: nil, events: [] }
+      end
+
+      # Cheap banner lookup for the layout — one indexed query on the happy
+      # path (no active storm), two when a banner is showing.
+      def self.banner_event
+        return nil unless RailsErrorDashboard.configuration.enable_storm_protection
+        return nil unless StormEvent.table_exists?
+
+        StormEvent.active.recent_first.first ||
+          StormEvent.ended_within(RECENT_BANNER_WINDOW).recent_first.first
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/issue_tracker_client.rb

@@ -8,8 +8,9 @@ module RailsErrorDashboard
   module Services
     # Base class and factory for issue tracker API clients.
     #
-    # Supports GitHub, GitLab, and Codeberg/Gitea/Forgejo via a unified interface.
-    # Each provider implements the same methods with provider-specific API calls.
+    # Supports GitHub, GitLab, Codeberg/Gitea/Forgejo, and Linear via a unified
+    # interface. Each provider implements the same methods with provider-specific
+    # API calls.
     #
     # @example
     #   client = IssueTrackerClient.for(:github, token: "ghp_xxx", repo: "user/repo")
@@ -23,9 +24,9 @@ module RailsErrorDashboard
 
       # Factory method — returns the correct client for the provider
       #
-      # @param provider [Symbol] :github, :gitlab, or :codeberg
+      # @param provider [Symbol] :github, :gitlab, :codeberg, or :linear
       # @param token [String] API authentication token
-      # @param repo [String] Repository identifier ("owner/repo")
+      # @param repo [String] Repository identifier ("owner/repo"), or Linear team key ("ENG")
       # @param api_url [String, nil] Custom API base URL (for self-hosted)
       # @return [IssueTrackerClient] Provider-specific client instance
       def self.for(provider, token:, repo:, api_url: nil)
@@ -36,8 +37,10 @@ module RailsErrorDashboard
           GitLabIssueClient.new(token: token, repo: repo, api_url: api_url)
         when :codeberg
           CodebergIssueClient.new(token: token, repo: repo, api_url: api_url)
+        when :linear
+          LinearIssueClient.new(token: token, repo: repo, api_url: api_url)
         else
-          raise ArgumentError, "Unknown issue tracker provider: #{provider}. Supported: :github, :gitlab, :codeberg"
+          raise ArgumentError, "Unknown issue tracker provider: #{provider}. Supported: :github, :gitlab, :codeberg, :linear"
         end
       end