rails_error_dashboard 0.1.37 → 0.2.0

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -24,6 +24,7 @@ module RailsErrorDashboard
               total_month: base_scope.where("occurred_at >= ?", 30.days.ago).count,
               unresolved: base_scope.unresolved.count,
               resolved: base_scope.resolved.count,
+              reopened: reopened_count,
               by_platform: base_scope.group(:platform).count,
               top_errors: top_errors,
               #  Trend visualizations
@@ -55,6 +56,7 @@ module RailsErrorDashboard
             total_month: 0,
             unresolved: 0,
             resolved: 0,
+            reopened: 0,
             by_platform: {},
             top_errors: {},
             errors_trend_7d: {},
@@ -93,6 +95,12 @@ module RailsErrorDashboard
         scope
       end
 
+      def reopened_count
+        return 0 unless ErrorLog.column_names.include?("reopened_at")
+
+        base_scope.where.not(reopened_at: nil).count
+      end
+
       def top_errors
         base_scope.where("occurred_at >= ?", 7.days.ago)
                   .group(:error_type)

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -39,6 +39,7 @@ module RailsErrorDashboard
         query = filter_by_assignment(query)
         query = filter_by_priority(query)
         query = filter_by_snoozed(query)
+        query = filter_by_reopened(query)
         query
       end
 
@@ -195,6 +196,13 @@ module RailsErrorDashboard
         end
       end
 
+      def filter_by_reopened(query)
+        return query unless @filters[:reopened] == "true"
+        return query unless ErrorLog.column_names.include?("reopened_at")
+
+        query.where.not(reopened_at: nil)
+      end
+
       def filter_by_timeframe(query)
         return query unless @filters[:timeframe].present?
 

data/lib/rails_error_dashboard/services/backtrace_parser.rb

@@ -14,6 +14,19 @@ module RailsErrorDashboard
         new(backtrace_string).parse
       end
 
+      # Convert Thread::Backtrace::Location objects to frame hashes
+      # Uses structured data directly — no regex needed.
+      # @param locations [Array<Thread::Backtrace::Location>, nil] Backtrace locations
+      # @return [Array<Hash>] Parsed frames with same structure as .parse
+      def self.from_locations(locations)
+        return [] if locations.nil? || locations.empty?
+
+        new(nil).send(:convert_locations, locations)
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BacktraceParser.from_locations failed: #{e.message}")
+        []
+      end
+
       def initialize(backtrace_string)
         @backtrace_string = backtrace_string
       end
@@ -29,6 +42,24 @@ module RailsErrorDashboard
 
       private
 
+      def convert_locations(locations)
+        locations.map.with_index do |loc, index|
+          file_path = loc.absolute_path || loc.path
+          line_number = loc.lineno
+          method_name = loc.label || "(unknown)"
+
+          {
+            index: index,
+            file_path: file_path,
+            line_number: line_number,
+            method_name: method_name,
+            category: categorize_frame(file_path),
+            full_line: loc.to_s,
+            short_path: shorten_path(file_path)
+          }
+        end
+      end
+
       def parse_frame(line, index)
         match = line.match(FRAME_PATTERN)
         return nil unless match

data/lib/rails_error_dashboard/services/backtrace_processor.rb

@@ -29,8 +29,14 @@ module RailsErrorDashboard
       # Extracts file paths and method names, ignoring line numbers,
       # then produces an order-independent SHA256 digest.
       # @param backtrace [String, Array<String>, nil] The backtrace
+      # @param locations [Array<Thread::Backtrace::Location>, nil] Optional structured locations
       # @return [String, nil] 16-character hex signature
-      def self.calculate_signature(backtrace)
+      def self.calculate_signature(backtrace, locations: nil)
+        # Try structured locations first (more reliable, no regex)
+        if locations && !locations.empty?
+          return signature_from_locations(locations)
+        end
+
         return nil if backtrace.blank?
 
         lines = backtrace.is_a?(String) ? backtrace.split("\n") : backtrace
@@ -47,6 +53,30 @@ module RailsErrorDashboard
         file_paths = frames.map { |frame| frame.split(":").first }.sort
         Digest::SHA256.hexdigest(file_paths.join("|"))[0..15]
       end
+
+      # Calculate signature directly from Location objects
+      # @param locations [Array<Thread::Backtrace::Location>] Backtrace locations
+      # @return [String, nil] 16-character hex signature
+      def self.signature_from_locations(locations)
+        frames = locations.first(20).map do |loc|
+          path = loc.absolute_path || loc.path
+          next nil unless path&.end_with?(".rb")
+          file_name = File.basename(path)
+          method_name = loc.label
+          method_name ? "#{file_name}:#{method_name}" : file_name
+        end.compact.uniq
+
+        return nil if frames.empty?
+
+        file_paths = frames.map { |frame| frame.split(":").first }.sort
+        Digest::SHA256.hexdigest(file_paths.join("|"))[0..15]
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] signature_from_locations failed: #{e.message}"
+        )
+        nil
+      end
+      private_class_method :signature_from_locations
     end
   end
 end

data/lib/rails_error_dashboard/services/cause_chain_extractor.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Extract the exception cause chain from an exception.
+    #
+    # Ruby exceptions can have a `cause` (set automatically by `raise` inside a `rescue`).
+    # This service walks the chain recursively with a depth limit to prevent
+    # infinite loops from circular cause references.
+    #
+    # Returns a JSON string of cause entries, or nil if no cause exists.
+    #
+    # @example
+    #   CauseChainExtractor.call(exception)
+    #   # => '[{"class_name":"OriginalError","message":"connection refused","backtrace":["app/models/user.rb:10"]}]'
+    class CauseChainExtractor
+      MAX_DEPTH = 5
+      MAX_MESSAGE_LENGTH = 1000
+      MAX_BACKTRACE_LINES = 20
+
+      # @param exception [Exception] The exception to extract cause chain from
+      # @return [String, nil] JSON string of cause chain, or nil if no cause
+      def self.call(exception)
+        return nil unless exception.respond_to?(:cause) && exception.cause
+
+        chain = []
+        current = exception.cause
+        seen = Set.new
+        depth = 0
+
+        while current && depth < MAX_DEPTH
+          # Guard against circular cause references
+          break if seen.include?(current.object_id)
+          seen.add(current.object_id)
+
+          chain << {
+            class_name: current.class.name,
+            message: current.message&.to_s&.slice(0, MAX_MESSAGE_LENGTH),
+            backtrace: truncate_backtrace(current.backtrace)
+          }
+
+          current = current.respond_to?(:cause) ? current.cause : nil
+          depth += 1
+        end
+
+        chain.empty? ? nil : chain.to_json
+      rescue => e
+        # SAFETY: Never let cause chain extraction break error logging
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] CauseChainExtractor failed: #{e.class} - #{e.message}"
+        )
+        nil
+      end
+
+      def self.truncate_backtrace(backtrace)
+        return nil unless backtrace.is_a?(Array)
+        backtrace.first(MAX_BACKTRACE_LINES)
+      end
+      private_class_method :truncate_backtrace
+    end
+  end
+end

data/lib/rails_error_dashboard/services/environment_snapshot.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Capture runtime environment info at boot time
+    #
+    # Snapshots Ruby version, Rails version, loaded gem versions, web server,
+    # and database adapter. Memoized — computed once per process lifetime.
+    # Stored as JSON on each error so historical errors show the environment
+    # that was running when they occurred (not the current environment).
+    class EnvironmentSnapshot
+      TRACKED_GEMS = %w[
+        activerecord actionpack sidekiq solid_queue puma unicorn
+        passenger redis pg mysql2 sqlite3 good_job
+      ].freeze
+
+      # Return cached environment snapshot (frozen hash)
+      # @return [Hash] Environment info
+      def self.snapshot
+        @cached_snapshot ||= new.capture.freeze
+      end
+
+      # Clear cached snapshot (for testing)
+      def self.reset!
+        @cached_snapshot = nil
+      end
+
+      # Capture current environment info
+      # @return [Hash] Environment snapshot
+      def capture
+        {
+          ruby_version: RUBY_VERSION,
+          ruby_engine: RUBY_ENGINE,
+          ruby_platform: RUBY_PLATFORM,
+          rails_version: rails_version,
+          rails_env: rails_env,
+          gem_versions: detect_gem_versions,
+          server: detect_server,
+          database_adapter: detect_database_adapter
+        }
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] EnvironmentSnapshot.capture failed: #{e.message}")
+        { ruby_version: RUBY_VERSION, ruby_engine: RUBY_ENGINE }
+      end
+
+      private
+
+      def rails_version
+        Rails.version
+      rescue
+        "unknown"
+      end
+
+      def rails_env
+        Rails.env.to_s
+      rescue
+        "unknown"
+      end
+
+      def detect_gem_versions
+        TRACKED_GEMS.each_with_object({}) do |gem_name, hash|
+          spec = Gem.loaded_specs[gem_name]
+          hash[gem_name] = spec.version.to_s if spec
+        end
+      rescue
+        {}
+      end
+
+      def detect_server
+        return "puma" if defined?(Puma)
+        return "unicorn" if defined?(Unicorn)
+        return "passenger" if defined?(PhusionPassenger)
+        "unknown"
+      rescue
+        "unknown"
+      end
+
+      def detect_database_adapter
+        ActiveRecord::Base.connection_db_config.adapter
+      rescue
+        "unknown"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/error_hash_generator.rb

@@ -20,10 +20,15 @@ module RailsErrorDashboard
       # @param controller_name [String, nil] Controller context
       # @param action_name [String, nil] Action context
       # @param application_id [Integer, nil] Application for per-app deduplication
+      # @param context [Hash] Full error context (passed to custom fingerprint lambda)
       # @return [String] 16-character hex hash
-      def self.call(exception, controller_name: nil, action_name: nil, application_id: nil)
+      def self.call(exception, controller_name: nil, action_name: nil, application_id: nil, context: {})
+        # Check for custom fingerprint lambda
+        custom = try_custom_fingerprint(exception, context)
+        return custom if custom
+
         normalized_message = normalize_message(exception.message)
-        file_path = extract_app_frame(exception.backtrace)
+        file_path = extract_app_frame_from_locations(exception) || extract_app_frame(exception.backtrace)
 
         digest_input = [
           exception.class.name,
@@ -74,6 +79,27 @@ module RailsErrorDashboard
           &.gsub(/'[^']*'/, "''")                # Replace single-quoted strings
       end
 
+      # Extract first meaningful app code frame using backtrace_locations
+      # More reliable than string parsing — uses Location#absolute_path directly.
+      # @param exception [Exception] The exception with backtrace_locations
+      # @return [String, nil] File path of first app code frame, or nil
+      def self.extract_app_frame_from_locations(exception)
+        locations = exception.backtrace_locations
+        return nil if locations.nil? || locations.empty?
+
+        first_app_location = locations.find { |loc|
+          path = loc.absolute_path || loc.path
+          !path&.include?("/gems/")
+        }
+
+        first_app_location && (first_app_location.absolute_path || first_app_location.path)
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] extract_app_frame_from_locations failed: #{e.message}"
+        )
+        nil
+      end
+
       # Extract first meaningful app code frame from backtrace
       # @param backtrace [Array<String>, nil] Exception backtrace
       # @return [String, nil] File path of first app code frame
@@ -86,6 +112,28 @@ module RailsErrorDashboard
 
         first_app_frame&.split(":")&.first
       end
+
+      # Try custom fingerprint lambda if configured
+      # Returns 16-char hex hash from custom key, or nil to fall back to default
+      # @param exception [Exception] The exception
+      # @param context [Hash] Error context
+      # @return [String, nil] 16-character hex hash or nil
+      def self.try_custom_fingerprint(exception, context)
+        fingerprint_fn = RailsErrorDashboard.configuration.custom_fingerprint
+        return nil unless fingerprint_fn
+
+        result = fingerprint_fn.call(exception, context)
+        return nil unless result.is_a?(String) && !result.empty?
+
+        Digest::SHA256.hexdigest(result)[0..15]
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] Custom fingerprint lambda failed: #{e.class} - #{e.message}. " \
+          "Falling back to default hash."
+        )
+        nil
+      end
+      private_class_method :try_custom_fingerprint
     end
   end
 end

data/lib/rails_error_dashboard/services/notification_throttler.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Throttle error notifications to prevent alert fatigue
+    #
+    # Checks severity minimum, per-error cooldown, and threshold milestones.
+    # Uses in-memory cache (same pattern as BaselineAlertThrottler).
+    # Thread-safe via Mutex. Fail-open: returns true on any error.
+    class NotificationThrottler
+      # Severity levels ranked from lowest to highest
+      SEVERITY_RANK = { low: 0, medium: 1, high: 2, critical: 3 }.freeze
+
+      @last_notification_times = {}
+      @mutex = Mutex.new
+
+      class << self
+        # Should we send a notification for this error?
+        # Checks: severity minimum + cooldown period
+        # @param error_log [ErrorLog] The error to check
+        # @return [Boolean] true if notification should be sent
+        def should_notify?(error_log)
+          return false unless severity_meets_minimum?(error_log)
+
+          cooldown_ok?(error_log)
+        rescue => e
+          # Fail-open: if throttler breaks, allow notification
+          RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] NotificationThrottler.should_notify? failed: #{e.message}")
+          true
+        end
+
+        # Does the error's severity meet the configured minimum?
+        # @param error_log [ErrorLog] The error to check
+        # @return [Boolean] true if severity is at or above minimum
+        def severity_meets_minimum?(error_log)
+          config = RailsErrorDashboard.configuration
+          minimum = config.notification_minimum_severity || :low
+          severity = SeverityClassifier.classify(error_log.error_type)
+
+          (SEVERITY_RANK[severity] || 0) >= (SEVERITY_RANK[minimum] || 0)
+        rescue => e
+          RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] NotificationThrottler.severity_meets_minimum? failed: #{e.message}")
+          true
+        end
+
+        # Has the error's occurrence count reached a configured threshold milestone?
+        # @param error_log [ErrorLog] The error to check
+        # @return [Boolean] true if occurrence_count matches a threshold
+        def threshold_reached?(error_log)
+          thresholds = RailsErrorDashboard.configuration.notification_threshold_alerts
+          return false if thresholds.nil? || thresholds.empty?
+
+          thresholds.include?(error_log.occurrence_count)
+        rescue => e
+          RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] NotificationThrottler.threshold_reached? failed: #{e.message}")
+          false
+        end
+
+        # Record that a notification was sent for this error
+        # @param error_log [ErrorLog] The error that was notified about
+        def record_notification(error_log)
+          key = error_log.error_hash
+
+          @mutex.synchronize do
+            @last_notification_times[key] = Time.current
+          end
+        rescue => e
+          RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] NotificationThrottler.record_notification failed: #{e.message}")
+        end
+
+        # Clear all throttle state (for testing)
+        def clear!
+          @mutex.synchronize do
+            @last_notification_times.clear
+          end
+        end
+
+        # Remove old entries to prevent memory growth
+        # @param max_age_hours [Integer] Remove entries older than this (default: 24)
+        def cleanup!(max_age_hours: 24)
+          cutoff_time = max_age_hours.hours.ago
+
+          @mutex.synchronize do
+            @last_notification_times.delete_if { |_, time| time < cutoff_time }
+          end
+        end
+
+        private
+
+        # Is the error outside the cooldown window?
+        # @param error_log [ErrorLog] The error to check
+        # @return [Boolean] true if not in cooldown (ok to notify)
+        def cooldown_ok?(error_log)
+          cooldown_minutes = RailsErrorDashboard.configuration.notification_cooldown_minutes
+          return true if cooldown_minutes.nil? || cooldown_minutes <= 0
+
+          key = error_log.error_hash
+
+          @mutex.synchronize do
+            last_time = @last_notification_times[key]
+            return true if last_time.nil?
+
+            Time.current > (last_time + cooldown_minutes.minutes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/platform_detector.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require "browser"
-
 module RailsErrorDashboard
   module Services
-    # Detects the platform (iOS/Android/API) from user agent string
+    # Detects the platform (iOS/Android/API) from user agent string.
+    # Uses the browser gem when available, falls back to regex matching.
     class PlatformDetector
       def self.detect(user_agent)
         new(user_agent).detect
@@ -17,6 +16,16 @@ module RailsErrorDashboard
       def detect
         return "API" if @user_agent.blank?
 
+        if defined?(Browser)
+          detect_with_browser_gem
+        else
+          detect_with_regex
+        end
+      end
+
+      private
+
+      def detect_with_browser_gem
         browser = Browser.new(@user_agent)
 
         if browser.device.iphone? || browser.device.ipad?
@@ -24,18 +33,34 @@ module RailsErrorDashboard
         elsif browser.platform.android?
           "Android"
         elsif @user_agent&.include?("Expo")
-          # Expo apps might have specific patterns
-          if @user_agent.include?("iOS")
-            "iOS"
-          elsif @user_agent.include?("Android")
-            "Android"
-          else
-            "Mobile"
-          end
+          detect_expo_platform
         else
           "API"
         end
       end
+
+      def detect_with_regex
+        case @user_agent
+        when /iPhone|iPad|iPod/i
+          "iOS"
+        when /Android/i
+          "Android"
+        when /Expo/
+          detect_expo_platform
+        else
+          "API"
+        end
+      end
+
+      def detect_expo_platform
+        if @user_agent.include?("iOS")
+          "iOS"
+        elsif @user_agent.include?("Android")
+          "Android"
+        else
+          "Mobile"
+        end
+      end
     end
   end
 end