rails_error_dashboard 0.9.0 → 0.10.0

data/lib/generators/rails_error_dashboard/install/install_generator.rb

@@ -348,7 +348,19 @@ module RailsErrorDashboard
           end
         end
 
+        # Start after the highest timestamp already present, not at the current
+        # clock. The counter increments per copied file, so a re-run that happens
+        # within N seconds of the previous install (N = number of migrations)
+        # would otherwise reuse numbers the first install already consumed —
+        # and Rails aborts the whole `db:migrate` with "Multiple migrations have
+        # the version number ...", so the upgrade silently applies nothing.
         timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        highest_existing = [ "db/migrate", "db/error_dashboard_migrate" ].flat_map do |dir|
+          full_path = File.join(destination_root, dir)
+          next [] unless Dir.exist?(full_path)
+          Dir.glob(File.join(full_path, "*.rb")).map { |f| File.basename(f)[/^\d+/].to_i }
+        end.max
+        timestamp = highest_existing + 1 if highest_existing && highest_existing >= timestamp
 
         Dir.glob(File.join(source_dir, "*.rb")).sort.each do |source_file|
           basename = File.basename(source_file)

data/lib/rails_error_dashboard/commands/flush_rack_attack_events.rb

@@ -8,7 +8,10 @@ module RailsErrorDashboard
     # hourly-bucketed rows. Uses find_or_initialize_by + increment for
     # cross-database compatibility (no raw SQL upsert).
     #
-    # counts keys: "rule\x1Fmatch_type\x1Fdiscriminator\x1Fpath\x1Fhttp_method"
+    # counts keys: "rule\x1Fmatch_type\x1Fdiscriminator\x1Fpath\x1Fhttp_method\x1Fuser_agent"
+    #
+    # http_method and user_agent are carried on the key but are NOT part of the
+    # row's identity — see upsert_event.
     class FlushRackAttackEvents
       def self.call(counts:)
         new(counts: counts).call
@@ -25,7 +28,7 @@ module RailsErrorDashboard
         app_id = current_application_id
 
         @counts.each do |key, count|
-          rule, match_type, discriminator, path, http_method =
+          rule, match_type, discriminator, path, http_method, user_agent =
             Services::RackAttackTracker.parse_key(key)
 
           next if rule.blank? || match_type.blank?
@@ -36,6 +39,7 @@ module RailsErrorDashboard
             discriminator: discriminator,
             path: path,
             http_method: http_method,
+            user_agent: user_agent,
             period: period,
             app_id: app_id,
             count: count
@@ -49,7 +53,8 @@ module RailsErrorDashboard
 
       private
 
-      def upsert_event(rule:, match_type:, discriminator:, path:, http_method:, period:, app_id:, count:)
+      def upsert_event(rule:, match_type:, discriminator:, path:, http_method:, user_agent:,
+                       period:, app_id:, count:)
         # nil and "" must map to the same row — the unique index treats them as
         # distinct in some adapters, so normalize blanks to nil consistently.
         record = RackAttackEvent.find_or_initialize_by(
@@ -61,7 +66,11 @@ module RailsErrorDashboard
           application_id: app_id
         )
 
+        # http_method and user_agent are deliberately NOT part of the upsert key
+        # (the unique index is already at 2736 of MySQL's 3072 bytes), so they
+        # are first-write-wins attributes of the bucket rather than identity.
         record.http_method = http_method.presence if record.http_method.blank?
+        record.user_agent = user_agent.presence if record.user_agent.blank?
         record.event_count = (record.event_count || 0) + count
         record.last_seen_at = Time.current
         record.save!

data/lib/rails_error_dashboard/configuration.rb

@@ -478,12 +478,22 @@ module RailsErrorDashboard
       errors = []
       warnings = []
 
