rails_error_dashboard 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d762f92c5645173b17543925db4d5740d1294af6a2da64e0a9cef6b6032211b
-  data.tar.gz: 056bca6e5ba6083666cf44302979bc8d3ff276d76563de87793051619b616994
+  metadata.gz: 15c3e5f83e8ce2990ce4649cd7c71be0542ca7149863a6bc85ff8505d5ee0a4d
+  data.tar.gz: ccd0115a385bfbfeab743f6e84a4ff77875f449a0adfc16c54b2fa0e21f43029
 SHA512:
-  metadata.gz: 5383eafcd408b881b4721fc496df7077c387c6ecb7f10543dfe8570049dda45c2c408f59f2f0e10c2c385a448a8d1acc6719da0367a654b8e42455bd4c568797
-  data.tar.gz: 6c77de41c4c43f81eab6f7a3bd59626ca2d48d002fe312c535c71e8b8ffd33ec5eddcbec2b3601a8d3d52aee25ceb65037fdf4d56497730f3d85b7a5c8b463e7
+  metadata.gz: 972ecd630a40e2aa58dc33e22492acafb4910310a078a6172458796b6073420a27f773e6709004bd6172eabc6db1acd0de9128f345fa3931a905ea59592e591b
+  data.tar.gz: a1b25a254a0154f94f260054ddcf7cedaf08039f4f62b234270eb9b7c0ffa84d03d0e09fb0213f7c53aa143200aa6edcfcd4916d54eb8495b6dcb375b8dca2c7

data/app/jobs/rails_error_dashboard/async_error_logging_job.rb

@@ -23,6 +23,16 @@ module RailsErrorDashboard
         context[:_serialized_cause_chain] = exception_data[:cause_chain]
       end
 
+      # The type as REPORTED, independent of whether a Ruby class of that name
+      # exists here. reconstruct_exception falls back to StandardError for an
+      # unconstantizable name -- which is the normal case for a frontend or
+      # mobile report -- and reading error_type off the reconstructed object
+      # then renamed every such error StandardError, collapsing distinct
+      # client errors into one group.
+      if exception_data[:class_name].present?
+        context[:_reported_error_type] = exception_data[:class_name]
+      end
+
       # Log the error synchronously in the background job.
       # .new(...).call bypasses the async check (we're already async);
       # worker: true makes an unreachable error store raise instead of being

data/app/jobs/rails_error_dashboard/retention_cleanup_job.rb

@@ -47,6 +47,7 @@ module RailsErrorDashboard
       cleanup_storm_flush_batches(cutoff)
       cleanup_diagnostic_dumps(cutoff)
       cleanup_swallowed_exceptions(cutoff)
+      cleanup_event_timing_gaps(cutoff)
 
       expired_scope = self.class.expired_scope(cutoff)
       return 0 if expired_scope.none?
@@ -58,6 +59,12 @@ module RailsErrorDashboard
 
       # Batch delete dependent records (occurrences, comments, cascade patterns)
       ErrorOccurrence.where(error_log_id: expired_ids_scope).in_batches(of: 1000).delete_all
+      # Hour buckets for storm-shed events. Listed explicitly because this job
+      # deletes with delete_all, which does not fire the has_many :dependent
+      # callback on ErrorLog -- without this line the buckets outlive the group
+      # they describe, forever. The migration's own comment promised this
+      # pruning before the code existed.
+      EventCount.where(error_log_id: expired_ids_scope).in_batches(of: 1000).delete_all if EventCount.table_exists?
       ErrorComment.where(error_log_id: expired_ids_scope).in_batches(of: 1000).delete_all
       CascadePattern.where(parent_error_id: expired_ids_scope)
                     .or(CascadePattern.where(child_error_id: expired_ids_scope))
@@ -153,6 +160,53 @@ module RailsErrorDashboard
       )
     end
 
