rails_pulse 0.1.0

data/lib/rails_pulse/migration.rb

@@ -0,0 +1,29 @@
+module RailsPulse
+  # Determine the appropriate migration version based on Rails version
+  migration_version = case Rails.version
+  when /^8\./
+    8.0
+  when /^7\.2/
+    7.2
+  when /^7\.1/
+    7.1
+  when /^7\.0/
+    7.0
+  else
+    7.1 # Default fallback
+  end
+
+  class Migration < ActiveRecord::Migration[migration_version]
+    # This base migration class ensures that Rails Pulse migrations
+    # target the correct database when using multiple database configuration.
+    # The connection is determined by the connects_to configuration.
+
+    def connection
+      if RailsPulse.connects_to
+        RailsPulse::ApplicationRecord.connection
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rails_pulse/subscribers/operation_subscriber.rb

@@ -0,0 +1,280 @@
+module RailsPulse
+  module Subscribers
+    class OperationSubscriber
+      def self.subscribe!
+        # Helper method to clean SQL labels by removing Rails comments
+        def self.clean_sql_label(sql)
+          return sql unless sql
+          # Remove Rails SQL comments like /*action='search',application='Dummy',controller='home'*/
+          sql.gsub(/\/\*[^*]*\*\//, "").strip
+        end
+
+        # Helper method to convert absolute paths to relative paths
+        def self.relative_path(absolute_path)
+          return absolute_path unless absolute_path&.start_with?("/")
+
+          rails_root = Rails.root.to_s
+          if absolute_path.start_with?(rails_root)
+            absolute_path.sub(rails_root + "/", "")
+          else
+            absolute_path
+          end
+        end
+
+        # Helper method to find the first app frame in the call stack
+        def self.find_app_frame
+          app_path = Rails.root.join("app").to_s
+          caller_locations.each do |loc|
+            path = loc.absolute_path || loc.path
+            return path if path && path.start_with?(app_path)
+          end
+          nil
+        end
+
+        # Helper method to resolve controller action source location
+        def self.controller_action_source_location(payload)
+          return nil unless payload[:controller] && payload[:action]
+          begin
+            controller_klass = payload[:controller].constantize
+            if controller_klass.instance_methods(false).include?(payload[:action].to_sym)
+              file, line = controller_klass.instance_method(payload[:action]).source_location
+              return "#{relative_path(file)}:#{line}" if file && line
+            end
+            # fallback: try superclass (for ApplicationController actions)
+            if controller_klass.superclass.respond_to?(:instance_method)
+              if controller_klass.superclass.instance_methods(false).include?(payload[:action].to_sym)
+                file, line = controller_klass.superclass.instance_method(payload[:action]).source_location
+                return "#{relative_path(file)}:#{line}" if file && line
+              end
+            end
+          rescue => e
+            Rails.logger.debug "[RailsPulse] Could not resolve controller source location: #{e.class} - #{e.message}"
+          end
+          nil
+        end
+
+        # Helper method to capture operation data
+        def self.capture_operation(event_name, start, finish, payload, operation_type, label_key = nil)
+          return unless RailsPulse.configuration.enabled
+          return if RequestStore.store[:skip_recording_rails_pulse_activity]
+
+          request_id = RequestStore.store[:rails_pulse_request_id]
+          return unless request_id
+
+          # Skip RailsPulse-related operations to prevent recursion
+          if operation_type == "sql"
+            sql = payload[:sql]
+            return if sql&.include?("rails_pulse_")
+          end
+
+          label = case label_key
+          when :sql then clean_sql_label(payload[:sql])
+          when :template then relative_path(payload[:identifier] || payload[:template])
+          when :partial then relative_path(payload[:identifier] || payload[:partial])
+          when :controller then "#{payload[:controller]}##{payload[:action]}"
+          when :cache then payload[:key]
+          else payload[label_key] || event_name
+          end
+
+          codebase_location =
+            if payload[:identifier]
+              relative_path(payload[:identifier])
+            elsif payload[:template]
+              relative_path(payload[:template])
+            elsif operation_type == "controller"
+              controller_action_source_location(payload) || find_app_frame || caller_locations(3, 1).first&.path
+            elsif operation_type == "sql"
+              relative_path(find_app_frame || caller_locations(3, 1).first&.path)
+            else
+              find_app_frame || caller_locations(3, 1).first&.path
+            end
+
+          operation_data = {
+            request_id: request_id,
+            operation_type: operation_type,
+            label: label,
+            duration: (finish - start) * 1000,
+            codebase_location: codebase_location,
+            start_time: start.to_f,
+            occurred_at: Time.zone.at(start)
+          }
+
+          RequestStore.store[:rails_pulse_operations] ||= []
+          RequestStore.store[:rails_pulse_operations] << operation_data
+        end
+
+        # SQL queries
+        ActiveSupport::Notifications.subscribe "sql.active_record" do |name, start, finish, id, payload|
+          begin
+            next if payload[:name] == "SCHEMA"
+            capture_operation(name, start, finish, payload, "sql", :sql)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in SQL subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Controller action processing
+        ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "controller", :controller)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in controller subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Template rendering
+        ActiveSupport::Notifications.subscribe "render_template.action_view" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "template", :template)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in template subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Partial rendering
+        ActiveSupport::Notifications.subscribe "render_partial.action_view" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "partial", :partial)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in partial subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Layout rendering
+        ActiveSupport::Notifications.subscribe "render_layout.action_view" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "layout", :template)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in layout subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Cache operations
+        ActiveSupport::Notifications.subscribe "cache_read.active_support" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "cache_read", :cache)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in cache_read subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        ActiveSupport::Notifications.subscribe "cache_write.active_support" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "cache_write", :cache)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in cache_write subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # HTTP client requests (if using Net::HTTP)
+        ActiveSupport::Notifications.subscribe "request.net_http" do |name, start, finish, id, payload|
+          begin
+            next unless RailsPulse.configuration.enabled
+            label = "#{payload[:method]} #{payload[:uri]}"
+            codebase_location = find_app_frame || caller_locations(2, 1).first&.path
+            operation_data = {
+              request_id: RequestStore.store[:rails_pulse_request_id],
+              operation_type: "http",
+              label: label,
+              duration: (finish - start) * 1000,
+              codebase_location: codebase_location,
+              start_time: start.to_f,
+              occurred_at: Time.zone.at(start)
+            }
+
+            if operation_data[:request_id]
+              RequestStore.store[:rails_pulse_operations] ||= []
+              RequestStore.store[:rails_pulse_operations] << operation_data
+            end
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in HTTP subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Active Job processing
+        ActiveSupport::Notifications.subscribe "perform.active_job" do |name, start, finish, id, payload|
+          begin
+            next unless RailsPulse.configuration.enabled
+            label = "#{payload[:job].class.name}"
+            codebase_location = find_app_frame || caller_locations(2, 1).first&.path
+            operation_data = {
+              request_id: RequestStore.store[:rails_pulse_request_id],
+              operation_type: "job",
+              label: label,
+              duration: (finish - start) * 1000,
+              codebase_location: codebase_location,
+              start_time: start.to_f,
+              occurred_at: Time.zone.at(start)
+            }
+
+            if operation_data[:request_id]
+              RequestStore.store[:rails_pulse_operations] ||= []
+              RequestStore.store[:rails_pulse_operations] << operation_data
+            end
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in job subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Collection rendering (for rendering collections)
+        ActiveSupport::Notifications.subscribe "render_collection.action_view" do |name, start, finish, id, payload|
+          begin
+            capture_operation(name, start, finish, payload, "collection", :template)
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in collection subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Action Mailer
+        ActiveSupport::Notifications.subscribe "deliver.action_mailer" do |name, start, finish, id, payload|
+          begin
+            next unless RailsPulse.configuration.enabled
+            label = "#{payload[:mailer]}##{payload[:action]}"
+            codebase_location = find_app_frame || caller_locations(2, 1).first&.path
+            operation_data = {
+              request_id: RequestStore.store[:rails_pulse_request_id],
+              operation_type: "mailer",
+              label: label,
+              duration: (finish - start) * 1000,
+              codebase_location: codebase_location,
+              start_time: start.to_f,
+              occurred_at: Time.zone.at(start)
+            }
+
+            if operation_data[:request_id]
+              RequestStore.store[:rails_pulse_operations] ||= []
+              RequestStore.store[:rails_pulse_operations] << operation_data
+            end
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in mailer subscriber: #{e.class} - #{e.message}"
+          end
+        end
+
+        # Active Storage
+        ActiveSupport::Notifications.subscribe "service_upload.active_storage" do |name, start, finish, id, payload|
+          begin
+            next unless RailsPulse.configuration.enabled
+            label = "Upload: #{payload[:key]}"
+            codebase_location = find_app_frame || caller_locations(2, 1).first&.path
+            operation_data = {
+              request_id: RequestStore.store[:rails_pulse_request_id],
+              operation_type: "storage",
+              label: label,
+              duration: (finish - start) * 1000,
+              codebase_location: codebase_location,
+              start_time: start.to_f,
+              occurred_at: Time.zone.at(start)
+            }
+
+            if operation_data[:request_id]
+              RequestStore.store[:rails_pulse_operations] ||= []
+              RequestStore.store[:rails_pulse_operations] << operation_data
+            end
+          rescue => e
+            Rails.logger.error "[RailsPulse] Exception in storage subscriber: #{e.class} - #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/version.rb

