solidstats 2.0.0 → 3.0.0

data/app/services/solidstats/log_size_monitor_service.rb

@@ -1,94 +1,225 @@
 module Solidstats
   class LogSizeMonitorService
-    WARNING_THRESHOLD = 25  # In megabytes
-    DANGER_THRESHOLD = 50   # In megabytes
+   CACHE_FILE = "logs.json"
+    SUMMARY_FILE = "summary.json"
 
-    def collect_data
-      log_files = scan_log_directory
-      total_size_bytes = log_files.sum { |file| file[:size_bytes] }
+    # Size thresholds in bytes
+    WARNING_SIZE = 500.megabytes
+    ERROR_SIZE = 1.gigabyte
 
-      # 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
-      }
+    def self.get_logs_data
+      cache_file_path = solidstats_cache_path(CACHE_FILE)
+
+      if File.exist?(cache_file_path) && cache_fresh?(cache_file_path)
+        JSON.parse(File.read(cache_file_path))
+      else
+        scan_and_cache
+      end
+    rescue JSON::ParserError, Errno::ENOENT
+      Rails.logger.error("Error reading logs cache, regenerating...")
+      scan_and_cache
+    end
+
+    def self.scan_and_cache
+      logs_data = scan_log_files
+
+      # Cache the logs data
+      cache_logs_data(logs_data)
+
+      # Update summary.json with log monitoring card
+      update_summary_json(logs_data)
+
+      logs_data
     end
 
-    def truncate_log(filename = nil)
+    def self.truncate_log(filename)
+      return { status: "error", message: "Filename required" } if filename.blank?
+
+      log_file_path = find_log_file(filename)
+      return { status: "error", message: "Log file not found" } unless log_file_path
+
       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" }
+        # Check if file is writable
+        unless File.writable?(log_file_path)
+          return { status: "error", message: "File is not writable" }
         end
+
+        # Get original size for reporting
+        original_size = File.size(log_file_path)
+
+        # Truncate the file
+        File.truncate(log_file_path, 0)
+
+        # Update cache after truncation
+        scan_and_cache
+
+        {
+          status: "success",
+          message: "Log file truncated successfully",
+          original_size: format_file_size(original_size),
+          filename: filename
+        }
       rescue => e
-        { success: false, message: "Failed to truncate log file: #{e.message}" }
+        Rails.logger.error("Error truncating log file #{filename}: #{e.message}")
+        { status: "error", message: "Failed to truncate: #{e.message}" }
       end
     end
 
     private
 
-    def log_directory
-      Rails.root.join("log").to_s
+    def self.scan_log_files
+      log_files = discover_log_files
+      total_size = 0
+      files_data = []
+
+      log_files.each do |file_path|
+        next unless File.exist?(file_path) && File.readable?(file_path)
+
+        file_stat = File.stat(file_path)
+        file_size = file_stat.size
+        total_size += file_size
+
+        files_data << {
+          name: File.basename(file_path),
+          path: file_path,
+          size_bytes: file_size,
+          size_human: format_file_size(file_size),
+          last_modified: file_stat.mtime.iso8601,
+          status: determine_file_status(file_size),
+          can_truncate: File.writable?(file_path)
+        }
+      end
+
+      # Sort by size descending
+      files_data.sort_by! { |f| -f[:size_bytes] }
+
+      {
+        summary: {
+          total_files: files_data.length,
+          total_size: format_file_size(total_size),
+          total_size_bytes: total_size,
+          largest_file: files_data.first&.dig(:name) || "None",
+          largest_file_size: files_data.first&.dig(:size_human) || "0 B",
+          last_updated: Time.current.iso8601,
+          status: determine_overall_status(total_size, files_data)
+        },
+        files: files_data
+      }
     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
+    def self.discover_log_files
+      log_paths = []
+
+      # Rails log directory
+      if defined?(Rails) && Rails.root
+        rails_log_dir = Rails.root.join("log")
+        log_paths += Dir.glob(rails_log_dir.join("*.log")) if Dir.exist?(rails_log_dir)
       end
 
