rails_pulse 0.2.4 → 0.2.5.pre.pre.3

data/lib/rails_pulse/configuration.rb

@@ -4,10 +4,14 @@ module RailsPulse
                   :route_thresholds,
                   :request_thresholds,
                   :query_thresholds,
+                  :job_thresholds,
                   :ignored_routes,
                   :ignored_requests,
                   :ignored_queries,
+                  :ignored_jobs,
+                  :ignored_queues,
                   :track_assets,
+                  :track_jobs,
                   :custom_asset_patterns,
                   :mount_path,
                   :full_retention_period,
@@ -17,32 +21,60 @@ module RailsPulse
                   :authentication_enabled,
                   :authentication_method,
                   :authentication_redirect_path,
-                  :tags
+                  :tags,
+                  :job_tracking_mode,
+                  :job_adapters,
+                  :capture_job_arguments,
+                  :mount_dashboard,
+                  :logger,
+                  :async
 
     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 }
+      @job_thresholds = { slow: 5_000, very_slow: 30_000, critical: 60_000 }
       @ignored_routes = []
       @ignored_requests = []
       @ignored_queries = []
+      @ignored_jobs = []
+      @ignored_queues = []
       @track_assets = false
+      @track_jobs = false
       @custom_asset_patterns = []
       @mount_path = nil
-      @full_retention_period = 2.weeks
+      @full_retention_period = 30.days
       @archiving_enabled = true
       @max_table_records = {
-        rails_pulse_requests: 10000,
-        rails_pulse_operations: 50000,
-        rails_pulse_routes: 1000,
-        rails_pulse_queries: 500
+        rails_pulse_operations: 100_000,
+        rails_pulse_requests: 50_000,
+        rails_pulse_job_runs: 50_000,
+        rails_pulse_queries: 10_000,
+        rails_pulse_routes: 1_000,
+        rails_pulse_jobs: 1_000
       }
       @connects_to = nil
       @authentication_enabled = Rails.env.production?
       @authentication_method = nil
       @authentication_redirect_path = "/"
       @tags = [ "ignored", "critical", "experimental" ]
+      @job_tracking_mode = :universal
+      @job_adapters = {
+        sidekiq: { enabled: true, track_queue_depth: false },
+        solid_queue: { enabled: true, track_recurring: false },
+        good_job: { enabled: true, track_cron: false },
+        delayed_job: { enabled: true },
+        resque: { enabled: true }
+      }
+      @capture_job_arguments = false
+
+      # Dashboard settings
+      @mount_dashboard = true
+      @logger = nil
+
+      # Tracking mode settings
+      @async = true
 
       validate_configuration!
     end
@@ -67,6 +99,9 @@ module RailsPulse
       validate_database_settings!
       validate_authentication_settings!
       validate_tags!
+      validate_job_settings!
+      validate_dashboard_settings!
+      validate_tracking_settings!
     end
 
     # Revalidate configuration after changes
@@ -77,7 +112,7 @@ module RailsPulse
     private
 
     def validate_thresholds!
-      [ @route_thresholds, @request_thresholds, @query_thresholds ].each do |thresholds|
+      [ @route_thresholds, @request_thresholds, @query_thresholds, @job_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}"
@@ -150,6 +185,44 @@ module RailsPulse
       end
     end
 