+    # Timing gaps are pruned by their OWN age, not by a group.
+    #
+    # A gap describes an interval, not an error, so there is no error_log_id to
+    # cascade from -- without this it would accumulate for the life of the
+    # installation. It also runs ABOVE the early return in #perform, which
+    # fires whenever no error logs happen to be expired: gaps expire
+    # independently of errors, exactly like the rack-attack events whose
+    # comment already warns about this.
+    #
+    # Safe to prune on covered_until: once the cutoff has moved past a gap, no
+    # window the dashboard displays can still reach it, so the warning it
+    # carries is no longer meaningful. Own rescue, like its siblings.
+    def cleanup_event_timing_gaps(cutoff)
+      return unless EventTimingGap.table_exists?
+
+      # Kept for the LONGER of the two horizons that govern it.
+      #
+      # This used the configured retention cutoff alone, which is wrong
+      # whenever retention is shorter than the window the dashboard reports on:
+      # at retention_days = 7 the gap was deleted while the events it qualified
+      # were still on the page -- ten monthly events, no warning, group still
+      # active. A gap outlives its own retention precisely because the figures
+      # it qualifies do.
+      #
+      # Deleting it only once BOTH clocks have passed means the warning can
+      # never disappear while the numbers it describes are still displayed.
+      # The reverse case is unaffected: with the 90-day default the retention
+      # cutoff is already the later of the two, so nothing is kept longer than
+      # before.
+      gap_cutoff = [ cutoff, Queries::DashboardStats::WIDEST_DISPLAYED_WINDOW.ago ].min
+
+      deleted = 0
+      EventTimingGap.where("covered_until < ?", gap_cutoff).in_batches(of: 1000) do |batch|
+        deleted += batch.delete_all
+      end
+
+      if deleted > 0
+        RailsErrorDashboard::Logger.info(
+          "[RailsErrorDashboard] Retention cleanup: deleted #{deleted} event timing gaps"
+        )
+      end
+    rescue => e
+      RailsErrorDashboard::Logger.debug(
+        "[RailsErrorDashboard] Event timing gap retention cleanup failed: #{e.class} - #{e.message}"
+      )
+    end
+
     # Expire aggregated Rack Attack event rows. Isolated in its own rescue so a
     # failure here (e.g. table not yet migrated) never blocks error cleanup.
     def cleanup_rack_attack_events(cutoff)

data/app/jobs/rails_error_dashboard/storm_flush_job.rb

@@ -21,11 +21,14 @@ module RailsErrorDashboard
         entries: entries, overflow: overflow, episode: episode, batch_id: batch_id
       )
 
-      # A batch that reconciled nothing because every write failed is not a
-      # delivered batch. Fail the job so Active Job retries it rather than
-      # dropping counts that were only ever held in one process's memory.
+      # A batch that wrote nothing is not a delivered batch. Fail the job so
+      # Active Job retries it rather than dropping counts that were only ever
+      # held in one process's memory. Two shapes reach here: every entry failed
+      # permanently, and a transient store failure that rolled the whole batch
+      # back (retryable: true) -- the latter is intact and safe to replay.
       if result.is_a?(Hash) && result[:success] == false
-        raise FlushFailed, "storm flush reconciled nothing: #{result[:error]}"
+        reason = result[:retryable] ? "storm flush rolled back" : "storm flush reconciled nothing"
+        raise FlushFailed, "#{reason}: #{result[:error]}"
       end
 
       result

data/app/models/rails_error_dashboard/error_log.rb

@@ -37,6 +37,16 @@ module RailsErrorDashboard
     # Association for tracking individual error occurrences
     has_many :error_occurrences, class_name: "RailsErrorDashboard::ErrorOccurrence", dependent: :destroy
 
+    # Hour buckets for storm-shed events. delete_all, not destroy: these rows
+    # are pure counters with no callbacks, and a group can own one per hour.
+    #
+    # The association has to live HERE. `dependent:` on EventCount's own
+    # belongs_to is rejected by Rails (":dependent option must be one of
+    # [:destroy, :delete, :destroy_async]"), so the cleanup can only be
+    # declared from the parent side. Retention deletes them separately as well,
+    # because it uses delete_all, which does not fire callbacks.
+    has_many :event_counts, class_name: "RailsErrorDashboard::EventCount", dependent: :delete_all
+
     # Comments used as internal audit trail for workflow actions (snooze, mute, status changes).
     # Manual comment form removed in v0.6 — discussion now lives on issue tracker.
     has_many :comments, class_name: "RailsErrorDashboard::ErrorComment", foreign_key: :error_log_id, dependent: :destroy

