solidstats 2.0.0 → 3.0.0

data/lib/generators/solidstats/install/install_generator.rb

@@ -2,30 +2,71 @@ require "rails/generators/base"
 
 module Solidstats
   module Generators
-    # This generator installs Solidstats routes in the host application
+    # This generator installs Solidstats in the host application
     #
     # @example
     #   $ rails generate solidstats:install
     #
     # This will:
     # 1. Add the Solidstats routes to the host application's config/routes.rb
-    # 2. Show a helpful README with next steps
+    # 2. Create a solidstats directory for data storage
+    # 3. Add the solidstats directory to .gitignore
+    # 4. Show a helpful README with next steps
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path("templates", __dir__)
-      desc "Adds Solidstats routes to your development application"
+      desc "Installs Solidstats in your Rails application"
 
       def add_routes
-        route_code = <<-RUBY
+        route_string = %Q(mount Solidstats::Engine => "/solidstats")
+        route_code = %Q(
   # Solidstats Routes (development only)
-  mount Solidstats::Engine => "/solidstats" if Rails.env.development?
-        RUBY
+  #{route_string} if Rails.env.development?
+        )
 
-        route route_code
-        say_status :routes, "Mounting Solidstats engine at /solidstats (development environment only)", :green
+        # Check if the route already exists
+        if File.read(File.join(destination_root, "config", "routes.rb")).include?(route_string)
+          say_status :skip, "Solidstats route already exists", :yellow
+        else
+          route route_code.strip
+          say_status :routes, "Mounting Solidstats engine at /solidstats (development only)", :green
+        end
       end
 
-      def show_readme
-        readme "README" if behavior == :invoke
+      def create_solidstats_directory
+        empty_directory "solidstats"
+        create_file "solidstats/.keep", ""
+        say_status :create, "solidstats directory for data storage", :green
+      end
+
+      def add_to_gitignore
+        gitignore_path = File.join(destination_root, ".gitignore")
+        gitignore_content = "\n# Solidstats data directory\nsolidstats/\n"
+
+        if File.exist?(gitignore_path)
+          append_to_file ".gitignore", gitignore_content unless File.read(gitignore_path).include?("solidstats/")
+        else
+          create_file ".gitignore", gitignore_content.strip
+        end
+        say_status :update, ".gitignore to exclude solidstats directory", :green
+      end
+
+      def show_next_steps
+        say ""
+        say "✅ Solidstats has been installed successfully!", :green
+        say ""
+        say "To get started, you need to prime the data for the dashboard."
+        say "You can prime data for all services at once by running:", :yellow
+        say "  rake solidstats:prime:all", :cyan
+        say ""
+        say "Or, you can run them individually:", :yellow
+        say "  rake solidstats:prime:log_size"
+        say "  rake solidstats:prime:bundler_audit"
+        say "  rake solidstats:prime:todos"
+        say "  rake solidstats:prime:style_patrol"
+        say "  rake solidstats:prime:coverage"
+        say "  rake solidstats:prime:load_lens"
+        say ""
+        say "After the tasks complete, start your server and visit http://localhost:3000/solidstats to see the dashboard."
       end
     end
   end

data/lib/generators/solidstats/install/templates/README

@@ -5,6 +5,11 @@ Solidstats has been successfully installed for development!
 Your Solidstats dashboard is now available at: /solidstats
 (Only in development environment)
 
+Setup completed:
+✓ Routes mounted at /solidstats
+✓ Data directory created: ./solidstats
+✓ Added solidstats/ to .gitignore
+
 To access your stats:
 1. Start your Rails server: bundle exec rails s
 2. Visit: http://localhost:3000/solidstats
@@ -15,4 +20,6 @@ Solidstats will show you:
 - Code quality metrics
 - And more!
 
+Note: The solidstats directory stores cached data and is excluded from git.
+
 ===============================================================================

data/lib/solidstats/engine.rb

@@ -25,91 +25,26 @@ module Solidstats
       end
     end
 
-    # Load and configure ViewComponent if available
-    initializer "solidstats.setup_view_component", after: :load_config_initializers do |app|
-      setup_view_component(app) if view_component_available?
-    end
-
     # Add custom paths for autoloading
     initializer "solidstats.autoload_paths" do |app|
       app.config.autoload_paths += Dir[Engine.root.join("app", "components", "**")]
       app.config.autoload_paths += Dir[Engine.root.join("app", "services", "**")]
     end
 
