solidstats 0.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e3efc1790ad2beb55d19f731457a39034c744524da80c85674bc0d02fdb1d83
-  data.tar.gz: 50a12e44bf70c1b297d86f8645267f4648b1476df611cba0e72fffb26e40c638
+  metadata.gz: b1e51da79f65a50793bc1bfc777ed19df5d81795739ceda8558d3261745b53ae
+  data.tar.gz: e58f0018fd96135789f192372b2b85f7165cf51a6921fa7e2a56057bebdb14b5
 SHA512:
-  metadata.gz: a5d7b257090f0869fc20c6c1144f7a120d7e8bdc12d8474df5db603d6918f417d7b59a24a38f0e89cf0e89c0d2507de6a7984f8f293a3a1d3b3f5e368e29d2de
-  data.tar.gz: c7dccdf4109e89e33ccad5a58af97e9cb4ea7e317243a6de9eafc0e24a5001abef0650b9a133bc8af6b5c52bdbf187c4818a28a519e55df42731611d89fe74da
+  metadata.gz: 3fc113aaaf952e1d9a320b55618b72d4b6025ec81d3bc274f29a090ddbc6a0f500bbd50aa2873d8e02d850dac992ef28214e5709f0160bc2ce0e88e348182f0a
+  data.tar.gz: 976d3989eeffc2781c1040846af1435147be33a407b6e5a2bae1db8dfba091f9678635b1863c3dcc36916adf5d2b334cc0f0a7d523225066bb4fdac074ebf270

data/CHANGELOG.md

@@ -5,6 +5,82 @@ 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).
 
+## [1.1.0] - 2025-05-23
+
+### Added
+- Log Size Monitor feature:
+  - Comprehensive monitoring of all Rails application log files
+  - Total log directory size tracking with status indicators
+  - Individual log file monitoring with size and status details
+  - Visual indicators for log size status (OK, Warning, Danger)
+  - Visual meter showing log size relative to thresholds
+  - One-click log truncation for individual files or all logs
+  - Sortable log file table with size and last modified information
+  - Log management recommendations
+
+### Fixed
+- Fixed log file truncation when filename is provided without extension
+- Added constraints to route handling to improve filename parameter handling
+
+## [1.0.0] - 2025-05-22
+
+### Added
+- Fully functional refresh button with AJAX updates
+- Dynamic dashboard refreshing for all components:
+  - Security metrics and score update in real-time
+  - Vulnerability table regeneration with fresh data
+  - Donut chart visualization updates
+  - Gem impact analysis section updates
+  - Vulnerability details section updates
+- Enhanced disabled button tooltips with inline display
+- Comprehensive security dashboard features:
+  - Security score rating (A+, B, C) based on vulnerabilities
+  - Detailed vulnerability table with filtering and searching
+  - Visual severity breakdown with interactive donut chart
+  - Gem impact analysis with affected gem grouping
+  - Detailed vulnerability information with remediation options
+
+### Fixed
+- Vulnerability details no longer hidden under sticky header when clicking "More details"
+- Improved scroll offset calculations for better navigation
+- Added visual feedback with animations when viewing details
+- Fixed "Back to vulnerabilities table" button positioning
+
+## [0.0.4] - 2025-05-20
+
+### Added
+- Service-based architecture for data collection with caching
+- Base DataCollectorService class for shared functionality
+- Specialized services: AuditService and TodoService
+- Comprehensive UI/UX redesign with modern dashboard layout:
+  - Sticky navigation menu with intuitive section links
+  - Organized dashboard sections (Overview, Security, Code Quality, Tasks)
+  - Tabbed interfaces for better content organization
+  - Interactive summary cards with click-to-navigate functionality
+- Enhanced security visualization:
+  - Visual security score indicator (A+, B, C ratings) with color coding
+  - Improved vulnerability metrics display with severity breakdown
+  - Detailed vulnerability table with filtering and search capabilities
+  - New "Affected Gems" tab with visual cards for vulnerable dependencies
+  - Timeline visualization for security history
+- Improved code quality section:
+  - Dedicated tabs for Metrics, Test Coverage, and Code Health
+  - Visual progress bars for test coverage
+- Task management improvements:
+  - Organized tabs for TODOs, FIXMEs, and HACKs
+  - Better categorization and display of code tasks
+- Responsive layout adjustments for various screen sizes
+- Quick floating navigation menu for easy section access
+- Toast notification system for user feedback
+
+### Fixed
+- Ruby version compatibility issues with dependency constraints
+- Support for multiple Ruby versions (2.7+, 3.0+, 3.2+)
+- Automatic Rails version selection based on Ruby version (6.1 through 8.x)
+- Documentation of compatibility matrix in README
+- Variable scope issues in nested template partials
+- Consistent passing of data between dashboard partials
+
 ## [0.0.3] - 2025-05-20
 
 ### Added