-      # Block boot with default or blank credentials in production
+      # Block boot with default or blank credentials anywhere that is not local
+      # development or test.
+      #
+      # Deliberately an ALLOWLIST of safe environments rather than a check for
+      # `production`. Gating on Rails.env.production? tests one literal string,
+      # so an internet-facing `staging`, `uat`, `demo` or `preprod` box booted
+      # happily on credentials this project publishes in its own README
+      # (GHSA-qhgm-3pxf-mvc6). Every future environment name a team invents is
+      # now refused by default and has to be added here on purpose.
+      #
       # Skip during asset precompilation (SECRET_KEY_BASE_DUMMY=1) — ENV vars aren't available at build time
       if default_credentials? &&
-         defined?(Rails) && Rails.respond_to?(:env) && Rails.env.production? &&
+         defined?(Rails) && Rails.respond_to?(:env) &&
+         !Rails.env.development? && !Rails.env.test? &&
          ENV["SECRET_KEY_BASE_DUMMY"].blank?
-        errors << "Default or blank credentials cannot be used in production. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables, or use authenticate_with for custom auth."
+        errors << "Default or blank credentials cannot be used in #{Rails.env}. Only development and test may run on the built-in credentials. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables, or use authenticate_with for custom auth."
       end
 
       # Validate sampling_rate (must be between 0.0 and 1.0)

data/lib/rails_error_dashboard/engine.rb

@@ -85,6 +85,13 @@ module RailsErrorDashboard
       if RailsErrorDashboard.configuration.enable_rack_attack_tracking &&
          defined?(Rack::Attack)
         RailsErrorDashboard::Subscribers::RackAttackSubscriber.subscribe!
+
+        # Buffered counts live on the Puma threads that served the requests and
+        # are only written out on the flush interval, which a low-traffic rule
+        # may never reach. Without this, everything still buffered at SIGTERM
+        # (every deploy) is lost. at_exit, not Signal.trap — trapping would
+        # clobber Puma's USR1/USR2 handlers (safety rule 9).
+        at_exit { RailsErrorDashboard::Services::RackAttackTracker.flush_all_threads! }
       end
 
       # Subscribe to ActionCable AS::Notifications events (requires breadcrumbs + ActionCable)

data/lib/rails_error_dashboard/queries/rack_attack_summary.rb

@@ -24,7 +24,8 @@ module RailsErrorDashboard
 
       def call
         {
-          events: aggregated_events
+          events: aggregated_events,
+          overflow_count: overflow_count
         }
       end
 
@@ -36,15 +37,27 @@ module RailsErrorDashboard
         scope
       end
 
+      # Counts dropped by the tracker's LRU eviction, kept out of the per-rule
+      # listing (they belong to no single rule) but reported so the dashboard
+      # never silently under-states volume.
+      def overflow_count
+        base_query.where(match_type: RackAttackEvent::OVERFLOW_MATCH_TYPE).sum(:event_count).to_i
+      rescue => e
+        0
+      end
+
       def aggregated_events
-        rows = base_query.pluck(
-          :rule, :match_type, :discriminator, :path, :event_count, :last_seen_at, :period_hour
-        )
+        rows = base_query
+          .where.not(match_type: RackAttackEvent::OVERFLOW_MATCH_TYPE)
+          .pluck(
+            :rule, :match_type, :discriminator, :path, :event_count, :last_seen_at,
+            :period_hour, :user_agent
+          )
         return [] if rows.empty?
 
         grouped = {}
 
-        rows.each do |rule, match_type, discriminator, path, event_count, last_seen_at, period_hour|
+        rows.each do |rule, match_type, discriminator, path, event_count, last_seen_at, period_hour, user_agent|
           key = rule.to_s.presence || "unknown"
           count = event_count.to_i
           seen_at = last_seen_at || period_hour
@@ -55,12 +68,19 @@ module RailsErrorDashboard
             count: 0,
             ips: Set.new,
             path_counts: Hash.new(0),
