rails_error_dashboard 0.10.0 → 0.11.0

data/config/locales/zh-CN.yml

@@ -137,6 +137,7 @@ zh-CN:
             any: 任意严重程度
           all_apps: 全部应用
           all_platforms: 全部平台
+          all_environments: 全部环境
           all_types: 全部类型
           all_timeframes: 全部时间
           all_frequencies: 全部频率
@@ -165,6 +166,7 @@ zh-CN:
             search: 搜索：%{value}
             application: 应用：%{value}
             platform: 平台：%{value}
+            environment: 环境：%{value}
             error_type: 类型：%{value}
             severity: 严重程度：%{value}
             timeframe: 时间范围：%{value}
@@ -180,6 +182,7 @@ zh-CN:
           last_seen: 最近出现
           application: 应用
           platform: 平台
+          environment: 环境
           select_all: 选择全部错误
         batch:
           selected:
@@ -566,6 +569,7 @@ zh-CN:
           low: 低
         platform: 平台
         view_all_platform: 查看 %{platform} 的所有错误
+        view_all_environment: 查看 %{environment} 的所有错误
         user: 用户
         view_user_errors: 查看该用户的所有错误
         user_id: ID：%{id}
@@ -759,8 +763,7 @@ zh-CN:
         column_ips: IP 地址
         column_top_path: 主要路径
         column_top_agent: 主要代理
-        overflow_notice_html: >-
-          由于跟踪器缓冲区已满，%{count} 个事件无法归属到任何规则。请调高 %{option} 以捕获更多事件。
+        overflow_notice_html: 由于跟踪器缓冲区已满，%{count} 个事件无法归属到任何规则。请调高 %{option} 以捕获更多事件。
         match_type:
           blocklist: blocklist
           throttle: throttle
@@ -950,6 +953,8 @@ zh-CN:
         max_backtrace_lines: 堆栈跟踪深度上限
         sampling_rate: 错误捕获的采样比例
         application_name: 本应用的名称（未设置时自动检测）
+        environment: 错误所属的环境（未设置时为 Rails.env）
+        notification_environments: 仅对这些环境发送通知（未设置时为全部）
         database: 错误日志使用的数据库
         use_separate_database: 为错误日志使用独立数据库
         user_model: 用户关联所用的模型名（未设置时自动检测）
@@ -1087,11 +1092,13 @@ zh-CN:
         unknown_application: 未知
       error_alert:
         subject: "\U0001F6A8 [%{application}] %{error_type}：%{message}"
+        subject_with_environment: "\U0001F6A8 [%{application} · %{environment}] %{error_type}：%{message}"
         heading: "\U0001F6A8 错误告警"
         labels:
           application: 应用
           error_type: 错误类型
           platform: 平台
+          environment: 环境
           occurred_at: 发生时间
           user_id: 用户 ID
           ip_address: IP 地址
@@ -1154,6 +1161,7 @@ zh-CN:
           application: 应用
           error_type: 错误类型
           platform: 平台
+          environment: 环境
           occurred: 发生时间
           message: 消息
           user: 用户
@@ -1452,6 +1460,10 @@ zh-CN:
         platform_chart:
           title: 按平台统计错误
           quick_links: 快捷链接：
+        environment_chart:
+          title: 按环境统计的错误
+          quick_links: 快捷链接：
+          unknown: 未知
         type_chart:
           title: 出现最多的 10 种错误类型
         hour_chart:
@@ -1791,6 +1803,6 @@ zh-CN:
         axis_count: 数量
         axis_number_of_errors: 错误数量
         axis_hours: 小时
-        suffix_hours: "小时"
+        suffix_hours: 小时
         series_total_errors: 错误总数
         series_hours_to_resolve: 解决耗时（小时）