-    # Load custom rake tasks
-    rake_tasks do
-      load_rake_tasks
-    end
-
     # Add custom generators path
     config.generators do |g|
       g.test_framework :minitest, spec: false, fixture: false
     end
 
-    private
-
-    # Check if ViewComponent is available and properly loaded
-    # @return [Boolean] true if ViewComponent is available
-    def view_component_available?
-      defined?(ViewComponent::Base) && Solidstats.view_component_available?
-    end
-
-    # Configure ViewComponent integration
-    # @param app [Rails::Application] Rails application instance
-    def setup_view_component(app)
-      log_info "🔍 Solidstats: Setting up ViewComponent integration..."
-
-      begin
-        version = ViewComponent::VERSION rescue "unknown"
-        log_info "✅ ViewComponent #{version} detected and configured"
-
-        configure_view_component_settings(app)
-        setup_preview_paths(app)
-
-        log_info "🎯 ViewComponent::Base: #{ViewComponent::Base}"
-      rescue StandardError => e
-        log_error "❌ ViewComponent setup failed: #{e.message}"
-        raise Solidstats::ComponentError, "Failed to configure ViewComponent: #{e.message}"
-      end
-    end
-
-    # Configure ViewComponent specific settings
-    # @param app [Rails::Application] Rails application instance
-    def configure_view_component_settings(app)
-      return unless app.config.respond_to?(:view_component)
-
-      view_component_config = app.config.view_component
-      view_component_config.show_previews = config.solidstats.enable_previews
-      view_component_config.default_preview_layout = "solidstats/component_preview"
-
-      # Set preview controller if not already set
-      unless view_component_config.preview_controller
-        view_component_config.preview_controller = "Solidstats::ComponentPreviewsController"
-      end
-    end
-
-    # Setup preview paths for component development
-    # @param app [Rails::Application] Rails application instance
-    def setup_preview_paths(app)
-      return unless app.config.respond_to?(:view_component) && config.solidstats.enable_previews
-
-      preview_path = Engine.root.join("app", "components", "solidstats", "previews")
+    # Isolate the Solidstats engine's namespace
+    isolate_namespace Solidstats
 
-      unless app.config.view_component.preview_paths.include?(preview_path)
-        app.config.view_component.preview_paths << preview_path
-        log_info "📁 Added preview path: #{preview_path}"
-      end
+    # Set up Solidstats asset precompilation
+    initializer "solidstats.assets.precompile" do |app|
+      app.config.assets.precompile += %w[solidstats/application.css]
     end
 
-    # Load custom rake tasks
-    def load_rake_tasks
-      task_files = Dir[Engine.root.join("lib", "tasks", "**", "*.rake")]
-      task_files.each { |file| load file }
-
-      log_info "📋 Loaded #{task_files.size} rake task(s)" if task_files.any?
-    rescue StandardError => e
-      log_error "Failed to load rake tasks: #{e.message}"
-    end
+    private
 
     # Logging helpers with consistent formatting
     def log_info(message)

data/lib/solidstats/version.rb

@@ -1,3 +1,3 @@
 module Solidstats
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/lib/solidstats.rb

@@ -1,315 +1,31 @@
-# frozen_string_literal: true
-
 require "solidstats/version"
 require "solidstats/engine"
-require "solidstats/asset_compatibility"
-require "solidstats/asset_manifest"
 
+# Top-level module for Solidstats gem
 module Solidstats
