rails_pulse 0.1.2 → 0.1.4

data/app/views/rails_pulse/routes/index.html.erb

@@ -10,64 +10,61 @@
 <% end %>
 
 <div
-  class="row"
   data-controller="rails-pulse--index"
   data-rails-pulse--index-chart-id-value="average_response_times_chart"
 >
-  <div class="grid-item">
-    <%= render 'rails_pulse/components/panel', { title: 'Average Response Time', } do %>
-      <%= search_form_for @ransack_query, url: routes_path, class: "flex items-center justify-between gap mb-4" do |form| %>
-        <div class="flex items-center grow gap">
-          <%= form.search_field :route_path_cont, placeholder: "Filter by route", autocomplete: "off", class: "input", style: "max-inline-size: 250px" %>
-          <%= form.select :period_start_range,
-            RailsPulse::RoutesController::TIME_RANGE_OPTIONS,
-            { selected: @selected_time_range },
-            { class: "input" }
-          %>
-          <%= form.select :avg_duration,
-            duration_options(:route),
-            { selected: @selected_response_range },
-            { class: "input" }
-          %>
-          <%= link_to "Reset", routes_path, class: "btn btn--borderless show@md" if params.has_key?(:q) %>
-          <%= form.submit "Search", class: "btn show@sm" %>
+  <%= render 'rails_pulse/components/panel', { title: 'Average Response Time', card_classes: 'b-full' } do %>
+    <%= search_form_for @ransack_query, url: routes_path, class: "flex items-center justify-between gap mb-4" do |form| %>
+      <div class="flex items-center grow gap">
+        <%= form.search_field :route_path_cont, placeholder: "Filter by route", autocomplete: "off", class: "input", style: "max-inline-size: 250px" %>
+        <%= form.select :period_start_range,
+          RailsPulse::RoutesController::TIME_RANGE_OPTIONS,
+          { selected: @selected_time_range },
+          { class: "input" }
+        %>
+        <%= form.select :avg_duration,
+          duration_options(:route),
+          { selected: @selected_response_range },
+          { class: "input" }
+        %>
+        <%= link_to "Reset", routes_path, class: "btn btn--borderless show@md" if params.has_key?(:q) %>
+        <%= form.submit "Search", class: "btn show@sm" %>
+      </div>
+    <% end %>
+
+    <% if @has_data %>
+      <% if @chart_data && @chart_data.values.any? { |v| v > 0 } %>
+        <div
+          class="chart-container chart-container--slim"
+          data-rails-pulse--index-target="chart"
+        >
+          <%= bar_chart(
+            @chart_data,
+            code: false,
+            id: "average_response_times_chart",
+            height: "100%",
+            options: bar_chart_options(
+              units: "ms",
+              zoom: true,
+              chart_start: 0,
+              chart_end: @chart_data.length - 1,
+              xaxis_formatter: @xaxis_formatter,
+              tooltip_formatter: @tooltip_formatter,
+              zoom_start: @zoom_start,
+              zoom_end: @zoom_end,
+              chart_data: @chart_data
+            )
+          ) %>
         </div>
       <% end %>
 
-      <% if @has_data %>
-        <% if @chart_data && @chart_data.values.any? { |v| v > 0 } %>
-          <div
-            class="chart-container chart-container--slim"
-            data-rails-pulse--index-target="chart"
-          >
-            <%= bar_chart(
-              @chart_data,
-              code: false,
-              id: "average_response_times_chart",
-              height: "100%",
-              options: bar_chart_options(
-                units: "ms",
-                zoom: true,
-                chart_start: 0,
-                chart_end: @chart_data.length - 1,
-                xaxis_formatter: @xaxis_formatter,
-                tooltip_formatter: @tooltip_formatter,
-                zoom_start: @zoom_start,
-                zoom_end: @zoom_end,
-                chart_data: @chart_data
-              )
-            ) %>
-          </div>
-        <% end %>
-
-        <%= turbo_frame_tag :routes_index_table, data: { rails_pulse__index_target: "indexTable" } do %>
-          <%= render 'rails_pulse/routes/table' %>
-        <% end %>
-      <% else %>
-        <%= render 'rails_pulse/components/empty_state', 
-            title: 'No route data found for the selected filters.', 
-            description: 'Try adjusting your time range or filters to see results.' %>
+      <%= turbo_frame_tag :index_table, data: { rails_pulse__index_target: "indexTable" } do %>
+        <%= render 'rails_pulse/routes/table' %>
       <% end %>