data/db/migrate/20260826000001_add_environment_to_error_logs.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Records which environment an error came from (production, staging, uat, ...).
+#
+# RED had this column in v0.1.x and dropped it in the v1.0-launch refactor. It
+# returns as a nullable string: NULL means "captured before this column
+# existed", which is information the dashboard uses (no badge, matched as a
+# wildcard by FindOrIncrementError and adopted on the next occurrence), not a
+# gap to paper over with a default. `rails_error_dashboard:backfill_environments`
+# fills NULLs from environment_info.rails_env for anyone who wants history too.
+class AddEnvironmentToErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    # Guard against the squashed schema migration having already added this
+    # column -- without it, every later migration is silently cancelled.
+    return if column_exists?(:rails_error_dashboard_error_logs, :environment)
+
+    # 64 chars: long enough for "preprod-eu-west-2-canary", short enough that
+    # the composite index below stays cheap on MySQL's utf8mb4 key limit.
+    add_column :rails_error_dashboard_error_logs, :environment, :string, limit: 64
+
+    # Mirrors index_error_logs_on_platform_and_occurred_at: the index filter is
+    # "this environment, newest first".
+    add_index :rails_error_dashboard_error_logs, [ :environment, :occurred_at ],
+              name: "index_error_logs_on_environment_and_occurred_at"
+  end
+end

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

@@ -11,6 +11,17 @@ RailsErrorDashboard.configure do |config|
   config.dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
   config.dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
 
+  # Environment awareness (v0.11.0). Every error records the environment it
+  # came from, the index can filter by it, and staging can be kept out of
+  # your pager. Defaults to Rails.env; override when a deploy runs under
+  # RAILS_ENV=production but is really "staging", "uat", "preprod"... names
+  # are free-form, never an enum.
+  # config.environment = ENV.fetch("ERROR_DASHBOARD_ENVIRONMENT", "staging")
+  #
+  # Only notify (Slack, email, Discord, PagerDuty, webhooks, storm and
+  # baseline alerts) for these environments. nil = every environment.
+  # config.notification_environments = %w[production]
+
   # === Custom Authentication (optional) ===
   # Use your app's existing auth instead of HTTP Basic Auth.
   # The lambda runs in controller context (via instance_exec), giving access to

data/lib/rails_error_dashboard/commands/backfill_environments.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: fill in `environment` on error logs captured before the column
+    # existed, using the rails_env recorded in environment_info at capture time.
+    #
+    # Opt-in (rails_error_dashboard:backfill_environments). Live errors do not
+    # need it — FindOrIncrementError adopts a NULL row on its next occurrence —
+    # but history that never recurs would otherwise stay unbadged and
+    # unfilterable forever.
+    #
+    # Runs in batches, one UPDATE per row: the value is inside a JSON text
+    # column, so it has to be parsed in Ruby and no portable single UPDATE can
+    # do it across PostgreSQL, MySQL and SQLite.
+    class BackfillEnvironments
+      BATCH_SIZE = 500
+      COLUMN_LIMIT = 64
+
+      def self.call(batch_size: BATCH_SIZE)
+        new(batch_size: batch_size).call
+      end
+
+      def initialize(batch_size: BATCH_SIZE)
+        @batch_size = batch_size
+      end
+
+      # @return [Integer] rows updated
+      def call
+        return 0 unless ErrorLog.column_names.include?("environment")
+
+        updated = 0
+        ErrorLog.where(environment: nil).where.not(environment_info: nil)
+                .in_batches(of: @batch_size) do |batch|
+          batch.pluck(:id, :environment_info).each do |id, raw|
+            env = rails_env_from(raw)
+            next if env.nil?
+
+            updated += ErrorLog.where(id: id, environment: nil).update_all(environment: env)
+          end
+        end
+        updated
+      end
+
+      private
+
+      def rails_env_from(raw)
+        parsed = JSON.parse(raw.to_s)
+        return nil unless parsed.is_a?(Hash)
+
+        value = parsed["rails_env"].to_s.strip
+        value.empty? ? nil : value[0, COLUMN_LIMIT]
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/find_or_increment_error.rb

@@ -9,6 +9,12 @@ module RailsErrorDashboard
     # 1. Unresolved errors with same hash within 24 hours → increment occurrence count
     # 2. Resolved/wont_fix errors with same hash (any age) → reopen and increment
     # 3. No match → create new error record
+    #
+    # Environment is a MATCH dimension, not part of the hash: the same error in
+    # staging and production is two rows with independent status. A row with a
+    # NULL environment predates the column; it matches as a wildcard and is
+    # stamped by the first occurrence that claims it, so history migrates
+    # itself without a backfill. An exact match always wins over a NULL one.
     class FindOrIncrementError
       def self.call(error_hash, attributes = {})
         new(error_hash, attributes).call
@@ -35,23 +41,40 @@ module RailsErrorDashboard
       private
 
       def find_unresolved
