rails_pulse 0.1.0

data/lib/rails_pulse/cleanup_service.rb

@@ -0,0 +1,212 @@
+module RailsPulse
+  class CleanupService
+    def self.perform
+      new.perform
+    end
+
+    def initialize
+      @config = RailsPulse.configuration
+      @stats = {
+        time_based: {},
+        count_based: {},
+        total_deleted: 0
+      }
+    end
+
+    def perform
+      return unless cleanup_enabled?
+
+      Rails.logger.info "[RailsPulse] Starting data cleanup..."
+
+      perform_time_based_cleanup
+      perform_count_based_cleanup
+
+      log_cleanup_summary
+      @stats
+    end
+
+    private
+
+    def cleanup_enabled?
+      @config.archiving_enabled
+    end
+
+    def perform_time_based_cleanup
+      return unless @config.full_retention_period
+
+      cutoff_time = @config.full_retention_period.ago
+      Rails.logger.info "[RailsPulse] Time-based cleanup: removing records older than #{cutoff_time}"
+
+      # Clean up in order that respects foreign key constraints
+      @stats[:time_based][:operations] = cleanup_operations_by_time(cutoff_time)
+      @stats[:time_based][:requests] = cleanup_requests_by_time(cutoff_time)
+      @stats[:time_based][:queries] = cleanup_queries_by_time(cutoff_time)
+      @stats[:time_based][:routes] = cleanup_routes_by_time(cutoff_time)
+    end
+
+    def perform_count_based_cleanup
+      return unless @config.max_table_records&.any?
+
+      Rails.logger.info "[RailsPulse] Count-based cleanup: enforcing table record limits"
+
+      # Clean up in order that respects foreign key constraints
+      @stats[:count_based][:operations] = cleanup_operations_by_count
+      @stats[:count_based][:requests] = cleanup_requests_by_count
+      @stats[:count_based][:queries] = cleanup_queries_by_count
+      @stats[:count_based][:routes] = cleanup_routes_by_count
+    end
+
+    # Time-based cleanup methods
+    def cleanup_operations_by_time(cutoff_time)
+      return 0 unless defined?(RailsPulse::Operation)
+
+      count = RailsPulse::Operation.where("occurred_at < ?", cutoff_time).count
+      RailsPulse::Operation.where("occurred_at < ?", cutoff_time).delete_all
+      count
+    end
+
+    def cleanup_requests_by_time(cutoff_time)
+      return 0 unless defined?(RailsPulse::Request)
+
+      count = RailsPulse::Request.where("occurred_at < ?", cutoff_time).count
+      RailsPulse::Request.where("occurred_at < ?", cutoff_time).delete_all
+      count
+    end
+
+    def cleanup_queries_by_time(cutoff_time)
+      return 0 unless defined?(RailsPulse::Query)
+
+      # Only delete queries that have no associated operations
+      query_ids_with_operations = RailsPulse::Operation.distinct.pluck(:query_id).compact
+      count = RailsPulse::Query
+        .where("created_at < ?", cutoff_time)
+        .where.not(id: query_ids_with_operations)
+        .count
+      RailsPulse::Query
+        .where("created_at < ?", cutoff_time)
+        .where.not(id: query_ids_with_operations)
+        .delete_all
+      count
+    end
+
+    def cleanup_routes_by_time(cutoff_time)
+      return 0 unless defined?(RailsPulse::Route)
+
+      # Only delete routes that have no associated requests
+      route_ids_with_requests = RailsPulse::Request.distinct.pluck(:route_id).compact
+      count = RailsPulse::Route
+        .where("created_at < ?", cutoff_time)
+        .where.not(id: route_ids_with_requests)
+        .count
+      RailsPulse::Route
+        .where("created_at < ?", cutoff_time)
+        .where.not(id: route_ids_with_requests)
+        .delete_all
+      count
+    end
+
+    # Count-based cleanup methods
+    def cleanup_operations_by_count
+      return 0 unless defined?(RailsPulse::Operation)
+
+      max_records = @config.max_table_records[:rails_pulse_operations]
+      return 0 unless max_records
+
+      current_count = RailsPulse::Operation.count
+      return 0 if current_count <= max_records
+
+      records_to_delete = current_count - max_records
+      ids_to_delete = RailsPulse::Operation
+        .order(:occurred_at)
+        .limit(records_to_delete)
+        .pluck(:id)
+
+      RailsPulse::Operation.where(id: ids_to_delete).delete_all
+      records_to_delete
+    end
+
+    def cleanup_requests_by_count
+      return 0 unless defined?(RailsPulse::Request)
+
+      max_records = @config.max_table_records[:rails_pulse_requests]
+      return 0 unless max_records
+
+      current_count = RailsPulse::Request.count
+      return 0 if current_count <= max_records
+
+      records_to_delete = current_count - max_records
+      ids_to_delete = RailsPulse::Request
+        .order(:occurred_at)
+        .limit(records_to_delete)
+        .pluck(:id)
+
+      RailsPulse::Request.where(id: ids_to_delete).delete_all
+      records_to_delete
+    end
+
+    def cleanup_queries_by_count
+      return 0 unless defined?(RailsPulse::Query)
+
+      max_records = @config.max_table_records[:rails_pulse_queries]
+      return 0 unless max_records
+
+      # Only consider queries that have no associated operations
+      query_ids_with_operations = RailsPulse::Operation.distinct.pluck(:query_id).compact
+      available_queries = RailsPulse::Query.where.not(id: query_ids_with_operations)
+      current_count = available_queries.count
+      return 0 if current_count <= max_records
+
+      records_to_delete = current_count - max_records
+      ids_to_delete = available_queries
+        .order(:created_at)
+        .limit(records_to_delete)
+        .pluck(:id)
+
+      RailsPulse::Query.where(id: ids_to_delete).delete_all
+      records_to_delete
+    end
+
+    def cleanup_routes_by_count
+      return 0 unless defined?(RailsPulse::Route)
+
+      max_records = @config.max_table_records[:rails_pulse_routes]
+      return 0 unless max_records
+
+      # Only consider routes that have no associated requests
+      route_ids_with_requests = RailsPulse::Request.distinct.pluck(:route_id).compact
+      available_routes = RailsPulse::Route.where.not(id: route_ids_with_requests)
+      current_count = available_routes.count
+      return 0 if current_count <= max_records
+
+      records_to_delete = current_count - max_records
+      ids_to_delete = available_routes
+        .order(:created_at)
+        .limit(records_to_delete)
+        .pluck(:id)
+
+      RailsPulse::Route.where(id: ids_to_delete).delete_all
+      records_to_delete
+    end
+
+    def log_cleanup_summary
+      total_time_based = @stats[:time_based].values.sum
+      total_count_based = @stats[:count_based].values.sum
+      @stats[:total_deleted] = total_time_based + total_count_based
+
+      Rails.logger.info "[RailsPulse] Cleanup completed:"
+      Rails.logger.info "  Time-based: #{total_time_based} records deleted"
+      Rails.logger.info "  Count-based: #{total_count_based} records deleted"
+      Rails.logger.info "  Total: #{@stats[:total_deleted]} records deleted"
+
+      if @stats[:total_deleted] > 0
+        Rails.logger.info "  Breakdown:"
+        @stats[:time_based].each do |table, count|
+          Rails.logger.info "    #{table} (time): #{count}" if count > 0
+        end
+        @stats[:count_based].each do |table, count|
+          Rails.logger.info "    #{table} (count): #{count}" if count > 0
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/configuration.rb