data/app/models/rails_error_dashboard/event_count.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # How many storm-shed events landed on one error group in one hour.
+  #
+  # Storm protection sheds events by folding N of them into the group's
+  # occurrence_count and writing no ErrorOccurrence row. That keeps the total
+  # exact but leaves the events with no timestamp of their own, so a window
+  # query has nothing to filter them by. This table gives them one.
+  #
+  # Window volume is therefore:
+  #
+  #   ErrorOccurrence rows in the window  +  EventCount buckets in the window
+  #
+  # Ordinary captures contribute the first term, shed events the second, and
+  # neither is double counted: an event that wrote an occurrence row is never
+  # also bucketed here.
+  #
+  # Inherits ErrorLogsRecord so separate-database routing applies.
+  class EventCount < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_event_counts"
+
+    belongs_to :error_log, class_name: "RailsErrorDashboard::ErrorLog", optional: true
+
+    scope :in_window, ->(from, to = nil) {
+      scope = where(arel_table[:bucket_at].gteq(from))
+      to ? scope.where(arel_table[:bucket_at].lt(to)) : scope
+    }
+
+    # Bucket width, shared with the PRODUCER.
+    #
+    # This must equal CountBuffer::BUCKET_SECONDS, and there is a spec that
+    # asserts it. The producer tallies 15-minute buckets precisely so that a
+    # local midnight falls on a bucket EDGE in every UTC offset in use --
+    # including +05:30 (Kolkata) and +05:45 (Kathmandu). Rounding those buckets
+    # to the hour here destroyed exactly the property the producer paid for:
+    # a storm event at 23:59:30 and one at 00:00:30 in Kolkata shared one
+    # bucket, and a day's total was wrong by the whole straddle.
+    BUCKET_SECONDS = Services::StormProtection::CountBuffer::BUCKET_SECONDS
+
+    # The bucket a time belongs to, in UTC. One definition, used by the writer
+    # and the readers -- a mismatch here silently splits or merges a bucket.
+    # @param time [Time]
+    # @return [Time]
+    def self.bucket_for(time)
+      time = (time || Time.current)
+      Time.at((time.to_i / BUCKET_SECONDS) * BUCKET_SECONDS).utc
+    end
+
+    # Add +count+ shed events to (error_log_id, bucket_at), creating the row if
+    # it is not there yet.
+    #
+    # Adapter-portable by hand rather than via upsert_all: the increment has to
+    # read the existing value, and the ON CONFLICT / ON DUPLICATE KEY syntaxes
+    # differ. The UPDATE-first shape means the common case (a storm flushing
+    # repeatedly into the same hour) is a single statement, and the INSERT race
+    # is resolved by retrying the UPDATE once.
+    #
+    # @return [Symbol] :written when the bucket landed, :unavailable when the
+    #   rollup is permanently unusable (no table, bad args, an adapter that
+    #   refuses the statement). A TRANSIENT failure raises instead.
+    #
+    #   Three states, not a boolean: the caller has to tell "the bucket is
+    #   permanently unavailable, degrade" from "the write failed, retry the
+    #   batch". Collapsing both into false made FlushStormCounts abort the
+    #   whole transaction on a host that had simply never migrated the rollup
+    #   table -- rolling back the authoritative lifetime count with it.
+    def self.accumulate(error_log_id:, bucket_at:, count:)
+      return :unavailable unless error_log_id && count.to_i.positive?
+      return :unavailable unless table_exists?
+
+      bucket = bucket_for(bucket_at)
+      updated = where(error_log_id: error_log_id, bucket_at: bucket)
+        .update_all([ "count = count + ?, updated_at = ?", count.to_i, Time.current ])
+      return :written if updated.positive?
+
+      begin
+        # requires_new: a failed INSERT aborts its transaction on PostgreSQL,
+        # which would take the caller's surrounding transaction with it.
+        transaction(requires_new: true) do
+          create!(error_log_id: error_log_id, bucket_at: bucket, count: count.to_i)
+        end
+        :written
+      rescue ActiveRecord::RecordNotUnique
+        # Another process created the same bucket between the UPDATE and the
+        # INSERT. The row exists now, so the UPDATE that missed a moment ago
+        # succeeds.
+        where(error_log_id: error_log_id, bucket_at: bucket)
+          .update_all([ "count = count + ?, updated_at = ?", count.to_i, Time.current ])
+          .positive? ? :written : :unavailable
+      end
+    rescue *Commands::LogError::RETRYABLE_STORE_ERRORS => e
+      # TRANSIENT: the store may be back in a moment. Do NOT swallow it.
+      #
+      # Returning false here let FlushStormCounts finalize its batch ledger
+      # with the bucket missing, so the replay was suppressed as
+      # already-applied and those events were erased from every time window --
+      # permanently -- while the lifetime count stayed correct. The caller
+      # turns this into an abort-and-retry of the whole batch.
+      RailsErrorDashboard::Logger.debug(
+        "[RailsErrorDashboard] EventCount.accumulate hit a transient failure: #{e.class} - #{e.message}"
+      )
+      raise
+    rescue StandardError => e
+      # PERMANENT: a malformed row, a missing table, an adapter that refuses
+      # this statement. Retrying cannot help, and failing the flush would turn
+      # a lost time bucket into a lost COUNT -- the authoritative total is
+      # occurrence_count on the group, and it is already written.
+      #
+      # This is the only case the old comment actually described.
+      RailsErrorDashboard::Logger.debug(
+        "[RailsErrorDashboard] EventCount.accumulate failed permanently: #{e.class} - #{e.message}"
+      )
+      :unavailable
+    end
+
+    # Whether the rollup table is usable.
+    #
+    # A transient connection failure here is NOT "the table does not exist":
+    # swallowing it returned false before any write was attempted, so a storm
+    # flush reported success with no bucket written, and EventVolume silently
+    # dropped the bucket term from its reads. Let the transient class through
+    # so the caller can retry; only a genuinely absent table returns false.
+    def self.table_exists?
+      connection.table_exists?(table_name)
+    rescue *Commands::LogError::RETRYABLE_STORE_ERRORS
+      raise
+    rescue StandardError
+      false
+    end
+  end
+end