+            agent_counts: Hash.new(0),
+            ai_count: 0,
             last_seen: nil
           }
 
           entry[:count] += count
           entry[:ips] << discriminator.to_s if discriminator.present?
           entry[:path_counts][path.to_s] += count if path.present?
+          if user_agent.present?
+            agent = Services::AiAgentClassifier.name(user_agent) || user_agent.to_s
+            entry[:agent_counts][agent] += count
+            entry[:ai_count] += count if Services::AiAgentClassifier.ai?(user_agent)
+          end
           entry[:last_seen] = [ entry[:last_seen], seen_at ].compact.max
 
           # Prefer the most severe match type when a rule spans several. A rule
@@ -74,11 +94,17 @@ module RailsErrorDashboard
           r[:paths] = r[:path_counts].sort_by { |_p, c| -c }.map(&:first)
           r[:unique_ips] = r[:ips].size
           r[:ips] = r[:ips].to_a
+          # Which client matched most often — the question unique_ips cannot
+          # answer, because one AI agent is a whole fleet of addresses (#170).
+          r[:top_agent] = r[:agent_counts].max_by { |_agent, count| count }&.first
+          r[:agents] = r[:agent_counts].sort_by { |_a, c| -c }.map(&:first)
+          r[:unique_agents] = r[:agent_counts].size
           # Distinct rate-limited clients is the meaningful figure here; the old
           # breadcrumb-derived :error_count no longer applies now that events are
           # stored independently of errors.
           r[:error_count] = 0
           r.delete(:path_counts)
+          r.delete(:agent_counts)
         end
 
         grouped.values.sort_by { |r| -r[:count] }

