solidstats 2.0.0 → 3.0.0.beta.1

data/lib/solidstats/engine.rb

@@ -1,127 +1,22 @@
-# frozen_string_literal: true
-
-require "rails/engine" if defined?(Rails)
-
 module Solidstats
   class Engine < ::Rails::Engine
-    isolate_namespace Solidstats if defined?(Rails)
-
-    # Engine configuration
-    config.solidstats = ActiveSupport::OrderedOptions.new
-
-    # Set default configuration values
-    config.before_configuration do
-      config.solidstats.cache_duration = 1.hour
-      config.solidstats.enable_components = true
-      config.solidstats.log_level = :info
-      config.solidstats.enable_previews = Rails.env.development?
-    end
+    isolate_namespace Solidstats
 
-    # Ensure gem only runs in development environment
-    initializer "solidstats.environment_check", before: :load_config_initializers do
+    initializer "solidstats.only_in_dev" do
       unless Rails.env.development?
-        raise Solidstats::ConfigurationError,
-              "Solidstats can only be used in development mode. Current environment: #{Rails.env}"
-      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}"
+        raise "Solidstats can only be used in development mode."
       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"
+    initializer "solidstats.assets.precompile" do |app|
+      if Rails.env.development?
+        app.config.assets.precompile += %w[ solidstats/application.css ]
       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")
-
-      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
-    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
-
-    # Logging helpers with consistent formatting
-    def log_info(message)
-      Rails.logger&.info("[Solidstats] #{message}")
-    end
-
-    def log_error(message)
-      Rails.logger&.error("[Solidstats] #{message}")
-    end
-
-    def log_debug(message)
-      Rails.logger&.debug("[Solidstats] #{message}")
+    # Load the solidstats rake tasks
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__), "../tasks/**/*.rake")].each { |f| load f }
     end
   end
 end

data/lib/solidstats/version.rb

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

data/lib/solidstats.rb

@@ -1,28 +1,12 @@
-# frozen_string_literal: true
-
 require "solidstats/version"
 require "solidstats/engine"
-require "solidstats/asset_compatibility"
-require "solidstats/asset_manifest"
 
 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
+    # @return [String] Gem root path
     def root
-      @root ||= Pathname.new(File.dirname(__dir__))
+      File.dirname(__dir__)
     end
 
     # Returns version string
@@ -30,286 +14,5 @@ module Solidstats
     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
-
-      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
-  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
-  end
-end
-
-# Auto-require common dependencies if in Rails environment
-if defined?(Rails) && Rails.env.development?
-  # Ensure ViewComponent is available
-  Solidstats.ensure_view_component!
-
-  # 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}"
   end
 end

data/lib/tasks/solidstats_install.rake

@@ -1,19 +1,8 @@
 
-# frozen_string_literal: true
-
 namespace :solidstats do
-  desc "Install Solidstats in the current Rails application"
+  desc "Install Solidstats into your Rails application"
   task :install do
-    puts "🚀 Installing Solidstats..."
-
-    # Check Rails environment
-    unless Rails.env.development?
-      puts "⚠️  Warning: Solidstats is designed for development environments."
-      puts "Current environment: #{Rails.env}"
-    end
-
-    # Run the generator
-    if system("rails generate solidstats:install")
+    if system "rails g solidstats:install"
       puts "\n✅ Solidstats installation completed successfully!"
       puts "   Start your Rails server and visit http://localhost:3000/solidstats\n\n"
     else
@@ -21,113 +10,4 @@ namespace :solidstats do
       puts "   bundle exec rails generate solidstats:install\n\n"
     end
   end