@@ -0,0 +1,176 @@
+module RailsPulse
+  class Configuration
+    attr_accessor :enabled,
+                  :route_thresholds,
+                  :request_thresholds,
+                  :query_thresholds,
+                  :ignored_routes,
+                  :ignored_requests,
+                  :ignored_queries,
+                  :track_assets,
+                  :custom_asset_patterns,
+                  :mount_path,
+                  :full_retention_period,
+                  :archiving_enabled,
+                  :max_table_records,
+                  :component_cache_enabled,
+                  :component_cache_duration,
+                  :connects_to,
+                  :authentication_enabled,
+                  :authentication_method,
+                  :authentication_redirect_path
+
+    def initialize
+      @enabled = true
+      @route_thresholds = { slow: 500, very_slow: 1500, critical: 3000 }
+      @request_thresholds = { slow: 700, very_slow: 2000, critical: 4000 }
+      @query_thresholds = { slow: 100, very_slow: 500, critical: 1000 }
+      @ignored_routes = []
+      @ignored_requests = []
+      @ignored_queries = []
+      @track_assets = false
+      @custom_asset_patterns = []
+      @mount_path = nil
+      @full_retention_period = 2.weeks
+      @archiving_enabled = true
+      @max_table_records = {
+        rails_pulse_requests: 10000,
+        rails_pulse_operations: 50000,
+        rails_pulse_routes: 1000,
+        rails_pulse_queries: 500
+      }
+      @component_cache_enabled = true
+      @component_cache_duration = 1.hour
+      @connects_to = nil
+      @authentication_enabled = Rails.env.production?
+      @authentication_method = nil
+      @authentication_redirect_path = "/"
+
+      validate_configuration!
+    end
+
+    # Get all routes to ignore, including asset patterns if track_assets is false
+    def ignored_routes
+      routes = @ignored_routes.dup
+
+      unless @track_assets
+        routes.concat(default_asset_patterns)
+        routes.concat(@custom_asset_patterns)
+      end
+
+      routes
+    end
+
+    # Validate configuration settings
+    def validate_configuration!
+      validate_thresholds!
+      validate_retention_settings!
+      validate_patterns!
+      validate_cache_settings!
+      validate_database_settings!
+      validate_authentication_settings!
+    end
+
+    # Revalidate configuration after changes
+    def revalidate!
+      validate_configuration!
+    end
+
+    private
+
+    def validate_thresholds!
+      [ @route_thresholds, @request_thresholds, @query_thresholds ].each do |thresholds|
+        thresholds.each do |key, value|
+          unless value.is_a?(Numeric) && value > 0
+            raise ArgumentError, "Threshold #{key} must be a positive number, got #{value}"
+          end
+        end
+      end
+    end
+
+    def validate_retention_settings!
+      unless @full_retention_period.respond_to?(:seconds)
+        raise ArgumentError, "full_retention_period must be a time duration (e.g., 2.weeks), got #{@full_retention_period}"
+      end
+
+      @max_table_records.each do |table, count|
+        unless count.is_a?(Integer) && count > 0
+          raise ArgumentError, "max_table_records[#{table}] must be a positive integer, got #{count}"
+        end
+      end
+    end
+
+    def validate_patterns!
+      [ @ignored_routes, @ignored_requests, @ignored_queries, @custom_asset_patterns ].each do |patterns|
+        patterns.each do |pattern|
+          unless pattern.is_a?(String) || pattern.is_a?(Regexp)
+            raise ArgumentError, "Ignored patterns must be strings or regular expressions, got #{pattern.class}"
+          end
+
+          # Test regex patterns to ensure they're valid
+          if pattern.is_a?(Regexp)
+            begin
+              "test" =~ pattern
+            rescue RegexpError => e
+              raise ArgumentError, "Invalid regular expression pattern: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+
+    def validate_cache_settings!
+      unless @component_cache_duration.respond_to?(:seconds)
+        raise ArgumentError, "component_cache_duration must be a time duration (e.g., 1.hour), got #{@component_cache_duration}"
+      end
+    end
+
+    def validate_database_settings!
+      if @connects_to && !@connects_to.is_a?(Hash)
+        raise ArgumentError, "connects_to must be a hash with database connection configuration"
+      end
+    end
+
+    def validate_authentication_settings!
+      if @authentication_enabled && @authentication_method.nil?
+        Rails.logger.warn "RailsPulse: Authentication is enabled but no authentication method is configured. This will deny all access."
+      end
+
+      if @authentication_method && ![ Proc, Symbol, String, NilClass ].include?(@authentication_method.class)
+        raise ArgumentError, "authentication_method must be a Proc, Symbol, String, or nil, got #{@authentication_method.class}"
+      end
+    end
+
+    # Default patterns for common asset types and paths
+    def default_asset_patterns
+      [
+        # Asset file extensions
+        %r{\.(png|jpg|jpeg|gif|svg|css|js|ico|woff|woff2|ttf|eot|map)$}i,
+
+        # Common Rails asset paths
+        %r{^/assets/},
+        %r{^/packs/},
+        %r{^/.*?/assets/},  # Catches /connect/assets/, /admin/assets/, etc.
+
+        # Webpack dev server
+        %r{^/__webpack_hmr},
+        %r{^/sockjs-node/},
+
+        # Common health check endpoints
+        "/health",
+        "/health_check",
+        "/status",
+        "/ping",
+
+        # Favicon requests
+        "/favicon.ico",
+        "/apple-touch-icon.png",
+        "/apple-touch-icon-precomposed.png",
+
+        # Robots and sitemaps
+        "/robots.txt",
+        "/sitemap.xml"
+      ]
+    end
+  end
+end