data/lib/rails_error_dashboard/services/ai_agent_classifier.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Classifies a User-Agent string into a coarse traffic kind, and names the
+    # agent when it is a recognised one.
+    #
+    # WHY THIS EXISTS (issue #170): tracking which AI agents read an app is the
+    # reason people reach for Rack::Attack's `track` rules now. Counting IPs
+    # cannot answer it — one agent is a rotating fleet of hundreds of addresses,
+    # so unique-IP totals overstate the population badly. The user agent is the
+    # signal that actually identifies the reader.
+    #
+    # Deliberately plain string matching, NOT the `browser` gem: `browser` is an
+    # optional dependency that degrades gracefully everywhere else in this gem,
+    # and it does not know these agents anyway. This runs on the flush path, not
+    # the request path, but it stays allocation-cheap regardless.
+    #
+    # The bot lists are necessarily a snapshot. An unrecognised agent falls back
+    # to :other rather than being guessed at — a wrong attribution is worse than
+    # an honest "unknown" when the whole point is measurement.
+    class AiAgentClassifier
+      # Order matters: the first match wins, so more specific patterns lead.
+      #
+      # AI agents split into two behaviours worth telling apart, because they
+      # answer different questions:
+      # - :ai_assistant — fetches on demand, because a human asked something now
+      # - :ai_crawler   — bulk-fetches to build a training corpus or index
+      AI_ASSISTANTS = {
+        "ChatGPT-User" => /ChatGPT-User/i,
+        "Claude-User" => /Claude-User/i,
+        "Claude Code" => /Claude-?Code/i,
+        "Perplexity-User" => /Perplexity-User/i,
+        "Gemini-User" => /Gemini-User/i
+      }.freeze
+
+      AI_CRAWLERS = {
+        "GPTBot" => /GPTBot/i,
+        "OAI-SearchBot" => /OAI-SearchBot/i,
+        "ClaudeBot" => /ClaudeBot/i,
+        "anthropic-ai" => /anthropic-ai/i,
+        "PerplexityBot" => /PerplexityBot/i,
+        "Google-Extended" => /Google-Extended/i,
+        "Applebot-Extended" => /Applebot-Extended/i,
+        "Bytespider" => /Bytespider/i,
+        "CCBot" => /CCBot/i,
+        "Meta-ExternalAgent" => /Meta-ExternalAgent/i,
+        "Amazonbot" => /Amazonbot/i,
+        "cohere-ai" => /cohere-ai/i,
+        "DuckAssistBot" => /DuckAssistBot/i,
+        "YouBot" => /YouBot/i,
+        "Diffbot" => /Diffbot/i,
+        "Timpibot" => /Timpibot/i
+      }.freeze
+
+      # Conventional search/SEO crawlers. Not AI traffic, but worth naming so
+      # they can be excluded rather than silently inflating an "unknown" bucket.
+      CRAWLERS = {
+        "Googlebot" => /Googlebot/i,
+        "Bingbot" => /bingbot/i,
+        "DuckDuckBot" => /DuckDuckBot/i,
+        "Baiduspider" => /Baiduspider/i,
+        "YandexBot" => /YandexBot/i,
+        "AhrefsBot" => /AhrefsBot/i,
+        "SemrushBot" => /SemrushBot/i,
+        "Applebot" => /Applebot/i,
+        "facebookexternalhit" => /facebookexternalhit/i,
+        "LLMS-Txt-Scanner" => /LLMS-Txt-Scanner/i
+      }.freeze
+
+      # Checked only after every bot pattern has missed, because plenty of bots
+      # embed a full browser UA string and would match these first.
+      BROWSER_HINTS = /Mozilla|Chrome|Safari|Firefox|Edge|Opera|Gecko|WebKit/i
+
+      # Non-browser HTTP clients — usually scripts, monitors or scrapers.
+      LIBRARIES = {
+        "curl" => /\bcurl\//i,
+        "wget" => /\bWget\//i,
+        "python-requests" => /python-requests/i,
+        "httpx" => /\bhttpx\//i,
+        "Go-http-client" => /Go-http-client/i,
+        "Java" => /\bJava\//i,
+        "okhttp" => /\bokhttp\//i,
+        "axios" => /\baxios\//i,
+        "Faraday" => /Faraday/i,
+        "RubyGems" => /Ruby\b/i
+      }.freeze
+
+      KINDS = %i[ai_assistant ai_crawler crawler browser library other].freeze
+
+      class << self
+        # @param user_agent [String, nil]
+        # @return [Symbol] one of KINDS
+        def kind(user_agent)
+          ua = user_agent.to_s
+          return :other if ua.strip.empty?
+
+          return :ai_assistant if match_name(AI_ASSISTANTS, ua)
+          return :ai_crawler if match_name(AI_CRAWLERS, ua)
+          return :crawler if match_name(CRAWLERS, ua)
+          return :library if match_name(LIBRARIES, ua)
+          return :browser if ua.match?(BROWSER_HINTS)
+
+          :other
+        rescue => e
+          :other
+        end
+
+        # Canonical name for a recognised agent, or nil when unrecognised.
+        # Never invents a name — callers show the raw UA in that case.
+        #
+        # @param user_agent [String, nil]
+        # @return [String, nil]
+        def name(user_agent)
+          ua = user_agent.to_s
+          return nil if ua.strip.empty?
+
+          match_name(AI_ASSISTANTS, ua) ||
+            match_name(AI_CRAWLERS, ua) ||
+            match_name(CRAWLERS, ua) ||
+            match_name(LIBRARIES, ua)
+        rescue => e
+          nil
+        end
+
+        # Whether this agent is an LLM reader of either flavour. This is the
+        # predicate the dashboard's "AI agents" figure counts.
+        #
+        # @param user_agent [String, nil]
+        # @return [Boolean]
+        def ai?(user_agent)
+          %i[ai_assistant ai_crawler].include?(kind(user_agent))
+        end
+
+        # @return [Hash] { kind:, name:, ai: } — one pass for callers that want all three
+        def classify(user_agent)
+          k = kind(user_agent)
+          {
+            kind: k,
+            name: name(user_agent),
+            ai: %i[ai_assistant ai_crawler].include?(k)
+          }
+        end
+
+        private
+
+        def match_name(table, ua)
+          table.each { |agent_name, pattern| return agent_name if ua.match?(pattern) }
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/rack_attack_tracker.rb