-  # Base error class for all Solidstats-specific errors
-  class Error < StandardError; end
-
-  # Configuration-related errors
-  class ConfigurationError < Error; end
-
-  # Component-related errors
-  class ComponentError < Error; end
-
-  # Service-related errors
-  class ServiceError < Error; end
-
-  class << self
-    # Returns the absolute path to this gem's root directory
-    # @return [Pathname] Gem root path
-    def root
-      @root ||= Pathname.new(File.dirname(__dir__))
-    end
-
-    # Returns version string
-    # @return [String] Version
-    def version
-      VERSION
-    end
-
-    # Returns the gem's app directory
-    # @return [Pathname] App directory path
-    def app_path
-      @app_path ||= root.join("app")
-    end
-
-    # Returns the components directory
-    # @return [Pathname] Components directory path
-    def components_path
-      @components_path ||= app_path.join("components", "solidstats")
-    end
-
-    # Returns the services directory
-    # @return [Pathname] Services directory path
-    def services_path
-      @services_path ||= app_path.join("services", "solidstats")
-    end
-
-    # Check if ViewComponent is available and properly loaded
-    # @return [Boolean] True if ViewComponent is loaded and usable
-    def view_component_available?
-      defined?(ViewComponent::Base) &&
-        ViewComponent::Base.respond_to?(:new) &&
-        defined?(Rails)
-    end
-
-    # Safely load ViewComponent if not already loaded
-    # @return [Boolean] True if ViewComponent was loaded successfully
-    def ensure_view_component!
-      return true if view_component_available?
-
-      unless defined?(Rails)
-        logger.warn "[Solidstats] Rails not available - ViewComponent cannot be loaded"
-        return false
-      end
-
-      begin
-        require "view_component"
-        require "view_component/engine"
-
-        # Verify it loaded correctly
-        if view_component_available?
-          logger.info "[Solidstats] ViewComponent loaded successfully"
-          true
-        else
-          logger.error "[Solidstats] ViewComponent loaded but not properly initialized"
-          false
-        end
-      rescue LoadError => e
-        logger.warn "[Solidstats] ViewComponent not available: #{e.message}"
-        false
-      rescue StandardError => e
-        logger.error "[Solidstats] Failed to load ViewComponent: #{e.message}"
-        false
-      end
-    end
-
-    # Check if running in development mode
-    # @return [Boolean] True if in development
-    def development?
-      defined?(Rails) && Rails.env.development?
-    end
-
-    # Check if running in production mode
-    # @return [Boolean] True if in production
-    def production?
-      defined?(Rails) && Rails.env.production?
-    end
-
-    # Check if running in test mode
-    # @return [Boolean] True if in test
-    def test?
-      defined?(Rails) && Rails.env.test?
-    end
-
-    # Current Rails environment
-    # @return [String, nil] Environment name or nil if Rails not available
-    def environment
-      Rails.env if defined?(Rails)
-    end
-
-    # Configuration object for the gem
-    # @return [Configuration] Configuration instance
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # Configure the gem with a block
-    # @yield [Configuration] Configuration object
-    # @example
-    #   Solidstats.configure do |config|
-    #     config.cache_duration = 30.minutes
-    #     config.enable_components = true
-    #   end
-    def configure
-      yield(configuration) if block_given?
-      configuration
-    end
-
-    # Reset configuration to defaults
-    # @return [Configuration] New configuration instance
-    def reset_configuration!
-      @configuration = Configuration.new
-    end
-
-    # Logger instance with fallback
-    # @return [Logger] Logger instance
-    def logger
-      @logger ||= build_logger
-    end
-
-    # Set a custom logger
-    # @param custom_logger [Logger] Custom logger instance
-    def logger=(custom_logger)
-      @logger = custom_logger
-    end
-
-    # Check if Solidstats can run in current environment
-    # @return [Boolean] True if environment is suitable
-    # @raise [ConfigurationError] If environment is not suitable
-    def environment_suitable?
-      unless development?
-        raise ConfigurationError,
-              "Solidstats can only be used in development mode. Current: #{environment || 'unknown'}"
-      end
+  # Gem setup
+  extend self
 
-      true
-    end
-
-    # Get engine instance
-    # @return [Solidstats::Engine] Engine instance
-    def engine
-      Engine
-    end
-
-    # Get asset strategy for current application
-    # @return [Symbol] Asset strategy (:sprockets, :webpacker, :importmap, :auto)
-    def asset_strategy
-      return configuration.assets[:strategy] if configuration.assets[:strategy] != :auto
-
-      # Auto-detect asset strategy
-      if defined?(Importmap) && File.exist?(Rails.root.join("config/importmap.rb"))
-        :importmap
-      elsif defined?(Webpacker) && File.exist?(Rails.root.join("config/webpacker.yml"))
-        :webpacker
-      elsif defined?(Sprockets)
-        :sprockets
-      else
-        :none
-      end
-    end
-
-    # Check if assets should be fingerprinted
-    # @return [Boolean] True if fingerprinting is enabled
-    def asset_fingerprinting?
-      configuration.assets[:fingerprint] && !Rails.env.development?
-    end
-
-    # Get the asset prefix for engine assets
-    # @return [String] Asset prefix
-    def asset_prefix
-      case asset_strategy
-      when :importmap, :sprockets
-        "solidstats"
-      when :webpacker
-        "solidstats"
-      else
-        "solidstats"
-      end
-    end
-
-    private
-
-    # Build appropriate logger based on environment
-    # @return [Logger] Logger instance
-    def build_logger
-      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-        Rails.logger
-      else
-        require "logger"
-        Logger.new($stdout, level: Logger::INFO).tap do |log|
-          log.formatter = proc do |severity, datetime, progname, msg|
-            "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
-          end
-        end
-      end
-    end
+  # Gem version
+  def version
+    VERSION
   end
 
