rails_pulse 0.1.3 → 0.1.4

data/app/views/rails_pulse/queries/_table.html.erb

@@ -1,9 +1,7 @@
 <% columns = [
   { field: :normalized_sql, label: 'Query', class: 'w-auto' },
-  { field: :execution_count_sort, label: 'Executions', class: 'w-24' },
-  { field: :avg_duration_sort, label: 'Avg Time', class: 'w-24' },
-  { field: :total_time_consumed_sort, label: 'Total Time', class: 'w-28' },
-  { field: :performance_status, label: 'Status', class: 'w-16', sortable: false }
+  { field: :avg_duration_sort, label: 'Average Query Time', class: 'w-44' },
+  { field: :execution_count_sort, label: 'Executions', class: 'w-24' }
 ] %>
 
 <table class="table mbs-4" data-controller="rails-pulse--table-sort">
@@ -17,10 +15,8 @@
             <%= link_to html_escape(truncate_sql(summary.normalized_sql)), query_path(summary.query_id), data: { turbo_frame: '_top', } %>
           </div>
         </td>
-        <td class="whitespace-nowrap"><%= number_with_delimiter summary.execution_count %></td>
         <td class="whitespace-nowrap"><%= summary.avg_duration.to_i %> ms</td>
-        <td class="whitespace-nowrap"><%= number_with_delimiter summary.total_time_consumed.to_i %> ms</td>
-        <td class="whitespace-nowrap text-center"><%= query_status_indicator(summary.avg_duration) %></td>
+        <td class="whitespace-nowrap"><%= number_with_delimiter summary.execution_count %></td>
       </tr>
     <% end %>
   </tbody>

data/app/views/rails_pulse/requests/_table.html.erb

@@ -1,28 +1,39 @@
-<%
-  columns = []
-  columns << { field: :route_path, label: 'Route', class: 'w-auto' } if @route.blank?
-
-  columns += [
-    { field: :occurred_at, label: 'Timestamp', class: 'w-36' },
-    { field: :duration, label: 'Response Time', class: 'w-24' },
-    { field: :status, label: 'HTTP Status', class: 'w-20' },
-    { field: :status_indicator, label: 'Status', class: 'w-16' }
-  ]
-%>
+<% columns = [
+  { field: :occurred_at, label: 'Timestamp', class: 'w-36' },
+  { field: :route_path, label: 'Route', class: 'w-auto' },
+  { field: :duration, label: 'Response Time', class: 'w-36' },
+  { field: :status, label: 'Status', class: 'w-20' }
+] %>
 
 <table class="table mbs-4" data-controller="rails-pulse--table-sort">
   <%= render "rails_pulse/components/table_head", columns: columns %>
 
   <tbody>
-    <% @table_data.each do |route_request| %>
+    <% @table_data.each do |request| %>
+      <%
+        # Determine performance class based on request duration
+        performance_class = case request.duration
+        when 0..100 then "text-green-600"
+        when 100..300 then "text-yellow-600"
+        when 300..1000 then "text-orange-600"
+        else "text-red-600"
+        end
+      %>
       <tr>
-        <% if @route.blank? %>
-          <td class="whitespace-nowrap"><%= link_to route_request.route.path_and_method, request_path(route_request), data: { turbo_frame: '_top' } %></td>
-        <% end %>
-        <td class="whitespace-nowrap"><%= link_to human_readable_occurred_at(route_request.occurred_at), request_path(route_request), data: { turbo_frame: '_top' } %></td>
-        <td class="whitespace-nowrap"><%= route_request.duration.round(2) %> ms</td>
-        <td class="whitespace-nowrap"><%= route_request.status %></td>
-        <td class="whitespace-nowrap text-center"><%= request_status_indicator(route_request.duration) %></td>
+        <td class="whitespace-nowrap">
+          <%= link_to human_readable_occurred_at(request.occurred_at), request_path(request), data: { turbo_frame: '_top' } %>
+        </td>
+        <td class="whitespace-nowrap">
+          <%= link_to "#{request.route.path} #{request.route.method}", route_path(request.route), data: { turbo_frame: '_top' } %>
+        </td>
+        <td class="whitespace-nowrap">
+          <span class="<%= performance_class %> font-medium">
+            <%= request.duration.round(2) %> ms
+          </span>
+        </td>
+        <td class="whitespace-nowrap">
+          <span class="text-green-600"><%= request.status %></span>
+        </td>
       </tr>
     <% end %>
   </tbody>

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