@@ -32,6 +32,14 @@ module RailsErrorDashboard
       MAX_DISCRIMINATOR_LENGTH = 191
       MAX_PATH_LENGTH          = 191
       MAX_METHOD_LENGTH        = 10
+      MAX_USER_AGENT_LENGTH    = 191
+
+      # Reserved rule/match_type used to account for counts dropped by LRU
+      # eviction. Without this the evicted count vanishes silently and the
+      # dashboard under-reports with no indication anything was lost — the same
+      # problem StormProtection::CountBuffer solves with an overflow counter.
+      OVERFLOW_RULE       = "__overflow__"
+      OVERFLOW_MATCH_TYPE = "overflow"
 
       # Separator for the composite buffer key. Chosen because it cannot appear in
       # an HTTP method and is vanishingly unlikely in a rule name or path.
@@ -46,7 +54,9 @@ module RailsErrorDashboard
         # @param discriminator [String] rate-limit key (usually IP or user id)
         # @param path [String] request path
         # @param http_method [String] request method
-        def record(rule:, match_type:, discriminator: nil, path: nil, http_method: nil)
+        # @param user_agent [String] client user agent, for AI/crawler attribution
+        def record(rule:, match_type:, discriminator: nil, path: nil, http_method: nil,
+                   user_agent: nil)
           return unless enabled?
 
           key = build_key(
@@ -54,15 +64,21 @@ module RailsErrorDashboard
             match_type.to_s,
             truncate(discriminator, MAX_DISCRIMINATOR_LENGTH),
             truncate(path, MAX_PATH_LENGTH),
-            truncate(http_method, MAX_METHOD_LENGTH)
+            truncate(http_method, MAX_METHOD_LENGTH),
+            truncate(user_agent, MAX_USER_AGENT_LENGTH)
           )
 
           counts = (Thread.current[COUNTS_THREAD_KEY] ||= {})
           counts[key] = (counts[key] || 0) + 1
 
-          # LRU eviction — Ruby hashes preserve insertion order, so the first key
-          # is the oldest. Bounds memory under rotating-discriminator attacks.
-          evict_oldest!(counts) if counts.size > max_cache_size
+          # LRU eviction — bounds memory under rotating-discriminator attacks.
+          # Loops because the overflow bucket occupies a slot of its own once
+          # created, so a single eviction may not bring the map back under cap.
+          # evict_oldest! returns false once only the overflow key is left, which
+          # guarantees termination even if max_cache_size is misconfigured to 0.
+          while counts.size > max_cache_size
+            break unless evict_oldest!(counts)
+          end
 
           maybe_flush!
           nil
@@ -93,6 +109,46 @@ module RailsErrorDashboard
           nil
         end
 
+        # Flush every live thread's buffer, not just the caller's.
+        #
+        # WHY: flush! only ever sees Thread.current. Buffers live on the Puma
+        # threads that served the requests, so at shutdown (and from a background
+        # job) the caller's own buffer is empty while the real counts sit on
+        # threads nobody is asking. Without this, everything buffered at SIGTERM
+        # is lost, and a rule that matches once and then sees no further traffic
+        # on that thread is never persisted at all.
+        #
+        # Thread#[] reads another thread's fiber-locals directly, so no thread
+        # registry is needed — the same approach SwallowedExceptionTracker uses.
+        # sync: true because callers are already off the request path.
+        def flush_all_threads!
+          Thread.list.each do |thread|
+            # Rescue per thread, not just around the whole loop: one thread
+            # whose write fails must not strand the buffers of every thread
+            # after it in the list.
+            begin
+              counts = thread[COUNTS_THREAD_KEY]
+              next if counts.nil? || counts.empty?
+
+              snapshot = counts.dup
+              counts.clear
+              thread[FLUSH_THREAD_KEY] = nil
+
+              dispatch_flush(snapshot, sync: true)
+            rescue => e
+              RailsErrorDashboard::Logger.debug(
+                "[RailsErrorDashboard] RackAttackTracker.flush_all_threads! skipped a thread: #{e.class} - #{e.message}"
+              )
+            end
+          end
+          nil
+        rescue => e
+          RailsErrorDashboard::Logger.debug(
+            "[RailsErrorDashboard] RackAttackTracker.flush_all_threads! failed: #{e.class} - #{e.message}"
+          )
+          nil
+        end
+
         # Clear thread-local state without persisting. Used by specs and by
         # thread teardown paths.
         def reset!