data/lib/rails_pulse/engine.rb

@@ -0,0 +1,88 @@
+require "rails_pulse/version"
+require "rails_pulse/migration"
+require "rails_pulse/middleware/request_collector"
+require "rails_pulse/middleware/asset_server"
+require "rails_pulse/subscribers/operation_subscriber"
+require "request_store"
+require "rack/static"
+require "rails_charts"
+require "ransack"
+require "pagy"
+require "turbo-rails"
+require "groupdate"
+
+module RailsPulse
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsPulse
+
+    # Load Rake tasks
+    rake_tasks do
+      Dir.glob(File.expand_path("../tasks/**/*.rake", __FILE__)).each { |file| load file }
+    end
+
+    # Register the install generator
+    generators do
+      require "generators/rails_pulse/install_generator"
+    end
+
+    initializer "rails_pulse.static_assets", before: "sprockets.environment" do |app|
+      # Configure Rack::Static middleware to serve pre-compiled assets
+      assets_path = Engine.root.join("public")
+
+      # Add custom middleware for serving Rails Pulse assets with proper headers
+      # Insert after Rack::Runtime but before ActionDispatch::Static for better compatibility
+      app.middleware.insert_after Rack::Runtime, RailsPulse::Middleware::AssetServer,
+        assets_path.to_s,
+        {
+          urls: [ "/rails-pulse-assets" ],
+          headers: Engine.asset_headers
+        }
+    end
+
+    initializer "rails_pulse.middleware" do |app|
+      app.middleware.use RailsPulse::Middleware::RequestCollector
+    end
+
+    initializer "rails_pulse.operation_notifications" do
+      RailsPulse::Subscribers::OperationSubscriber.subscribe!
+    end
+
+    initializer "rails_pulse.rails_charts_theme" do
+      RailsCharts.options[:theme] = "railspulse"
+    end
+
+    initializer "rails_pulse.ransack", after: "ransack.initialize" do
+      # Ensure Ransack is loaded before our models
+    end
+
+    initializer "rails_pulse.database_configuration", before: "active_record.initialize_timezone" do
+      # Ensure database configuration is applied early in the initialization process
+      # This allows models to properly connect to configured databases
+    end
+
+    initializer "rails_pulse.timezone" do
+      # Configure Rails Pulse to always use UTC for consistent time operations
+      # This prevents Groupdate timezone mismatch errors across different host applications
+      # Note: We don't set Time.zone_default as it would affect the entire application
+      # Instead, we explicitly use time_zone: "UTC" in all groupdate calls
+    end
+
+    # CSP helper methods
+    def self.csp_sources
+      {
+        script_src: [ "'self'", "'nonce-'" ],
+        style_src: [ "'self'", "'nonce-'" ],
+        img_src: [ "'self'", "data:" ]
+      }
+    end
+
+    private
+
+    def self.asset_headers
+      {
+        "Cache-Control" => "public, max-age=31536000, immutable",
+        "Vary" => "Accept-Encoding"
+      }
+    end
+  end
+end

