rails_error_dashboard 0.10.0 → 0.11.1

data/lib/rails_error_dashboard/commands/flush_storm_counts.rb

@@ -59,20 +59,38 @@ module RailsErrorDashboard
 
         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?
+        env = current_environment
+
+        # Priority 1: unresolved match — one UPDATE, no row instantiation.
+        # Environment mirrors FindOrIncrementError: exact row first, then a
+        # legacy NULL row which is stamped as it is claimed. Two statements
+        # rather than one IN (env, NULL), because update_all would hit BOTH
+        # rows when they coexist and double-count.
+        unresolved = ErrorLog.unresolved.where(error_hash: error_hash, application_id: application.id)
+        if env
+          updated = unresolved.where(environment: env)
+            .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
+          return count if updated.positive?
+
+          updated = unresolved.where(environment: nil)
+            .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?, environment = ?",
+                          count, last_seen, env ])
+          return count if updated.positive?
+        else
+          updated = unresolved.update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
+          return count if updated.positive?
+        end
 
         # Priority 2: resolved/wont_fix match — reopen, mirroring
         # FindOrIncrementError so storm recurrences don't stay buried
-        resolved = ErrorLog
+        resolved_scope = ErrorLog
           .where(error_hash: error_hash, application_id: application.id)
           .where(status: %w[resolved wont_fix])
-          .order(last_seen_at: :desc)
-          .first
+        if env
+          resolved_scope = resolved_scope.where(environment: [ env, nil ])
+            .order(Arel.sql("CASE WHEN environment IS NULL THEN 1 ELSE 0 END"))
+        end
+        resolved = resolved_scope.order(last_seen_at: :desc).first
         if resolved
           attrs = {
             resolved: false,
@@ -82,6 +100,7 @@ module RailsErrorDashboard
             last_seen_at: last_seen
           }
           attrs[:reopened_at] = Time.current if ErrorLog.column_names.include?("reopened_at")
+          attrs[:environment] = env if env && resolved.environment.blank?
           resolved.update!(attrs)
           return count
         end
@@ -89,7 +108,11 @@ module RailsErrorDashboard
         # 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)