@@ -111,9 +167,16 @@ module RailsErrorDashboard
         end
 
         # Decompose a buffer key back into its parts.
-        # @return [Array<String>] [rule, match_type, discriminator, path, http_method]
+        #
+        # The limit must match the field count exactly. With a limit of 5 the
+        # user agent would be glued onto http_method instead of standing alone.
+        # split also drops trailing empty fields without the limit, so a key
+        # whose user agent is blank must still yield six elements.
+        #
+        # @return [Array<String>] [rule, match_type, discriminator, path, http_method, user_agent]
         def parse_key(key)
-          key.to_s.split(KEY_SEPARATOR, 5)
+          parts = key.to_s.split(KEY_SEPARATOR, 6)
+          parts.fill("", parts.length, 6 - parts.length)
         end
 
         private
@@ -128,9 +191,28 @@ module RailsErrorDashboard
           parts.map(&:to_s).join(KEY_SEPARATOR)
         end
 
+        # Evict the oldest entry, rolling its count into the overflow bucket so
+        # the total stays truthful. Ruby hashes preserve insertion order, so the
+        # first key is the oldest.
+        #
+        # The overflow key is skipped when choosing a victim: it is written once
+        # and would otherwise be the oldest key forever, so evicting it would
+        # discard exactly the accounting this method exists to keep.
+        # @return [Boolean] true if an entry was evicted, false if the overflow
+        #   bucket is all that remains (which is what terminates the caller's loop)
         def evict_oldest!(hash)
-          oldest_key = hash.each_key.first
-          hash.delete(oldest_key) if oldest_key
+          oldest_key = hash.each_key.find { |k| k != overflow_key }
+          return false unless oldest_key
+
+          dropped = hash.delete(oldest_key).to_i
+          hash[overflow_key] = (hash[overflow_key] || 0) + dropped if dropped.positive?
+          true
+        end
+
+        def overflow_key
+          @overflow_key ||= build_key(
+            OVERFLOW_RULE, OVERFLOW_MATCH_TYPE, "", "", "", ""
+          )
         end
 
         # Cheap periodic flush check — a float subtraction, no I/O.

data/lib/rails_error_dashboard/subscribers/rack_attack_subscriber.rb

@@ -70,9 +70,10 @@ module RailsErrorDashboard
 
           match_type = event_name.split(".").first # "throttle", "blocklist", "track"
           rule = env["rack.attack.matched"].to_s
-          discriminator = env["rack.attack.match_discriminator"].to_s
+          discriminator = resolve_discriminator(env, request)
           path = request.respond_to?(:path) ? request.path.to_s : ""
           method = request.respond_to?(:request_method) ? request.request_method.to_s : ""
+          user_agent = resolve_user_agent(request, env)
 
           # Persist independently of error capture. A throttled request returns
           # HTTP 429 and raises nothing, so it would otherwise never reach the
@@ -82,7 +83,8 @@ module RailsErrorDashboard
             match_type: match_type,
             discriminator: discriminator,
             path: path,
-            http_method: method
+            http_method: method,
+            user_agent: user_agent
           )
 
           # Also record a breadcrumb so the event still shows up in the activity