-      # Sort by size (largest first)
-      log_files.sort_by { |file| -file[:size_bytes] }
+      # Remove duplicates and filter readable files
+      log_paths.uniq.select { |path| File.readable?(path) }
     end
 
-    def bytes_to_mb(bytes)
-      (bytes.to_f / (1024 * 1024)).round(2)
+    def self.find_log_file(filename)
+      discovered_files = discover_log_files
+      discovered_files.find { |path| File.basename(path) == filename }
     end
 
-    def calculate_status(size_bytes)
-      size_mb = bytes_to_mb(size_bytes)
+    def self.determine_file_status(size_bytes)
+      if size_bytes >= ERROR_SIZE
+        "error"
+      elsif size_bytes >= WARNING_SIZE
+        "warning"
+      else
+        "success"
+      end
+    end
+
+    def self.determine_overall_status(total_size, files_data)
+      error_files = files_data.count { |f| f[:status] == "error" }
+      warning_files = files_data.count { |f| f[:status] == "warning" }
 
-      if size_mb >= DANGER_THRESHOLD
-        :danger
-      elsif size_mb >= WARNING_THRESHOLD
-        :warning
+      if error_files > 0 || total_size >= ERROR_SIZE * 2
+        "error"
+      elsif warning_files > 0 || total_size >= WARNING_SIZE * 3
+        "warning"
       else
-        :ok
+        "success"
+      end
+    end
+
+    def self.format_file_size(size_bytes)
+      return "0 B" if size_bytes.zero?
+
+      units = [ "B", "KB", "MB", "GB", "TB" ]
+      base = 1024.0
+      exp = (Math.log(size_bytes) / Math.log(base)).to_i
+      exp = [ exp, units.length - 1 ].min
+
+      "%.1f %s" % [ size_bytes / (base ** exp), units[exp] ]
+    end
+
+    def self.cache_logs_data(logs_data)
+      cache_file_path = solidstats_cache_path(CACHE_FILE)
+      ensure_solidstats_directory
+
+      File.write(cache_file_path, JSON.pretty_generate(logs_data))
+    rescue => e
+      Rails.logger.error("Failed to cache logs data: #{e.message}")
+    end
+
+    def self.update_summary_json(logs_data)
+      summary_file_path = solidstats_cache_path(SUMMARY_FILE)
+
+      # Read existing summary or create new one
+      begin
+        existing_summary = File.exist?(summary_file_path) ? JSON.parse(File.read(summary_file_path)) : {}
+      rescue JSON::ParserError
+        existing_summary = {}
       end
+
+      # Create badges based on status
+      badges = []
+      badges << { "text" => "#{logs_data[:summary][:total_files]} Files", "color" => "info" }
+
+      case logs_data[:summary][:status]
+      when "error"
+        badges << { "text" => "Large Size", "color" => "error" }
+      when "warning"
+        badges << { "text" => "Growing", "color" => "warning" }
+      else
+        badges << { "text" => "Healthy", "color" => "success" }
+      end
+
+      # Update the log monitoring entry
+      existing_summary["Log Files"] = {
+        "icon" => "file-text",
+        "status" => logs_data[:summary][:status],
+        "value" => logs_data[:summary][:total_size],
+        "last_updated" => logs_data[:summary][:last_updated],
+        "url" => "/solidstats/logs/size",
+        "badges" => badges
+      }
+
+      # Write updated summary
+      File.write(summary_file_path, JSON.pretty_generate(existing_summary))
+    rescue => e
+      Rails.logger.error("Failed to update summary.json: #{e.message}")
+    end
+
+    def self.cache_fresh?(cache_file_path, max_age = 30.minutes)
+      File.mtime(cache_file_path) > max_age.ago
+    rescue
+      false
+    end
+
+    def self.solidstats_cache_path(filename)
+      Rails.root.join("solidstats", filename)
+    end
+
+    def self.ensure_solidstats_directory
+      dir_path = File.dirname(solidstats_cache_path("dummy"))
+      FileUtils.mkdir_p(dir_path) unless Dir.exist?(dir_path)
     end
   end
 end