@@ -55,8 +55,16 @@
             )
           ) %>
         </div>
+      <% else %>
+        <div class="p-4 text-center text-muted">
+          No response time data available for the selected filters.
+        </div>
       <% end %>
 
+      <div class="alert flex items-start mbs-8" role="alert">
+        <p>The chart above shows aggregated average response times grouped by time periods while the table below shows specific request details.</p>
+      </div>
+
       <%= turbo_frame_tag :index_table, data: { rails_pulse__index_target: "indexTable" } do %>
         <%= render 'rails_pulse/requests/table' %>
       <% end %>

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

@@ -8,8 +8,6 @@
         <dd><%= link_to @request.route.path_and_method, route_path(@request.route) %></dd>
         <dt>Timestamp</dt>
         <dd><%= human_readable_occurred_at(@request.occurred_at) %></dd>
-        <dt>Request UUID</dt>
-        <dd><code><%= @request.request_uuid %></code></dd>
         <dt>Duration</dt>
         <dd><%= @request.duration.round(2) %> ms</dd>
         <dt>Status</dt>

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

@@ -0,0 +1,39 @@
+<% columns = [
+  { field: :occurred_at, label: 'Timestamp', class: 'w-auto' },
+  { field: :duration, label: 'Response Time', class: 'w-36' },
+  { field: :status, label: 'Status', class: 'w-20' }
+] %>
+
+<table class="table mbs-4" data-controller="rails-pulse--table-sort">
+  <%= render "rails_pulse/components/table_head", columns: columns %>
+
+  <tbody>
+    <% @table_data.each do |request| %>
+      <tr>
+        <td class="whitespace-nowrap">
+          <%= link_to human_readable_occurred_at(request.occurred_at), request_path(request), data: { turbo_frame: '_top' } %>
+        </td>
+        <td class="whitespace-nowrap">
+          <% performance_class = case request.duration
+            when 0..100 then "text-green-600"
+            when 100..300 then "text-yellow-600"
+            when 300..1000 then "text-orange-600"
+            else "text-red-600"
+            end %>
+          <span class="<%= performance_class %> font-medium">
+            <%= request.duration.round(2) %> ms
+          </span>
+        </td>
+        <td class="whitespace-nowrap">
+          <% if request.is_error? %>
+            <span class="text-red-600">Error (<%= request.status %>)</span>
+          <% else %>
+            <span class="text-green-600"><%= request.status %></span>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<%= render "rails_pulse/components/table_pagination" %>

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

@@ -1,11 +1,8 @@
 <% columns = [
   { field: :route_path, label: 'Route', class: 'w-auto' },
-  { field: :avg_duration_sort, label: 'Average Response Time', class: 'w-36' },
-  { field: :max_duration_sort, label: 'Max Response Time', class: 'w-32' },
-  { field: :count_sort, label: 'Requests', class: 'w-24' },
-  { field: :requests_per_minute, label: 'Requests Per Minute', class: 'w-28' },
-  { field: :error_rate_percentage, label: 'Error Rate (%)', class: 'w-20' },
-  { field: :status_indicator, label: 'Status', class: 'w-16', sortable: false }
+  { field: :avg_duration_sort, label: 'Average Response Time', class: 'w-48' },
+  { field: :max_duration_sort, label: 'Max Response Time', class: 'w-44' },
+  { field: :count_sort, label: 'Requests', class: 'w-24' }
 ] %>
 
 <table class="table mbs-4" data-controller="rails-pulse--table-sort">
@@ -18,9 +15,6 @@
         <td class="whitespace-nowrap"><%= summary.avg_duration.to_i %> ms</td>
         <td class="whitespace-nowrap"><%= summary.max_duration.to_i %> ms</td>
         <td class="whitespace-nowrap"><%= number_with_delimiter summary.count %></td>
-        <td class="whitespace-nowrap"><%= summary.count < 1 ? '< 1' : (summary.count / 60.0).round(2) %></td>
-        <td class="whitespace-nowrap"><%= ((summary.error_count.to_f / summary.count) * 100).round(2) %>%</td>
-        <td class="whitespace-nowrap text-center"><%= route_status_indicator(summary.avg_duration >= 500 ? 1 : 0) %></td>
       </tr>
     <% end %>
   </tbody>

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

