rails_error_dashboard 0.1.1 → 0.1.3

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -71,6 +71,21 @@ module RailsErrorDashboard
           attributes[:backtrace_signature] = calculate_backtrace_signature_from_backtrace(truncated_backtrace)
         end
 
+        #  Add git/release info if columns exist
+        if ErrorLog.column_names.include?("git_sha")
+          attributes[:git_sha] = RailsErrorDashboard.configuration.git_sha ||
+                                  ENV["GIT_SHA"] ||
+                                  ENV["HEROKU_SLUG_COMMIT"] ||
+                                  ENV["RENDER_GIT_COMMIT"] ||
+                                  detect_git_sha_from_command
+        end
+
+        if ErrorLog.column_names.include?("app_version")
+          attributes[:app_version] = RailsErrorDashboard.configuration.app_version ||
+                                      ENV["APP_VERSION"] ||
+                                      detect_version_from_file
+        end
+
         # Find existing error or create new one
         # This ensures accurate occurrence tracking
         error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))
@@ -86,7 +101,7 @@ module RailsErrorDashboard
               session_id: error_context.session_id
             )
           rescue => e
-            Rails.logger.error("Failed to create error occurrence: #{e.message}")
+            RailsErrorDashboard::Logger.error("Failed to create error occurrence: #{e.message}")
           end
         end
 
@@ -112,10 +127,14 @@ module RailsErrorDashboard
       rescue => e
         # Don't let error logging cause more errors - fail silently
         # CRITICAL: Log but never propagate exception
+        # Log to Rails logger for visibility during development
         Rails.logger.error("[RailsErrorDashboard] LogError command failed: #{e.class} - #{e.message}")
-        Rails.logger.error("Original exception: #{@exception.class} - #{@exception.message}") if @exception
-        Rails.logger.error("Context: #{@context.inspect}") if @context
-        Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        Rails.logger.error("Backtrace: #{e.backtrace&.first(10)&.join("\n")}")
+
+        RailsErrorDashboard::Logger.error("[RailsErrorDashboard] LogError command failed: #{e.class} - #{e.message}")
+        RailsErrorDashboard::Logger.error("Original exception: #{@exception.class} - #{@exception.message}") if @exception
+        RailsErrorDashboard::Logger.error("Context: #{@context.inspect}") if @context
+        RailsErrorDashboard::Logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
         nil # Explicitly return nil, never raise
       end
 
@@ -127,7 +146,7 @@ module RailsErrorDashboard
         RailsErrorDashboard.configuration.notification_callbacks[:error_logged].each do |callback|
           callback.call(error_log)
         rescue => e
-          Rails.logger.error("Error in error_logged callback: #{e.message}")
+          RailsErrorDashboard::Logger.error("Error in error_logged callback: #{e.message}")
         end
 
         # Trigger critical_error callbacks if this is a critical error
@@ -135,7 +154,7 @@ module RailsErrorDashboard
           RailsErrorDashboard.configuration.notification_callbacks[:critical_error].each do |callback|
             callback.call(error_log)
           rescue => e
-            Rails.logger.error("Error in critical_error callback: #{e.message}")
+            RailsErrorDashboard::Logger.error("Error in critical_error callback: #{e.message}")
           end
         end
       end
@@ -210,7 +229,7 @@ module RailsErrorDashboard
           end
         rescue NameError
           # Handle invalid class names in configuration
-          Rails.logger.warn("Invalid ignored exception class: #{ignored}")
+          RailsErrorDashboard::Logger.warn("Invalid ignored exception class: #{ignored}")
           false
         end
       end
@@ -348,13 +367,32 @@ module RailsErrorDashboard
         # Enqueue alert job (which will handle throttling)
         BaselineAlertJob.perform_later(error_log.id, anomaly)
 