@@ -0,0 +1,3 @@
+module RailsPulse
+  VERSION = "0.1.0"
+end

data/lib/rails_pulse.rb

@@ -0,0 +1,38 @@
+require "rails_pulse/version"
+require "rails_pulse/engine"
+require "rails_pulse/configuration"
+require "rails_pulse/cleanup_service"
+
+module RailsPulse
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    def clear_metric_cache!
+      Rails.cache.delete_matched("rails_pulse_metric*")
+    end
+
+    def warm_metric_cache!
+      # Pre-warm cache for common metrics
+      [ :average_response_times, :percentile_response_times, :request_count_totals, :error_rate_per_route ].each do |metric|
+        begin
+          Rails.logger.info "Warming cache for metric: #{metric}"
+          # This would trigger cache generation by making the request
+        rescue => e
+          Rails.logger.error "Failed to warm cache for #{metric}: #{e.message}"
+        end
+      end
+    end
+
+    def connects_to
+      configuration&.connects_to
+    end
+  end
+
+  # Ensure configuration is initialized
+  self.configuration ||= Configuration.new
+end

data/lib/tasks/rails_pulse_tasks.rake

@@ -0,0 +1,138 @@
+namespace :rails_pulse do
+  desc "Copies Rails Pulse migrations to the application."
+  task :install_migrations do
+    source_dir = File.expand_path("../../../db/migrate", __FILE__)
+    destination_dir = File.join(Rails.root, "db/migrate")
+
+    # Define the correct migration order
+    migration_order = [
+      "create_routes.rb",
+      "create_requests.rb",
+      "create_queries.rb",
+      "create_operations.rb"
+    ]
+
+    puts "Copying migrations..."
+    base_time = Time.now.utc
+
+    migration_order.each_with_index do |migration_name, index|
+      # Find the source migration file
+      source_file = Dir.glob(File.join(source_dir, "*#{migration_name}")).first
+      next unless source_file
+
+      # Generate new timestamp
+      timestamp = (base_time + index.seconds).strftime("%Y%m%d%H%M%S")
+      new_filename = "#{timestamp}_#{migration_name.gsub('.rb', '')}.rails_pulse.rb"
+      destination_file = File.join(destination_dir, new_filename)
+
+      # Check if any version of this migration already exists
+      existing_migration = Dir.glob(File.join(destination_dir, "*#{migration_name.gsub('.rb', '')}*")).first
+
+      if existing_migration
+        puts "Skipping existing migration: #{File.basename(existing_migration)}"
+      else
+        FileUtils.cp(source_file, destination_file)
+        puts "Copied migration: #{new_filename}"
+      end
+    end
+  end
+
+  desc "Copies Rails Pulse example configuration to the application."
+  task :install_config do
+    source_file = File.expand_path("../../../lib/generators/rails_pulse/templates/rails_pulse.rb", __FILE__)
+    destination_file = File.join(Rails.root, "config/initializers/rails_pulse.rb")
+
+    if File.exist?(destination_file)
+      puts "Config already exists at #{destination_file}, skipping."
+    else
+      FileUtils.cp(source_file, destination_file)
+      puts "Copied example config to #{destination_file}"
+    end
+  end
+
+  desc "Runs all install tasks for Rails Pulse (migrations and config)."
+  task install: [ :install_migrations, :install_config ]
+
+  desc "Performs data cleanup based on configured retention policies."
+  task cleanup: :environment do
+    puts "Starting Rails Pulse data cleanup..."
+
+    config = RailsPulse.configuration
+
+    unless config.archiving_enabled
+      puts "Cleanup is disabled (archiving_enabled = false). Exiting."
+      exit
+    end
+
+    stats = RailsPulse::CleanupService.perform
+
+    puts "Cleanup completed!"
+    puts "Records deleted:"
+    puts "  Time-based cleanup: #{stats[:time_based].values.sum}"
+    puts "  Count-based cleanup: #{stats[:count_based].values.sum}"
+    puts "  Total: #{stats[:total_deleted]}"
+
+    if stats[:total_deleted] > 0
+      puts "\nBreakdown by table:"
+      stats[:time_based].each do |table, count|
+        puts "  #{table} (time-based): #{count}" if count > 0
+      end
+      stats[:count_based].each do |table, count|
+        puts "  #{table} (count-based): #{count}" if count > 0
+      end
+    end
+  rescue => e
+    puts "Cleanup failed: #{e.message}"
+    puts e.backtrace.join("\n") if ENV["VERBOSE"]
+    exit 1
+  end
+
+  desc "Shows current table sizes and cleanup configuration."
+  task cleanup_stats: :environment do
+    config = RailsPulse.configuration
+
+    puts "Rails Pulse Cleanup Configuration:"
+    puts "  Cleanup enabled: #{config.archiving_enabled}"
+    puts "  Retention period: #{config.full_retention_period}"
+    puts "  Table limits: #{config.max_table_records}"
+    puts
+
+    puts "Current table sizes:"
+
+    tables = {
+      "rails_pulse_requests" => "RailsPulse::Request",
+      "rails_pulse_operations" => "RailsPulse::Operation",
+      "rails_pulse_routes" => "RailsPulse::Route",
+      "rails_pulse_queries" => "RailsPulse::Query"
+    }
+
+    tables.each do |table_name, model_name|
+      begin
+        model_class = model_name.constantize
+        count = model_class.count
+        limit = config.max_table_records[table_name.to_sym]
+        status = limit && count > limit ? " (OVER LIMIT)" : ""
+        puts "  #{table_name}: #{count} records#{status}"
+      rescue NameError
+        puts "  #{table_name}: Model not found"
+      rescue => e
+        puts "  #{table_name}: Error - #{e.message}"
+      end
+    end
+
+    if config.full_retention_period
+      cutoff_time = config.full_retention_period.ago
+      puts
+      puts "Records older than #{cutoff_time}:"
+
+      begin
+        old_requests = RailsPulse::Request.where("occurred_at < ?", cutoff_time).count
+        old_operations = RailsPulse::Operation.where("occurred_at < ?", cutoff_time).count
+        puts "  rails_pulse_requests: #{old_requests} old records"
+        puts "  rails_pulse_operations: #{old_operations} old records"
+      rescue => e
+        puts "  Error calculating old records: #{e.message}"
+      end
+    end
+  end
+end