@@ -28,8 +104,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-- Improved TODO dashboard partial:
-  - Ensured correct handling of nil keys in the hotspots hash.
-  - Displayed TODO, FIXME, and HACK counts with color-coded badges.
-  - Added expandable details for files with most TODOs and all TODO items.
-  - Enhanced UI with better grouping and error handling for TODO data.
+### Added
+- Future enhancements will be listed here

data/README.md

@@ -1,12 +1,30 @@
-
-Solidstats is a local-only Rails engine that shows your project's health at `/solidstats`.
+Solidstats is a local-only Rails engine that shows your project's health at `/solidstats`. The dashboard provides real-time insights into your application's security, code quality, and development tasks.
 
 ## Features
-- Bundler Audit scan
-- Rubocop offense count
-- TODO/FIXME tracker
+- Interactive security dashboard with real-time refresh capability
+- Comprehensive gem vulnerability analysis with severity breakdown
+- Visual security score rating (A+, B, C) and metrics
+- Bundler Audit scan with detailed remediation suggestions
+- Interactive vulnerability details with patched version information
+- 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
+- Rubocop offense count and quality metrics
+- TODO/FIXME tracker with file hotspots
 - Test coverage summary
 
+## Compatibility
+
+- Ruby 2.7+: Compatible with Rails 6.1 through Rails 7.0
+- Ruby 3.0-3.1: Compatible with Rails 6.1 through Rails 7.x
+- Ruby 3.2+: Compatible with all Rails 6.1+ versions
+
+Solidstats automatically detects your Ruby version and selects a compatible Rails version.
+
+### CI/Testing
+
+This gem is automatically tested across multiple Ruby versions (2.7, 3.0, 3.1, and 3.2) to ensure compatibility. If you're contributing to this gem, make sure your changes work across all supported Ruby versions.
+
 ## Installation
 
 ```ruby
@@ -35,5 +53,36 @@ The installer will automatically mount the engine in your routes:
 mount Solidstats::Engine => '/solidstats' if Rails.env.development?
 ```
 
+## Usage
+
+Visit `/solidstats` in your development environment to access the dashboard. The dashboard provides an overview of your application's health and is organized into the following sections:
+
+### Overview
+Shows summary cards for security issues, TODO items, and code quality metrics.
+
+### Security
+Provides a comprehensive security dashboard with:
+- Security score rating based on vulnerability severity
+- Vulnerability metrics showing critical, high, medium and low issues
+- Interactive vulnerability table with filtering and searching
+- Gem impact analysis showing which gems are affected
+- Detailed vulnerability information with remediation suggestions
+
+You can refresh the dashboard data at any time by clicking the "Refresh" button in the top navigation bar. This will:
+1. Trigger a fresh security audit of your application
+2. Update all metrics and visualizations with current data
+3. Show real-time feedback during the refresh process
+4. Update the "Last Updated" timestamp
+
+### Code Quality
+Displays code quality metrics, test coverage, and code health indicators.
+
+### Tasks
+Shows a breakdown of TODO, FIXME, and HACK annotations found in your codebase, with file hotspots and expandable details.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/infolily/solidstats.
+
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/controllers/solidstats/dashboard_controller.rb

@@ -1,138 +1,77 @@
 module Solidstats
   class DashboardController < ApplicationController
-    AUDIT_CACHE_FILE = Rails.root.join("tmp", "solidstats_audit.json")
     TODO_CACHE_FILE = Rails.root.join("tmp", "solidstats_todos.json")
     AUDIT_CACHE_HOURS = 12 # Configure how many hours before refreshing
 
     def index