-        Rails.logger.info(
+        RailsErrorDashboard::Logger.info(
           "Baseline alert queued for #{error_log.error_type} on #{error_log.platform}: " \
           "#{anomaly[:level]} (#{anomaly[:std_devs_above]&.round(1)}σ above baseline)"
         )
       rescue => e
         # Don't let baseline alerting cause errors
-        Rails.logger.error("Failed to check baseline anomaly: #{e.message}")
+        RailsErrorDashboard::Logger.error("Failed to check baseline anomaly: #{e.message}")
+      end
+
+      # Detect git SHA from git command (fallback)
+      def detect_git_sha_from_command
+        return nil unless File.exist?(Rails.root.join(".git"))
+        `git rev-parse --short HEAD 2>/dev/null`.strip.presence
+      rescue => e
+        RailsErrorDashboard::Logger.debug("Could not detect git SHA: #{e.message}")
+        nil
+      end
+
+      # Detect app version from VERSION file (fallback)
+      def detect_version_from_file
+        version_file = Rails.root.join("VERSION")
+        return File.read(version_file).strip if File.exist?(version_file)
+        nil
+      rescue => e
+        RailsErrorDashboard::Logger.debug("Could not detect version: #{e.message}")
+        nil
       end
     end
   end

data/lib/rails_error_dashboard/commands/resolve_error.rb

@@ -32,7 +32,7 @@ module RailsErrorDashboard
         RailsErrorDashboard.configuration.notification_callbacks[:error_resolved].each do |callback|
           callback.call(error)
         rescue => e
-          Rails.logger.error("Error in error_resolved callback: #{e.message}")
+          RailsErrorDashboard::Logger.error("Error in error_resolved callback: #{e.message}")
         end
 
         # Emit ActiveSupport::Notifications instrumentation event

data/lib/rails_error_dashboard/configuration.rb

@@ -82,6 +82,10 @@ module RailsErrorDashboard
     # Notification callbacks (managed via helper methods, not set directly)
     attr_reader :notification_callbacks
 
+    # Internal logging configuration
+    attr_accessor :enable_internal_logging
+    attr_accessor :log_level
+
     def initialize
       # Default values
       @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
@@ -145,6 +149,10 @@ module RailsErrorDashboard
       @baseline_alert_severities = [ :critical, :high ] # Alert on critical and high severity anomalies
       @baseline_alert_cooldown_minutes = ENV.fetch("BASELINE_ALERT_COOLDOWN", "120").to_i
 
+      # Internal logging defaults - SILENT by default
+      @enable_internal_logging = false  # Opt-in for debugging
+      @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
+
       @notification_callbacks = {
         error_logged: [],
         critical_error: [],

data/lib/rails_error_dashboard/error_reporter.rb

@@ -32,10 +32,10 @@ module RailsErrorDashboard
       rescue => e
         # Don't let error logging cause more errors - fail silently
         # Log failure for debugging but NEVER propagate exception
-        Rails.logger.error("[RailsErrorDashboard] ErrorReporter failed: #{e.class} - #{e.message}")
-        Rails.logger.error("Original error: #{error.class} - #{error.message}") if error
-        Rails.logger.error("Context: #{context.inspect}") if context
-        Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+        RailsErrorDashboard::Logger.error("[RailsErrorDashboard] ErrorReporter failed: #{e.class} - #{e.message}")
+        RailsErrorDashboard::Logger.error("Original error: #{error.class} - #{error.message}") if error
+        RailsErrorDashboard::Logger.error("Context: #{context.inspect}") if context
+        RailsErrorDashboard::Logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
         nil # Explicitly return nil, never raise
       end
     end

data/lib/rails_error_dashboard/logger.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Internal logger wrapper for Rails Error Dashboard
+  #
+  # By default, all logging is SILENT to keep production logs clean.
+  # Users can opt-in to verbose logging for debugging.
+  #
+  # @example Enable logging for debugging
+  #   RailsErrorDashboard.configure do |config|
+  #     config.enable_internal_logging = true
+  #     config.log_level = :debug
+  #   end
+  #
+  # @example Production troubleshooting (errors only)
+  #   RailsErrorDashboard.configure do |config|
+  #     config.enable_internal_logging = true
+  #     config.log_level = :error
+  #   end
+  module Logger
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    }.freeze
+
+    class << self
+      # Log debug message (only if internal logging enabled)
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.debug("Processing error #123")
+      def debug(message)
+        return unless logging_enabled?
+        return unless log_level_enabled?(:debug)
+
+        Rails.logger.debug(formatted_message(message))
+      end
+
+      # Log info message (only if internal logging enabled)
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.info("Registered plugin: MyPlugin")
+      def info(message)
+        return unless logging_enabled?
+        return unless log_level_enabled?(:info)
+
+        Rails.logger.info(formatted_message(message))
+      end
+
+      # Log warning message (only if internal logging enabled)
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.warn("Plugin already registered")
+      def warn(message)
+        return unless logging_enabled?
+        return unless log_level_enabled?(:warn)
+
+        Rails.logger.warn(formatted_message(message))
+      end
+
+      # Log error message
+      # Errors are logged by default unless log_level is :silent
+      #
+      # @param message [String] The message to log
+      # @example
+      #   RailsErrorDashboard::Logger.error("Failed to save error log")
+      def error(message)
+        return unless log_level_enabled?(:error)
+
+        Rails.logger.error(formatted_message(message))
+      end
+
+      private
+
+      # Check if internal logging is enabled
+      #
+      # @return [Boolean]
+      def logging_enabled?
+        RailsErrorDashboard.configuration.enable_internal_logging
+      end
+
+      # Check if the given log level is enabled
+      #
+      # @param level [Symbol] The log level to check (:debug, :info, :warn, :error)
+      # @return [Boolean]
+      def log_level_enabled?(level)
+        config_level = RailsErrorDashboard.configuration.log_level || :silent
+        LOG_LEVELS[level] >= LOG_LEVELS[config_level]
+      end
+
+      # Format message with gem prefix
+      #
+      # @param message [String] The message to format
+      # @return [String] Formatted message with prefix
+      def formatted_message(message)
+        "[RailsErrorDashboard] #{message}"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -36,8 +36,8 @@ module RailsErrorDashboard
           )
         rescue => e
           # If error reporting fails, log it but DON'T break the app
