rails_error_dashboard 0.1.0

data/lib/rails_error_dashboard/plugin.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Base class for creating plugins
+  # Plugins can hook into error lifecycle events and extend functionality
+  #
+  # Example plugin:
+  #
+  #   class MyNotificationPlugin < RailsErrorDashboard::Plugin
+  #     def name
+  #       "My Custom Notifier"
+  #     end
+  #
+  #     def on_error_logged(error_log)
+  #       # Send notification to custom service
+  #       MyService.notify(error_log)
+  #     end
+  #   end
+  #
+  #   # Register the plugin
+  #   RailsErrorDashboard.register_plugin(MyNotificationPlugin.new)
+  #
+  class Plugin
+    # Plugin name (must be implemented by subclass)
+    def name
+      raise NotImplementedError, "Plugin must implement #name"
+    end
+
+    # Plugin description (optional)
+    def description
+      "No description provided"
+    end
+
+    # Plugin version (optional)
+    def version
+      "1.0.0"
+    end
+
+    # Called when plugin is registered
+    # Use this for initialization logic
+    def on_register
+      # Override in subclass if needed
+    end
+
+    # Called when a new error is logged (first occurrence)
+    # @param error_log [ErrorLog] The newly created error log
+    def on_error_logged(error_log)
+      # Override in subclass to handle event
+    end
+
+    # Called when an existing error recurs (subsequent occurrences)
+    # @param error_log [ErrorLog] The updated error log
+    def on_error_recurred(error_log)
+      # Override in subclass to handle event
+    end
+
+    # Called when an error is resolved
+    # @param error_log [ErrorLog] The resolved error log
+    def on_error_resolved(error_log)
+      # Override in subclass to handle event
+    end
+
+    # Called when errors are batch resolved
+    # @param error_logs [Array<ErrorLog>] The resolved error logs
+    def on_errors_batch_resolved(error_logs)
+      # Override in subclass to handle event
+    end
+
+    # Called when errors are batch deleted
+    # @param error_ids [Array<Integer>] The IDs of deleted errors
+    def on_errors_batch_deleted(error_ids)
+      # Override in subclass to handle event
+    end
+
+    # Called when an error is viewed in the dashboard
+    # @param error_log [ErrorLog] The viewed error log
+    def on_error_viewed(error_log)
+      # Override in subclass to handle event
+    end
+
+    # Helper method to check if plugin is enabled
+    # Override this to add conditional logic
+    def enabled?
+      true
+    end
+
+    # Helper method to safely execute plugin hooks
+    # Prevents plugin errors from breaking the main application
+    def safe_execute(method_name, *args)
+      return unless enabled?
+
+      send(method_name, *args)
+    rescue => e
+      Rails.logger.error("Plugin '#{name}' failed in #{method_name}: #{e.message}")
+      Rails.logger.error(e.backtrace.first(5).join("\n"))
+    end
+  end
+end