+    def validate_job_settings!
+      unless @ignored_jobs.is_a?(Array) && @ignored_queues.is_a?(Array)
+        raise ArgumentError, "ignored_jobs and ignored_queues must be arrays"
+      end
+
+      unless [ true, false ].include?(@track_jobs)
+        raise ArgumentError, "track_jobs must be a boolean"
+      end
+
+      unless @job_adapters.is_a?(Hash)
+        raise ArgumentError, "job_adapters must be a hash"
+      end
+
+      unless @job_thresholds.is_a?(Hash)
+        raise ArgumentError, "job_thresholds must be a hash"
+      end
+
+      unless @job_tracking_mode.is_a?(Symbol)
+        raise ArgumentError, "job_tracking_mode must be a symbol"
+      end
+
+      unless [ true, false ].include?(@capture_job_arguments)
+        raise ArgumentError, "capture_job_arguments must be a boolean"
+      end
+    end
+
+    def validate_dashboard_settings!
+      unless [ true, false ].include?(@mount_dashboard)
+        raise ArgumentError, "mount_dashboard must be true or false, got #{@mount_dashboard}"
+      end
+    end
+
+    def validate_tracking_settings!
+      unless [ true, false ].include?(@async)
+        raise ArgumentError, "async must be true or false, got #{@async}"
+      end
+    end
+
     # Default patterns for common asset types and paths
     def default_asset_patterns
       [

data/lib/rails_pulse/engine.rb

@@ -2,12 +2,14 @@ require "rails_pulse/version"
 require "rails_pulse/middleware/request_collector"
 require "rails_pulse/middleware/asset_server"
 require "rails_pulse/subscribers/operation_subscriber"
+require "rails_pulse/job_run_collector"
+require "rails_pulse/active_job_extensions"
+require "rails_pulse/extensions/active_record"
 require "request_store"
 require "rack/static"
 require "ransack"
 require "pagy"
 require "turbo-rails"
-require "groupdate"
 
 module RailsPulse
   class Engine < ::Rails::Engine
@@ -49,6 +51,30 @@ module RailsPulse
       # Ensure Ransack is loaded before our models
     end
 
+    initializer "rails_pulse.active_job" do
+      ActiveSupport.on_load(:active_job) do
+        include RailsPulse::ActiveJobExtensions
+      end
+    end
+
+    initializer "rails_pulse.configure_sidekiq", after: "rails_pulse.active_job" do
+      if defined?(Sidekiq) && RailsPulse.configuration.job_adapters.dig(:sidekiq, :enabled)
+        require "rails_pulse/adapters/sidekiq_middleware"
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add RailsPulse::Adapters::SidekiqMiddleware
+          end
+        end
+      end
+    end
+
+    initializer "rails_pulse.configure_delayed_job", after: "rails_pulse.active_job" do
+      if defined?(Delayed::Job) && RailsPulse.configuration.job_adapters.dig(:delayed_job, :enabled)
+        require "rails_pulse/adapters/delayed_job_plugin"
+        Delayed::Worker.plugins << RailsPulse::Adapters::DelayedJobPlugin
+      end
+    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
@@ -56,9 +82,14 @@ module RailsPulse
 
     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
+      # Our custom group_by_date extension works regardless of ActiveRecord.default_timezone
+    end
+
+    initializer "rails_pulse.configure_logger", before: :initialize_logger do
+      RailsPulse.configure do |config|
+        config.logger ||= Rails.logger
+      end
     end
 
     initializer "rails_pulse.disable_turbo" do

data/lib/rails_pulse/extensions/active_record.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RailsPulse
+  module Extensions
+    module ActiveRecord
+      # Extends ActiveRecord::Relation with database-agnostic date grouping
+      # This is a replacement for Groupdate that works regardless of ActiveRecord.default_timezone
+      module QueryMethods
+        # Groups records by date extracted from a timestamp column
+        # Works across PostgreSQL, MySQL, and SQLite
+        #
+        # @param column [Symbol, String] the timestamp column to group by (default: :period_start)
+        # @return [ActiveRecord::Relation] relation with DATE grouping applied
+        #
+        # @example Group summaries by date
+        #   RailsPulse::Summary.where(...).group_by_date(:period_start).sum(:count)
+        #   # => { Date(2024-01-01) => 100, Date(2024-01-02) => 150, ... }
+        #
+        # @example Group by different column
+        #   Model.group_by_date(:created_at).count
+        #
+        def group_by_date(column = :period_start)
+          group(Arel.sql(date_sql(column.to_s))).extending(DateResultTransformer)
+        end
+
+        private
+
+        # Returns database-specific SQL for extracting date from timestamp
+        def date_sql(column)
+          adapter = connection.adapter_name.downcase
+
+          case adapter
+          when "postgresql"
+            "DATE(#{column})"
+          when "mysql", "mysql2"
+            "DATE(#{column})"
+          when "sqlite"
+            "DATE(#{column})"
+          else
+            # Fallback for unknown adapters
+            "DATE(#{column})"
+          end
+        end
+      end
+
+      # Module to transform aggregation result keys from strings to Date objects
+      # This makes the API match Groupdate's behavior
+      module DateResultTransformer
+        def sum(*args)
+          super.transform_keys { |date_str| Date.parse(date_str.to_s) }
+        end
+
+        def count(*args)
+          result = super
+          # count can return an integer or a hash depending on whether group is used
+          result.is_a?(Hash) ? result.transform_keys { |date_str| Date.parse(date_str.to_s) } : result
+        end
+
+        def average(*args)
+          super.transform_keys { |date_str| Date.parse(date_str.to_s) }
+        end
+
+        def maximum(*args)
+          super.transform_keys { |date_str| Date.parse(date_str.to_s) }
+        end
+
+        def minimum(*args)
+          super.transform_keys { |date_str| Date.parse(date_str.to_s) }
+        end
+
+        def pluck(*args)
+          result = super
+          # If grouping, transform the keys
+          result.is_a?(Hash) ? result.transform_keys { |date_str| Date.parse(date_str.to_s) } : result
+        end
+      end
+    end
+  end
+end
+
+# Extend ActiveRecord::Relation with our date grouping methods
+ActiveRecord::Relation.include(RailsPulse::Extensions::ActiveRecord::QueryMethods)

data/lib/rails_pulse/job_run_collector.rb

@@ -0,0 +1,172 @@
+require "securerandom"
+
+module RailsPulse
+  class JobRunCollector
+    class << self
+      def track(active_job, adapter: detect_adapter)
+        return yield unless tracking_enabled?
+        return yield if ignore_job?(active_job)
+
+        previous_request_id = RequestStore.store[:rails_pulse_request_id]
+        previous_operations = RequestStore.store[:rails_pulse_operations]
+        previous_job_run_id = RequestStore.store[:rails_pulse_job_run_id]
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        occurred_at = Time.current
+
+        job = nil
+        job_run = nil
+
+        with_recording_suppressed do
+          job = find_or_create_job(active_job)
+          job_run = create_job_run(job, active_job, adapter, occurred_at)
+        end
+
+        RequestStore.store[:rails_pulse_request_id] = nil
+        RequestStore.store[:rails_pulse_job_run_id] = job_run.id
+        RequestStore.store[:rails_pulse_operations] = []
+
+        yield
+
+        duration = elapsed_time_ms(start_time)
+        with_recording_suppressed do
+          job_run.update!(status: "success", duration: duration)
+        end
+      rescue => error
+        duration = elapsed_time_ms(start_time)
+        with_recording_suppressed do
+          job_run.update!(
+            status: failure_status_for(error),
+            duration: duration,
+            error_class: error.class.name,
+            error_message: error.message
+          ) if job_run
+        end
+        raise
+      ensure
+        begin
+          save_operations(job_run)
+        rescue => e
+          Rails.logger.error "[RailsPulse] Failed to persist job operations: #{e.class} - #{e.message}"
+        ensure
+          RequestStore.store[:rails_pulse_job_run_id] = previous_job_run_id
+          RequestStore.store[:rails_pulse_operations] = previous_operations
+          RequestStore.store[:rails_pulse_request_id] = previous_request_id
+        end
+      end
+
+      def should_ignore_job?(job)
+        ignore_job?(job)
+      end
+
+      private
+
+      def tracking_enabled?
+        config = RailsPulse.configuration
+        config.enabled && config.track_jobs
+      end
+
+      def ignore_job?(job)
+        config = RailsPulse.configuration
+        job_class = job.class.name
+        queue_name = job.queue_name
+
+        return true if config.ignored_jobs&.include?(job_class)
+        return true if config.ignored_queues&.include?(queue_name)
+        return true if job_class.start_with?("RailsPulse::")
+
+        false
+      end
+
+      def find_or_create_job(active_job)
+        RailsPulse::Job.find_or_create_by!(name: active_job.class.name) do |job|
+          job.queue_name = active_job.queue_name
+        end
+      end
+
+      def create_job_run(job, active_job, adapter, occurred_at)
+        RailsPulse::JobRun.create!(
+          job: job,
+          run_id: active_job.job_id || SecureRandom.uuid,
+          status: initial_status_for(active_job),
+          enqueued_at: safe_timestamp(active_job.try(:enqueued_at)),
+          occurred_at: occurred_at,
+          attempts: (active_job.respond_to?(:executions) ? active_job.executions : 0),
+          adapter: adapter,
+          arguments: serialized_arguments(active_job)
+        )
+      end
+
+      def serialized_arguments(active_job)
+        return unless RailsPulse.configuration.capture_job_arguments
+
+        Array(active_job.arguments).to_json
+      rescue StandardError => e
+        Rails.logger.debug "[RailsPulse] Unable to serialize job arguments: #{e.class} - #{e.message}"
+        nil
+      end
+
+      def initial_status_for(active_job)
+        active_job.respond_to?(:scheduled_at) ? "enqueued" : "running"
+      end
+
+      def failure_status_for(error)
+        error.is_a?(StandardError) ? "failed" : "discarded"
+      end
+
+      def save_operations(job_run)
+        return unless job_run
+
+        operations_data = RequestStore.store[:rails_pulse_operations] || []
+        operations_data.each do |operation_data|
+          operation_data[:job_run_id] = job_run.id
+          operation_data[:request_id] = nil
+
+          with_recording_suppressed do
+            RailsPulse::Operation.create!(operation_data)
+          end
+        rescue => e
+          Rails.logger.error "[RailsPulse] Failed to save job operation: #{e.class} - #{e.message}"
+        end
+      ensure
+        RequestStore.store[:rails_pulse_operations] = nil
+      end
+
+      def detect_adapter
+        return "sidekiq" if defined?(::Sidekiq)
+        return "solid_queue" if defined?(::SolidQueue)
+        return "good_job" if defined?(::GoodJob)
+        return "delayed_job" if defined?(::Delayed::Job)
+        return "resque" if defined?(::Resque)
+        return "que" if defined?(::Que)
+
+        "active_job"
+      end
+
+      def elapsed_time_ms(start_time)
+        return 0.0 unless start_time
+
+        ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+      end
+
+      def safe_timestamp(value)
+        case value
+        when Time, ActiveSupport::TimeWithZone
+          value
+        when Integer
+          Time.at(value)
+        else
+          nil
+        end
+      end
+
+      def with_recording_suppressed
+        previous = RequestStore.store[:skip_recording_rails_pulse_activity]
+        RequestStore.store[:skip_recording_rails_pulse_activity] = true
+        yield
+      ensure
+        RequestStore.store[:skip_recording_rails_pulse_activity] = previous
+      end
+    end
+  end
+end

data/lib/rails_pulse/middleware/request_collector.rb

@@ -31,52 +31,35 @@ module RailsPulse
           return result
         end
 
-        # Clear any previous request ID to avoid conflicts
+        # Clear any previous request data
         RequestStore.store[:rails_pulse_request_id] = nil
+        RequestStore.store[:rails_pulse_operations] = []
 
         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
-
+        # Process request
         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
+        # Collect all tracking data
+        # Deep copy operations array to prevent race condition in async mode
+        operations = RequestStore.store[:rails_pulse_operations] || []
+        tracking_data = {
+          method: req.request_method,
+          path: req.path,
+          duration: duration,
+          status: status,
+          is_error: status.to_i >= 500,
+          request_uuid: req.uuid,
+          controller_action: controller_action,
+          occurred_at: occurred_at,
+          operations: operations.map(&:dup)
+        }
+
+        # Send to tracker (non-blocking if async mode enabled)
+        RailsPulse::Tracker.track_request(tracking_data)
 
         [ status, headers, response ]
       ensure
@@ -87,12 +70,6 @@ module RailsPulse
 
       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 || []

data/lib/rails_pulse/subscribers/operation_subscriber.rb

@@ -59,7 +59,8 @@ module RailsPulse
           return if RequestStore.store[:skip_recording_rails_pulse_activity]
 
           request_id = RequestStore.store[:rails_pulse_request_id]
-          return unless request_id
+          job_run_id = RequestStore.store[:rails_pulse_job_run_id]
+          return unless request_id || job_run_id
 
           # Skip RailsPulse-related operations to prevent recursion
           if operation_type == "sql"
@@ -91,6 +92,7 @@ module RailsPulse
 
           operation_data = {
             request_id: request_id,
+            job_run_id: job_run_id,
             operation_type: operation_type,
             label: label,
             duration: (finish - start) * 1000,
@@ -174,6 +176,7 @@ module RailsPulse
             codebase_location = find_app_frame || caller_locations(2, 1).first&.path
             operation_data = {
               request_id: RequestStore.store[:rails_pulse_request_id],
+              job_run_id: RequestStore.store[:rails_pulse_job_run_id],
               operation_type: "http",
               label: label,
               duration: (finish - start) * 1000,
@@ -182,7 +185,7 @@ module RailsPulse
               occurred_at: Time.zone.at(start)
             }
 
-            if operation_data[:request_id]
+            if operation_data[:request_id] || operation_data[:job_run_id]
               RequestStore.store[:rails_pulse_operations] ||= []
               RequestStore.store[:rails_pulse_operations] << operation_data
             end
@@ -199,6 +202,7 @@ module RailsPulse
             codebase_location = find_app_frame || caller_locations(2, 1).first&.path
             operation_data = {
               request_id: RequestStore.store[:rails_pulse_request_id],
+              job_run_id: RequestStore.store[:rails_pulse_job_run_id],
               operation_type: "job",
               label: label,
               duration: (finish - start) * 1000,
@@ -207,7 +211,7 @@ module RailsPulse
               occurred_at: Time.zone.at(start)
             }
 
-            if operation_data[:request_id]
+            if operation_data[:request_id] || operation_data[:job_run_id]
               RequestStore.store[:rails_pulse_operations] ||= []
               RequestStore.store[:rails_pulse_operations] << operation_data
             end
@@ -233,6 +237,7 @@ module RailsPulse
             codebase_location = find_app_frame || caller_locations(2, 1).first&.path
             operation_data = {
               request_id: RequestStore.store[:rails_pulse_request_id],
+              job_run_id: RequestStore.store[:rails_pulse_job_run_id],
               operation_type: "mailer",
               label: label,
               duration: (finish - start) * 1000,
@@ -241,7 +246,7 @@ module RailsPulse
               occurred_at: Time.zone.at(start)
             }
 
-            if operation_data[:request_id]
+            if operation_data[:request_id] || operation_data[:job_run_id]
               RequestStore.store[:rails_pulse_operations] ||= []
               RequestStore.store[:rails_pulse_operations] << operation_data
             end
@@ -258,6 +263,7 @@ module RailsPulse
             codebase_location = find_app_frame || caller_locations(2, 1).first&.path
             operation_data = {
               request_id: RequestStore.store[:rails_pulse_request_id],
+              job_run_id: RequestStore.store[:rails_pulse_job_run_id],
               operation_type: "storage",
               label: label,
               duration: (finish - start) * 1000,
@@ -266,7 +272,7 @@ module RailsPulse
               occurred_at: Time.zone.at(start)
             }
 
-            if operation_data[:request_id]
+            if operation_data[:request_id] || operation_data[:job_run_id]
               RequestStore.store[:rails_pulse_operations] ||= []
               RequestStore.store[:rails_pulse_operations] << operation_data
             end