rails_error_dashboard 0.11.4 → 0.11.6

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

@@ -155,22 +155,35 @@ module RailsErrorDashboard
           # Cheap in-process bucketing key. Deliberately NOT the canonical
           # error_hash (that needs application_id = DB); the flush job
           # recomputes the canonical hash from the stored parts.
+          # Environment is a MATCH dimension (one row per environment), so it
+          # is part of the in-process key too: a staging event and a
+          # production event of the same error must not share one entry, or
+          # the flush job would reconcile both into whichever environment
+          # the worker runs in.
           def gate_key(parts)
-            parts[:gate_key] ||= parts[:custom_hash] || Digest::SHA256.hexdigest(
-              "#{parts[:error_class]}|#{ErrorHashGenerator.normalize_message(parts[:message])}|" \
-              "#{parts[:first_app_frame]}|#{parts[:controller_name]}|#{parts[:action_name]}"
+            parts[:gate_key] ||= Digest::SHA256.hexdigest(
+              "#{parts[:custom_hash] || identity_key(parts)}|#{parts[:environment]}"
             )[0..15]
           end
 
+          def identity_key(parts)
+            "#{parts[:error_class]}|#{ErrorHashGenerator.normalize_message(parts[:message])}|" \
+              "#{parts[:first_app_frame]}|#{parts[:controller_name]}|#{parts[:action_name]}"
+          end
+
           def gate_parts(exception, context)
             {
               error_class: exception.class.name,
-              message: exception.message.to_s[0, 500],
+              message: exception.message.to_s[0, ErrorHashGenerator::HASH_MESSAGE_LIMIT],
               first_app_frame: ErrorHashGenerator.extract_app_frame_from_locations(exception) ||
                                ErrorHashGenerator.extract_app_frame(exception.backtrace),
               controller_name: context[:controller_name]&.to_s,
               action_name: context[:action_name]&.to_s,
-              custom_hash: custom_hash_for(exception, context)
+              custom_hash: custom_hash_for(exception, context),
+              # Only an EXPLICIT environment from the caller. nil means "the
+              # worker's own environment", resolved at flush time exactly as
+              # LogError resolves it for a full capture.
+              environment: context[:environment].to_s.strip.presence&.[](0, 64)
             }
           end
 
@@ -203,19 +216,46 @@ module RailsErrorDashboard
             @last_flush = now
             snapshot = count_buffer.snapshot!
             episode = breaker.episode_snapshot
-            breaker.clear_closed_episode!
 
-            StormFlushJob.perform_later(
-              entries: snapshot[:entries],
-              overflow: snapshot[:overflow],
-              episode: serialize_episode(episode)
-            )
+            begin
+              job = StormFlushJob.perform_later(
+                entries: snapshot[:entries],
+                overflow: snapshot[:overflow],
+                episode: serialize_episode(episode)
+              )
+              # Active Job swallows ActiveJob::EnqueueError and returns false
+              # (and a job that was not enqueued says so) — a failed handoff
+              # that never raises.
+              unless enqueued?(job)
+                reason = (job.respond_to?(:enqueue_error) && job.enqueue_error&.message) || "enqueue returned #{job.inspect}"
+                raise "StormFlushJob was not enqueued: #{reason}"
+              end
+            rescue => e
+              # The queue is often the very thing that is down during a storm
+              # (a SolidQueue enqueue is a DB write). The batch is not gone:
+              # put it back so the next interval retries, and leave the
+              # closed episode in place so it is persisted by that retry.
+              count_buffer.restore(snapshot[:entries], snapshot[:overflow])
+              RailsErrorDashboard::Logger.error(
+                "[RailsErrorDashboard] Storm flush enqueue failed (batch retained for retry): #{e.class} - #{e.message}"
+              )
+              return
+            end
+
+            breaker.clear_closed_episode!
           rescue => e
             RailsErrorDashboard::Logger.error(
-              "[RailsErrorDashboard] Storm flush enqueue failed: #{e.class} - #{e.message}"
+              "[RailsErrorDashboard] Storm flush failed: #{e.class} - #{e.message}"
             )
           end
 
+          def enqueued?(job)
+            return false unless job
+            return job.successfully_enqueued? if job.respond_to?(:successfully_enqueued?)
+
+            true
+          end
+
           def serialize_episode(episode)
             return nil unless episode
 

data/lib/rails_error_dashboard/services/system_health_snapshot.rb

@@ -8,11 +8,18 @@ module RailsErrorDashboard
     # Puma stats, job queue, RubyVM/YJIT, ActionCable, file descriptors, system load,
     # system memory pressure, GC context, and TCP connection states.
     #
-    # NOT memoized — fresh data every call (unlike EnvironmentSnapshot).
+    # NOT memoized — fresh data every call (unlike EnvironmentSnapshot), with
+    # one exception: job-queue depth counts are queries against the queue
+    # store, so they are cached per process for
+    # config.system_health_queue_stats_cache_seconds (failures included), with
+    # one refresh in flight at a time (and can be switched off with
+    # config.system_health_queue_stats = false).
     # Every metric call individually wrapped in rescue => nil.
     #
     # Safety contract (from HOST_APP_SAFETY.md):
-    # - Total snapshot < 1ms budget (~0.3ms typical on Linux)
+    # - In-process metrics < 1ms budget (~0.3ms typical on Linux). The
+    #   queue-depth counts are the documented exception: their latency is
+    #   the queue store's, which is why they are cached and optional.
     # - NEVER ObjectSpace.each_object or ObjectSpace.count_objects (heap scan)
     # - NEVER Thread.list.map(&:backtrace) (GVL hold)
     # - Thread.list.count only (O(1), safe)
@@ -133,7 +140,59 @@ module RailsErrorDashboard
 
       # Auto-detect and capture job queue stats
       # @return [Hash, nil] Job queue stats with :adapter key, or nil
+      # Process-wide cache for the queue-depth counts: { at: monotonic, stats: Hash|nil }.
+      # A nil stats entry is a FAILED collection, cached for the same interval
+      # so a broken queue store is not re-queried on every error.
+      def self.queue_stats_cache
+        @queue_stats_cache ||= Concurrent::AtomicReference.new(nil)
+      end
+
+      # Single-flight guard for the refresh. Never blocks: a thread that finds
+      # a refresh already running serves the stale entry (or nil) instead of
+      # starting a second one, so a burst of errors on a cold cache runs the
+      # queue counts once, not once per thread.
+      def self.queue_stats_refresh_lock
+        @queue_stats_refresh_lock ||= Mutex.new
+      end
+
+      def self.reset_queue_stats_cache!
+        queue_stats_cache.set(nil)
+      end
+
       def job_queue_stats
+        config = RailsErrorDashboard.configuration
+        return nil unless config.system_health_queue_stats
+
+        ttl = config.system_health_queue_stats_cache_seconds.to_f
+        return collect_job_queue_stats if ttl <= 0
+
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        cached = self.class.queue_stats_cache.get
+        return present_cached(cached, now) if cached && (now - cached[:at]) < ttl
+
+        lock = self.class.queue_stats_refresh_lock
+        return present_cached(cached, now, stale: true) unless lock.try_lock
+
+        begin
+          stats = collect_job_queue_stats
+          self.class.queue_stats_cache.set({ at: now, stats: stats })
+          stats
+        ensure
+          lock.unlock
+        end
+      rescue => e
+        nil
+      end
+
+      def present_cached(cached, now, stale: false)
+        return nil unless cached && cached[:stats]
+
+        presented = cached[:stats].merge(cached_age_seconds: (now - cached[:at]).round(1))
+        presented[:stale] = true if stale
+        presented
+      end
+
+      def collect_job_queue_stats
         if defined?(::Sidekiq::Stats)
           sidekiq_stats
         elsif defined?(::SolidQueue)

data/lib/rails_error_dashboard/value_objects/error_context.rb

@@ -7,7 +7,7 @@ module RailsErrorDashboard
     class ErrorContext
       attr_reader :user_id, :request_url, :request_params, :user_agent, :ip_address, :platform,
                   :controller_name, :action_name, :request_id, :session_id,
-                  :http_method, :hostname, :content_type, :request_duration_ms
+                  :http_method, :hostname, :content_type, :request_duration_ms, :environment
 
       def initialize(context, source = nil)
         @context = context
@@ -27,8 +27,15 @@ module RailsErrorDashboard
         @hostname = extract_hostname
         @content_type = extract_content_type
         @request_duration_ms = extract_request_duration_ms
+        @environment = extract_environment
       end
 
+      # Everything a second ErrorContext needs to rebuild THIS context from a
+      # plain hash. ErrorReporter hands `to_h` to LogError, which constructs a
+      # new ErrorContext from it, so any reader that is not represented here
+      # is silently nil on the far side of that hop. request_id/session_id
+      # were exactly that: extracted from the request, dropped here, and every
+      # occurrence on the main capture path stored nil for both.
       def to_h
         {
           user_id: user_id,
@@ -39,10 +46,13 @@ module RailsErrorDashboard
           platform: platform,
           controller_name: controller_name,
           action_name: action_name,
+          request_id: request_id,
+          session_id: session_id,
           http_method: http_method,
           hostname: hostname,
           content_type: content_type,
-          request_duration_ms: request_duration_ms
+          request_duration_ms: request_duration_ms,
+          environment: environment
         }
       end
 
@@ -246,6 +256,13 @@ module RailsErrorDashboard
         nil
       end
 
+      # An explicit environment from the caller (a sender attributing an event
+      # to its own environment). nil means "resolve from configuration".
+      def extract_environment
+        value = @context[:environment].to_s.strip
+        value.empty? ? nil : value
+      end
+
       # Auto-detect user_id from ActiveSupport::CurrentAttributes
       # Checks for common patterns: Current.user, Current.account (with .id)
       # Returns nil if CurrentAttributes is not used or user is not set

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.11.4"
+  VERSION = "0.11.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 0.11.6
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -279,6 +279,7 @@ files:
 - app/jobs/rails_error_dashboard/application_job.rb
 - app/jobs/rails_error_dashboard/async_error_logging_job.rb
 - app/jobs/rails_error_dashboard/baseline_alert_job.rb
+- app/jobs/rails_error_dashboard/baseline_calculation_job.rb
 - app/jobs/rails_error_dashboard/close_linked_issue_job.rb
 - app/jobs/rails_error_dashboard/concerns/localized_job.rb
 - app/jobs/rails_error_dashboard/create_issue_job.rb
@@ -407,6 +408,7 @@ files:
 - 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
+- db/migrate/20260908000001_add_release_to_error_occurrences.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
@@ -575,7 +577,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.11.4
+    RED (Rails Error Dashboard) v0.11.6
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install: