rails_error_dashboard 0.1.0

data/lib/rails_error_dashboard/queries/developer_insights.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Developer-focused insights
+    # Provides actionable metrics instead of environment breakdowns
+    class DeveloperInsights
+      def self.call(days = 7)
+        new(days).call
+      end
+
+      def initialize(days = 7)
+        @days = days
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          critical_metrics: critical_metrics,
+          error_trends: error_trends,
+          hot_spots: hot_spots,
+          platform_health: platform_health,
+          resolution_metrics: resolution_metrics,
+          error_velocity: error_velocity,
+          top_impacted_users: top_impacted_users,
+          recurring_issues: recurring_issues
+        }
+      end
+
+      private
+
+      def base_query
+        @base_query ||= ErrorLog.where("occurred_at >= ?", @start_date)
+      end
+
+      # Critical metrics developers care about
+      def critical_metrics
+        {
+          total_errors: base_query.count,
+          unresolved_count: base_query.unresolved.count,
+          critical_unresolved: base_query.unresolved.where(
+            error_type: critical_error_types
+          ).count,
+          new_error_types: new_error_types_count,
+          recurring_errors: base_query.where("occurrence_count > ?", 5).count,
+          errors_last_hour: ErrorLog.where("occurred_at >= ?", 1.hour.ago).count,
+          errors_trending_up: errors_trending_up?
+        }
+      end
+
+      # Error trends over time
+      def error_trends
+        {
+          hourly: hourly_distribution,
+          daily: daily_distribution,
+          by_type_over_time: type_trends
+        }
+      end
+
+      # Hot spots - where errors are concentrated
+      def hot_spots
+        {
+          top_error_types: base_query.group(:error_type)
+                                    .order("count_id DESC")
+                                    .limit(10)
+                                    .count,
+          most_frequent: base_query.order(occurrence_count: :desc)
+                                  .limit(10)
+                                  .pluck(:error_type, :message, :occurrence_count)
+                                  .map { |type, msg, count|
+                                    { error_type: type, message: msg.truncate(100), count: count }
+                                  },
+          recent_spikes: detect_spikes
+        }
+      end
+
+      # Platform health breakdown
+      def platform_health
+        platforms = base_query.group(:platform).count
+
+        {
+          by_platform: platforms,
+          ios_stability: calculate_stability("iOS"),
+          android_stability: calculate_stability("Android"),
+          api_stability: calculate_stability("API")
+        }
+      end
+
+      # Resolution metrics
+      def resolution_metrics
+        total = base_query.count
+        resolved = base_query.resolved.count
+
+        {
+          resolution_rate: total.zero? ? 0 : (resolved.to_f / total * 100).round(2),
+          average_resolution_time: average_resolution_time,
+          unresolved_age: unresolved_age_distribution,
+          resolved_today: ErrorLog.resolved
+                                 .where("resolved_at >= ?", Time.current.beginning_of_day)
+                                 .count
+        }
+      end
+
+      # Error velocity - how fast errors are being introduced
+      def error_velocity
+        current_period = base_query.count
+        previous_period = ErrorLog.where(
+          "occurred_at >= ? AND occurred_at < ?",
+          (@days * 2).days.ago,
+          @start_date
+        ).count
+
+        change = current_period - previous_period
+        change_percent = previous_period.zero? ? 0 : (change.to_f / previous_period * 100).round(2)
+
+        {
+          current_period_count: current_period,
+          previous_period_count: previous_period,
+          change: change,
+          change_percent: change_percent,
+          trend: change >= 0 ? "increasing" : "decreasing"
+        }
+      end
+
+      # Users most impacted by errors
+      def top_impacted_users
+        base_query.where.not(user_id: nil)
+                 .group(:user_id)
+                 .order("count_id DESC")
+                 .limit(10)
+                 .count
+                 .transform_keys { |user_id| user_id || "Guest" }
+      end
+
+      # Recurring issues that keep coming back
+      def recurring_issues
+        base_query.where("occurrence_count > ?", 3)
+                 .where("(last_seen_at - first_seen_at) > ?", 1.day.to_i)
+                 .order(occurrence_count: :desc)
+                 .limit(10)
+                 .pluck(:error_type, :message, :occurrence_count, :first_seen_at, :last_seen_at)
+                 .map { |type, msg, count, first, last|
+                   {
+                     error_type: type,
+                     message: msg.truncate(100),
+                     occurrence_count: count,
+                     duration_days: ((last - first) / 1.day).round(1),
+                     first_seen: first,
+                     last_seen: last
+                   }
+                 }
+      end
+
+      # Helper methods
+
+      def critical_error_types
+        %w[
+          SecurityError
+          NoMemoryError
+          SystemStackError
+          SignalException
+          ActiveRecord::StatementInvalid
+        ]
+      end
+
+      def new_error_types_count
+        # Error types that first appeared in this period
+        current_types = base_query.distinct.pluck(:error_type)
+        all_time_types = ErrorLog.where("occurred_at < ?", @start_date)
+                               .distinct
+                               .pluck(:error_type)
+
+        (current_types - all_time_types).count
+      end
+
+      def errors_trending_up?
+        last_24h = ErrorLog.where("occurred_at >= ?", 24.hours.ago).count
+        prev_24h = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
+                                 48.hours.ago, 24.hours.ago).count
+
+        last_24h > prev_24h
+      end
+
+      def hourly_distribution
+        base_query.group("EXTRACT(HOUR FROM occurred_at)")
+                 .order("EXTRACT(HOUR FROM occurred_at)")
+                 .count
+      end
+
+      def daily_distribution
+        base_query.group("DATE(occurred_at)")
+                 .order("DATE(occurred_at)")
+                 .count
+      end
+
+      def type_trends
+        # Get top 5 error types and their trend over days
+        top_types = base_query.group(:error_type)
+                             .order("count_id DESC")
+                             .limit(5)
+                             .pluck(:error_type)
+
+        trends = {}
+        top_types.each do |error_type|
+          trends[error_type] = base_query.where(error_type: error_type)
+                                        .group("DATE(occurred_at)")
+                                        .count
+        end
+
+        trends
+      end
+
+      def calculate_stability(platform)
+        total = base_query.where(platform: platform).count
+        return 100.0 if total.zero?
+
+        # Stability = 100 - (errors per 1000 requests ratio)
+        # Simplified: just show error rate
+        100.0 - [ (total.to_f / 10), 100.0 ].min
+      end
+
+      def average_resolution_time
+        resolved_errors = base_query.resolved
+                                   .where.not(resolved_at: nil)
+
+        return 0 if resolved_errors.count.zero?
+
+        total_time = resolved_errors.sum { |error|
+          (error.resolved_at - error.occurred_at).to_i
+        }
+
+        average_seconds = total_time / resolved_errors.count
+        (average_seconds / 3600.0).round(2) # Convert to hours
+      end
+
+      def unresolved_age_distribution
+        unresolved = base_query.unresolved
+
+        {
+          under_1_hour: unresolved.where("occurred_at >= ?", 1.hour.ago).count,
+          "1_24_hours": unresolved.where("occurred_at >= ? AND occurred_at < ?",
+                                       24.hours.ago, 1.hour.ago).count,
+          "1_7_days": unresolved.where("occurred_at >= ? AND occurred_at < ?",
+                                      7.days.ago, 24.hours.ago).count,
+          over_7_days: unresolved.where("occurred_at < ?", 7.days.ago).count
+        }
+      end
+
+      def detect_spikes
+        # Find error types that suddenly spiked in last 24 hours
+        last_24h = ErrorLog.where("occurred_at >= ?", 24.hours.ago)
+        prev_24h = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
+                                 48.hours.ago, 24.hours.ago)
+
+        current_counts = last_24h.group(:error_type).count
+        previous_counts = prev_24h.group(:error_type).count
+
+        spikes = []
+        current_counts.each do |error_type, current_count|
+          previous_count = previous_counts[error_type] || 0
+
+          # Spike if current is > 2x previous AND at least 5 errors
+          if current_count > previous_count * 2 && current_count >= 5
+            spikes << {
+              error_type: error_type,
+              current_count: current_count,
+              previous_count: previous_count,
+              increase_percent: previous_count.zero? ? 999 : ((current_count - previous_count).to_f / previous_count * 100).round(0)
+            }
+          end
+        end
+
+        spikes.sort_by { |s| -s[:increase_percent] }.first(5)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Fetch errors with filtering and pagination
+    # This is a read operation that returns a filtered collection of errors
+    class ErrorsList
+      def self.call(filters = {})
+        new(filters).call
+      end
+
+      def initialize(filters = {})
+        @filters = filters
+      end
+
+      def call
+        query = ErrorLog.order(occurred_at: :desc)
+        # Only eager load user if User model exists
+        query = query.includes(:user) if defined?(::User)
+        query = apply_filters(query)
+        query
+      end
+
+      private
+
+      def apply_filters(query)
+        query = filter_by_environment(query)
+        query = filter_by_error_type(query)
+        query = filter_by_resolved(query)
+        query = filter_by_platform(query)
+        query = filter_by_search(query)
+        query
+      end
+
+      def filter_by_environment(query)
+        return query unless @filters[:environment].present?
+
+        query.where(environment: @filters[:environment])
+      end
+
+      def filter_by_error_type(query)
+        return query unless @filters[:error_type].present?
+
+        query.where(error_type: @filters[:error_type])
+      end
+
+      def filter_by_resolved(query)
+        return query unless @filters[:unresolved] == "true" || @filters[:unresolved] == true
+
+        query.unresolved
+      end
+
+      def filter_by_platform(query)
+        return query unless @filters[:platform].present?
+
+        query.where(platform: @filters[:platform])
+      end
+
+      def filter_by_search(query)
+        return query unless @filters[:search].present?
+
+        query.where("message ILIKE ?", "%#{@filters[:search]}%")
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/errors_list_v2.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Fetch errors with improved filtering for developers
+    # Removes environment filtering (each env has separate DB)
+    # Adds time-based, severity, and frequency filtering
+    class ErrorsListV2
+      def self.call(filters = {})
+        new(filters).call
+      end
+
+      def initialize(filters = {})
+        @filters = filters
+      end
+
+      def call
+        query = ErrorLog.order(occurred_at: :desc)
+        # Only eager load user if User model exists
+        query = query.includes(:user) if defined?(::User)
+        query = apply_filters(query)
+        query
+      end
+
+      private
+
+      def apply_filters(query)
+        query = filter_by_timeframe(query)
+        query = filter_by_error_type(query)
+        query = filter_by_resolved(query)
+        query = filter_by_platform(query)
+        query = filter_by_severity(query)
+        query = filter_by_frequency(query)
+        query = filter_by_search(query)
+        query
+      end
+
+      # Time-based filtering (more useful than environment)
+      def filter_by_timeframe(query)
+        return query unless @filters[:timeframe].present?
+
+        case @filters[:timeframe]
+        when "last_hour"
+          query.where("occurred_at >= ?", 1.hour.ago)
+        when "today"
+          query.where("occurred_at >= ?", Time.current.beginning_of_day)
+        when "yesterday"
+          query.where("occurred_at >= ? AND occurred_at < ?",
+                     1.day.ago.beginning_of_day,
+                     Time.current.beginning_of_day)
+        when "last_7_days"
+          query.where("occurred_at >= ?", 7.days.ago)
+        when "last_30_days"
+          query.where("occurred_at >= ?", 30.days.ago)
+        when "last_90_days"
+          query.where("occurred_at >= ?", 90.days.ago)
+        else
+          query
+        end
+      end
+
+      def filter_by_error_type(query)
+        return query unless @filters[:error_type].present?
+
+        query.where(error_type: @filters[:error_type])
+      end
+
+      def filter_by_resolved(query)
+        return query unless @filters[:unresolved] == "true" || @filters[:unresolved] == true
+
+        query.unresolved
+      end
+
+      def filter_by_platform(query)
+        return query unless @filters[:platform].present?
+
+        query.where(platform: @filters[:platform])
+      end
+
+      # Filter by severity (based on error type)
+      def filter_by_severity(query)
+        return query unless @filters[:severity].present?
+
+        case @filters[:severity]
+        when "critical"
+          # Security, data loss, crashes
+          critical_errors = [
+            "SecurityError",
+            "ActiveRecord::RecordInvalid",
+            "NoMemoryError",
+            "SystemStackError",
+            "SignalException"
+          ]
+          query.where(error_type: critical_errors)
+        when "high"
+          # Business logic failures
+          high_errors = [
+            "ActiveRecord::RecordNotFound",
+            "ArgumentError",
+            "TypeError",
+            "NoMethodError"
+          ]
+          query.where(error_type: high_errors)
+        when "medium"
+          # Validation, timeouts
+          medium_errors = [
+            "ActiveRecord::RecordInvalid",
+            "Timeout::Error",
+            "Net::ReadTimeout"
+          ]
+          query.where(error_type: medium_errors)
+        else
+          query
+        end
+      end
+
+      # Filter by frequency (how often error occurs)
+      def filter_by_frequency(query)
+        return query unless @filters[:frequency].present?
+
+        case @filters[:frequency]
+        when "high"
+          # Occurs more than 10 times
+          query.where("occurrence_count > ?", 10)
+        when "medium"
+          # Occurs 3-10 times
+          query.where("occurrence_count >= ? AND occurrence_count <= ?", 3, 10)
+        when "low"
+          # Occurs 1-2 times
+          query.where("occurrence_count <= ?", 2)
+        when "recurring"
+          # Seen multiple times over more than 1 hour
+          query.where("occurrence_count > ? AND (last_seen_at - first_seen_at) > ?",
+                     1, 1.hour.to_i)
+        else
+          query
+        end
+      end
+
+      def filter_by_search(query)
+        return query unless @filters[:search].present?
+
+        search_term = "%#{@filters[:search]}%"
+        query.where("message ILIKE ? OR error_type ILIKE ? OR backtrace ILIKE ?",
+                   search_term, search_term, search_term)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/filter_options.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Fetch available filter options
+    # This is a read operation that returns distinct values for filters
+    class FilterOptions
+      def self.call
+        new.call
+      end
+
+      def call
+        {
+          environments: ErrorLog.distinct.pluck(:environment).compact,
+          error_types: ErrorLog.distinct.pluck(:error_type).compact.sort,
+          platforms: ErrorLog.distinct.pluck(:platform).compact
+        }
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/platform_detector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "browser"
+
+module RailsErrorDashboard
+  module Services
+    # Detects the platform (iOS/Android/API) from user agent string
+    class PlatformDetector
+      def self.detect(user_agent)
+        new(user_agent).detect
+      end
+
+      def initialize(user_agent)
+        @user_agent = user_agent
+      end
+
+      def detect
+        return "API" if @user_agent.blank?
+
+        browser = Browser.new(@user_agent)
+
+        if browser.device.iphone? || browser.device.ipad?
+          "iOS"
+        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
+        else
+          "API"
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/value_objects/error_context.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module ValueObjects
+    # Immutable value object representing error context
+    # Extracts and normalizes context information from various sources
+    class ErrorContext
+      attr_reader :user_id, :request_url, :request_params, :user_agent, :ip_address, :platform,
+                  :controller_name, :action_name
+
+      def initialize(context, source = nil)
+        @context = context
+        @source = source
+
+        @user_id = extract_user_id
+        @request_url = build_request_url
+        @request_params = extract_params
+        @user_agent = extract_user_agent
+        @ip_address = extract_ip_address
+        @platform = detect_platform
+        @controller_name = extract_controller_name
+        @action_name = extract_action_name
+      end
+
+      def to_h
+        {
+          user_id: user_id,
+          request_url: request_url,
+          request_params: request_params,
+          user_agent: user_agent,
+          ip_address: ip_address,
+          platform: platform,
+          controller_name: controller_name,
+          action_name: action_name
+        }
+      end
+
+      private
+
+      def extract_user_id
+        @context[:current_user]&.id ||
+          @context[:user_id] ||
+          @context[:user]&.id
+      end
+
+      def build_request_url
+        return @context[:request]&.fullpath if @context[:request]
+        return @context[:request_url] if @context[:request_url]
+        return "Background Job: #{@context[:job]&.class}" if @context[:job]
+        return "Sidekiq: #{@context[:job_class]}" if @context[:job_class]
+        return "Service: #{@context[:service]}" if @context[:service]
+        return @source if @source
+
+        "Rails Application"
+      end
+
+      def extract_params
+        params = {}
+
+        # HTTP request params
+        if @context[:request]
+          params = @context[:request].params.except(:controller, :action)
+        end
+
+        # Background job params
+        if @context[:job]
+          params = {
+            job_class: @context[:job].class.name,
+            job_id: @context[:job].job_id,
+            queue: @context[:job].queue_name,
+            arguments: @context[:job].arguments,
+            executions: @context[:job].executions
+          }
+        end
+
+        # Sidekiq params
+        if @context[:job_class]
+          params = {
+            job_class: @context[:job_class],
+            job_id: @context[:jid],
+            queue: @context[:queue],
+            retry_count: @context[:retry_count]
+          }
+        end
+
+        # Custom params
+        params.merge!(@context[:params]) if @context[:params]
+
+        # Additional context (from mobile apps, etc.)
+        params.merge!(@context[:additional_context]) if @context[:additional_context]
+
+        params.to_json
+      end
+
+      def extract_user_agent
+        return @context[:request]&.user_agent if @context[:request]
+        return "Sidekiq Worker" if @source&.to_s&.include?("active_job") || @context[:job]
+        return @context[:user_agent] if @context[:user_agent]
+
+        "Rails Application"
+      end
+
+      def extract_ip_address
+        return @context[:request]&.remote_ip if @context[:request]
+        return "background_job" if @context[:job]
+        return "sidekiq_worker" if @context[:job_class]
+        return @context[:ip_address] if @context[:ip_address]
+
+        "application_layer"
+      end
+
+      def detect_platform
+        # Check if it's from a mobile request
+        user_agent = extract_user_agent
+        return Services::PlatformDetector.detect(user_agent) if @context[:request]
+
+        # Everything else is API/backend
+        "API"
+      end
+
+      def extract_controller_name
+        # From Rails request params
+        return @context[:request].params[:controller] if @context[:request]&.params&.[](:controller)
+
+        # From explicit context
+        return @context[:controller_name] if @context[:controller_name]
+
+        # From Rails controller instance
+        return @context[:controller]&.class&.name if @context[:controller]
+
+        nil
+      end
+
+      def extract_action_name
+        # From Rails request params
+        return @context[:request].params[:action] if @context[:request]&.params&.[](:action)
+
+        # From explicit context
+        return @context[:action_name] if @context[:action_name]
+
+        # From action parameter
+        return @context[:action] if @context[:action]
+
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -0,0 +1,3 @@
+module RailsErrorDashboard
+  VERSION = "0.1.0"
+end