-      @audit_output = fetch_audit_output
-      @rubocop_output = "JSON.parse(`rubocop --format json`)"
-      @todo_items = fetch_todo_items
-      @todo_stats = calculate_todo_stats(@todo_items)
-      @coverage = "read_coverage_percent"
-    end
-
-    private
-
-    def fetch_audit_output
-      # Check if cache file exists and is recent enough
-      if File.exist?(AUDIT_CACHE_FILE)
-        cached_data = JSON.parse(File.read(AUDIT_CACHE_FILE))
-        last_run_time = Time.parse(cached_data["timestamp"])
+      # Use new services for data collection
+      audit_service = AuditService.new
+      todo_service = TodoService.new
+      log_monitor_service = LogSizeMonitorService.new
 
-        # Use cached data if it's less than AUDIT_CACHE_HOURS old
-        if Time.now - last_run_time < AUDIT_CACHE_HOURS.hours
-          return cached_data["output"]
-        end
-      end
-
-      # Cache expired or doesn't exist, run the audit
-      raw_output = `bundle audit check --update --format json`
-      json_part = raw_output[/\{.*\}/m] # extract JSON starting from first '{'
-      audit_output = JSON.parse(json_part) rescue { error: "Failed to parse JSON" }
-
-      # Save to cache file with timestamp
-      cache_data = {
-        "output" => audit_output,
-        "timestamp" => Time.now.iso8601
-      }
+      # Get full data for detailed views
+      @audit_output = audit_service.fetch
+      @todo_items = todo_service.fetch
+      @log_data = log_monitor_service.collect_data
 
-      # Ensure the tmp directory exists
-      FileUtils.mkdir_p(File.dirname(AUDIT_CACHE_FILE))
+      # Get summary data for dashboard cards
+      @audit_summary = audit_service.summary
+      @todo_summary = todo_service.summary
 
-      # Write the cache file
-      File.write(AUDIT_CACHE_FILE, JSON.generate(cache_data))
-
-      audit_output
+      # TODO: Refactor these to use services as well
+      @rubocop_output = "JSON.parse(`rubocop --format json`)"
+      @coverage = "100"
     end
 
-    def fetch_todo_items
-      # Check if cache file exists and is recent enough
-      if File.exist?(TODO_CACHE_FILE)
-        cached_data = JSON.parse(File.read(TODO_CACHE_FILE))
-        last_run_time = Time.parse(cached_data["timestamp"])
-
-        # Use cached data if it's less than AUDIT_CACHE_HOURS old
-        if Time.now - last_run_time < AUDIT_CACHE_HOURS.hours
-          return cached_data["output"]
-        end
-      end
-
-      todos = []
-      # Updated grep pattern to match only all-uppercase or all-lowercase variants
-      raw_output = `grep -r -n -E "(TODO|FIXME|HACK|todo|fixme|hack)" app lib`.split("\n")
-
-      raw_output.each do |line|
-        if line =~ /^(.+):(\d+):(.+)$/
-          file = $1
-          line_num = $2
-          content = $3
-
-          # Match only exact lowercase or uppercase variants
-          type_match = content.match(/(TODO|FIXME|HACK|todo|fixme|hack)/)
-          if type_match
-            # Convert to uppercase for consistency
-            type = type_match.to_s.upcase
-
-            todos << {
-              file: file,
-              line: line_num.to_i,
-              content: content.strip,
-              type: type
-            }
-          end
-        end
-      end
-
-      # Save to cache file with timestamp
-      cache_data = {
-        "output" => todos,
-        "timestamp" => Time.now.iso8601
+    # 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
+
+      # Get current time for last updated display
+      last_updated = Time.now.strftime("%B %d, %Y at %H:%M")
+
+      # 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"
       }
-
-      # Ensure the tmp directory exists
-      FileUtils.mkdir_p(File.dirname(TODO_CACHE_FILE))
-
-      # Write the cache file
-      File.write(TODO_CACHE_FILE, JSON.generate(cache_data))
-
-      todos
+    rescue StandardError => e
+      # Return error information
+      render json: {
+        status: "error",
+        message: "Failed to refresh data: #{e.message}"
+      }, status: :internal_server_error
     end