data/public/rails-pulse-assets/csp-test.js

@@ -0,0 +1,110 @@
+// CSP Test JavaScript
+// This file tests that external JS files load correctly under strict CSP
+
+(function() {
+  'use strict';
+  
+  function updateStatus(elementId, status, success) {
+    const element = document.getElementById(elementId);
+    if (element) {
+      element.textContent = status;
+      element.className = success ? 'badge badge--success' : 'badge badge--error';
+    }
+  }
+  
+  function checkAssetLoading() {
+    // Check CSS loading
+    const cssLoaded = document.querySelector('link[href*="rails-pulse.css"]');
+    updateStatus('css-status', cssLoaded ? 'Loaded' : 'Failed', !!cssLoaded);
+    
+    // Check if main JS bundle exists (has Stimulus controllers)
+    const hasStimulus = window.Stimulus !== undefined;
+    updateStatus('js-status', hasStimulus ? 'Loaded' : 'Failed', hasStimulus);
+    
+    // Check icons bundle (should have icon definitions)
+    const hasIcons = document.querySelector('script[src*="rails-pulse-icons.js"]');
+    updateStatus('icons-status', hasIcons ? 'Loaded' : 'Failed', !!hasIcons);
+    
+    // Check Stimulus controllers are registered
+    const stimulusControllers = hasStimulus && window.Stimulus.router.modulesByIdentifier.size > 0;
+    updateStatus('stimulus-status', stimulusControllers ? 'Active' : 'Failed', stimulusControllers);
+  }
+  
+  function setupAjaxTest() {
+    const button = document.getElementById('ajax-test-btn');
+    const result = document.getElementById('ajax-result');
+    
+    if (button && result) {
+      button.addEventListener('click', async () => {
+        try {
+          button.disabled = true;
+          button.textContent = 'Loading...';
+          
+          // Test a simple fetch request
+          const response = await fetch('/rails_pulse/csp_test', {
+            headers: { 'Accept': 'application/json' }
+          });
+          
+          const data = await response.json();
+          
+          result.innerHTML = `
+            <div class="text-success">✓ AJAX request completed successfully</div>
+            <div class="text-subtle mt-1">Status: ${response.status} ${response.statusText}</div>
+            <div class="text-subtle mt-1">Response: ${data.message}</div>
+          `;
+        } catch (error) {
+          result.innerHTML = `
+            <div class="text-error">✗ AJAX request failed</div>
+            <div class="text-subtle mt-1">Error: ${error.message}</div>
+          `;
+        } finally {
+          button.disabled = false;
+          button.textContent = 'Test AJAX Loading';
+        }
+      });
+    }
+  }
+  
+  function trackCSPViolations() {
+    let violationCount = 0;
+    const countElement = document.getElementById('violation-count');
+    
+    // Listen for CSP violations
+    document.addEventListener('securitypolicyviolation', (event) => {
+      violationCount++;
+      if (countElement) {
+        countElement.textContent = violationCount;
+        countElement.className = violationCount > 0 ? 'badge badge--error' : 'badge badge--success';
+      }
+      console.warn('CSP Violation:', event.violatedDirective, event.blockedURI);
+    });
+    
+    // Initialize count display
+    if (countElement) {
+      countElement.textContent = '0';
+      countElement.className = 'badge badge--success';
+    }
+  }
+  
+  function initializeTests() {
+    checkAssetLoading();
+    setupAjaxTest();
+    trackCSPViolations();
+  }
+  
+  // Run tests when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initializeTests);
+  } else {
+    initializeTests();
+  }
+  
+  console.log('CSP Test JS loaded successfully - monitoring for violations');
+  
+  // Add a visible indicator for system tests
+  const indicator = document.createElement('div');
+  indicator.id = 'js-loaded-indicator';
+  indicator.textContent = 'CSP Test JS loaded successfully';
+  indicator.style.display = 'none'; // Hidden but accessible to tests
+  document.body.appendChild(indicator);
+})();