solidstats 1.1.0 → 3.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1e51da79f65a50793bc1bfc777ed19df5d81795739ceda8558d3261745b53ae
-  data.tar.gz: e58f0018fd96135789f192372b2b85f7165cf51a6921fa7e2a56057bebdb14b5
+  metadata.gz: dd313b23c968d18619f31b5157b96b2a9c75435398121e800deaf6c2e7d4bfd4
+  data.tar.gz: 1f7407373917b47d1ef56ebe7e03138cd36ef111517a930e0c8b6354bc2e389f
 SHA512:
-  metadata.gz: 3fc113aaaf952e1d9a320b55618b72d4b6025ec81d3bc274f29a090ddbc6a0f500bbd50aa2873d8e02d850dac992ef28214e5709f0160bc2ce0e88e348182f0a
-  data.tar.gz: 976d3989eeffc2781c1040846af1435147be33a407b6e5a2bae1db8dfba091f9678635b1863c3dcc36916adf5d2b334cc0f0a7d523225066bb4fdac074ebf270
+  metadata.gz: adcd27c59ddc3e68c8843583dd274d96312959155c3a0491f06540cd1eb474681bcb7de407b6d286bc1a9e97dd03b4e94099b3e40f5232a37929b3c2565e1cd2
+  data.tar.gz: 515a1510e1911e65f8b7784bf746341112f469de7800170923f3f3f716c537825fe742afa266ecb5fc091ad9c1e3c7aebfbef328eef964da69960a7b0d63506b

data/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.0.0] - 2025-06-11
+
+### Added
+- **LoadLens Performance Monitor**: A new development performance monitoring feature that parses development logs to track Rails application performance. It includes metrics for response times, database performance, view rendering, and error rates.
+- **Style Patrol**: A new code quality analysis feature to enforce style guidelines and improve code health.
+- **My TODOs Feature**: A new service to manage and track TODO items within the codebase, with a dedicated UI and refresh functionality.
+- **Bundler Audit Security**: Added security auditing for Bundler, with a dedicated UI to display vulnerability details and remediation suggestions.
+
+### Changed
+- **Dashboard Redesign**: The Solidstats dashboard has been completely redesigned with DaisyUI, providing a modern, consistent, and themeable user interface.
+- **Refactored Services**: The `LogSizeMonitorService` has been refactored for enhanced log management and caching.
+- **Improved Installation**: The installation process has been enhanced with automatic directory creation and `.gitignore` updates.
+
+### Fixed
+- Updated route aliases and paths for better consistency across the application.
+- Replaced static dashboard titles with dynamic links for improved navigation.
+
 ## [1.1.0] - 2025-05-23
 
 ### Added

data/README.md

@@ -9,6 +9,7 @@ Solidstats is a local-only Rails engine that shows your project's health at `/so
 - Gem impact analysis showing affected gems by severity
 - Log Size Monitor for tracking and managing application log files
 - Log file truncation tool for individual or all log files
+- LoadLens - Development performance monitoring with request tracking
 - Rubocop offense count and quality metrics
 - TODO/FIXME tracker with file hotspots
 - Test coverage summary
@@ -77,6 +78,32 @@ You can refresh the dashboard data at any time by clicking the "Refresh" button
 ### Code Quality
 Displays code quality metrics, test coverage, and code health indicators.
 
+### LoadLens Performance
+Monitors your Rails app's performance in development by parsing `log/development.log`:
+- **Response Times**: Average response time across all requests
+- **Database Performance**: ActiveRecord query timing analysis  
+- **View Rendering**: Template rendering performance metrics
+- **Error Tracking**: HTTP status code analysis and error rates
+- **Slow Request Detection**: Identifies requests taking >1000ms
+- **Request History**: Recent request details with timing breakdown
+
+LoadLens automatically tracks performance data and provides manual refresh capability. Data is stored in daily rotating JSON files and cleaned up after 7 days.
+
+**CLI Commands:**
+```bash
+# Parse development logs manually
+rake solidstats:load_lens:parse_logs
+
+# Refresh performance data
+rake solidstats:load_lens:refresh
+
+# View performance summary
+rake solidstats:load_lens:summary
+
+# Clean old data files
+rake solidstats:load_lens:clean_old_data
+```
+
 ### Tasks
 Shows a breakdown of TODO, FIXME, and HACK annotations found in your codebase, with file hotspots and expandable details.
 