-  # Configuration class for Solidstats gem
-  class Configuration
-    # @!attribute [rw] cache_duration
-    #   @return [ActiveSupport::Duration] Cache duration for services
-    attr_accessor :cache_duration
-
-    # @!attribute [rw] enable_components
-    #   @return [Boolean] Whether to enable ViewComponent integration
-    attr_accessor :enable_components
-
-    # @!attribute [rw] log_level
-    #   @return [Symbol] Logging level
-    attr_accessor :log_level
-
-    # @!attribute [rw] enable_previews
-    #   @return [Boolean] Whether to enable component previews
-    attr_accessor :enable_previews
-
-    # @!attribute [rw] preview_layout
-    #   @return [String] Layout for component previews
-    attr_accessor :preview_layout
-
-    # @!attribute [rw] assets
-    #   @return [Hash] Asset configuration options
-    attr_accessor :assets
-
-    # @!attribute [rw] css_framework
-    #   @return [Symbol] CSS framework integration (:none, :bootstrap, :tailwind)
-    attr_accessor :css_framework
-
-    def initialize
-      set_defaults
-    end
-
-    # Check if components are enabled and available
-    # @return [Boolean] True if components can be used
-    def components_enabled?
-      @enable_components && Solidstats.view_component_available?
-    end
-
-    # Check if previews are enabled
-    # @return [Boolean] True if previews should be shown
-    def previews_enabled?
-      @enable_previews && Solidstats.development?
-    end
-
-    # Validate configuration
-    # @return [Boolean] True if configuration is valid
-    # @raise [ConfigurationError] If configuration is invalid
-    def validate!
-      unless cache_duration.respond_to?(:seconds)
-        raise ConfigurationError, "cache_duration must be a time duration"
-      end
-
-      unless [ :debug, :info, :warn, :error, :fatal, :unknown ].include?(@log_level)
-        raise ConfigurationError, "log_level must be a valid log level symbol"
-      end
-
-      true
-    end
-
-    private
-
-    def set_defaults
-      @cache_duration = 1.hour
-      @enable_components = true
-      @log_level = :info
-      @enable_previews = true
-      @preview_layout = "solidstats/component_preview"
-      @assets = {
-        fingerprint: true,
-        strategy: :auto,
-        precompile: true,
-        compile_on_demand: Rails.env.development?
-      }
-      @css_framework = :none
-    end
+  # Simple logger for internal use
+  def logger
+    @logger ||= Logger.new($stdout)
   end
-end
 
-# Auto-require common dependencies if in Rails environment
-if defined?(Rails) && Rails.env.development?
-  # Ensure ViewComponent is available
-  Solidstats.ensure_view_component!
+  # Error classes for Solidstats specific exceptions
+  class Error < StandardError; end
+  class ComponentError < Error; end
+  class ServiceError < Error; end
 
-  # Auto-require core services that are commonly used
-  begin
-    require_relative "solidstats/gem_metadata/fetcher_service" if
-      File.exist?(File.join(__dir__, "solidstats/gem_metadata/fetcher_service.rb"))
-  rescue LoadError => e
-    Solidstats.logger.debug "[Solidstats] Could not auto-load services: #{e.message}"
+  # Load and initialize Solidstats in a Rails environment
+  def self.load!
+    nil unless defined?(Rails)
   end
 end
+
+# Load Solidstats automatically when Rails is loaded
+Solidstats.load! if defined?(Rails)