-
-  desc "Validate Solidstats installation and configuration"
-  task validate: :environment do
-    puts "🔍 Validating Solidstats installation..."
-
-    begin
-      # Check basic configuration
-      Solidstats.configuration
-      puts "✅ Configuration loaded"
-
-      # Check ViewComponent availability
-      if Solidstats.view_component_available?
-        version = defined?(ViewComponent::VERSION) ? ViewComponent::VERSION : "unknown"
-        puts "✅ ViewComponent available (#{version})"
-      else
-        puts "❌ ViewComponent not available"
-      end
-
-      # Check asset strategy
-      strategy = Solidstats.asset_strategy
-      puts "✅ Asset strategy: #{strategy}"
-
-      # Validate asset manifest
-      Solidstats::AssetManifest.validate_assets!
-      puts "✅ All required assets present"
-
-      # Check routes
-      if Rails.application.routes.routes.any? { |r| r.path.spec.to_s.include?("solidstats") }
-        puts "✅ Routes mounted"
-      else
-        puts "⚠️  Routes not mounted - add 'mount Solidstats::Engine => \"/solidstats\"' to config/routes.rb"
-      end
-
-      puts "\n🎉 Solidstats validation complete!"
-
-    rescue => e
-      puts "❌ Validation failed: #{e.message}"
-      exit 1
-    end
-  end
-
-  desc "Show asset configuration information"
-  task assets: :environment do
-    puts "📦 Solidstats Asset Configuration"
-    puts "=" * 40
-
-    puts "Asset Strategy: #{Solidstats.asset_strategy}"
-    puts "Fingerprinting: #{Solidstats.asset_fingerprinting?}"
-    puts "Asset Prefix: #{Solidstats.asset_prefix}"
-
-    puts "\nPrecompiled Assets:"
-    Solidstats::AssetManifest.assets_for_environment.each do |asset|
-      puts "  • #{asset}"
-    end
-
-    if Rails.application.config.respond_to?(:assets)
-      puts "\nAsset Paths:"
-      Rails.application.config.assets.paths.select { |p| p.include?("solidstats") }.each do |path|
-        puts "  • #{path}"
-      end
-    end
-  end
-
-  desc "Test asset compilation"
-  task compile_assets: :environment do
-    puts "🔧 Testing asset compilation..."
-
-    begin
-      test_assets = [ "solidstats/application.css", "solidstats/application.js" ]
-
-      if Rails.application.config.respond_to?(:assets)
-        manifest = Rails.application.assets
-
-        # Check if we're using Propshaft (Rails 7+) or Sprockets
-        if manifest.respond_to?(:find_asset)
-          # Sprockets
-          test_assets.each do |asset|
-            if manifest.find_asset(asset)
-              puts "✅ #{asset} - found and compilable (Sprockets)"
-            else
-              puts "❌ #{asset} - not found (Sprockets)"
-            end
-          end
-        elsif manifest.respond_to?(:load_path) && manifest.load_path.respond_to?(:find)
-          # Propshaft
-          test_assets.each do |asset|
-            if manifest.load_path.find(asset)
-              puts "✅ #{asset} - found and compilable (Propshaft)"
-            else
-              puts "❌ #{asset} - not found (Propshaft)"
-            end
-          end
-        else
-          # Unknown asset pipeline
-          puts "⚠️  Unknown asset pipeline type: #{manifest.class}"
-          puts "Available methods: #{manifest.methods.grep(/find/).join(', ')}"
-        end
-      else
-        puts "⚠️  No asset pipeline detected"
-      end
-
-      puts "✅ Asset compilation test complete"
-
-    rescue => e
-      puts "❌ Asset compilation failed: #{e.message}"
-      puts "Asset pipeline class: #{Rails.application.assets.class}" if Rails.application.respond_to?(:assets)
-      exit 1
-    end
-  end
 end

data/lib/tasks/solidstats_performance.rake

@@ -0,0 +1,84 @@
+# 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
+  
+  # Keep performance namespace for backward compatibility
+  namespace :performance do
+    desc "Parse development log and extract performance metrics (alias for load_lens:parse_logs)"
+    task parse_logs: :environment do
+      Rake::Task["solidstats:load_lens:parse_logs"].invoke
+    end
+
+    desc "Refresh performance data cache (alias for load_lens:refresh)"
+    task refresh: :environment do
+      Rake::Task["solidstats:load_lens:refresh"].invoke
+    end
+
+    desc "Show performance data summary (alias for load_lens:summary)"
+    task summary: :environment do
+      Rake::Task["solidstats:load_lens:summary"].invoke
+    end
+
+    desc "Clean old performance data files (alias for load_lens:clean_old_data)"
+    task clean_old_data: :environment do
+      Rake::Task["solidstats:load_lens:clean_old_data"].invoke
+    end
+  end
+end