-          Rails.logger.error("[RailsErrorDashboard] Middleware error reporting failed: #{e.class} - #{e.message}")
-          Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+          RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Middleware error reporting failed: #{e.class} - #{e.message}")
+          RailsErrorDashboard::Logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
         end
 
         # Re-raise original exception to let Rails handle the response

data/lib/rails_error_dashboard/plugin.rb

@@ -92,9 +92,9 @@ module RailsErrorDashboard
       send(method_name, *args)
     rescue => e
       # Log plugin failures but never propagate - plugins must not break the app
-      Rails.logger.error("[RailsErrorDashboard] Plugin '#{name}' failed in #{method_name}: #{e.class} - #{e.message}")
-      Rails.logger.error("Plugin version: #{version}")
-      Rails.logger.error(e.backtrace&.first(10)&.join("\n")) if e.backtrace
+      RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Plugin '#{name}' failed in #{method_name}: #{e.class} - #{e.message}")
+      RailsErrorDashboard::Logger.error("Plugin version: #{version}")
+      RailsErrorDashboard::Logger.error(e.backtrace&.first(10)&.join("\n")) if e.backtrace
       nil # Explicitly return nil, never raise
     end
   end

data/lib/rails_error_dashboard/plugin_registry.rb

@@ -18,13 +18,13 @@ module RailsErrorDashboard
         end
 
         if plugins.any? { |p| p.name == plugin.name }
-          Rails.logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
+          RailsErrorDashboard::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})")
+        RailsErrorDashboard::Logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
         true
       end
 

data/lib/rails_error_dashboard/plugins/jira_integration_plugin.rb

@@ -62,7 +62,7 @@ module RailsErrorDashboard
           labels: [ "rails-error-dashboard", error_log.platform ].compact
         }
 