@@ -102,6 +104,42 @@ module RailsErrorDashboard
 
           Services::BreadcrumbCollector.add("rack_attack", message, metadata: metadata)
         end
+
+        # Resolve the discriminator, falling back to the client IP.
+        #
+        # WHY (issue #170): a `track` rule declared without :limit/:period is a
+        # Rack::Attack::Check, and Check#matched_by? sets only "rack.attack.matched"
+        # and "rack.attack.match_type" — never "rack.attack.match_discriminator".
+        # Only Throttle#annotate_request_with_matched_data sets that key. The value
+        # the rule's block returns (typically `req.ip`) is used purely as a truthy
+        # match test and then discarded upstream.
+        #
+        # Without this fallback every track row stores a blank discriminator, so
+        # RackAttackSummary reports "Unique IPs: 0" for a rule that plainly matched
+        # real clients. We use request.ip rather than re-invoking the rule's block:
+        # the block is arbitrary host code that may have side effects or return a
+        # non-IP value, and re-running it from a notification subscriber would
+        # execute it a second time per request.
+        def resolve_discriminator(env, request)
+          explicit = env["rack.attack.match_discriminator"].to_s
+          return explicit unless explicit.empty?
+
+          # request.ip parses X-Forwarded-For and can raise on malformed input.
+          request.respond_to?(:ip) ? request.ip.to_s : ""
+        rescue => e
+          ""
+        end
+
+        # The user agent identifies WHICH client matched a rule — the question
+        # IP counts cannot answer, since one AI agent is a rotating fleet of
+        # addresses (issue #170). Falls back to the raw env key so a request
+        # object that does not implement #user_agent still yields the value.
+        def resolve_user_agent(request, env)
+          ua = request.respond_to?(:user_agent) ? request.user_agent : nil
+          (ua || env["HTTP_USER_AGENT"]).to_s
+        rescue => e
+          ""
+        end
       end
     end
   end

data/lib/rails_error_dashboard/version.rb

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

data/lib/rails_error_dashboard.rb

@@ -84,6 +84,7 @@ require "rails_error_dashboard/services/variable_serializer"
 require "rails_error_dashboard/services/local_variable_capturer"
 require "rails_error_dashboard/services/swallowed_exception_tracker"
 require "rails_error_dashboard/services/rack_attack_tracker"
+require "rails_error_dashboard/services/ai_agent_classifier"
 require "rails_error_dashboard/services/crash_capture"
 require "rails_error_dashboard/services/diagnostic_dump_generator"
 require "rails_error_dashboard/services/coverage_tracker"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -232,9 +232,16 @@ description: 'Own your errors. Own your stack. A fully open-source, self-hosted
   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. 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)'
+  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)'
 email:
 - anjan.jagirdar@gmail.com
 executables: []
@@ -384,6 +391,7 @@ files:
 - db/migrate/20260503000001_backfill_resolved_status.rb
 - 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
 - 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
@@ -464,6 +472,7 @@ files:
 - lib/rails_error_dashboard/queries/storm_history.rb
 - lib/rails_error_dashboard/queries/swallowed_exception_summary.rb
 - lib/rails_error_dashboard/queries/user_impact_summary.rb
+- lib/rails_error_dashboard/services/ai_agent_classifier.rb
 - lib/rails_error_dashboard/services/analytics_cache_manager.rb
 - lib/rails_error_dashboard/services/backtrace_parser.rb
 - lib/rails_error_dashboard/services/backtrace_processor.rb
@@ -550,7 +559,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.9.0
+    RED (Rails Error Dashboard) v0.10.0
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install:
@@ -589,5 +598,5 @@ requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
 summary: Self-hosted error tracking for Rails — local variables, system health, separate
-  or shared database. A free, open-source Sentry alternative.
+  or shared database, dashboard in 11 languages. A free, open-source Sentry alternative.
 test_files: []