@@ -1,7 +1,5 @@
 <%= render 'rails_pulse/components/breadcrumbs' %>
 
-<h1 class="text-2xl mis-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",
@@ -62,7 +60,7 @@
         <% end %>
 
         <%= turbo_frame_tag :index_table, data: { rails_pulse__index_target: "indexTable" } do %>
-          <%= render 'rails_pulse/requests/table' %>
+          <%= render 'rails_pulse/routes/requests_table' %>
         <% end %>
       <% else %>
         <%= render 'rails_pulse/components/empty_state',

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/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) }

data/lib/generators/rails_pulse/convert_to_migrations_generator.rb

@@ -13,18 +13,32 @@ module RailsPulse
 
       def check_schema_file
         unless File.exist?("db/rails_pulse_schema.rb")
-          say "No db/rails_pulse_schema.rb file found. Run 'rails generate rails_pulse:install' first.", :red
-          exit 1
+          # 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?
-          say "Rails Pulse tables already exist. No conversion needed.", :yellow
-          say "Use 'rails generate rails_pulse:upgrade' to update existing installation.", :blue
-          exit 0
+          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(
@@ -34,17 +48,19 @@ module RailsPulse
       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. Delete: db/rails_pulse_schema.rb (no longer needed)
-          3. Remove db/rails_pulse_migrate/ directory if it exists
-          4. Restart your Rails server
+          2. Restart your Rails server
 
-          Future Rails Pulse updates will come as regular migrations.
+          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

data/lib/generators/rails_pulse/install_generator.rb

@@ -18,6 +18,10 @@ module RailsPulse
         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
@@ -45,10 +49,9 @@ module RailsPulse
       end
 
       def create_separate_database_setup
-        create_file "db/rails_pulse_migrate/.keep"
-
         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
@@ -80,6 +83,7 @@ module RailsPulse
           2. Run: rails db:prepare (creates database and loads schema)
           3. Restart your Rails server
 
+          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
@@ -92,12 +96,12 @@ module RailsPulse
 
           Next steps:
           1. Run: rails db:migrate (creates Rails Pulse tables in your main database)
-          2. Delete: db/rails_pulse_schema.rb (no longer needed)
-          3. Restart your Rails server
+          2. Restart your Rails server
 
+          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 was created from db/rails_pulse_schema.rb
+          Note: The installation migration loads from db/rails_pulse_schema.rb
           and includes all current Rails Pulse tables and columns.
 
         MESSAGE

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

@@ -1,5 +1,5 @@
 # Generated from Rails Pulse schema - automatically loads current schema definition
-class InstallRailsPulseTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+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
@@ -15,8 +15,9 @@ class InstallRailsPulseTables < ActiveRecord::Migration[<%= ActiveRecord::Migrat
       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
+end

data/lib/generators/rails_pulse/upgrade_generator.rb

@@ -132,7 +132,8 @@ module RailsPulse
           To convert to single database setup:
           1. Run: rails generate rails_pulse:convert_to_migrations
           2. Run: rails db:migrate
-          3. Delete: db/rails_pulse_schema.rb
+
+          The schema file db/rails_pulse_schema.rb will remain as your single source of truth.
 
         MESSAGE
       end

data/lib/rails_pulse/engine.rb

@@ -66,6 +66,27 @@ module RailsPulse
       # Instead, we explicitly use time_zone: "UTC" in all groupdate calls
     end
 
+    initializer "rails_pulse.disable_turbo" do
+      # Disable Turbo navigation globally for Rails Pulse to avoid CSP issues with charts
+      # This ensures all navigation within Rails Pulse uses full page refreshes
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Helpers::UrlHelper.module_eval do
+          alias_method :original_link_to, :link_to
+
+          def link_to(*args, &block)
+            # Only modify links within Rails Pulse namespace
+            if respond_to?(:controller) && controller.class.name.start_with?("RailsPulse::")
+              options = args.extract_options!
+              options[:data] ||= {}
+              options[:data][:turbo] = false unless options[:data].key?(:turbo)
+              args << options
+            end
+            original_link_to(*args, &block)
+          end
+        end
+      end
+    end
+
     # CSP helper methods
     def self.csp_sources
       {

data/lib/rails_pulse/version.rb

@@ -1,3 +1,3 @@
 module RailsPulse
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end