-
-    def calculate_todo_stats(todos)
-      return {} if todos.nil? || todos.empty?
-
-      stats = {
-        total: todos.count,
-        by_type: {
-          "TODO" => todos.count { |t| t[:type] == "TODO" },
-          "FIXME" => todos.count { |t| t[:type] == "FIXME" },
-          "HACK" => todos.count { |t| t[:type] == "HACK" }
-        },
-        by_file: {}
-      }
-
-      # Group by file path
-      todos.each do |todo|
-        file_path = todo[:file]
-        stats[:by_file][file_path] ||= 0
-        stats[:by_file][file_path] += 1
+    
+    def truncate_log
+      log_monitor_service = LogSizeMonitorService.new
+      filename = params[:filename]
+      
+      # Add .log extension if not included in the filename
+      if filename.present? && !filename.end_with?('.log')
+        filename = "#{filename}.log"
       end
-
-      # Find files with most TODOs (top 5)
-      stats[:hotspots] = stats[:by_file].sort_by { |_, count| -count }
-                                       .first(5)
-                                       .to_h
-
-      stats
-    end
-
-    def read_coverage_percent
-      file = Rails.root.join("coverage", ".last_run.json")
-      return 0 unless File.exist?(file)
-
-      data = JSON.parse(File.read(file))
-      data.dig("result", "covered_percent").to_f.round(2)
+      
+      result = log_monitor_service.truncate_log(filename)
+      
+      render json: result
     end
   end
 end

data/app/services/solidstats/audit_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Solidstats
+  # Service to collect and process security audit data
+  class AuditService < DataCollectorService
+    # Initialize with default cache settings for audits
+    def initialize
+      super(Rails.root.join("tmp", "solidstats_audit.json"))
+    end
+
+    # Generate a summary for the dashboard display
+    # @return [Hash] Summary information with status, count, and message
+    def summary
+      data = fetch
+      vuln_count = data["vulnerabilities"]&.count || 0
+
+      {
+        count: vuln_count,
+        status: determine_status(vuln_count),
+        message: generate_message(vuln_count)
+      }
+    end
+
+    private
+
+    # Determine the status indicator based on vulnerability count
+    # @param count [Integer] Number of vulnerabilities
+    # @return [String] Status indicator (success, warning, or danger)
+    def determine_status(count)
+      case count
+      when 0 then "success"
+      when 1..2 then "warning"
+      else "danger"
+      end
+    end
+
+    # Generate a status message based on vulnerability count
+    # @param count [Integer] Number of vulnerabilities
+    # @return [String] Human-readable status message
+    def generate_message(count)
+      case count
+      when 0 then "No vulnerabilities found"
+      when 1 then "1 vulnerability found"
+      else "#{count} vulnerabilities found"
+      end
+    end
+
+    # Collect fresh audit data by running bundle-audit
+    # @return [Hash] Parsed audit data
+    def collect_data
+      raw_output = `bundle audit check --update --format json`
+      json_part = raw_output[/\{.*\}/m] # extract JSON starting from first '{'
+      JSON.parse(json_part) rescue { "error" => "Failed to parse JSON", "vulnerabilities" => [] }
+    end
+  end
+end