data/lib/rails_error_dashboard/plugin_registry.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Registry for managing plugins
+  # Provides plugin registration and event dispatching
+  class PluginRegistry
+    class << self
+      # Get all registered plugins
+      def plugins
+        @plugins ||= []
+      end
+
+      # Register a plugin
+      # @param plugin [Plugin] The plugin instance to register
+      def register(plugin)
+        unless plugin.is_a?(Plugin)
+          raise ArgumentError, "Plugin must be an instance of RailsErrorDashboard::Plugin"
+        end
+
+        if plugins.any? { |p| p.name == plugin.name }
+          Rails.logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
+          return false
+        end
+
+        plugins << plugin
+        plugin.on_register
+        Rails.logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
+        true
+      end
+
+      # Unregister a plugin by name
+      # @param plugin_name [String] The name of the plugin to unregister
+      def unregister(plugin_name)
+        plugins.reject! { |p| p.name == plugin_name }
+      end
+
+      # Clear all plugins (useful for testing)
+      def clear
+        @plugins = []
+      end
+
+      # Get a plugin by name
+      # @param plugin_name [String] The name of the plugin
+      # @return [Plugin, nil] The plugin instance or nil if not found
+      def find(plugin_name)
+        plugins.find { |p| p.name == plugin_name }
+      end
+
+      # Dispatch an event to all registered plugins
+      # @param event_name [Symbol] The event name (e.g., :on_error_logged)
+      # @param args [Array] Arguments to pass to the event handler
+      def dispatch(event_name, *args)
+        plugins.each do |plugin|
+          next unless plugin.enabled?
+
+          plugin.safe_execute(event_name, *args)
+        end
+      end
+
+      # Get count of registered plugins
+      def count
+        plugins.size
+      end
+
+      # Check if any plugins are registered
+      def any?
+        plugins.any?
+      end
+
+      # Get list of plugin names
+      def names
+        plugins.map(&:name)
+      end
+
+      # Get plugin information for debugging
+      def info
+        plugins.map do |plugin|
+          {
+            name: plugin.name,
+            version: plugin.version,
+            description: plugin.description,
+            enabled: plugin.enabled?
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/plugins/audit_log_plugin.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Plugins
+    # Example plugin: Audit logging
+    # Logs all error dashboard activities to a separate audit log
+    #
+    # Usage:
+    #   RailsErrorDashboard.register_plugin(
+    #     RailsErrorDashboard::Plugins::AuditLogPlugin.new(logger: Rails.logger)
+    #   )
+    #
+    class AuditLogPlugin < Plugin
+      def initialize(logger: Rails.logger)
+        @logger = logger
+      end
+
+      def name
+        "Audit Logger"
+      end
+
+      def description
+        "Logs all error dashboard activities for compliance and auditing"
+      end
+
+      def version
+        "1.0.0"
+      end
+
+      def on_error_logged(error_log)
+        log_event(
+          event: "error_logged",
+          error_id: error_log.id,
+          error_type: error_log.error_type,
+          platform: error_log.platform,
+          environment: error_log.environment,
+          timestamp: Time.current
+        )
+      end
+
+      def on_error_recurred(error_log)
+        log_event(
+          event: "error_recurred",
+          error_id: error_log.id,
+          error_type: error_log.error_type,
+          occurrence_count: error_log.occurrence_count,
+          timestamp: Time.current
+        )
+      end
+
+      def on_error_resolved(error_log)
+        log_event(
+          event: "error_resolved",
+          error_id: error_log.id,
+          error_type: error_log.error_type,
+          resolved_by: error_log.resolved_by_name,
+          resolution_comment: error_log.resolution_comment,
+          timestamp: Time.current
+        )
+      end
+
+      def on_errors_batch_resolved(error_logs)
+        log_event(
+          event: "errors_batch_resolved",
+          count: error_logs.size,
+          error_ids: error_logs.map(&:id),
+          timestamp: Time.current
+        )
+      end
+
+      def on_errors_batch_deleted(error_ids)
+        log_event(
+          event: "errors_batch_deleted",
+          count: error_ids.size,
+          error_ids: error_ids,
+          timestamp: Time.current
+        )
+      end
+
+      def on_error_viewed(error_log)
+        log_event(
+          event: "error_viewed",
+          error_id: error_log.id,
+          error_type: error_log.error_type,
+          timestamp: Time.current
+        )
+      end
+
+      private
+
+      def log_event(data)
+        @logger.info("[RailsErrorDashboard Audit] #{data.to_json}")
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/plugins/jira_integration_plugin.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Plugins
+    # Example plugin: Jira integration
+    # Automatically creates Jira tickets for critical errors
+    #
+    # Usage:
+    #   RailsErrorDashboard.register_plugin(
+    #     RailsErrorDashboard::Plugins::JiraIntegrationPlugin.new(
+    #       jira_url: ENV['JIRA_URL'],
+    #       jira_username: ENV['JIRA_USERNAME'],
+    #       jira_api_token: ENV['JIRA_API_TOKEN'],
+    #       jira_project_key: ENV['JIRA_PROJECT_KEY'],
+    #       only_critical: true
+    #     )
+    #   )
+    #
+    class JiraIntegrationPlugin < Plugin
+      def initialize(jira_url: nil, jira_username: nil, jira_api_token: nil, jira_project_key: nil, only_critical: true)
+        @jira_url = jira_url
+        @jira_username = jira_username
+        @jira_api_token = jira_api_token
+        @jira_project_key = jira_project_key
+        @only_critical = only_critical
+      end
+
+      def name
+        "Jira Integration"
+      end
+
+      def description
+        "Automatically creates Jira tickets for critical errors"
+      end
+
+      def version
+        "1.0.0"
+      end
+
+      def enabled?
+        @jira_url.present? && @jira_username.present? && @jira_api_token.present? && @jira_project_key.present?
+      end
+
+      def on_error_logged(error_log)
+        return if @only_critical && !error_log.critical?
+
+        create_jira_ticket(error_log)
+      end
+
+      private
+
+      def create_jira_ticket(error_log)
+        # Example Jira ticket creation
+        # In production, you'd use the jira-ruby gem or make API calls directly
+
+        ticket_data = {
+          project: { key: @jira_project_key },
+          summary: "[#{error_log.environment}] #{error_log.error_type}",
+          description: build_description(error_log),
+          issuetype: { name: "Bug" },
+          priority: { name: jira_priority(error_log) },
+          labels: [ "rails-error-dashboard", error_log.platform, error_log.environment ]
+        }
+
+        Rails.logger.info("Would create Jira ticket: #{ticket_data.to_json}")
+
+        # Actual implementation:
+        # require 'httparty'
+        # response = HTTParty.post(
+        #   "#{@jira_url}/rest/api/2/issue",
+        #   basic_auth: { username: @jira_username, password: @jira_api_token },
+        #   headers: { 'Content-Type' => 'application/json' },
+        #   body: { fields: ticket_data }.to_json
+        # )
+      end
+
+      def build_description(error_log)
+        <<~DESC
+          h2. Error Details
+
+          *Error Type:* #{error_log.error_type}
+          *Message:* #{error_log.message}
+          *Platform:* #{error_log.platform}
+          *Environment:* #{error_log.environment}
+          *Severity:* #{error_log.severity}
+          *Controller:* #{error_log.controller_name}
+          *Action:* #{error_log.action_name}
+          *First Seen:* #{error_log.first_seen_at}
+          *Occurrences:* #{error_log.occurrence_count}
+
+          h2. Backtrace
+
+          {code}
+          #{error_log.backtrace&.lines&.first(10)&.join}
+          {code}
+
+          h2. Dashboard Link
+
+          [View in Dashboard|#{dashboard_url(error_log)}]
+        DESC
+      end
+
+      def jira_priority(error_log)
+        case error_log.severity.to_s
+        when "critical"
+          "Highest"
+        when "high"
+          "High"
+        when "medium"
+          "Medium"
+        else
+          "Low"
+        end
+      end
+
+      def dashboard_url(error_log)
+        base_url = RailsErrorDashboard.configuration.dashboard_base_url || "http://localhost:3000"
+        "#{base_url}/error_dashboard/errors/#{error_log.id}"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/plugins/metrics_plugin.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Plugins
+    # Example plugin: Metrics tracking
+    # Tracks error counts and sends to metrics service (e.g., StatsD, Datadog)
+    #
+    # Usage:
+    #   RailsErrorDashboard.register_plugin(
+    #     RailsErrorDashboard::Plugins::MetricsPlugin.new
+    #   )
+    #
+    class MetricsPlugin < Plugin
+      def name
+        "Metrics Tracker"
+      end
+
+      def description
+        "Tracks error metrics and sends to monitoring service"
+      end
+
+      def version
+        "1.0.0"
+      end
+
+      def on_error_logged(error_log)
+        increment_counter("errors.new", error_log)
+        increment_counter("errors.by_type.#{sanitize_metric_name(error_log.error_type)}", error_log)
+        increment_counter("errors.by_platform.#{error_log.platform || 'unknown'}", error_log)
+        increment_counter("errors.by_environment.#{error_log.environment}", error_log)
+      end
+
+      def on_error_recurred(error_log)
+        increment_counter("errors.recurred", error_log)
+        increment_counter("errors.occurrence.#{error_log.id}", error_log)
+      end
+
+      def on_error_resolved(error_log)
+        increment_counter("errors.resolved", error_log)
+      end
+
+      def on_errors_batch_resolved(error_logs)
+        increment_counter("errors.batch_resolved", count: error_logs.size)
+      end
+
+      def on_errors_batch_deleted(error_ids)
+        increment_counter("errors.batch_deleted", count: error_ids.size)
+      end
+
+      private
+
+      def increment_counter(metric_name, data)
+        # Example: Send to StatsD
+        # StatsD.increment(metric_name, tags: metric_tags(data))
+
+        # Example: Send to Datadog
+        # Datadog::Statsd.increment(metric_name, tags: metric_tags(data))
+
+        # For demonstration, just log
+        Rails.logger.info("Metrics: #{metric_name} - #{data.is_a?(Hash) ? data : data.class.name}")
+      end
+
+      def metric_tags(data)
+        return [] unless data.respond_to?(:platform)
+
+        [
+          "platform:#{data.platform || 'unknown'}",
+          "environment:#{data.environment}",
+          "severity:#{data.severity}"
+        ]
+      end
+
+      def sanitize_metric_name(name)
+        name.gsub("::", ".").downcase
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Fetch analytics statistics for charts and trends
+    # This is a read operation that aggregates error data over time
+    class AnalyticsStats
+      def self.call(days = 30)
+        new(days).call
+      end
+
+      def initialize(days = 30)
+        @days = days
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          days: @days,
+          error_stats: error_statistics,
+          errors_over_time: errors_over_time,
+          errors_by_type: errors_by_type,
+          errors_by_platform: errors_by_platform,
+          errors_by_environment: errors_by_environment,
+          errors_by_hour: errors_by_hour,
+          top_users: top_affected_users,
+          resolution_rate: resolution_rate,
+          mobile_errors: mobile_errors_count,
+          api_errors: api_errors_count
+        }
+      end
+
+      private
+
+      def base_query
+        ErrorLog.where("occurred_at >= ?", @start_date)
+      end
+
+      def error_statistics
+        {
+          total: base_query.count,
+          unresolved: base_query.unresolved.count,
+          by_type: base_query.group(:error_type).count.sort_by { |_, count| -count }.to_h,
+          by_day: base_query.group("DATE(occurred_at)").count
+        }
+      end
+
+      def errors_over_time
+        base_query.group_by_day(:occurred_at).count
+      end
+
+      def errors_by_type
+        base_query.group(:error_type)
+                  .count
+                  .sort_by { |_, count| -count }
+                  .first(10)
+                  .to_h
+      end
+
+      def errors_by_platform
+        base_query.group(:platform).count
+      end
+
+      def errors_by_environment
+        base_query.group(:environment).count
+      end
+
+      def errors_by_hour
+        base_query.group_by_hour(:occurred_at).count
+      end
+
+      def top_affected_users
+        user_model = RailsErrorDashboard.configuration.user_model
+
+        base_query.where.not(user_id: nil)
+                  .group(:user_id)
+                  .count
+                  .sort_by { |_, count| -count }
+                  .first(10)
+                  .map { |user_id, count| [ find_user_email(user_id, user_model), count ] }
+                  .to_h
+      end
+
+      def find_user_email(user_id, user_model)
+        user = user_model.constantize.find_by(id: user_id)
+        user&.email || "User ##{user_id}"
+      rescue
+        "User ##{user_id}"
+      end
+
+      def resolution_rate
+        total = error_statistics[:total]
+        return 0 if total.zero?
+
+        resolved_count = ErrorLog.resolved.where("occurred_at >= ?", @start_date).count
+        ((resolved_count.to_f / total) * 100).round(1)
+      end
+
+      def mobile_errors_count
+        base_query.where(platform: [ "iOS", "Android" ]).count
+      end
+
+      def api_errors_count
+        base_query.where("platform IS NULL OR platform = ?", "API").count
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Fetch dashboard statistics
+    # This is a read operation that aggregates error data for the dashboard
+    class DashboardStats
+      def self.call
+        new.call
+      end
+
+      def call
+        {
+          total_today: ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count,
+          total_week: ErrorLog.where("occurred_at >= ?", 7.days.ago).count,
+          total_month: ErrorLog.where("occurred_at >= ?", 30.days.ago).count,
+          unresolved: ErrorLog.unresolved.count,
+          resolved: ErrorLog.resolved.count,
+          by_environment: ErrorLog.group(:environment).count,
+          by_platform: ErrorLog.group(:platform).count,
+          top_errors: top_errors
+        }
+      end
+
+      private
+
+      def top_errors
+        ErrorLog.where("occurred_at >= ?", 7.days.ago)
+                .group(:error_type)
+                .count
+                .sort_by { |_, count| -count }
+                .first(10)
+                .to_h
+      end
+    end
+  end
+end