data/Rakefile

@@ -1,5 +1,5 @@
 require "bundler/setup"
-
-load "rails/tasks/statistics.rake"
-
 require "bundler/gem_tasks"
+
+# Load solidstats-specific tasks
+Dir[File.join(File.dirname(__FILE__), 'lib', 'tasks', '*.rake')].each { |f| load f }

data/app/assets/stylesheets/solidstats/dashboard.css

@@ -0,0 +1,48 @@
+/* Solidstats Dashboard with DaisyUI */
+
+/* Custom animations for dashboard */
+.dashboard-enter {
+  animation: fadeInUp 0.6s ease-out;
+}
+
+@keyframes fadeInUp {
+  from {
+    opacity: 0;
+    transform: translateY(30px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+/* Gradient text for brand */
+.gradient-text {
+  background: linear-gradient(135deg, #3b82f6, #8b5cf6);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+/* Light mode improvements */
+[data-theme="light"] .card {
+  background-color: #ffffff;
+  border: 1px solid #e5e7eb;
+}
+
+[data-theme="light"] .card:hover {
+  box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1);
+}
+
+[data-theme="light"] .stat-value {
+  color: #1f2937;
+}
+
+[data-theme="light"] .card-title {
+  color: #1f2937;
+}
+
+[data-theme="light"] .navbar {
+  background-color: #ffffff;
+  border-bottom: 1px solid #e5e7eb;
+}

data/app/controllers/solidstats/dashboard_controller.rb

@@ -1,77 +1,99 @@
 module Solidstats
   class DashboardController < ApplicationController
+    layout 'solidstats/dashboard'
+    
     TODO_CACHE_FILE = Rails.root.join("tmp", "solidstats_todos.json")
     AUDIT_CACHE_HOURS = 12 # Configure how many hours before refreshing
 
-    def index
-      # Use new services for data collection
-      audit_service = AuditService.new
-      todo_service = TodoService.new
-      log_monitor_service = LogSizeMonitorService.new
-
-      # Get full data for detailed views
-      @audit_output = audit_service.fetch
-      @todo_items = todo_service.fetch
-      @log_data = log_monitor_service.collect_data
 
-      # Get summary data for dashboard cards
-      @audit_summary = audit_service.summary
-      @todo_summary = todo_service.summary
-
-      # TODO: Refactor these to use services as well
-      @rubocop_output = "JSON.parse(`rubocop --format json`)"
-      @coverage = "100"
+    def dashboard
+      # Load dashboard cards from JSON file
+      @dashboard_cards = load_dashboard_cards
+      @quick_actions = quick_actions_data
+      render 'dashboard'
     end
 
-    # Force refresh all dashboard data
     def refresh
-      # Create services
-      audit_service = AuditService.new
-      todo_service = TodoService.new
-      log_monitor_service = LogSizeMonitorService.new
-
-      # Force refresh of data
-      audit_output = audit_service.fetch(true) # Force refresh
-      todo_items = todo_service.fetch(true)    # Force refresh
-      log_data = log_monitor_service.collect_data
-
-      # Get updated summaries
-      audit_summary = audit_service.summary
-      todo_summary = todo_service.summary
+      # Refresh all services
+      Solidstats::LogSizeMonitorService.scan_and_cache
+      Solidstats::BundlerAuditService.scan_and_cache
+      Solidstats::MyTodoService.collect_todos
+      Solidstats::StylePatrolService.refresh_cache
+      Solidstats::CoverageCompassService.refresh_cache
+      Solidstats::LoadLensService.scan_and_cache
+      
+      redirect_to solidstats_dashboard_path, notice: 'Dashboard data refreshed successfully!'
+    end
 
-      # Get current time for last updated display
-      last_updated = Time.now.strftime("%B %d, %Y at %H:%M")
+    private
 
-      # Return JSON response with refreshed data
-      render json: {
-        audit_output: audit_output,
-        todo_items: todo_items,
-        audit_summary: audit_summary,
-        todo_summary: todo_summary,
-        log_data: log_data,
-        last_updated: last_updated,
-        status: "success"
-      }
-    rescue StandardError => e
-      # Return error information
-      render json: {
-        status: "error",
-        message: "Failed to refresh data: #{e.message}"
-      }, status: :internal_server_error
+    def quick_actions_data
+      [
+        {
+          icon: 'refresh-cw',
+          label: 'Refresh Data',
+          color: 'blue',
+          action: 'refresh_dashboard'
+        },
+        {
+          icon: 'settings',
+          label: 'Configure',
+          color: 'purple',
+          action: 'open_settings'
+        },
+        {
+          icon: 'download',
+          label: 'Export',
+          color: 'green',
+          action: 'export_data'
+        },
+        {
+          icon: 'bell',
+          label: 'Alerts',
+          color: 'orange',
+          action: 'view_alerts'
+        }
+      ]
     end
-    
-    def truncate_log
-      log_monitor_service = LogSizeMonitorService.new
-      filename = params[:filename]
+
+    def load_dashboard_cards
+      json_file_path = Rails.root.join("solidstats", "summary.json")
       
-      # Add .log extension if not included in the filename
-      if filename.present? && !filename.end_with?('.log')
-        filename = "#{filename}.log"
+      begin
+        # Read and parse the JSON file
+        json_data = JSON.parse(File.read(json_file_path))
+        
+        # Transform the JSON data into the format expected by the view
+        json_data.map do |name, data|
+          {
+            name: name,
+            icon: data["icon"],
+            status: data["status"],
+            value: data["value"],
+            last_updated: Time.parse(data["last_updated"]),
+            url: data["url"],
+            badges: data["badges"] || []
+          }
+        end
+      rescue Errno::ENOENT
+        Rails.logger.warn("Summary JSON file not found, generating initial data...")
+        generate_initial_data
+        retry
+      rescue JSON::ParserError => e
+        Rails.logger.error("Error parsing summary JSON: #{e.message}")
+        # Fallback to empty array if JSON is invalid
+        []
       end
-      
-      result = log_monitor_service.truncate_log(filename)
-      
-      render json: result
+    end
+
+    def generate_initial_data
+      # Force a scan to create initial data if missing
+      Solidstats::LogSizeMonitorService.scan_and_cache
+      Solidstats::BundlerAuditService.scan_and_cache
+      Solidstats::MyTodoService.collect_todos
+      Solidstats::StylePatrolService.refresh_cache
+      Solidstats::CoverageCompassService.refresh_cache
+      Solidstats::DevLogParserService.scan_and_cache
     end
   end
 end

data/app/controllers/solidstats/logs_controller.rb

@@ -0,0 +1,72 @@
+module Solidstats
+  class LogsController < ApplicationController
+    layout 'solidstats/dashboard'
+    
+    def logs_size
+      @logs_data = Solidstats::LogSizeMonitorService.get_logs_data
+    end
+
+    def truncate
+      filename = params[:filename]
+      
+      # Validate filename presence
+      if filename.blank?
+        return render json: {
+          status: "error",
+          message: "Filename is required"
+        }, status: :bad_request
+      end
+      
+      # Remove any path traversal attempts for security
+      filename = File.basename(filename)
+      
+      # Ensure it's a .log file
+      unless filename.end_with?('.log')
+        filename = "#{filename}.log" if filename.present?
+      end
+
+      # Additional security check
+      unless filename.end_with?('.log')
+        return render json: { 
+          status: "error", 
+          message: "Invalid file type. Only .log files can be truncated." 
+        }, status: :bad_request
+      end
+
+      result = Solidstats::LogSizeMonitorService.truncate_log(filename)
+
+      if result[:status] == "success"
+        render json: {
+          status: "success",
+          message: result[:message] || "Log file truncated successfully",
+          filename: filename,
+          original_size: result[:original_size]
+        }
+      else
+        render json: result, status: :unprocessable_entity
+      end
+    rescue StandardError => e
+      Rails.logger.error("Failed to truncate log #{filename}: #{e.message}")
+      render json: {
+        status: "error",
+        message: "Failed to truncate log: #{e.message}"
+      }, status: :internal_server_error
+    end
+
+    def refresh
+      # Force refresh of log monitoring data
+      result = Solidstats::LogSizeMonitorService.scan_and_cache
+      
+      render json: {
+        status: "success",
+        message: "Log data refreshed",
+        data: result
+      }
+    rescue StandardError => e
+      render json: {
+        status: "error", 
+        message: "Failed to refresh log data: #{e.message}"
+      }, status: :internal_server_error
+    end
+  end
+end

data/app/controllers/solidstats/performance_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Solidstats
+  class PerformanceController < ApplicationController
+    layout 'solidstats/dashboard'
+
+    def load_lens
+      @performance_data = LoadLensService.get_performance_data
+      @metrics = @performance_data[:summary] || {}
+      @recent_requests = @performance_data[:recent_requests] || []
+    end
+
+    def refresh
+      # Parse new log entries and refresh cache
+      parse_result = LoadLensService.parse_log_and_save
+      LoadLensService.refresh_data
+      
+      if parse_result[:success]
+        redirect_to load_lens_performance_index_path, notice: "LoadLens data refreshed! Parsed #{parse_result[:processed]} new requests."
+      else
+        redirect_to load_lens_performance_index_path, alert: "Failed to parse logs: #{parse_result[:error]}"
+      end
+    end
+  end
+end

data/app/controllers/solidstats/productivity_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Solidstats
+  class ProductivityController < ApplicationController
+    layout 'solidstats/dashboard'
+    
+    def my_todos
+      @todos = MyTodoService.collect_todos
+      @summary = MyTodoService.get_summary
+      
+      # Group todos by type for display
+      @todos_by_type = @todos.group_by { |todo| todo[:type] }
+      
+      # Recent todos (first 10 for quick view)
+      @recent_todos = @todos.first(10)
+      
+      # Stats for dashboard
+      @stats = {
+        total: @todos.length,
+        by_type: @todos_by_type.transform_values(&:count),
+        files_with_todos: @todos.map { |t| t[:file] }.uniq.length
+      }
+      
+      respond_to do |format|
+        format.html
+        format.json { render json: { todos: @todos, summary: @summary, stats: @stats } }
+      end
+    end
+    
+    def refresh_todos
+      @todos = MyTodoService.collect_todos(force_refresh: true)
+      
+      respond_to do |format|
+        format.html { redirect_to my_todos_productivity_index_path, notice: 'TODOs refreshed successfully!' }
+        format.json { render json: { status: 'success', message: 'TODOs refreshed', count: @todos.length } }
+      end
+    end
+  end
+end

data/app/controllers/solidstats/quality_controller.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Solidstats
+  class QualityController < ApplicationController
+    layout 'solidstats/dashboard'
+    
+    # Display Standard gem code quality analysis
+    def style_patrol
+      @analysis_data = Solidstats::StylePatrolService.collect_data
+      @summary = Solidstats::StylePatrolService.get_summary
+      
+      # Group issues by file for better display
+      if @analysis_data[:issues].present?
+        @issues_by_file = @analysis_data[:issues].group_by { |issue| issue[:file] }
+        @issues_by_severity = @analysis_data[:issues].group_by { |issue| issue[:severity] }
+      else
+        @issues_by_file = {}
+        @issues_by_severity = {}
+      end
+      
+      render 'style_patrol'
+    end
+    
+    # Force refresh of style patrol data
+    def refresh_style_patrol
+      @analysis_data = Solidstats::StylePatrolService.refresh_cache
+      redirect_to quality_style_patrol_path, notice: 'Code quality analysis refreshed successfully.'
+    rescue => e
+      redirect_to quality_style_patrol_path, alert: "Error refreshing analysis: #{e.message}"
+    end
+    
+    # Display SimpleCov code coverage analysis
+    def coverage_compass
+      # Get coverage data using the correct method
+      @analysis_data = Solidstats::CoverageCompassService.collect_data
+      
+      # Handle different response types from service
+      if @analysis_data
+        if @analysis_data[:setup_required]
+          @setup_instructions = @analysis_data[:instructions]
+          @show_setup = true
+          @analysis_data[:status] = 'setup_required'
+        elsif @analysis_data[:stale_data]
+          @stale_warning = true
+          @data_age_hours = @analysis_data[:data_age_hours]
+          @suggestions = @analysis_data[:suggestions]
+          @analysis_data = @analysis_data[:last_coverage] || @analysis_data
+          @analysis_data[:status] = 'stale'
+        elsif @analysis_data[:error]
+          @error_message = @analysis_data[:error]
+          @analysis_data[:status] = 'error'
+        else
+          @analysis_data[:status] = 'success'
+        end
+        
+        # Organize file coverage data for better display
+        organize_coverage_data
+      else
+        set_error_state
+        @analysis_data = { status: 'error' }
+      end
+      
+      render 'coverage_compass'
+    end
+    
+    # Force refresh of coverage compass data
+    def refresh_coverage_compass
+      Solidstats::CoverageCompassService.refresh_cache
+      redirect_to quality_coverage_compass_path, notice: 'Code coverage analysis refreshed successfully.'
+    rescue => e
+      redirect_to quality_coverage_compass_path, alert: "Error refreshing coverage analysis: #{e.message}"
+    end
+
+    private
+
+    def organize_coverage_data
+      file_coverage_data = @analysis_data[:file_coverage]
+      if file_coverage_data.present?
+        @file_coverage = file_coverage_data.map do |path, data|
+          {
+            file_path: path,
+            coverage_percent: data[:coverage_percentage] || 0,
+            total_lines: data[:total_lines] || 0,
+            covered_lines: data[:covered_lines] || 0,
+            missed_lines: data[:missed_lines] || []
+          }
+        end
+        
+        # Group files by coverage ranges for better visualization
+        @coverage_ranges = {
+          excellent: @file_coverage.select { |f| f[:coverage_percent] >= 90 },
+          good: @file_coverage.select { |f| f[:coverage_percent] >= 70 && f[:coverage_percent] < 90 },
+          needs_improvement: @file_coverage.select { |f| f[:coverage_percent] >= 50 && f[:coverage_percent] < 70 },
+          poor: @file_coverage.select { |f| f[:coverage_percent] < 50 }
+        }
+      else
+        @file_coverage = []
+        @coverage_ranges = { excellent: [], good: [], needs_improvement: [], poor: [] }
+      end
+      
+      # Set summary data
+      @summary = {
+        overall_coverage: @analysis_data[:overall_coverage] || 0,
+        coverage_percent: @analysis_data[:overall_coverage] || 0,
+        total_lines: @analysis_data[:total_lines] || 0,
+        covered_lines: @analysis_data[:covered_lines] || 0,
+        missed_lines: (@analysis_data[:total_lines] || 0) - (@analysis_data[:covered_lines] || 0),
+        total_files: @file_coverage.size,
+        health_score: calculate_health_score(@analysis_data[:overall_coverage] || 0),
+        coverage_grade: determine_coverage_grade(@analysis_data[:overall_coverage] || 0)
+      }
+    end
+
+    def set_error_state
+      @error_message = "Failed to retrieve coverage data"
+      @file_coverage = []
+      @coverage_ranges = { excellent: [], good: [], needs_improvement: [], poor: [] }
+      @summary = { 
+        overall_coverage: 0, 
+        coverage_percent: 0,
+        total_lines: 0, 
+        covered_lines: 0, 
+        missed_lines: 0,
+        total_files: 0,
+        health_score: 0,
+        coverage_grade: 'F'
+      }
+    end
+
+    def calculate_health_score(coverage_percent)
+      case coverage_percent
+      when 90..100 then 95
+      when 80..89 then 85
+      when 70..79 then 75
+      when 60..69 then 65
+      when 50..59 then 55
+      else 25
+      end
+    end
+
+    def determine_coverage_grade(coverage_percent)
+      case coverage_percent
+      when 90..100 then 'A+'
+      when 80..89 then 'A'
+      when 70..79 then 'B'
+      when 60..69 then 'C'
+      when 50..59 then 'D'
+      else 'F'
+      end
+    end
+  end
+end

data/app/controllers/solidstats/securities_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solidstats
+  class SecuritiesController < ApplicationController
+    layout 'solidstats/dashboard'
+    
+    # Display bundler audit security vulnerabilities
+    def bundler_audit
+      @vulnerabilities_data = Solidstats::BundlerAuditService.fetch_vulnerabilities
+      @vulnerabilities = @vulnerabilities_data.dig("output", "results") || []
+      @summary = Solidstats::BundlerAuditService.summary
+      @last_updated = @vulnerabilities_data.dig("output", "created_at")
+      
+      # Group vulnerabilities by severity for better display
+      @vulnerabilities_by_severity = @vulnerabilities.group_by do |vuln|
+        vuln.dig("advisory", "criticality") || "unknown"
+      end
+      
+      render 'bundler_audit'
+    end
+    
+    # Force refresh of bundler audit data
+    def refresh_bundler_audit
+      @vulnerabilities_data = Solidstats::BundlerAuditService.scan_and_cache
+      redirect_to securities_bundler_audit_path, notice: 'Security vulnerabilities refreshed successfully.'
+    rescue => e
+      redirect_to securities_bundler_audit_path, alert: "Error refreshing vulnerabilities: #{e.message}"
+    end
+  end
+end