data/app/models/rails_error_dashboard/event_timing_gap.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # An interval whose per-event timing evidence was lost.
+  #
+  # See the migration for why this is its own table rather than a flag on the
+  # storm episode: the episode is optional, and it is written after the counts
+  # transaction has already committed.
+  #
+  # Inherits ErrorLogsRecord so separate-database routing applies.
+  class EventTimingGap < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_event_timing_gaps"
+
+    # Gaps overlapping [from, to). Open-ended when +to+ is nil.
+    #
+    # Overlap, not containment: a gap that began before the window and runs
+    # into it still makes that window's timing unreliable. Checking only
+    # "starts inside the window" is the mistake the episode predicate made.
+    scope :overlapping, ->(from, to = nil) {
+      scope = where(arel_table[:covered_until].gteq(from))
+      to ? scope.where(arel_table[:covered_from].lt(to)) : scope
+    }
+
+    # Whether any recorded gap affects the given window.
+    #
+    # Every guard is deliberate: the table may not be migrated on an older
+    # host, and this is read on the dashboard path, which must never raise.
+    #
+    # @param from [Time] start of the window being displayed
+    # @param application_id [Integer, nil]
+    # @return [Boolean]
+    def self.affecting?(from, application_id: nil)
+      return false unless table_exists?
+
+      scope = overlapping(from)
+      # A NULL application_id means the gap applies everywhere, so it is
+      # included whatever is being filtered for.
+      scope = scope.where(application_id: [ application_id, nil ]) if application_id.present?
+      scope.exists?
+    rescue StandardError => e
+      RailsErrorDashboard::Logger.debug(
+        "[RailsErrorDashboard] EventTimingGap.affecting? failed: #{e.class} - #{e.message}"
+      )
+      false
+    end
+
+    def self.table_exists?
+      connection.table_exists?(table_name)
+    rescue *Commands::LogError::RETRYABLE_STORE_ERRORS
+      raise
+    rescue StandardError
+      false
+    end
+  end
+end

data/app/views/layouts/rails_error_dashboard.html.erb

@@ -744,9 +744,54 @@ dd { color: var(--text-primary); }
 }
 .red-stat-grid > * { min-width: 0; }
 
-/* Error detail responsive grid */
+/* Error detail hero
+   Same failure as the stat grids above: an inline `display: flex` cannot carry
+   a media query. The action row held `flex-shrink: 0` while the title column
+   was plain `flex: 1`, so at 390px up to five buttons kept their full width
+   and the title absorbed every pixel of the squeeze — "NoMethodError" wrapped
+   to roughly one character per line, making a very tall header before the
+   backtrace on the one screen an on-call engineer actually reads.
+
+   `flex: 1 1 260px` is the load-bearing part: the 260px basis stops the text
+   column collapsing toward zero. Dropping flex-shrink from the actions lets
+   them wrap onto their own line instead. */
+.red-error-hero {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: var(--space-4);
+  flex-wrap: wrap;
+}
+.red-error-hero-text { flex: 1 1 260px; min-width: 0; }
+.red-error-hero-actions { display: flex; gap: 6px; flex-wrap: wrap; }
+@media (max-width: 575.98px) {
+  /* Full-width buttons once stacked: a wrapped row of five reads as rubble. */
+  .red-error-hero-actions { width: 100%; }
+  .red-error-hero-actions .btn { flex: 1 1 auto; }
+}
+
+/* Error detail responsive grid
+   The single-column rule below stacks the panels, but `1fr` is min-content by
+   default, so a track still refused to shrink below its widest child: at 390px
+   the grid measured 334px while its content needed 419px, and the page scrolled
+   sideways independently of the hero. Same fix as the stat grids: minmax's 0
+   floor lets the track shrink, and min-width:0 lets its children do the same. */
 .red-detail-grid { display: grid; grid-template-columns: 1fr 260px; gap: var(--space-4); }