+        create_attrs = {
+          environment: env
+        }.compact
         ErrorLog.create!(
+          **create_attrs,
           application_id: application.id,
           error_type: entry["error_class"],
           message: entry["message"],
@@ -123,6 +146,14 @@ module RailsErrorDashboard
         Digest::SHA256.hexdigest(digest_input)[0..15]
       end
 
+      # nil when the column is not migrated yet, so every environment clause
+      # above disappears and the command behaves exactly as before.
+      def current_environment
+        return nil unless ErrorLog.column_names.include?("environment")
+
+        RailsErrorDashboard.configuration.current_environment
+      end
+
       def resolve_application
         # Same chain LogError uses — app name is process-global
         app_name = RailsErrorDashboard.configuration.application_name ||

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -290,6 +290,12 @@ module RailsErrorDashboard
           attributes[:environment_info] = Services::EnvironmentSnapshot.snapshot.to_json
         end
 
+        # Environment awareness (if column exists). context wins so a sender
+        # elsewhere can attribute an event to its own environment.
+        if ErrorLog.column_names.include?("environment")
+          attributes[:environment] = resolve_environment
+        end
+
         # Apply sensitive data filtering (on by default)
         attributes = Services::SensitiveDataFilter.filter_attributes(attributes)
 
@@ -424,12 +430,22 @@ module RailsErrorDashboard
       def maybe_notify(error_log)
         return if error_log.muted?
         return if Services::StormProtection::Gate.notifications_suppressed?
+        return unless Services::NotificationThrottler.environment_allowed?(error_log)
         return unless yield
 
         Services::ErrorNotificationDispatcher.call(error_log)
         Services::NotificationThrottler.record_notification(error_log)
       end
 
+      # The environment this error is attributed to: an explicit context value
+      # (truncated to the column) or the process-wide resolution. Never nil.
+      def resolve_environment
+        name = @context[:environment].to_s.strip
+        return name[0, 64] unless name.empty?
+
+        RailsErrorDashboard.configuration.current_environment
+      end
+
       # Find or create application for multi-app support
       def find_or_create_application
         app_name = RailsErrorDashboard.configuration.application_name ||
@@ -492,6 +508,7 @@ module RailsErrorDashboard
         # Return early if baseline alerts are disabled or error is muted
         return unless config.enable_baseline_alerts
         return if error_log.muted?
+        return unless Services::NotificationThrottler.environment_allowed?(error_log)
         return unless defined?(Queries::BaselineStats)
         return unless defined?(BaselineAlertJob)
 

data/lib/rails_error_dashboard/configuration.rb

@@ -14,6 +14,12 @@ module RailsErrorDashboard
     attr_accessor :application_name
     attr_accessor :database  # Database connection name for shared error dashboard DB
 
+    # Environment awareness. Errors record which environment they came from
+    # (production, staging, uat, ...). Names are free-form strings, never an
+    # enum -- teams invent environment names, and a fixed list is wrong tomorrow.
+    attr_accessor :environment                # Overrides Rails.env for captured errors (ENV: ERROR_DASHBOARD_ENVIRONMENT)
+    attr_accessor :notification_environments  # Only notify for these environments; nil = all (ENV: ERROR_DASHBOARD_NOTIFICATION_ENVIRONMENTS)
+
     # Notifications
     attr_accessor :slack_webhook_url
     attr_accessor :notification_email_recipients
@@ -262,6 +268,10 @@ module RailsErrorDashboard
       @application_name = ENV["APPLICATION_NAME"]  # Auto-detected if not set
       @database = nil  # Use primary database by default
 
+      # Environment awareness defaults: attribute to Rails.env unless overridden
+      @environment = ENV["ERROR_DASHBOARD_ENVIRONMENT"].to_s.strip.then { |v| v.empty? ? nil : v }
+      @notification_environments = parse_name_list(ENV["ERROR_DASHBOARD_NOTIFICATION_ENVIRONMENTS"])
+
       # Notification settings (disabled by default - enable during installation or in initializer)
       @slack_webhook_url = ENV["SLACK_WEBHOOK_URL"]
       @notification_email_recipients = ENV.fetch("ERROR_NOTIFICATION_EMAILS", "").split(",").map(&:strip)
@@ -792,6 +802,26 @@ module RailsErrorDashboard
         errors << "total_users_for_impact must be at least 1 (got: #{total_users_for_impact})"
       end
 
+      # Validate environment (free-form, but it has to fit the 64-char column)
+      unless environment.nil?
+        if !environment.is_a?(String) || environment.strip.empty?
+          errors << "environment must not be blank (got: #{environment.inspect}); leave it nil to use Rails.env"
+        elsif environment.length > 64
+          errors << "environment must be 64 characters or fewer (got #{environment.length})"
+        end
+      end
+
+      # Validate notification_environments (nil = notify everywhere; otherwise names only)
+      unless notification_environments.nil?
+        valid_list = notification_environments.is_a?(Array) &&
+                     notification_environments.any? &&
+                     notification_environments.all? { |name| name.is_a?(String) && !name.strip.empty? }
+        unless valid_list
+          errors << "notification_environments must be nil or a non-empty Array of environment names " \
+                    "(got: #{notification_environments.inspect})"
+        end
+      end
+
       # Validate notification_minimum_severity (must be valid symbol)
       if notification_minimum_severity
         valid_notification_severities = %i[critical high medium low]
@@ -822,6 +852,28 @@ module RailsErrorDashboard
       true
     end
 
+    # The environment this process attributes captured errors to.
+    #
+    # Explicit option first, then Rails.env. Never nil and never raises: an
+    # error must still be captured when the environment cannot be named.
+    #
+    # @return [String]
+    def current_environment
+      name = environment.to_s.strip
+      return name unless name.empty?
+
+      rails_env = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env.to_s.strip : ""
+      rails_env.empty? ? "unknown" : rails_env
+    rescue StandardError
+      "unknown"
+    end
+
+    # "production, uat" -> ["production", "uat"]; blank or all-blank -> nil.
+    def parse_name_list(raw)
+      list = raw.to_s.split(",").map(&:strip).reject(&:empty?)
+      list.empty? ? nil : list
+    end
+
     # Check if using default or blank demo credentials with basic auth
     #
     # Returns false if the user explicitly set ENV vars (even to the same default values),

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -25,6 +25,7 @@ module RailsErrorDashboard
             errors_over_time: errors_over_time,
             errors_by_type: errors_by_type,
             errors_by_platform: errors_by_platform,
+            errors_by_environment: errors_by_environment,
             errors_by_hour: errors_by_hour,
             top_users: top_affected_users,
             resolution_rate: resolution_rate,
@@ -88,6 +89,14 @@ module RailsErrorDashboard
         base_query.group(:platform).count
       end
 
+      # NULL (captured before the column existed) is reported under :unknown
+      # rather than dropped, so the chart's total still matches the period.
+      def errors_by_environment
+        return {} unless ErrorLog.column_names.include?("environment")
+
+        base_query.group(:environment).count.transform_keys { |env| env.nil? ? :unknown : env }
+      end
+
       def errors_by_hour
         # group_by_hour_of_day buckets into 0..23 to show diurnal patterns
         # (when in the day errors peak). The chart title says "Errors by Hour

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -28,6 +28,7 @@ module RailsErrorDashboard
         query = filter_by_error_type(query)
         query = filter_by_resolved(query)
         query = filter_by_platform(query)
+        query = filter_by_environment(query)
         query = filter_by_application(query)
         query = filter_by_user_id(query)
         query = filter_by_app_version(query)
@@ -92,6 +93,13 @@ module RailsErrorDashboard
         query.where(platform: @filters[:platform])
       end
 
+      def filter_by_environment(query)
+        return query unless @filters[:environment].present?
+        return query unless ErrorLog.column_names.include?("environment")
+
+        query.where(environment: @filters[:environment])
+      end
+
       def filter_by_application(query)
         return query unless @filters[:application_id].present?
 

data/lib/rails_error_dashboard/queries/filter_options.rb

@@ -17,11 +17,20 @@ module RailsErrorDashboard
         {
           error_types: base_scope.distinct.pluck(:error_type).compact.sort,
           platforms: base_scope.distinct.pluck(:platform).compact,
+          environments: environments,
           applications: Application.ordered_by_name.pluck(:name, :id),
           assignees: assignees
         }
       end
 
+      # Sorted so the select is stable between requests. Empty until the
+      # environment migration has run, so the index simply shows no filter.
+      def environments
+        return [] unless ErrorLog.column_names.include?("environment")
+
+        base_scope.distinct.pluck(:environment).compact.sort
+      end
+
       def assignees
         base_scope.where.not(assigned_to: nil)
                   .select(:assigned_to)

data/lib/rails_error_dashboard/services/discord_payload_builder.rb

@@ -47,6 +47,7 @@ module RailsErrorDashboard
                 value: error_log.platform || unknown,
                 inline: true
               },
+              *environment_fields(error_log, locale),
               {
                 name: NotificationHelpers.label(:occurrences, locale),
                 value: error_log.occurrence_count.to_s,
@@ -84,6 +85,13 @@ module RailsErrorDashboard
 
       # @param error_log [ErrorLog] The error
       # @return [Integer] Discord color integer
+      # One field when the error carries an environment, none for a legacy row.
+      def self.environment_fields(error_log, locale)
+        return [] unless error_log.respond_to?(:environment) && error_log.environment.present?
+
+        [ { name: NotificationHelpers.label(:environment, locale), value: error_log.environment, inline: true } ]
+      end
+
       def self.severity_color(error_log)
         SEVERITY_COLORS[error_log.severity] || DEFAULT_COLOR
       end

data/lib/rails_error_dashboard/services/error_broadcaster.rb

@@ -23,9 +23,11 @@ module RailsErrorDashboard
 
         platforms = ErrorLog.distinct.pluck(:platform).compact
         show_platform = platforms.size > 1
+        show_environment = ErrorLog.column_names.include?("environment") &&
+                           ErrorLog.distinct.pluck(:environment).compact.size > 1
 
         html = render_partial("rails_error_dashboard/errors/error_row",
-          error: error_log, show_platform: show_platform)
+          error: error_log, show_platform: show_platform, show_environment: show_environment)
 
         Turbo::StreamsChannel.broadcast_prepend_to(
           "error_list",
@@ -46,9 +48,11 @@ module RailsErrorDashboard
 
         platforms = ErrorLog.distinct.pluck(:platform).compact
         show_platform = platforms.size > 1
+        show_environment = ErrorLog.column_names.include?("environment") &&
+                           ErrorLog.distinct.pluck(:environment).compact.size > 1
 
         html = render_partial("rails_error_dashboard/errors/error_row",
-          error: error_log, show_platform: show_platform)
+          error: error_log, show_platform: show_platform, show_environment: show_environment)
 
         Turbo::StreamsChannel.broadcast_replace_to(
           "error_list",

data/lib/rails_error_dashboard/services/issue_body_formatter.rb

@@ -104,6 +104,7 @@ module RailsErrorDashboard
 
       def metadata_section
         items = []
+        items << "- **Environment:** #{@error.environment}" if @error.respond_to?(:environment) && @error.environment.present?
         items << "- **Platform:** #{@error.platform}" if @error.platform.present?
         items << "- **First seen:** #{@error.first_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}" if @error.first_seen_at
         items << "- **Occurrences:** #{@error.occurrence_count}" if @error.occurrence_count

data/lib/rails_error_dashboard/services/markdown_error_formatter.rb

@@ -435,6 +435,7 @@ module RailsErrorDashboard
 
       def metadata_section
         items = []
+        items << "- **Environment:** #{@error.environment}" if @error.respond_to?(:environment) && @error.environment.present?
         items << "- **Platform:** #{@error.platform}" if @error.platform.present?
         items << "- **First seen:** #{@error.first_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}" if @error.first_seen_at
         items << "- **Occurrences:** #{@error.occurrence_count}" if @error.occurrence_count

data/lib/rails_error_dashboard/services/notification_throttler.rb

@@ -29,6 +29,29 @@ module RailsErrorDashboard
           true
         end
 
+        # Does this error's environment pass config.notification_environments?
+        #
+        # nil list → everything notifies (the pre-0.11 behaviour). Accepts an
+        # ErrorLog, a bare environment name, or nothing (the process
+        # environment) — the storm and baseline paths have no row to hand over.
+        # A legacy row with a NULL environment is judged as the process
+        # environment, so upgrading never silences an error that was notifying
+        # before. Fails open: an allowlist bug must not lose a page.
+        #
+        # @param subject [ErrorLog, String, nil]
+        # @return [Boolean]
+        def environment_allowed?(subject = nil)
+          allowed = RailsErrorDashboard.configuration.notification_environments
+          return true if allowed.nil?
+
+          name = subject.respond_to?(:environment) ? subject.environment : subject
+          name = RailsErrorDashboard.configuration.current_environment if name.blank?
+          allowed.include?(name.to_s)
+        rescue => e
+          RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] NotificationThrottler.environment_allowed? failed: #{e.message}")
+          true
+        end
+
         # Does the error's severity meet the configured minimum?
         # @param error_log [ErrorLog] The error to check
         # @return [Boolean] true if severity is at or above minimum