data/app/services/solidstats/my_todo_service.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "find"
+require "json"
+
+module Solidstats
+  # Enhanced TODO service for comprehensive project scanning
+  class MyTodoService
+    CACHE_FILE = Rails.root.join("solidstats", "todos.json")
+    CACHE_DURATION = 24.hours
+
+    TODO_PATTERNS = [
+      /TODO:?\s*(.+)/i,
+      /FIXME:?\s*(.+)/i,
+      /HACK:?\s*(.+)/i,
+      /NOTE:?\s*(.+)/i,
+      /BUG:?\s*(.+)/i
+    ].freeze
+
+    SCAN_EXTENSIONS = %w[.rb .js .html .erb .yml .yaml .json .css .scss .vue .jsx .tsx .ts].freeze
+    EXCLUDE_DIRS = %w[node_modules vendor tmp log public/assets .git coverage pkg app/assets/builds solidstats].freeze
+
+    def self.collect_todos(force_refresh: false)
+      return cached_todos unless force_refresh || cache_expired?
+
+      todos = scan_project_files
+      cache_todos(todos)
+      update_summary_json(todos)
+      todos
+    end
+
+    def self.get_summary
+      todos = collect_todos
+      {
+        total_count: todos.length,
+        by_type: todos.group_by { |t| t[:type] }.transform_values(&:count),
+        by_file: todos.group_by { |t| t[:file] }.transform_values(&:count),
+        top_files: todos.group_by { |t| t[:file] }
+                       .transform_values(&:count)
+                       .sort_by { |_, count| -count }
+                       .first(5)
+                       .to_h,
+        status: determine_status(todos),
+        last_updated: Time.current.iso8601
+      }
+    end
+
+    private
+
+    def self.scan_project_files
+      todos = []
+      exclude_patterns = load_gitignore_patterns
+
+      Find.find(Rails.root) do |path|
+        if File.directory?(path)
+          Find.prune if should_exclude_directory?(path, exclude_patterns)
+          next
+        end
+
+        next unless should_scan_file?(path)
+        next if excluded_by_gitignore?(path, exclude_patterns)
+
+        scan_file_for_todos(path, todos)
+      end
+
+      todos.sort_by { |todo| [ todo[:file], todo[:line_number] ] }
+    end
+
+    def self.scan_file_for_todos(file_path, todos)
+      relative_path = file_path.sub("#{Rails.root}/", "")
+
+      File.readlines(file_path, chomp: true).each_with_index do |line, index|
+        TODO_PATTERNS.each do |pattern|
+          if match = line.match(pattern)
+            todos << {
+              file: relative_path,
+              line_number: index + 1,
+              content: match[1]&.strip || line.strip,
+              type: extract_todo_type(line),
+              full_line: line.strip,
+              created_at: Time.current
+            }
+            break # Only match first pattern per line
+          end
+        end
+      end
+    rescue => e
+      Rails.logger.warn "Error scanning file #{file_path}: #{e.message}"
+    end
+
+    def self.extract_todo_type(line)
+      case line.upcase
+      when /TODO/ then "todo"
+      when /FIXME/ then "fixme"
+      when /HACK/ then "hack"
+      when /NOTE/ then "note"
+      when /BUG/ then "bug"
+      else "todo"
+      end
+    end
+
+    def self.should_exclude_directory?(path, exclude_patterns)
+      relative_path = path.sub("#{Rails.root}/", "")
+
+      # Check standard exclude directories
+      EXCLUDE_DIRS.each do |dir|
+        # Check if this directory or any parent directory matches
+        path_parts = relative_path.split("/")
+        return true if path_parts.include?(dir)
+        return true if relative_path == dir
+        return true if relative_path.start_with?("#{dir}/")
+      end
+
+      # Check gitignore patterns
+      return true if exclude_patterns.any? { |pattern| File.fnmatch(pattern, relative_path, File::FNM_PATHNAME) }
+
+      false
+    end
+
+    def self.should_scan_file?(path)
+      SCAN_EXTENSIONS.any? { |ext| path.end_with?(ext) }
+    end
+
+    def self.excluded_by_gitignore?(file_path, exclude_patterns)
+      relative_path = file_path.sub("#{Rails.root}/", "")
+      exclude_patterns.any? { |pattern| File.fnmatch(pattern, relative_path, File::FNM_PATHNAME) }
+    end
+
+    def self.load_gitignore_patterns
+      gitignore_path = Rails.root.join(".gitignore")
+      return [] unless File.exist?(gitignore_path)
+
+      patterns = []
+      File.readlines(gitignore_path, chomp: true).each do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+
+        # Convert gitignore patterns to fnmatch patterns
+        pattern = line.gsub(/\*\*/, "*")
+        pattern = pattern.chomp("/")
+        patterns << pattern
+        patterns << "#{pattern}/*" if !pattern.include?("*")
+      end
+
+      patterns
+    end
+
+    def self.cached_todos
+      return [] unless File.exist?(CACHE_FILE)
+
+      JSON.parse(File.read(CACHE_FILE), symbolize_names: true)
+    rescue JSON::ParserError
+      []
+    end
+
+    def self.cache_todos(todos)
+      FileUtils.mkdir_p(File.dirname(CACHE_FILE))
+      File.write(CACHE_FILE, todos.to_json)
+    end
+
+    def self.cache_expired?
+      return true unless File.exist?(CACHE_FILE)
+
+      File.mtime(CACHE_FILE) < CACHE_DURATION.ago
+    end
+
+    def self.update_summary_json(todos)
+      summary_file_path = Rails.root.join("solidstats", "summary.json")
+
+      # Ensure directory exists
+      FileUtils.mkdir_p(File.dirname(summary_file_path))
+
+      # Read existing summary or create new one
+      begin
+        existing_summary = File.exist?(summary_file_path) ? JSON.parse(File.read(summary_file_path)) : {}
+      rescue JSON::ParserError
+        existing_summary = {}
+      end
+
+      # Calculate TODO statistics
+      todo_count = todos.length
+      status = determine_status(todos)
+      type_counts = todos.group_by { |t| t[:type] }.transform_values(&:count)
+
+      # Create badges based on TODO types and counts
+      badges = []
+      badges << { "text" => "#{todo_count} Items", "color" => "info" }
+
+      %w[todo fixme hack note bug].each do |type|
+        count = type_counts[type] || 0
+        if count > 0
+          color = case type
+          when "fixme" then "warning"
+          when "hack", "bug" then "error"
+          else "info"
+          end
+          badges << { "text" => "#{type.upcase}: #{count}", "color" => color }
+        end
+      end
+
+      # Update the TODO items entry
+      existing_summary["TODO Items"] = {
+        "icon" => "list-todo",
+        "status" => status,
+        "value" => generate_message(todo_count),
+        "last_updated" => Time.current.iso8601,
+        "url" => "/solidstats/productivity/my_todos",
+        "badges" => badges
+      }
+
+      # Write updated summary
+      File.write(summary_file_path, JSON.pretty_generate(existing_summary))
+      Rails.logger.info("Updated summary.json with TODO items")
+    rescue => e
+      Rails.logger.error("Failed to update summary.json: #{e.message}")
+    end
+
+    def self.determine_status(todos)
+      return "success" if todos.empty?
+
+      fixme_count = todos.count { |t| t[:type] == "fixme" }
+      hack_count = todos.count { |t| t[:type] == "hack" }
+      bug_count = todos.count { |t| t[:type] == "bug" }
+
+      if bug_count > 0 || hack_count > 0
+        "error"
+      elsif fixme_count > 0 || todos.length > 20
+        "warning"
+      else
+        "success"
+      end
+    end
+
+    def self.generate_message(count)
+      case count
+      when 0 then "No items found"
+      when 1 then "1 item found"
+      else "#{count} items found"
+      end
+    end
+  end
+end