-@media (max-width: 1023.98px) { .red-detail-grid { grid-template-columns: 1fr; } }
+.red-detail-grid > * { min-width: 0; }
+@media (max-width: 1023.98px) { .red-detail-grid { grid-template-columns: minmax(0, 1fr); } }
+
+/* Detail tables inside those panels (Request Context, Metadata).
+   Their label column is a fixed `width="200"` and their values are URLs and
+   JSON, so the table's intrinsic width stayed ~416px however narrow the panel
+   became — the last thing still pushing the detail page sideways on a phone
+   once the grid and the hero were fixed. Below the stacking breakpoint the
+   label column narrows and long values wrap on any character, so the table
+   fits its panel instead of widening the page. */
+@media (max-width: 1023.98px) {
+  .red-detail-grid .card-body > .table { table-layout: fixed; width: 100%; }
+  .red-detail-grid .card-body > .table th { width: 40%; }
+  .red-detail-grid .card-body > .table td { overflow-wrap: anywhere; }
+}
 
 /* Env badge */
 .red-env-badge {

data/app/views/rails_error_dashboard/errors/_request_context.html.erb

@@ -30,6 +30,8 @@
                       <div><small class="text-muted"><%= red_t("red.errors.request_context.snapshot_fidelity_lite") %></small></div>
                     <% when "minimal" %>
                       <div><small class="text-muted"><%= red_t("red.errors.request_context.snapshot_fidelity_minimal") %></small></div>
+                    <% when "partial" %>
+                      <div><small class="text-muted"><%= red_t("red.errors.request_context.snapshot_fidelity_partial") %></small></div>
                     <% end %>
                   <% end %>
                 </td>

data/app/views/rails_error_dashboard/errors/overview.html.erb

@@ -16,6 +16,18 @@
     </div>
   <% end %>
 
+  <%# A storm episode degraded without writing its time buckets, so the
+      time-window figures below rest on each group's first-seen timestamp
+      rather than on per-event records. The COUNTS are still exact -- only
+      their placement in time is approximate, and saying so beats presenting
+      a figure of unknown completeness as fact. %>
+  <% if @stats[:event_timing_incomplete] %>
+    <div class="alert-warning" style="display: flex; align-items: center; gap: 10px; padding: 10px var(--space-5); background: var(--status-warning-bg); border-radius: var(--radius-md); border: 1px solid var(--status-warning); margin-bottom: var(--space-6); font-size: 13px; color: var(--status-warning);">
+      <i class="bi bi-clock-history"></i>
+      <strong><%= red_t("red.errors.overview_page.event_timing_incomplete") %></strong>
+    </div>
+  <% end %>
+
   <!-- Spike / Critical Alerts Banner -->
   <% if @critical_alerts.any? %>
     <%

data/app/views/rails_error_dashboard/errors/show.html.erb

@@ -13,8 +13,8 @@
   </div>
 
   <!-- Hero card -->
-  <div style="display: flex; align-items: flex-start; justify-content: space-between; gap: var(--space-4); padding: var(--space-6); background: var(--surface-primary); border-radius: var(--radius-md); border: 1px solid var(--border-primary); margin-bottom: var(--space-4);">
-    <div style="flex: 1; min-width: 0;">
+  <div class="red-error-hero" style="padding: var(--space-6); background: var(--surface-primary); border-radius: var(--radius-md); border: 1px solid var(--border-primary); margin-bottom: var(--space-4);">
+    <div class="red-error-hero-text">
       <div style="display: flex; align-items: center; gap: 8px; margin-bottom: 6px;">
         <span class="badge bg-<%= severity_color(@error.severity) %>" style="display: inline-flex; align-items: center; gap: 4px;">
           <span style="width: 6px; height: 6px; border-radius: 50%; background: currentColor;"></span>
@@ -75,7 +75,7 @@
         <span><%= red_t("red.errors.show.hero.last_seen_html", time: local_time_ago(@error.last_seen_at)) %></span>
       </div>
     </div>
-    <div style="display: flex; gap: 6px; flex-shrink: 0;">
+    <div class="red-error-hero-actions">
       <% unless @error.resolved? %>
         <button type="button" class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#resolveModal" style="font-weight: 600;">
           <%= red_t("red.errors.show.actions.resolve") %>

data/config/locales/de.yml

@@ -583,6 +583,7 @@ de:
         snapshot_stale: aus einem früheren Auftreten — spätere lieferten keinen Kontext
         snapshot_fidelity_lite: reduzierte Erfassung (der Storm-Schutz hat die Kontext-Payloads verworfen)
         snapshot_fidelity_minimal: während eines Storms gezählt — es wurde kein Kontext erfasst
+        snapshot_fidelity_partial: gemischter Snapshot — einige Felder stammen aus einem früheren Vorkommen
         snapshot_unknown: erfasst, bevor RED die Herkunft von Momentaufnahmen aufzeichnete
       similar_errors:
         title: Ähnliche Fehler
@@ -940,6 +941,7 @@ de:
         rate_per_hour: "%{value}/Std."
         affected_users_incomplete: mindestens — der Storm-Schutz hat Detaildaten pro Ereignis verworfen
         data_unavailable: Statistiken sind derzeit nicht verfügbar — die Zahlen unten sind keine Messung.
+        event_timing_incomplete: "Zeitangaben sind unvollständig — der Sturmschutz hat Zeitstempel verworfen; die Gesamtzahlen stimmen."
         unresolved: Offen
         unresolved_hint: Behebung ausstehend
         resolution_rate: Behebungsquote

data/config/locales/en.yml

@@ -821,6 +821,7 @@ en:
         # but no backtrace or context was ever captured for it.
         snapshot_fidelity_lite: "reduced capture (storm protection shed the context payloads)"
         snapshot_fidelity_minimal: "counted during a storm — no context was captured"
+        snapshot_fidelity_partial: "mixed snapshot — some fields are kept from an earlier occurrence"
         snapshot_unknown: "captured before RED recorded snapshot provenance"
 
       similar_errors:
@@ -1330,6 +1331,7 @@ en:
         # Zero errors and "the dashboard could not read its data" are
         # different states. This banner says which one you are looking at.
         data_unavailable: "Statistics are currently unavailable — the figures below are not a measurement."
+        event_timing_incomplete: "Event timing is incomplete — storm protection dropped per-event timestamps; the totals are still exact."
         unresolved: "Unresolved"
         unresolved_hint: "Pending resolution"
         resolution_rate: "Resolution Rate"

data/config/locales/es.yml

@@ -608,6 +608,7 @@ es:
         snapshot_stale: de una aparición anterior — las posteriores no aportaron contexto
         snapshot_fidelity_lite: captura reducida (la protección ante storms descartó los payloads de contexto)
         snapshot_fidelity_minimal: contabilizado durante un storm — no se capturó ningún contexto
+        snapshot_fidelity_partial: instantánea mixta — algunos campos provienen de una aparición anterior
         snapshot_unknown: capturada antes de que RED registrara la procedencia de las instantáneas
       similar_errors:
         title: Errores similares
@@ -970,6 +971,7 @@ es:
         rate_per_hour: "%{value}/h"
         affected_users_incomplete: al menos — la protección ante storms descartó el detalle por evento
         data_unavailable: Las estadísticas no están disponibles por ahora — las cifras siguientes no son una medición.
+        event_timing_incomplete: "Las marcas de tiempo están incompletas — la protección contra tormentas las descartó; los totales siguen siendo exactos."
         unresolved: Sin resolver
         unresolved_hint: Pendientes de resolución
         resolution_rate: Tasa de resolución

data/config/locales/fr.yml

@@ -607,6 +607,7 @@ fr:
         snapshot_stale: issu d'une occurrence antérieure — les suivantes n'ont apporté aucun contexte
         snapshot_fidelity_lite: capture réduite (la protection contre les storms a écarté les payloads de contexte)
         snapshot_fidelity_minimal: comptabilisé pendant un storm — aucun contexte n'a été capturé
+        snapshot_fidelity_partial: instantané mixte — certains champs proviennent d'une occurrence antérieure
         snapshot_unknown: capturé avant que RED n'enregistre la provenance des instantanés
       similar_errors:
         title: Erreurs similaires
@@ -971,6 +972,7 @@ fr:
         rate_per_hour: "%{value}/h"
         affected_users_incomplete: au moins — la protection contre les storms a écarté le détail par événement
         data_unavailable: Les statistiques sont indisponibles pour le moment — les chiffres ci-dessous ne sont pas une mesure.
+        event_timing_incomplete: "L'horodatage est incomplet — la protection anti-tempête a supprimé les horodatages ; les totaux restent exacts."
         unresolved: Non résolues
         unresolved_hint: En attente de résolution
         resolution_rate: Taux de résolution

data/config/locales/it.yml

@@ -601,6 +601,7 @@ it:
         snapshot_stale: da un'occorrenza precedente — quelle successive non hanno fornito contesto
         snapshot_fidelity_lite: acquisizione ridotta (la protezione dagli storm ha scartato i payload di contesto)
         snapshot_fidelity_minimal: conteggiato durante uno storm — non è stato acquisito alcun contesto
+        snapshot_fidelity_partial: snapshot misto — alcuni campi provengono da un'occorrenza precedente
         snapshot_unknown: acquisita prima che RED registrasse la provenienza delle istantanee
       similar_errors:
         title: Errori simili
@@ -962,6 +963,7 @@ it:
         rate_per_hour: "%{value}/h"
         affected_users_incomplete: almeno — la protezione dagli storm ha scartato il dettaglio per evento
         data_unavailable: Le statistiche non sono al momento disponibili — i valori seguenti non sono una misurazione.
+        event_timing_incomplete: "Le marche temporali sono incomplete — la protezione tempeste le ha scartate; i totali restano esatti."
         unresolved: Non risolti
         unresolved_hint: In attesa di risoluzione
         resolution_rate: Tasso di risoluzione

data/config/locales/ja.yml

@@ -532,6 +532,7 @@ ja:
         snapshot_stale: より前の発生から取得 — それ以降の発生はコンテキストを伴いませんでした
         snapshot_fidelity_lite: 縮小された取得 (storm 保護によりコンテキストの payload が破棄されました)
         snapshot_fidelity_minimal: storm 中にカウントされました — コンテキストは取得されていません
+        snapshot_fidelity_partial: 混在したスナップショット — 一部のフィールドは以前の発生時のものです
         snapshot_unknown: RED がスナップショットの出所を記録する前に取得されました
       similar_errors:
         title: 類似エラー
@@ -846,6 +847,7 @@ ja:
         rate_per_hour: "%{value}/時"
         affected_users_incomplete: 最少値 — storm 保護によりイベントごとの詳細が破棄されました
         data_unavailable: 統計は現在利用できません — 以下の数値は計測値ではありません。
+        event_timing_incomplete: "発生時刻の記録が不完全です — ストーム保護がタイムスタンプを破棄しました。合計値は正確です。"
         unresolved: 未解決
         unresolved_hint: 解決待ち
         resolution_rate: 解決率

data/config/locales/pl.yml

@@ -611,6 +611,7 @@ pl:
         snapshot_stale: z wcześniejszego wystąpienia — późniejsze nie przyniosły kontekstu
         snapshot_fidelity_lite: ograniczone przechwytywanie (ochrona przed storm odrzuciła payloady kontekstu)
         snapshot_fidelity_minimal: zliczone podczas storm — nie przechwycono żadnego kontekstu
+        snapshot_fidelity_partial: mieszany zrzut — część pól pochodzi z wcześniejszego wystąpienia
         snapshot_unknown: przechwycono, zanim RED zaczął zapisywać pochodzenie migawek
       similar_errors:
         title: Podobne błędy
@@ -978,6 +979,7 @@ pl:
         rate_per_hour: "%{value}/godz."
         affected_users_incomplete: co najmniej — ochrona przed storm odrzuciła szczegóły poszczególnych zdarzeń
         data_unavailable: Statystyki są obecnie niedostępne — poniższe liczby nie są pomiarem.
+        event_timing_incomplete: "Znaczniki czasu są niepełne — ochrona przed burzą je odrzuciła; sumy pozostają dokładne."
         unresolved: Nierozwiązane
         unresolved_hint: Oczekują na rozwiązanie
         resolution_rate: Wskaźnik rozwiązań

data/config/locales/pt-BR.yml

@@ -606,6 +606,7 @@ pt-BR:
         snapshot_stale: de uma ocorrência anterior — as posteriores não trouxeram contexto
         snapshot_fidelity_lite: captura reduzida (a proteção contra storms descartou os payloads de contexto)
         snapshot_fidelity_minimal: contabilizado durante um storm — nenhum contexto foi capturado
+        snapshot_fidelity_partial: snapshot misto — alguns campos vêm de uma ocorrência anterior
         snapshot_unknown: capturado antes de o RED registrar a procedência dos instantâneos
       similar_errors:
         title: Erros semelhantes
@@ -966,6 +967,7 @@ pt-BR:
         rate_per_hour: "%{value}/h"
         affected_users_incomplete: no mínimo — a proteção contra storms descartou o detalhe por evento
         data_unavailable: As estatísticas estão indisponíveis no momento — os números abaixo não são uma medição.
+        event_timing_incomplete: "Os horários estão incompletos — a proteção contra tempestades descartou os carimbos de tempo; os totais continuam exatos."
         unresolved: Não resolvidos
         unresolved_hint: Aguardando resolução
         resolution_rate: Taxa de resolução

data/config/locales/ru.yml

@@ -614,6 +614,7 @@ ru:
         snapshot_stale: из более раннего появления — последующие не содержали контекста
         snapshot_fidelity_lite: сокращённый сбор (защита от storm отбросила payload контекста)
         snapshot_fidelity_minimal: учтено во время storm — контекст не собирался
+        snapshot_fidelity_partial: смешанный снимок — часть полей осталась от более раннего события
         snapshot_unknown: получен до того, как RED начал записывать происхождение снимков
       similar_errors:
         title: Похожие ошибки
@@ -981,6 +982,7 @@ ru:
         rate_per_hour: "%{value}/ч"
         affected_users_incomplete: не менее — защита от storm отбросила детализацию по событиям
         data_unavailable: Статистика сейчас недоступна — приведённые ниже числа не являются измерением.
+        event_timing_incomplete: "Отметки времени неполные — защита от шторма отбросила их; итоговые значения остаются точными."
         unresolved: Не решено
         unresolved_hint: Ожидают решения
         resolution_rate: Доля решённых

data/config/locales/uk.yml

@@ -612,6 +612,7 @@ uk:
         snapshot_stale: з ранішого випадку — подальші не містили контексту
         snapshot_fidelity_lite: скорочений збір (захист від storm відкинув payload контексту)
         snapshot_fidelity_minimal: враховано під час storm — контекст не збирався
+        snapshot_fidelity_partial: змішаний знімок — частина полів залишилася від давнішої події
         snapshot_unknown: отримано до того, як RED почав записувати походження знімків
       similar_errors:
         title: Схожі помилки
@@ -978,6 +979,7 @@ uk:
         rate_per_hour: "%{value}/год"
         affected_users_incomplete: щонайменше — захист від storm відкинув деталізацію за подіями
         data_unavailable: Статистика зараз недоступна — наведені нижче числа не є вимірюванням.
+        event_timing_incomplete: "Позначки часу неповні — захист від шторму відкинув їх; підсумкові значення залишаються точними."
         unresolved: Не вирішено
         unresolved_hint: Очікують вирішення
         resolution_rate: Частка вирішених

data/config/locales/zh-CN.yml

@@ -529,6 +529,7 @@ zh-CN:
         snapshot_stale: 来自更早的一次发生 — 之后的发生未携带上下文
         snapshot_fidelity_lite: 已精简的捕获（storm 保护丢弃了上下文 payload）
         snapshot_fidelity_minimal: 在 storm 期间计数 — 未捕获任何上下文
+        snapshot_fidelity_partial: 混合快照 — 部分字段来自更早的一次发生
         snapshot_unknown: 在 RED 记录快照来源之前捕获
       similar_errors:
         title: 相似错误
@@ -842,6 +843,7 @@ zh-CN:
         rate_per_hour: "%{value}/小时"
         affected_users_incomplete: 至少 — storm 保护丢弃了逐事件的明细
         data_unavailable: 统计数据当前不可用 — 下方数字并非测量结果。
+        event_timing_incomplete: "事件时间记录不完整 — 风暴保护丢弃了时间戳；总数仍然准确。"
         unresolved: 未解决
         unresolved_hint: 等待处理
         resolution_rate: 解决率