data/lib/rails_error_dashboard/services/pagerduty_payload_builder.rb

@@ -46,6 +46,7 @@ module RailsErrorDashboard
               controller: error_log.controller_name,
               action: error_log.action_name,
               platform: error_log.platform,
+              environment: error_log.environment,
               occurrences: error_log.occurrence_count,
               first_seen_at: error_log.first_seen_at&.iso8601,
               last_seen_at: error_log.last_seen_at&.iso8601,

data/lib/rails_error_dashboard/services/slack_payload_builder.rb

@@ -64,6 +64,7 @@ module RailsErrorDashboard
                 locale
               )
             },
+            *environment_fields(error_log, locale),
             {
               type: "mrkdwn",
               text: NotificationHelpers.field(
@@ -74,6 +75,14 @@ module RailsErrorDashboard
         }
       end
 
+      # One field when the error carries an environment, none for a legacy
+      # row — so pre-0.11 notifications render exactly as they did.
+      def self.environment_fields(error_log, locale)
+        return [] unless error_log.respond_to?(:environment) && error_log.environment.present?
+
+        [ { type: "mrkdwn", text: NotificationHelpers.field(:environment, error_log.environment, locale) } ]
+      end
+
       def self.message_block(error_log, locale)
         {
           type: "section",

data/lib/rails_error_dashboard/services/storm_protection/gate.rb

@@ -232,6 +232,8 @@ module RailsErrorDashboard
           def maybe_storm_notification(state)
             return if state == :closed
             return unless RailsErrorDashboard.configuration.storm_notification
+            # A storm on staging should not page whoever is on call for production.
+            return unless RailsErrorDashboard::Services::NotificationThrottler.environment_allowed?
 
             episode = breaker.episode_snapshot
             return unless episode

data/lib/rails_error_dashboard/services/webhook_payload_builder.rb

@@ -37,6 +37,7 @@ module RailsErrorDashboard
             message: error_log.message,
             severity: error_log.severity.to_s,
             platform: error_log.platform,
+            environment: error_log.environment,
             controller: error_log.controller_name,
             action: error_log.action_name,
             occurrence_count: error_log.occurrence_count,

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.10.0"
+  VERSION = "0.11.1"
 end

data/lib/rails_error_dashboard.rb

@@ -109,6 +109,7 @@ require "rails_error_dashboard/commands/resolve_error"
 require "rails_error_dashboard/commands/create_issue"
 require "rails_error_dashboard/commands/link_existing_issue"
 require "rails_error_dashboard/commands/flush_storm_counts"
+require "rails_error_dashboard/commands/backfill_environments"
 require "rails_error_dashboard/services/issue_body_formatter"
 require "rails_error_dashboard/commands/batch_resolve_errors"
 require "rails_error_dashboard/commands/batch_delete_errors"

data/lib/tasks/rails_error_dashboard_tasks.rake

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 namespace :rails_error_dashboard do
+  desc "Fill in environment on error logs captured before the column existed (from environment_info.rails_env)"
+  task backfill_environments: :environment do
+    updated = RailsErrorDashboard::Commands::BackfillEnvironments.call
+    puts "rails_error_dashboard: backfilled environment on #{updated} error log(s)."
+  end
+
   namespace :db do
     desc "Drop all Rails Error Dashboard database tables (⚠️  DESTRUCTIVE - deletes all error data)"
     task drop: :environment do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -219,29 +219,24 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
-description: 'Own your errors. Own your stack. A fully open-source, self-hosted error
-  tracking Rails engine — a free Sentry alternative that runs entirely inside your
-  own process, with no external services and zero recurring cost. Captures what SaaS
-  tools charge extra for: local and instance variables at the moment of failure (via
-  TracePoint), exception cause chains, swallowed-exception detection, breadcrumbs,
-  and system-health snapshots (GC, memory, threads, connection pool, Puma). Plus N+1
-  query detection, storm protection (a circuit breaker that shields your app from
-  error floods, ON by default), multi-app support, error sampling, and async logging
-  via Sidekiq, SolidQueue, or GoodJob. Runs on SQLite, PostgreSQL, or MySQL/Trilogy
-  — in your app''s existing database or an isolated separate error database. Beautiful
-  dashboard UI (dark/light), multi-channel notifications (Slack, Email, Discord, PagerDuty,
-  webhooks), workflow management, advanced analytics, platform detection (iOS/Android/Web/API),
-  and two-way issue sync with GitHub, GitLab, Codeberg, and Linear. Also: LLM observability,
-  AI-powered debugging help, and OpenTelemetry span export. The dashboard, mailers
-  and notification payloads are translated into 11 languages: English, German, Spanish,
-  French, Brazilian Portuguese, Italian, Polish, Russian, Ukrainian, Japanese, and
-  Simplified Chinese — 1,515 source strings, set via config.dashboard_locale with
-  a per-user picker. RED translates through its own private I18n backend and never
-  mutates your app''s I18n; a missing translation falls back to English. Backtraces,
-  exception names and webhook payload keys stay English by design. The ten non-English
-  locales are machine-translated and not yet reviewed by native speakers. 5-minute
-  setup, works out-of-the-box. Rails 7.0-8.1, Ruby 3.2-4.0. BETA: API may change before
-  v1.0.0. Live demo: https://rails-error-dashboard.anjan.dev (gandalf/youshallnotpass)'
+description: 'Rails Error Dashboard (RED) is an open-source, self-hosted Rails engine
+  for investigating production exceptions without sending error data to a monitoring
+  vendor. It groups errors and records request context and cause chains and, when
+  enabled, breadcrumbs plus local and instance variables captured before Ruby unwinds
+  the stack. RED attaches Rails and Ruby runtime health to the error record on every
+  captured occurrence, including Active Record pool, Puma, background jobs, GC, memory,
+  threads, file descriptors and system pressure. Built-in storm protection progressively
+  sheds expensive context and I/O during error floods while retaining useful exemplars
+  and exact occurrence counts. Run RED with your application''s database or an isolated
+  error database. It supports PostgreSQL, MySQL/Trilogy and SQLite, and includes workflow,
+  notifications (Slack, Email, Discord, PagerDuty, webhooks), two-way issue sync with
+  GitHub, GitLab, Codeberg and Linear, Copy as RSpec/curl/LLM, swallowed-exception
+  detection, LLM observability without prompt capture, OpenTelemetry span export and
+  Rails-specific operational views. The dashboard is translated into 11 languages
+  (machine-translated outside English, awaiting native review). A self-hosted Sentry
+  alternative that keeps error data in your own database. The gem is MIT and free
+  forever. Supports Rails 7.0-8.1 and Ruby 3.2-4.0. Beta: APIs may change before 1.0.
+  Live demo: https://rails-error-dashboard.anjan.dev'
 email:
 - anjan.jagirdar@gmail.com
 executables: []
@@ -392,6 +387,7 @@ files:
 - db/migrate/20260613000001_create_storm_events.rb
 - db/migrate/20260730000001_create_rails_error_dashboard_rack_attack_events.rb
 - db/migrate/20260824000001_add_user_agent_to_rack_attack_events.rb
+- db/migrate/20260826000001_add_environment_to_error_logs.rb
 - lib/generators/rails_error_dashboard/install/install_generator.rb
 - lib/generators/rails_error_dashboard/install/templates/README
 - lib/generators/rails_error_dashboard/install/templates/initializer.rb
@@ -401,6 +397,7 @@ files:
 - lib/rails_error_dashboard.rb
 - lib/rails_error_dashboard/commands/add_error_comment.rb
 - lib/rails_error_dashboard/commands/assign_error.rb
+- lib/rails_error_dashboard/commands/backfill_environments.rb
 - lib/rails_error_dashboard/commands/batch_delete_errors.rb
 - lib/rails_error_dashboard/commands/batch_mute_errors.rb
 - lib/rails_error_dashboard/commands/batch_resolve_errors.rb
@@ -559,7 +556,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.10.0
+    RED (Rails Error Dashboard) v0.11.1
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install:
@@ -597,6 +594,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Self-hosted error tracking for Rails — local variables, system health, separate
-  or shared database, dashboard in 11 languages. A free, open-source Sentry alternative.
+summary: Rails-native, self-hosted error monitoring with exception-time Ruby state,
+  runtime health, and storm-safe capture.
 test_files: []