-        Rails.logger.info("Would create Jira ticket: #{ticket_data.to_json}")
+        RailsErrorDashboard::Logger.info("Would create Jira ticket: #{ticket_data.to_json}")
 
         # Actual implementation:
         # require 'httparty'

data/lib/rails_error_dashboard/plugins/metrics_plugin.rb

@@ -56,7 +56,7 @@ module RailsErrorDashboard
         # 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}")
+        RailsErrorDashboard::Logger.info("Metrics: #{metric_name} - #{data.is_a?(Hash) ? data : data.class.name}")
       end
 
       def metric_tags(data)

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -22,7 +22,15 @@ module RailsErrorDashboard
           errors_trend_7d: errors_trend_7d,
           errors_by_severity_7d: errors_by_severity_7d,
           spike_detected: spike_detected?,
-          spike_info: spike_info
+          spike_info: spike_info,
+          # New metrics for Overview dashboard
+          error_rate: error_rate,
+          affected_users_today: affected_users_today,
+          affected_users_yesterday: affected_users_yesterday,
+          affected_users_change: affected_users_change,
+          trend_percentage: trend_percentage,
+          trend_direction: trend_direction,
+          top_errors_by_impact: top_errors_by_impact
         }
       end
 
@@ -164,6 +172,106 @@ module RailsErrorDashboard
           :critical
         end
       end