data/lib/tasks/solidstats.rake

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+namespace :solidstats do
+  desc "Install Solidstats in your Rails application"
+  task install: :environment do
+    puts "🚀 Running Solidstats installer..."
+    Rails::Generators.invoke("solidstats:install")
+  end
+
+  namespace :prime do
+    desc "Prime data for all Solidstats services"
+    task all: [
+      :log_size,
+      :bundler_audit,
+      :todos,
+      :style_patrol,
+      :coverage,
+      :load_lens
+    ] do
+      puts "✅ All Solidstats data has been primed."
+    end
+
+    desc "Prime data for LogSizeMonitorService"
+    task log_size: :environment do
+      puts "Priming data for Log Size Monitor..."
+      Solidstats::LogSizeMonitorService.scan_and_cache
+      puts "-> Log Size Monitor data primed."
+    end
+
+    desc "Prime data for BundlerAuditService"
+    task bundler_audit: :environment do
+      puts "Priming data for Bundler Audit..."
+      Solidstats::BundlerAuditService.scan_and_cache
+      puts "-> Bundler Audit data primed."
+    end
+
+    desc "Prime data for MyTodoService"
+    task todos: :environment do
+      puts "Priming data for My Todos..."
+      Solidstats::MyTodoService.collect_todos
+      puts "-> My Todos data primed."
+    end
+
+    desc "Prime data for StylePatrolService"
+    task style_patrol: :environment do
+      puts "Priming data for Style Patrol..."
+      Solidstats::StylePatrolService.refresh_cache
+      puts "-> Style Patrol data primed."
+    end
+
+    desc "Prime data for CoverageCompassService"
+    task coverage: :environment do
+      puts "Priming data for Coverage Compass..."
+      Solidstats::CoverageCompassService.refresh_cache
+      puts "-> Coverage Compass data primed."
+    end
+
+    desc "Prime data for LoadLensService"
+    task load_lens: :environment do
+      puts "Priming data for Load Lens..."
+      Solidstats::LoadLensService.scan_and_cache
+      puts "-> Load Lens data primed."
+    end
+  end
+end

data/lib/tasks/solidstats_performance.rake

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+namespace :solidstats do
+  namespace :load_lens do
+    desc "Parse development log and extract LoadLens performance metrics"
+    task parse_logs: :environment do
+      result = Solidstats::LoadLensService.parse_log_and_save
+
+      if result[:success]
+        puts "Successfully parsed #{result[:processed]} requests for LoadLens"
+      else
+        puts "Error parsing logs for LoadLens: #{result[:error]}"
+        exit 1
+      end
+    end
+
+    desc "Refresh LoadLens performance data cache"
+    task refresh: :environment do
+      puts "Refreshing LoadLens performance data..."
+      Solidstats::LoadLensService.refresh_data
+      puts "LoadLens performance data refreshed successfully!"
+    end
+
+    desc "Show LoadLens performance data summary"
+    task summary: :environment do
+      data = Solidstats::LoadLensService.get_performance_data
+      summary = data[:summary]
+
+      puts "\n=== LoadLens Performance Summary ==="
+      puts "Total Requests: #{summary[:total_requests]}"
+      puts "Average Response Time: #{summary[:avg_response_time]}ms"
+      puts "Average View Time: #{summary[:avg_view_time]}ms"
+      puts "Average DB Time: #{summary[:avg_db_time]}ms"
+      puts "Slow Requests (>1000ms): #{summary[:slow_requests]}"
+      puts "Error Rate: #{summary[:error_rate]}%"
+      puts "Status: #{summary[:status]}"
+      puts "Last Updated: #{summary[:last_updated]}"
+      puts "===================================="
+    end
+
+    desc "Clean old LoadLens performance data files"
+    task clean_old_data: :environment do
+      data_dir = Rails.root.join("tmp", "solidstats")
+      cutoff_date = 7.days.ago.to_date
+      deleted_count = 0
+
+      Dir.glob(data_dir.join("perf_*.json")).each do |file|
+        if match = File.basename(file).match(/perf_(\d{4}-\d{2}-\d{2})\.json/)
+          file_date = Date.parse(match[1])
+          if file_date < cutoff_date
+            File.delete(file)
+            deleted_count += 1
+            puts "Deleted #{File.basename(file)}"
+          end
+        end
+      end
+
+      puts "Cleaned #{deleted_count} old LoadLens performance data files"
+    end
+  end
+end

data/lib/tasks/solidstats_tasks.rake

@@ -1,4 +1,16 @@
-# desc "Explaining what the task does"
-# task :solidstats do
-#   # Task goes here
-# end
+require "fileutils"
+
+namespace :solidstats do
+  desc "Clean up all JSON files and caches generated by Solidstats"
+  task :clean do
+    solidstats_dir = Rails.root.join("solidstats")
+
+    if Dir.exist?(solidstats_dir)
+      puts "Removing Solidstats data directory: #{solidstats_dir}"
+      FileUtils.rm_rf(solidstats_dir)
+      puts "Solidstats data cleaned."
+    else
+      puts "Solidstats data directory not found, nothing to clean."
+    end
+  end
+end