data/app/services/solidstats/data_collector_service.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Solidstats
+  # Base service class for all data collectors
+  # This class handles caching logic and provides a common interface
+  # for all data collection services in SolidStats
+  class DataCollectorService
+    attr_reader :cache_file, :cache_duration
+
+    # Initialize the data collector with cache configuration
+    # @param cache_file [String] Path to the cache file
+    # @param cache_duration [ActiveSupport::Duration] Duration to keep the cache valid
+    def initialize(cache_file, cache_duration = 12.hours)
+      @cache_file = cache_file
+      @cache_duration = cache_duration
+    end
+
+    # Fetch data with caching
+    # Returns cached data if available and not expired,
+    # otherwise collects fresh data
+    # @param force_refresh [Boolean] Whether to force a refresh regardless of cache state
+    # @return [Hash] The collected data
+    def fetch(force_refresh = false)
+      return cached_data if fresh_cache? && !force_refresh
+
+      data = collect_data
+      save_to_cache(data)
+      data
+    end
+
+    # Get a summary of the data for dashboard display
+    # @return [Hash] Summary information
+    def summary
+      raise NotImplementedError, "Subclasses must implement summary"
+    end
+
+    private
+
+    # Get data from the cache file
+    # @return [Hash, nil] Cached data or nil if cache invalid
+    def cached_data
+      JSON.parse(File.read(cache_file))["output"]
+    rescue StandardError => e
+      Rails.logger.error "Error reading cache: #{e.message}"
+      nil
+    end
+
+    # Check if the cache is fresh (exists and not expired)
+    # @return [Boolean] True if cache is valid and not expired
+    def fresh_cache?
+      return false unless File.exist?(cache_file)
+
+      begin
+        cached_data = JSON.parse(File.read(cache_file))
+        last_run_time = Time.parse(cached_data["timestamp"])
+        Time.now - last_run_time < cache_duration
+      rescue StandardError => e
+        Rails.logger.error "Error checking cache freshness: #{e.message}"
+        false
+      end
+    end
+
+    # Save data to the cache file
+    # @param data [Hash] Data to save to cache
+    def save_to_cache(data)
+      cache_data = {
+        "output" => data,
+        "timestamp" => Time.now.iso8601
+      }
+
+      FileUtils.mkdir_p(File.dirname(cache_file))
+      File.write(cache_file, JSON.generate(cache_data))
+    rescue StandardError => e
+      Rails.logger.error "Error saving to cache: #{e.message}"
+    end
+
+    # Collect fresh data - to be implemented by subclasses
+    # @return [Hash] The collected data
+    def collect_data
+      raise NotImplementedError, "Subclasses must implement collect_data"
+    end
+  end
+end

data/app/services/solidstats/log_size_monitor_service.rb

@@ -0,0 +1,94 @@
+module Solidstats
+  class LogSizeMonitorService
+    WARNING_THRESHOLD = 25  # In megabytes
+    DANGER_THRESHOLD = 50   # In megabytes
+
+    def collect_data
+      log_files = scan_log_directory
+      total_size_bytes = log_files.sum { |file| file[:size_bytes] }
+      
+      # Create aggregated data
+      {
+        log_dir_path: log_directory,
+        total_size_bytes: total_size_bytes,
+        total_size_mb: bytes_to_mb(total_size_bytes),
+        status: calculate_status(total_size_bytes),
+        logs_count: log_files.size,
+        log_files: log_files,
+        created_at: Time.now.iso8601
+      }
+    end
+
+    def truncate_log(filename = nil)
+      begin
+        if filename.present?
+          # Truncate specific log file
+          # Ensure filename has .log extension
+          filename = "#{filename}.log" unless filename.end_with?('.log')
+          
+          file_path = File.join(log_directory, filename)
+          if File.exist?(file_path)
+            File.open(file_path, 'w') { |f| f.truncate(0) }
+            { success: true, message: "Log file '#{filename}' truncated successfully" }
+          else
+            { success: false, message: "Log file '#{filename}' not found" }
+          end
+        else
+          # Truncate all log files
+          scan_log_directory.each do |log_file|
+            File.open(log_file[:path], 'w') { |f| f.truncate(0) }
+          end
+          { success: true, message: "All log files truncated successfully" }
+        end
+      rescue => e
+        { success: false, message: "Failed to truncate log file: #{e.message}" }
+      end
+    end
+
+    private
+
+    def log_directory
+      Rails.root.join("log").to_s
+    end
+    
+    def scan_log_directory
+      log_files = []
+      
+      # Get all files in the log directory
+      Dir.glob(File.join(log_directory, "*.log")).each do |file_path|
+        if File.file?(file_path)
+          size_bytes = File.size(file_path)
+          filename = File.basename(file_path)
+          
+          log_files << {
+            filename: filename,
+            path: file_path,
+            size_bytes: size_bytes,
+            size_mb: bytes_to_mb(size_bytes),
+            status: calculate_status(size_bytes),
+            last_modified: File.mtime(file_path)
+          }
+        end
+      end
+      
+      # Sort by size (largest first)
+      log_files.sort_by { |file| -file[:size_bytes] }
+    end
+
+    def bytes_to_mb(bytes)
+      (bytes.to_f / (1024 * 1024)).round(2)
+    end
+
+    def calculate_status(size_bytes)
+      size_mb = bytes_to_mb(size_bytes)
+      
+      if size_mb >= DANGER_THRESHOLD
+        :danger
+      elsif size_mb >= WARNING_THRESHOLD
+        :warning
+      else
+        :ok
+      end
+    end
+  end
+end