-        ErrorLog.unresolved
-          .where(error_hash: @error_hash)
-          .where(application_id: @attributes[:application_id])
-          .where("occurred_at >= ?", 24.hours.ago)
-          .lock
-          .order(last_seen_at: :desc)
-          .first
+        with_environment(
+          ErrorLog.unresolved
+            .where(error_hash: @error_hash)
+            .where(application_id: @attributes[:application_id])
+            .where("occurred_at >= ?", 24.hours.ago)
+        ).lock.order(last_seen_at: :desc).first
       end
 
       def find_resolved
-        ErrorLog
-          .where(error_hash: @error_hash)
-          .where(application_id: @attributes[:application_id])
-          .where(status: %w[resolved wont_fix])
-          .lock
-          .order(last_seen_at: :desc)
-          .first
+        with_environment(
+          ErrorLog
+            .where(error_hash: @error_hash)
+            .where(application_id: @attributes[:application_id])
+            .where(status: %w[resolved wont_fix])
+        ).lock.order(last_seen_at: :desc).first
+      end
+
+      # Restrict to this occurrence's environment or a legacy NULL row, exact
+      # first. Literal SQL, no interpolation. A blank environment (column not
+      # migrated yet, or an attribute-less caller) leaves the scope unchanged.
+      def with_environment(scope)
+        env = @attributes[:environment]
+        return scope if env.blank? || !ErrorLog.column_names.include?("environment")
+
+        scope.where(environment: [ env, nil ])
+             .order(Arel.sql("CASE WHEN environment IS NULL THEN 1 ELSE 0 END"))
+      end
+
+      # {} unless this is a legacy NULL-environment row being claimed.
+      def environment_adoption(error)
+        return {} unless ErrorLog.column_names.include?("environment")
+        return {} if error.environment.present? || @attributes[:environment].blank?
+
+        { environment: @attributes[:environment] }
       end
 
       def increment_existing(error)
@@ -62,7 +85,8 @@ module RailsErrorDashboard
           request_url: @attributes[:request_url] || error.request_url,
           request_params: @attributes[:request_params] || error.request_params,
           user_agent: @attributes[:user_agent] || error.user_agent,
-          ip_address: @attributes[:ip_address] || error.ip_address
+          ip_address: @attributes[:ip_address] || error.ip_address,
+          **environment_adoption(error)
         )
         error
       end
@@ -78,7 +102,8 @@ module RailsErrorDashboard
           request_url: @attributes[:request_url] || error.request_url,
           request_params: @attributes[:request_params] || error.request_params,
           user_agent: @attributes[:user_agent] || error.user_agent,
-          ip_address: @attributes[:ip_address] || error.ip_address
+          ip_address: @attributes[:ip_address] || error.ip_address,
+          **environment_adoption(error)
         }
         attrs[:reopened_at] = Time.current if ErrorLog.column_names.include?("reopened_at")
         error.update!(attrs)
@@ -90,27 +115,28 @@ module RailsErrorDashboard
         ErrorLog.create!(@attributes.reverse_merge(resolved: false))
       rescue ActiveRecord::RecordNotUnique
         # Race condition: another process created the same error
-        retry_existing = ErrorLog.unresolved
-          .where(error_hash: @error_hash)
-          .where(application_id: @attributes[:application_id])
-          .where("occurred_at >= ?", 24.hours.ago)
-          .lock
-          .first
+        retry_existing = with_environment(
+          ErrorLog.unresolved
+            .where(error_hash: @error_hash)
+            .where(application_id: @attributes[:application_id])
+            .where("occurred_at >= ?", 24.hours.ago)
+        ).lock.first
 
         if retry_existing
           retry_existing.update!(
             occurrence_count: retry_existing.occurrence_count + 1,
-            last_seen_at: Time.current
+            last_seen_at: Time.current,
+            **environment_adoption(retry_existing)
           )
           retry_existing
         else
           # Also check resolved in race condition path
-          retry_resolved = ErrorLog
-            .where(error_hash: @error_hash)
-            .where(application_id: @attributes[:application_id])
-            .where(status: %w[resolved wont_fix])
-            .lock
-            .first
+          retry_resolved = with_environment(
+            ErrorLog
+              .where(error_hash: @error_hash)
+              .where(application_id: @attributes[:application_id])
+              .where(status: %w[resolved wont_fix])
+          ).lock.first
 
           if retry_resolved
             reopen_existing(retry_resolved)

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