data/lib/rails_pulse/middleware/asset_server.rb

@@ -0,0 +1,84 @@
+require "rack/static"
+
+module RailsPulse
+  module Middleware
+    class AssetServer < Rack::Static
+      MIME_TYPES = {
+        ".css" => "text/css",
+        ".js" => "application/javascript",
+        ".map" => "application/json",
+        ".svg" => "image/svg+xml"
+      }.freeze
+
+      def initialize(app, root, options = {})
+        @logger = Rails.logger if defined?(Rails)
+        # Rack::Static expects (app, options) where options[:root] is the root path
+        options = options.merge(root: root) if root.is_a?(String) || root.is_a?(Pathname)
+        super(app, options)
+      end
+
+      def call(env)
+        # Only handle requests for Rails Pulse assets
+        unless rails_pulse_asset_request?(env)
+          return @app.call(env)
+        end
+
+        # Log asset requests for debugging
+        @logger&.debug "[Rails Pulse] Asset request: #{env['PATH_INFO']}"
+
+        # Set proper MIME type based on file extension
+        set_content_type(env)
+
+        # Call parent Rack::Static with error handling
+        begin
+          status, headers, body = super(env)
+
+          # Add immutable cache headers for successful responses
+          if status == 200
+            headers.merge!(cache_headers)
+            @logger&.debug "[Rails Pulse] Asset served successfully: #{env['PATH_INFO']}"
+          elsif status == 404
+            log_missing_asset(env["PATH_INFO"]) if @logger
+          end
+
+          [ status, headers, body ]
+        rescue => e
+          log_asset_error(env["PATH_INFO"], e) if @logger
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def rails_pulse_asset_request?(env)
+        env["PATH_INFO"]&.start_with?("/rails-pulse-assets/")
+      end
+
+      def set_content_type(env)
+        path = env["PATH_INFO"]
+        extension = File.extname(path)
+
+        if MIME_TYPES.key?(extension)
+          env["rails_pulse.content_type"] = MIME_TYPES[extension]
+        end
+      end
+
+      def cache_headers
+        {
+          "Cache-Control" => "public, max-age=31536000, immutable",
+          "Vary" => "Accept-Encoding",
+          "Expires" => (Time.now + 1.year).httpdate
+        }
+      end
+
+      def log_missing_asset(path)
+        @logger.warn "[Rails Pulse] Asset not found: #{path}"
+      end
+
+      def log_asset_error(path, error)
+        @logger.error "[Rails Pulse] Error serving asset #{path}: #{error.message}"
+        @logger.error error.backtrace.join("\n") if @logger.debug?
+      end
+    end
+  end
+end