+
+      # Calculate error rate as a percentage
+      # Since we don't track total requests, we'll use error count as proxy
+      # In the future, this could be: (errors / total_requests) * 100
+      def error_rate
+        today_errors = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        return 0.0 if today_errors.zero?
+
+        # For now, use a simple heuristic: errors per hour today
+        # Assume we want < 1 error per hour = good (< 1%)
+        # 1-5 errors per hour = warning (1-5%)
+        # > 5 errors per hour = critical (> 5%)
+        hours_today = ((Time.current - Time.current.beginning_of_day) / 1.hour).round(1)
+        hours_today = 1.0 if hours_today < 1.0 # Avoid division by zero in early morning
+
+        errors_per_hour = today_errors / hours_today
+        # Convert to percentage scale (0-100)
+        # Scale: 0 errors/hr = 0%, 1 error/hr = 1%, 10 errors/hr = 10%, etc.
+        [ errors_per_hour, 100.0 ].min.round(1)
+      end
+
+      # Count distinct users affected by errors today
+      def affected_users_today
+        ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day)
+                .where.not(user_id: nil)
+                .distinct
+                .count(:user_id)
+      end
+
+      # Count distinct users affected by errors yesterday
+      def affected_users_yesterday
+        ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
+                      1.day.ago.beginning_of_day,
+                      Time.current.beginning_of_day)
+                .where.not(user_id: nil)
+                .distinct
+                .count(:user_id)
+      end
+
+      # Calculate change in affected users (today vs yesterday)
+      def affected_users_change
+        today = affected_users_today
+        yesterday = affected_users_yesterday
+
+        return 0 if today.zero? && yesterday.zero?
+        return today if yesterday.zero?
+
+        today - yesterday
+      end
+
+      # Calculate percentage change in errors (today vs yesterday)
+      def trend_percentage
+        today = ErrorLog.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        yesterday = ErrorLog.where("occurred_at >= ? AND occurred_at < ?",
+                                  1.day.ago.beginning_of_day,
+                                  Time.current.beginning_of_day).count
+
+        return 0.0 if today.zero? && yesterday.zero?
+        return 100.0 if yesterday.zero? && today.positive?
+
+        ((today - yesterday).to_f / yesterday * 100).round(1)
+      end
+
+      # Determine trend direction (increasing, decreasing, stable)
+      def trend_direction
+        trend = trend_percentage
+
+        if trend > 10
+          :increasing
+        elsif trend < -10
+          :decreasing
+        else
+          :stable
+        end
+      end
+
+      # Get top 5 errors ranked by impact score
+      # Impact = affected_users_count × occurrence_count
+      def top_errors_by_impact
+        ErrorLog.where("occurred_at >= ?", 7.days.ago)
+                .group(:error_type, :id)
+                .select("error_type, id, occurrence_count,
+                        COUNT(DISTINCT user_id) as affected_users,
+                        COUNT(DISTINCT user_id) * occurrence_count as impact_score")
+                .order("impact_score DESC")
+                .limit(5)
+                .map do |error|
+                  full_error = ErrorLog.find(error.id)
+                  {
+                    id: error.id,
+                    error_type: error.error_type,
+                    message: full_error.message&.truncate(80),
+                    severity: full_error.severity,
+                    occurrence_count: error.occurrence_count,
+                    affected_users: error.affected_users.to_i,
+                    impact_score: error.impact_score.to_i,
+                    occurred_at: full_error.occurred_at
+                  }
+                end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -29,6 +29,11 @@ module RailsErrorDashboard
         query = filter_by_platform(query)
         query = filter_by_search(query)
         query = filter_by_severity(query)
+        # Phase 3: Workflow filters
+        query = filter_by_status(query)
+        query = filter_by_assignment(query)
+        query = filter_by_priority(query)
+        query = filter_by_snoozed(query)
         query
       end
 
@@ -39,14 +44,23 @@ module RailsErrorDashboard
       end
 
       def filter_by_resolved(query)
-        # Default to unresolved only if no explicit filter is set
-        # If unresolved param is explicitly false (boolean, string, or "0"), show all errors
-        # Otherwise, default to showing only unresolved errors
-        if @filters[:unresolved] == false || @filters[:unresolved] == "false" || @filters[:unresolved] == "0"
-          # Show all errors (resolved and unresolved)
+        # Handle unresolved filter with explicit true/false values
+        # When checkbox is unchecked: unresolved=false → show all errors
+        # When checkbox is checked: unresolved=true → show only unresolved errors
+        # When no filter: nil → default to unresolved only
+
+        case @filters[:unresolved]
+        when false, "false", "0"
+          # Explicitly show all errors (resolved and unresolved)
           query
+        when true, "true", "1"
+          # Explicitly show only unresolved errors
+          query.unresolved
+        when nil, ""
+          # Default: show only unresolved errors when no filter is set
+          query.unresolved
         else
-          # Default: show only unresolved errors
+          # Fallback: show only unresolved errors
           query.unresolved
         end
       end
@@ -102,6 +116,47 @@ module RailsErrorDashboard
 
         query.where(error_type: error_types)
       end
+
+      # Phase 3: Workflow filter methods
+
+      def filter_by_status(query)
+        return query unless @filters[:status].present?
+        return query unless query.model.column_names.include?("status")
+
+        query.by_status(@filters[:status])
+      end
+
+      def filter_by_assignment(query)
+        return query unless @filters[:assigned_to].present?
+        return query unless query.model.column_names.include?("assigned_to")
+
+        case @filters[:assigned_to]
+        when "__unassigned__"
+          query.unassigned
+        when "__assigned__"
+          query.assigned
+        else
+          query.by_assignee(@filters[:assigned_to])
+        end
+      end
+
+      def filter_by_priority(query)
+        return query unless @filters[:priority_level].present?
+        return query unless query.model.column_names.include?("priority_level")
+
+        query.by_priority(@filters[:priority_level])
+      end
+
+      def filter_by_snoozed(query)
+        return query unless query.model.column_names.include?("snoozed_until")
+
+        # If hide_snoozed is checked, exclude snoozed errors
+        if @filters[:hide_snoozed] == "1" || @filters[:hide_snoozed] == true
+          query.active
+        else
+          query
+        end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/services/backtrace_parser.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Service: Parse and categorize backtrace frames
+    # Filters out framework noise to show only relevant application code
+    class BacktraceParser
+      # Match both formats:
+      # /path/file.rb:123:in `method'
+      # /path/file.rb:123:in 'ClassName#method'
+      FRAME_PATTERN = %r{^(.+):(\d+)(?::in [`'](.+)['`])?$}
+
+      def self.parse(backtrace_string)
+        new(backtrace_string).parse
+      end
+
+      def initialize(backtrace_string)
+        @backtrace_string = backtrace_string
+      end
+
+      def parse
+        return [] if @backtrace_string.blank?
+
+        lines = @backtrace_string.split("\n")
+        lines.map.with_index do |line, index|
+          parse_frame(line.strip, index)
+        end.compact
+      end
+
+      private
+
+      def parse_frame(line, index)
+        match = line.match(FRAME_PATTERN)
+        return nil unless match
+
+        file_path = match[1]
+        line_number = match[2].to_i
+        method_name = match[3] || "(unknown)"
+
+        {
+          index: index,
+          file_path: file_path,
+          line_number: line_number,
+          method_name: method_name,
+          category: categorize_frame(file_path),
+          full_line: line,
+          short_path: shorten_path(file_path)
+        }
+      end
+
+      def categorize_frame(file_path)
+        # Application code (highest priority)
+        return :app if app_code?(file_path)
+
+        # Gem code (dependencies)
+        return :gem if gem_code?(file_path)
+
+        # Rails framework
+        return :framework if rails_code?(file_path)
+
+        # Ruby core/stdlib
+        :ruby_core
+      end
+
+      def app_code?(file_path)
+        # Match /app/, /lib/ directories in the application
+        file_path.include?("/app/") ||
+          (file_path.include?("/lib/") && !file_path.include?("/gems/") && !file_path.include?("/ruby/"))
+      end
+
+      def gem_code?(file_path)
+        file_path.include?("/gems/") ||
+          file_path.include?("/bundler/gems/") ||
+          file_path.include?("/vendor/bundle/")
+      end
+
+      def rails_code?(file_path)
+        file_path.include?("/railties-") ||
+          file_path.include?("/actionpack-") ||
+          file_path.include?("/actionview-") ||
+          file_path.include?("/activerecord-") ||
+          file_path.include?("/activesupport-") ||
+          file_path.include?("/actioncable-") ||
+          file_path.include?("/activejob-") ||
+          file_path.include?("/actionmailer-") ||
+          file_path.include?("/activestorage-") ||
+          file_path.include?("/actionmailbox-") ||
+          file_path.include?("/actiontext-") ||
+          file_path.include?("/rails-")
+      end
+
+      def shorten_path(file_path)
+        # Remove gem version numbers and long paths
+        # /Users/.../.gem/ruby/3.4.0/gems/activerecord-8.0.4/lib/... → activerecord/.../file.rb
+        if file_path.include?("/gems/")
+          parts = file_path.split("/gems/").last
+          gem_and_path = parts.split("/", 2)
+          gem_name = gem_and_path.first.split("-").first # Remove version
+          path_in_gem = gem_and_path.last
+          "#{gem_name}/#{path_in_gem}"
+        # /path/to/app/controllers/... → app/controllers/...
+        elsif file_path.include?("/app/")
+          file_path.split("/app/").last.prepend("app/")
+        elsif file_path.include?("/lib/") && !file_path.include?("/ruby/")
+          file_path.split("/lib/").last.prepend("lib/")
+        else
+          # Just show filename for Ruby core
+          File.basename(file_path)
+        end
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/rails_error_dashboard.rb

@@ -1,6 +1,7 @@
 require "rails_error_dashboard/version"
 require "rails_error_dashboard/engine"
 require "rails_error_dashboard/configuration"
+require "rails_error_dashboard/logger"
 
 # External dependencies
 require "pagy"
@@ -11,6 +12,7 @@ require "httparty"
 # Core library files
 require "rails_error_dashboard/value_objects/error_context"
 require "rails_error_dashboard/services/platform_detector"
+require "rails_error_dashboard/services/backtrace_parser"
 require "rails_error_dashboard/services/similarity_calculator"
 require "rails_error_dashboard/services/cascade_detector"
 require "rails_error_dashboard/services/baseline_calculator"