+    <% else %>
+      <%= render 'rails_pulse/components/empty_state',
+          title: 'No route data found for the selected filters.',
+          description: 'Try adjusting your time range or filters to see results.' %>
     <% end %>
-  </div>
+  <% end %>
 </div>

data/app/views/rails_pulse/routes/show.html.erb

@@ -1,7 +1,5 @@
 <%= render 'rails_pulse/components/breadcrumbs' %>
 
-<h1 class="text-2xl mbe-2"><%= @route.path_and_method %></h1>
-
 <% unless turbo_frame_request? %>
   <div class="row">
     <%= render 'rails_pulse/components/metric_card', { class: "grid-item block", data: @average_query_times_metric_card } %>
@@ -14,7 +12,7 @@
 <div
   class="row"
   data-controller="rails-pulse--index"
-  data-rails-pulse--index-chart-id-value="route_repsonses_chart"
+  data-rails-pulse--index-chart-id-value="route_responses_chart"
 >
   <div class="grid-item">
     <%= render 'rails_pulse/components/panel', { title: 'Route Reqeusts', } do %>
@@ -44,7 +42,7 @@
             <%= bar_chart(
               @chart_data,
               code: false,
-              id: "route_repsonses_chart",
+              id: "route_responses_chart",
               height: "100%",
               options: bar_chart_options(
                 units: "ms",
@@ -61,12 +59,12 @@
           </div>
         <% end %>
 
-        <%= turbo_frame_tag :index_table do %>
-          <%= render 'rails_pulse/requests/table' %>
+        <%= turbo_frame_tag :index_table, data: { rails_pulse__index_target: "indexTable" } do %>
+          <%= render 'rails_pulse/routes/requests_table' %>
         <% end %>
       <% else %>
-        <%= render 'rails_pulse/components/empty_state', 
-            title: 'No route requests found for the selected filters.', 
+        <%= render 'rails_pulse/components/empty_state',
+            title: 'No route requests found for the selected filters.',
             description: 'Try adjusting your time range or filters to see results.' %>
       <% end %>
     <% end %>

data/config/initializers/rails_charts_csp_patch.rb

@@ -1,62 +1,54 @@
-# Monkey patch for RailsCharts CSP compliance
-# This adds nonce attributes to script tags generated by the RailsCharts gem
+# CSP patch for RailsCharts gem
+# Adds nonce attributes to script tags generated by RailsCharts for CSP compliance
 
 if defined?(RailsCharts)
   module RailsCharts
     module CspPatch
       def line_chart(data_source, options = {})
-        # Get the original chart HTML
         chart_html = super(data_source, options)
+        add_csp_nonce_to_chart(chart_html)
+      end
 
-        # Try to get CSP nonce from various sources
-        nonce = get_csp_nonce
-
-        if nonce.present? && chart_html.present?
-          # Add nonce to all script tags in the chart HTML
-          chart_html = add_nonce_to_scripts(chart_html.to_s, nonce)
-          # Ensure the HTML is marked as safe for Rails to render
-          chart_html = chart_html.html_safe if chart_html.respond_to?(:html_safe)
-        end
-
-        chart_html
+      def bar_chart(data_source, options = {})
+        chart_html = super(data_source, options)
+        add_csp_nonce_to_chart(chart_html)
       end
 
       private
 
-      def get_csp_nonce
-        # Try various methods to get the CSP nonce
-        nonce = nil
+      def add_csp_nonce_to_chart(chart_html)
+        return chart_html unless chart_html.present?
 
-        # Method 1: Check for Rails 6+ CSP nonce helper
-        if respond_to?(:content_security_policy_nonce)
-          nonce = content_security_policy_nonce
-        end
-
-        # Method 2: Check for custom csp_nonce helper
-        if nonce.blank? && respond_to?(:csp_nonce)
-          nonce = csp_nonce
-        end
+        nonce = get_csp_nonce
+        return chart_html unless nonce.present?
 
-        # Method 3: Check request environment
-        if nonce.blank? && defined?(request) && request
-          nonce = request.env["action_dispatch.content_security_policy_nonce"] ||
-                  request.env["secure_headers.content_security_policy_nonce"] ||
-                  request.env["csp_nonce"]
-        end
+        # Add nonce to script tags and mark as safe
+        modified_html = add_nonce_to_scripts(chart_html.to_s, nonce)
+        modified_html.html_safe if modified_html.respond_to?(:html_safe)
+      end
 
-        # Method 4: Check thread/request store
-        if nonce.blank?
-          nonce = Thread.current[:rails_pulse_csp_nonce] ||
-                  (defined?(RequestStore) && RequestStore.store[:rails_pulse_csp_nonce])
+      def get_csp_nonce
+        # Try common CSP nonce sources in order of preference
+        if respond_to?(:content_security_policy_nonce)
+          content_security_policy_nonce
+        elsif respond_to?(:csp_nonce)
+          csp_nonce
+        elsif defined?(request) && request
+          request.env["action_dispatch.content_security_policy_nonce"] ||
+          request.env["secure_headers.content_security_policy_nonce"] ||
+          request.env["csp_nonce"]
+        elsif respond_to?(:controller) && controller.respond_to?(:content_security_policy_nonce)
+          controller.content_security_policy_nonce
+        elsif defined?(@view_context) && @view_context.respond_to?(:content_security_policy_nonce)
+          @view_context.content_security_policy_nonce
+        else
+          Thread.current[:rails_pulse_csp_nonce] ||
+          (defined?(RequestStore) && RequestStore.store[:rails_pulse_csp_nonce])
         end
-
-        nonce.presence
       end
 
       def add_nonce_to_scripts(html, nonce)
-        # Use regex to add nonce to script tags that don't already have one
         html.gsub(/<script(?![^>]*\snonce=)([^>]*)>/i) do |match|
-          # Insert nonce attribute before the closing >
           attributes = $1
           if attributes.strip.empty?
             "<script nonce=\"#{nonce}\">"

data/config/routes.rb

@@ -3,7 +3,11 @@ RailsPulse::Engine.routes.draw do
 
   resources :routes, only: %i[index show]
   resources :requests, only: %i[index show]
-  resources :queries, only: %i[index show]
+  resources :queries, only: %i[index show] do
+    member do
+      post :analyze
+    end
+  end
   resources :operations, only: %i[show]
   resources :caches, only: %i[show], as: :cache
   patch "pagination/limit", to: "application#set_pagination_limit"

data/db/migrate/20250930105043_install_rails_pulse_tables.rb

@@ -0,0 +1,23 @@
+# Generated from Rails Pulse schema - automatically loads current schema definition
+class InstallRailsPulseTables < ActiveRecord::Migration["#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}".to_f]
+  def change
+    # Load and execute the Rails Pulse schema directly
+    # This ensures the migration is always in sync with the schema file
+    schema_file = File.join(File.dirname(__FILE__), "..", "rails_pulse_schema.rb")
+
+    if File.exist?(schema_file)
+      say "Loading Rails Pulse schema from db/rails_pulse_schema.rb"
+
+      # Load the schema file to define RailsPulse::Schema
+      load schema_file
+
+      # Execute the schema in the context of this migration
+      RailsPulse::Schema.call(connection)
+
+      say "Rails Pulse tables created successfully"
+      say "The schema file db/rails_pulse_schema.rb remains as your single source of truth"
+    else
+      raise "Rails Pulse schema file not found at db/rails_pulse_schema.rb"
+    end
+  end
+end

data/db/rails_pulse_schema.rb

@@ -4,7 +4,7 @@
 
 RailsPulse::Schema = lambda do |connection|
   # Skip if all tables already exist to prevent conflicts
-  required_tables = [:rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_summaries]
+  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_summaries ]
 
   if ENV["CI"] == "true"
     existing_tables = required_tables.select { |table| connection.table_exists?(table) }
@@ -25,6 +25,15 @@ RailsPulse::Schema = lambda do |connection|
 
   connection.create_table :rails_pulse_queries do |t|
     t.string :normalized_sql, limit: 1000, null: false, comment: "Normalized SQL query string (e.g., SELECT * FROM users WHERE id = ?)"
+    t.datetime :analyzed_at, comment: "When query analysis was last performed"
+    t.text :explain_plan, comment: "EXPLAIN output from actual SQL execution"
+    t.text :issues, comment: "JSON array of detected performance issues"
+    t.text :metadata, comment: "JSON object containing query complexity metrics"
+    t.text :query_stats, comment: "JSON object with query characteristics analysis"
+    t.text :backtrace_analysis, comment: "JSON object with call chain and N+1 detection"
+    t.text :index_recommendations, comment: "JSON array of database index recommendations"
+    t.text :n_plus_one_analysis, comment: "JSON object with enhanced N+1 query detection results"
+    t.text :suggestions, comment: "JSON array of optimization recommendations"
     t.timestamps
   end
 

data/lib/generators/rails_pulse/convert_to_migrations_generator.rb

@@ -0,0 +1,81 @@
+module RailsPulse
+  module Generators
+    class ConvertToMigrationsGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Convert Rails Pulse schema file to migrations for single database setup"
+
+      def self.next_migration_number(path)
+        next_migration_number = current_migration_number(path) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def check_schema_file
+        unless File.exist?("db/rails_pulse_schema.rb")
+          # Only show message in non-test environments to reduce test noise
+          unless Rails.env.test?
+            say "No db/rails_pulse_schema.rb file found. Run 'rails generate rails_pulse:install' first.", :red
+            exit 1
+          else
+            return false
+          end
+        end
+
+        if rails_pulse_tables_exist?
+          unless Rails.env.test?
+            say "Rails Pulse tables already exist. No conversion needed.", :yellow
+            say "Use 'rails generate rails_pulse:upgrade' to update existing installation.", :blue
+            exit 0
+          else
+            return false
+          end
+        end
+
+        true
+      end
+
+      def create_conversion_migration
+        # Only create migration if schema file check passes
+        return unless check_schema_file
+
+        say "Converting db/rails_pulse_schema.rb to migration...", :green
+
+        migration_template(
+          "migrations/install_rails_pulse_tables.rb",
+          "db/migrate/install_rails_pulse_tables.rb"
+        )
+      end
+
+      def display_completion_message
+        # Only display completion message if migration was created
+        return unless File.exist?("db/rails_pulse_schema.rb")
+
+        say <<~MESSAGE
+
+          Conversion complete!
+
+          Next steps:
+          1. Run: rails db:migrate
+          2. Restart your Rails server
+
+          The schema file db/rails_pulse_schema.rb remains as your single source of truth.
+          Future Rails Pulse updates will come as regular migrations in db/migrate/
+
+        MESSAGE
+      end
+
+      private
+
+      def rails_pulse_tables_exist?
+        return false unless defined?(ActiveRecord::Base)
+
+        connection = ActiveRecord::Base.connection
+        %w[rails_pulse_routes rails_pulse_queries rails_pulse_requests rails_pulse_operations rails_pulse_summaries]
+          .all? { |table| connection.table_exists?(table) }
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/generators/rails_pulse/install_generator.rb

@@ -1,53 +1,110 @@
 module RailsPulse
   module Generators
     class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
       source_root File.expand_path("templates", __dir__)
 
-      desc "Install Rails Pulse with schema-based setup"
+      desc "Install Rails Pulse with flexible database setup options"
+
+      class_option :database, type: :string, default: "single",
+                   desc: "Database setup: 'single' (default) or 'separate'"
+
+      def self.next_migration_number(path)
+        next_migration_number = current_migration_number(path) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
 
       def copy_schema
         copy_file "db/rails_pulse_schema.rb", "db/rails_pulse_schema.rb"
       end
 
+      def create_migration_directory
+        create_file "db/rails_pulse_migrate/.keep"
+      end
+
       def copy_initializer
         copy_file "rails_pulse.rb", "config/initializers/rails_pulse.rb"
       end
 
-      def create_database_migration_paths
+      def setup_database_configuration
         if separate_database?
-          create_file "db/rails_pulse_migrate/.keep"
+          create_separate_database_setup
+        else
+          create_single_database_setup
         end
       end
 
       def display_post_install_message
+        if separate_database?
+          display_separate_database_message
+        else
+          display_single_database_message
+        end
+      end
+
+      private
+
+      def separate_database?
+        options[:database] == "separate"
+      end
+
+      def create_separate_database_setup
+        say "Setting up separate database configuration...", :green
+
+        # Migration directory already created by create_migration_directory
+        # Could add database.yml configuration here if needed
+        # For now, users will configure manually
+      end
+
+      def create_single_database_setup
+        say "Setting up single database configuration...", :green
+
+        # Create a migration that loads the schema
+        migration_template(
+          "migrations/install_rails_pulse_tables.rb",
+          "db/migrate/install_rails_pulse_tables.rb"
+        )
+      end
+
+      def display_separate_database_message
         say <<~MESSAGE
 
-          Rails Pulse installation complete!
+          Rails Pulse installation complete! (Separate Database Setup)
 
           Next steps:
-          1. Configure your database in config/database.yml (see README for examples)
+          1. Add Rails Pulse database configuration to config/database.yml:
+
+             #{Rails.env}:
+               rails_pulse:
+                 <<: *default
+                 database: storage/#{Rails.env}_rails_pulse.sqlite3
+                 migrations_paths: db/rails_pulse_migrate
+
           2. Run: rails db:prepare (creates database and loads schema)
           3. Restart your Rails server
 
-          For separate database setup, add to config/database.yml:
-            #{environment}:
-              rails_pulse:
-                <<: *default
-                database: storage/#{environment}_rails_pulse.sqlite3
-                migrations_paths: db/rails_pulse_migrate
+          The schema file db/rails_pulse_schema.rb is your single source of truth.
+          Future schema changes will come as regular migrations in db/rails_pulse_migrate/
 
         MESSAGE
       end
 
-      private
+      def display_single_database_message
+        say <<~MESSAGE
 
-      def separate_database?
-        # Could make this configurable via options
-        false
-      end
+          Rails Pulse installation complete! (Single Database Setup)
+
+          Next steps:
+          1. Run: rails db:migrate (creates Rails Pulse tables in your main database)
+          2. Restart your Rails server
 
-      def environment
-        Rails.env.production? ? "production" : "development"
+          The schema file db/rails_pulse_schema.rb is your single source of truth.
+          Future schema changes will come as regular migrations in db/migrate/
+
+          Note: The installation migration loads from db/rails_pulse_schema.rb
+          and includes all current Rails Pulse tables and columns.
+
+        MESSAGE
       end
     end
   end

data/lib/generators/rails_pulse/templates/db/rails_pulse_schema.rb

@@ -3,8 +3,17 @@
 # Load with: rails db:schema:load:rails_pulse or db:prepare
 
 RailsPulse::Schema = lambda do |connection|
-  # Skip if tables already exist to prevent conflicts
-  return if connection.table_exists?(:rails_pulse_routes)
+  # Skip if all tables already exist to prevent conflicts
+  required_tables = [ :rails_pulse_routes, :rails_pulse_queries, :rails_pulse_requests, :rails_pulse_operations, :rails_pulse_summaries ]
+
+  if ENV["CI"] == "true"
+    existing_tables = required_tables.select { |table| connection.table_exists?(table) }
+    missing_tables = required_tables - existing_tables
+    puts "[RailsPulse::Schema] Existing tables: #{existing_tables.join(', ')}" if existing_tables.any?
+    puts "[RailsPulse::Schema] Missing tables: #{missing_tables.join(', ')}" if missing_tables.any?
+  end
+
+  return if required_tables.all? { |table| connection.table_exists?(table) }
 
   connection.create_table :rails_pulse_routes do |t|
     t.string :method, null: false, comment: "HTTP method (e.g., GET, POST)"
@@ -16,6 +25,15 @@ RailsPulse::Schema = lambda do |connection|
 
   connection.create_table :rails_pulse_queries do |t|
     t.string :normalized_sql, limit: 1000, null: false, comment: "Normalized SQL query string (e.g., SELECT * FROM users WHERE id = ?)"
+    t.datetime :analyzed_at, comment: "When query analysis was last performed"
+    t.text :explain_plan, comment: "EXPLAIN output from actual SQL execution"
+    t.text :issues, comment: "JSON array of detected performance issues"
+    t.text :metadata, comment: "JSON object containing query complexity metrics"
+    t.text :query_stats, comment: "JSON object with query characteristics analysis"
+    t.text :backtrace_analysis, comment: "JSON object with call chain and N+1 detection"
+    t.text :index_recommendations, comment: "JSON array of database index recommendations"
+    t.text :n_plus_one_analysis, comment: "JSON object with enhanced N+1 query detection results"
+    t.text :suggestions, comment: "JSON array of optimization recommendations"
     t.timestamps
   end
 
@@ -53,6 +71,58 @@ RailsPulse::Schema = lambda do |connection|
   connection.add_index :rails_pulse_operations, [ :query_id, :occurred_at ], name: "index_rails_pulse_operations_on_query_and_time"
   connection.add_index :rails_pulse_operations, [ :query_id, :duration, :occurred_at ], name: "index_rails_pulse_operations_query_performance"
   connection.add_index :rails_pulse_operations, [ :occurred_at, :duration, :operation_type ], name: "index_rails_pulse_operations_on_time_duration_type"
+
+  connection.create_table :rails_pulse_summaries do |t|
+    # Time fields
+    t.datetime :period_start, null: false, comment: "Start of the aggregation period"
+    t.datetime :period_end, null: false, comment: "End of the aggregation period"
+    t.string :period_type, null: false, comment: "Aggregation period type: hour, day, week, month"
+
+    # Polymorphic association to handle both routes and queries
+    t.references :summarizable, polymorphic: true, null: false, index: true, comment: "Link to Route or Query"
+    # This creates summarizable_type (e.g., 'RailsPulse::Route', 'RailsPulse::Query')
+    # and summarizable_id (route_id or query_id)
+
+    # Universal metrics
+    t.integer :count, default: 0, null: false, comment: "Total number of requests/operations"
+    t.float :avg_duration, comment: "Average duration in milliseconds"
+    t.float :min_duration, comment: "Minimum duration in milliseconds"
+    t.float :max_duration, comment: "Maximum duration in milliseconds"
+    t.float :p50_duration, comment: "50th percentile duration"
+    t.float :p95_duration, comment: "95th percentile duration"
+    t.float :p99_duration, comment: "99th percentile duration"
+    t.float :total_duration, comment: "Total duration in milliseconds"
+    t.float :stddev_duration, comment: "Standard deviation of duration"
+
+    # Request/Route specific metrics
+    t.integer :error_count, default: 0, comment: "Number of error responses (5xx)"
+    t.integer :success_count, default: 0, comment: "Number of successful responses"
+    t.integer :status_2xx, default: 0, comment: "Number of 2xx responses"
+    t.integer :status_3xx, default: 0, comment: "Number of 3xx responses"
+    t.integer :status_4xx, default: 0, comment: "Number of 4xx responses"
+    t.integer :status_5xx, default: 0, comment: "Number of 5xx responses"
+
+    t.timestamps
+  end
+
+  # Unique constraint and indexes for summaries
+  connection.add_index :rails_pulse_summaries, [ :summarizable_type, :summarizable_id, :period_type, :period_start ],
+          unique: true,
+          name: "idx_pulse_summaries_unique"
+  connection.add_index :rails_pulse_summaries, [ :period_type, :period_start ], name: "index_rails_pulse_summaries_on_period"
+  connection.add_index :rails_pulse_summaries, :created_at, name: "index_rails_pulse_summaries_on_created_at"
+
+  # Add indexes to existing tables for efficient aggregation
+  connection.add_index :rails_pulse_requests, [ :created_at, :route_id ], name: "idx_requests_for_aggregation"
+  connection.add_index :rails_pulse_requests, :created_at, name: "idx_requests_created_at"
+
+  connection.add_index :rails_pulse_operations, [ :created_at, :query_id ], name: "idx_operations_for_aggregation"
+  connection.add_index :rails_pulse_operations, :created_at, name: "idx_operations_created_at"
+
+  if ENV["CI"] == "true"
+    created_tables = required_tables.select { |table| connection.table_exists?(table) }
+    puts "[RailsPulse::Schema] Successfully created tables: #{created_tables.join(', ')}"
+  end
 end
 
 if defined?(RailsPulse::ApplicationRecord)

data/lib/generators/rails_pulse/templates/migrations/install_rails_pulse_tables.rb

@@ -0,0 +1,23 @@
+# Generated from Rails Pulse schema - automatically loads current schema definition
+class InstallRailsPulseTables < ActiveRecord::Migration[<%= Rails::VERSION::MAJOR %>.<%= Rails::VERSION::MINOR %>]
+  def change
+    # Load and execute the Rails Pulse schema directly
+    # This ensures the migration is always in sync with the schema file
+    schema_file = File.join(::Rails.root.to_s, "db/rails_pulse_schema.rb")
+
+    if File.exist?(schema_file)
+      say "Loading Rails Pulse schema from db/rails_pulse_schema.rb"
+
+      # Load the schema file to define RailsPulse::Schema
+      load schema_file
+
+      # Execute the schema in the context of this migration
+      RailsPulse::Schema.call(connection)
+
+      say "Rails Pulse tables created successfully"
+      say "The schema file db/rails_pulse_schema.rb remains as your single source of truth"
+    else
+      raise "Rails Pulse schema file not found at db/rails_pulse_schema.rb"
+    end
+  end
+end

data/lib/generators/rails_pulse/templates/migrations/upgrade_rails_pulse_tables.rb

@@ -0,0 +1,19 @@
+# Upgrade Rails Pulse tables with new features
+class UpgradeRailsPulseTables < ActiveRecord::Migration[<%= @migration_version %>]
+  def change
+    <% @missing_columns.each do |table_name, columns| %>
+      <% columns.each do |column_name, definition| %>
+    # Add <%= column_name %> column to <%= table_name %>
+    add_column :<%= table_name %>, :<%= column_name %>, :<%= definition[:type] %><% if definition[:comment] %>, comment: "<%= definition[:comment] %>"<% end %>
+      <% end %>
+    <% end %>
+  end
+
+  def down
+    <% @missing_columns.each do |table_name, columns| %>
+      <% columns.each do |column_name, _definition| %>
+    remove_column :<%= table_name %>, :<%= column_name %>
+      <% end %>
+    <% end %>
+  end
+end