data/lib/rails_pulse/middleware/request_collector.rb

@@ -0,0 +1,120 @@
+module RailsPulse
+  module Middleware
+    class RequestCollector
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # Skip if Rails Pulse is disabled
+        return @app.call(env) unless RailsPulse.configuration.enabled
+
+        # Skip logging if we are already recording RailsPulse activity. This is to avoid recursion issues
+        return @app.call(env) if RequestStore.store[:skip_recording_rails_pulse_activity]
+
+        req = ActionDispatch::Request.new(env)
+
+        # Skip RailsPulse engine requests
+        mount_path = RailsPulse.configuration.mount_path || "/rails_pulse"
+        if req.path.start_with?(mount_path)
+          RequestStore.store[:skip_recording_rails_pulse_activity] = true
+          result = @app.call(env)
+          RequestStore.store[:skip_recording_rails_pulse_activity] = false
+          return result
+        end
+
+        # Check if route should be ignored based on configuration
+        if should_ignore_route?(req)
+          RequestStore.store[:skip_recording_rails_pulse_activity] = true
+          result = @app.call(env)
+          RequestStore.store[:skip_recording_rails_pulse_activity] = false
+          return result
+        end
+
+        # Clear any previous request ID to avoid conflicts
+        RequestStore.store[:rails_pulse_request_id] = nil
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # Temporarily skip recording while we create the route and request
+        RequestStore.store[:skip_recording_rails_pulse_activity] = true
+        route = find_or_create_route(req)
+        controller_action = "#{env['action_dispatch.request.parameters']&.[]('controller')&.classify}##{env['action_dispatch.request.parameters']&.[]('action')}"
+        occurred_at = Time.current
+
+        request = nil
+        if route
+          request = RailsPulse::Request.create!(
+            route: route,
+            duration: 0, # will update after response
+            status: 0, # will update after response
+            is_error: false,
+            request_uuid: req.uuid,
+            controller_action: controller_action,
+            occurred_at: occurred_at
+          )
+          RequestStore.store[:rails_pulse_request_id] = request.id
+        end
+
+        # Re-enable recording for the actual request processing
+        RequestStore.store[:skip_recording_rails_pulse_activity] = false
+
+        status, headers, response = @app.call(env)
+        duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+        # Temporarily skip recording while we update the request and save operations
+        RequestStore.store[:skip_recording_rails_pulse_activity] = true
+        if request
+          request.update(duration: duration, status: status, is_error: status.to_i >= 500)
+
+          # Save collected operations
+          operations_data = RequestStore.store[:rails_pulse_operations] || []
+          operations_data.each do |operation_data|
+            begin
+              RailsPulse::Operation.create!(operation_data)
+            rescue => e
+              Rails.logger.error "[RailsPulse] Failed to save operation: #{e.message}"
+            end
+          end
+        end
+
+        [ status, headers, response ]
+      ensure
+        RequestStore.store[:skip_recording_rails_pulse_activity] = false
+        RequestStore.store[:rails_pulse_request_id] = nil
+        RequestStore.store[:rails_pulse_operations] = nil
+      end
+
+      private
+
+      def find_or_create_route(req)
+        method = req.request_method
+        path = req.path
+        RailsPulse::Route.find_or_create_by(method: method, path: path)
+      end
+
+      def should_ignore_route?(req)
+        # Get ignored routes from configuration
+        ignored_routes = RailsPulse.configuration.ignored_routes || []
+
+        # Create route identifier for matching
+        route_method_path = "#{req.request_method} #{req.path}"
+        route_path = req.path
+
+        # Check each ignored route pattern
+        ignored_routes.any? do |pattern|
+          case pattern
+          when String
+            # Exact string match against path or method+path
+            pattern == route_path || pattern == route_method_path
+          when Regexp
+            # Regex match against path or method+path
+            pattern.match?(route_path) || pattern.match?(route_method_path)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end