dbwatcher 1.1.1 → 1.1.3

data/lib/dbwatcher/services/system_info/runtime_info_collector.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+require_relative "../../logging"
+
+module Dbwatcher
+  module Services
+    module SystemInfo
+      # Runtime information collector service
+      #
+      # Collects runtime-specific information including Ruby version, Rails version,
+      # loaded gems, environment variables, and application configuration.
+      #
+      # @example
+      #   info = SystemInfo::RuntimeInfoCollector.call
+      #   puts info[:ruby_version]
+      #   puts info[:rails_version]
+      #   puts info[:gem_count]
+      #
+      # This class is necessarily complex due to the comprehensive runtime information
+      # it needs to collect across different Ruby and Rails environments.
+      # rubocop:disable Metrics/ClassLength
+      class RuntimeInfoCollector
+        include Dbwatcher::Logging
+
+        # Class method to create instance and call
+        #
+        # @return [Hash] runtime information
+        def self.call
+          new.call
+        end
+
+        # Collect runtime information
+        #
+        # @return [Hash] collected runtime information
+        # rubocop:disable Metrics/MethodLength
+        def call
+          log_info "#{self.class.name}: Collecting runtime information"
+
+          {
+            ruby_version: collect_ruby_version,
+            ruby_engine: collect_ruby_engine,
+            ruby_patchlevel: collect_ruby_patchlevel,
+            rails_version: collect_rails_version,
+            rails_env: collect_rails_env,
+            environment: collect_environment,
+            pid: Process.pid,
+            gem_count: collect_gem_count,
+            loaded_gems: collect_loaded_gems,
+            load_path: collect_load_path_info,
+            environment_variables: collect_environment_variables,
+            application_config: collect_application_config
+          }
+        rescue StandardError => e
+          log_error "Runtime info collection failed: #{e.message}"
+          { error: e.message }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        # Collect Ruby version information
+        #
+        # @return [String] Ruby version
+        def collect_ruby_version
+          RUBY_VERSION
+        rescue StandardError => e
+          log_error "Failed to get Ruby version: #{e.message}"
+          "unknown"
+        end
+
+        # Collect Ruby engine information
+        #
+        # @return [String] Ruby engine (e.g., ruby, jruby, rbx)
+        def collect_ruby_engine
+          defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+        rescue StandardError => e
+          log_error "Failed to get Ruby engine: #{e.message}"
+          "unknown"
+        end
+
+        # Collect Ruby patchlevel
+        #
+        # @return [String] Ruby patchlevel
+        def collect_ruby_patchlevel
+          RUBY_PATCHLEVEL.to_s
+        rescue StandardError => e
+          log_error "Failed to get Ruby patchlevel: #{e.message}"
+          "unknown"
+        end
+
+        # Collect Rails version if available
+        #
+        # @return [String] Rails version or nil
+        def collect_rails_version
+          return nil unless defined?(Rails)
+
+          Rails.version
+        rescue StandardError => e
+          log_error "Failed to get Rails version: #{e.message}"
+          nil
+        end
+
+        # Collect Rails environment if available
+        #
+        # @return [String] Rails environment or nil
+        def collect_rails_env
+          return nil unless defined?(Rails)
+
+          Rails.env
+        rescue StandardError => e
+          log_error "Failed to get Rails environment: #{e.message}"
+          nil
+        end
+
+        # Collect current environment
+        #
+        # @return [String] current environment
+        def collect_environment
+          ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+        rescue StandardError => e
+          log_error "Failed to get environment: #{e.message}"
+          "unknown"
+        end
+
+        # Collect loaded gems count
+        #
+        # @return [Integer] number of loaded gems
+        def collect_gem_count
+          Gem.loaded_specs.size
+        rescue StandardError => e
+          log_error "Failed to get gem count: #{e.message}"
+          0
+        end
+
+        # Collect loaded gems information
+        #
+        # @return [Hash] loaded gems with versions
+        def collect_loaded_gems
+          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics
+
+          gems = {}
+          Gem.loaded_specs.each do |name, spec|
+            gems[name] = spec.version.to_s
+          end
+          gems
+        rescue StandardError => e
+          log_error "Failed to get loaded gems: #{e.message}"
+          {}
+        end
+
+        # Collect load path information
+        #
+        # @return [Hash] load path statistics
+        def collect_load_path_info
+          {
+            size: $LOAD_PATH.size,
+            paths: Dbwatcher.configuration.system_info_include_performance_metrics ? $LOAD_PATH.first(10) : []
+          }
+        rescue StandardError => e
+          log_error "Failed to get load path info: #{e.message}"
+          { size: 0, paths: [] }
+        end
+
+        # Collect environment variables (filtered for security)
+        #
+        # @return [Hash] filtered environment variables
+        # rubocop:disable Metrics/MethodLength
+        def collect_environment_variables
+          return {} unless Dbwatcher.configuration.collect_sensitive_env_vars
+
+          env_vars = {}
+
+          # Safe environment variables to include
+          safe_vars = %w[
+            RAILS_ENV
+            RACK_ENV
+            RUBY_VERSION
+            PATH
+            HOME
+            USER
+            SHELL
+            TERM
+            LANG
+            LC_ALL
+            TZ
+            RAILS_LOG_LEVEL
+            RAILS_SERVE_STATIC_FILES
+            RAILS_CACHE_ID
+            RAILS_RELATIVE_URL_ROOT
+            BUNDLE_GEMFILE
+            BUNDLE_PATH
+            GEM_HOME
+            GEM_PATH
+          ]
+
+          safe_vars.each do |var|
+            env_vars[var] = ENV[var] if ENV[var]
+          end
+
+          env_vars
+        rescue StandardError => e
+          log_error "Failed to get environment variables: #{e.message}"
+          {}
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Collect application configuration
+        #
+        # @return [Hash] application configuration
+        def collect_application_config
+          config = {}
+
+          # Collect Rails configuration if available
+          config[:rails] = collect_rails_config if defined?(Rails)
+
+          # Collect DBWatcher configuration
+          config[:dbwatcher] = collect_dbwatcher_config if defined?(Dbwatcher)
+
+          config
+        rescue StandardError => e
+          log_error "Failed to get application config: #{e.message}"
+          {}
+        end
+
+        # Collect Rails configuration if available
+        #
+        # @return [Hash] Rails configuration
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def collect_rails_config
+          rails_config = {}
+
+          return rails_config unless defined?(Rails)
+
+          # Basic Rails configuration
+          rails_config[:environment] = Rails.env
+          rails_config[:version] = Rails.version
+          rails_config[:root] = Rails.root.to_s
+
+          # Rails application configuration
+          if Rails.application
+            app_config = Rails.application.config
+            rails_config[:app_name] = Rails.application.class.name.split("::").first
+            rails_config[:autoload_paths] =
+              app_config.respond_to?(:autoload_paths) ? app_config.autoload_paths.size : nil
+            rails_config[:eager_load_paths] =
+              app_config.respond_to?(:eager_load_paths) ? app_config.eager_load_paths.size : nil
+            rails_config[:eager_load] = app_config.respond_to?(:eager_load) ? app_config.eager_load : nil
+            rails_config[:cache_classes] = app_config.respond_to?(:cache_classes) ? app_config.cache_classes : nil
+            rails_config[:consider_all_requests_local] =
+              app_config.respond_to?(:consider_all_requests_local) ? app_config.consider_all_requests_local : nil
+
+            # Fix long line by breaking it up and removing redundant else
+            perform_caching = if app_config.action_controller.respond_to?(:perform_caching)
+                                app_config.action_controller.perform_caching
+                              end
+            rails_config[:action_controller] = { perform_caching: perform_caching }
+          end
+
+          rails_config
+        rescue StandardError => e
+          log_error "Failed to get Rails config: #{e.message}"
+          {}
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # Collect DBWatcher configuration
+        #
+        # @return [Hash] DBWatcher configuration
+        # rubocop:disable Metrics/MethodLength
+        def collect_dbwatcher_config
+          config = Dbwatcher.configuration
+
+          # Only include non-sensitive configuration options
+          # Split long lines to avoid line length issues
+          {
+            system_info_refresh_interval:
+              if config.respond_to?(:system_info_refresh_interval)
+                config.system_info_refresh_interval
+              else
+                300
+              end,
+            collect_sensitive_env_vars:
+              if config.respond_to?(:collect_sensitive_env_vars)
+                config.collect_sensitive_env_vars
+              else
+                false
+              end,
+            system_info_include_performance_metrics:
+              if config.respond_to?(:system_info_include_performance_metrics)
+                config.system_info_include_performance_metrics
+              else
+                true
+              end
+          }
+        rescue StandardError => e
+          log_error "Failed to get DBWatcher config: #{e.message}"
+          {}
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Sanitize database configuration to remove sensitive information
+        #
+        # @param db_config [Hash] database configuration
+        # @return [Hash] sanitized database configuration
+        def sanitize_database_config(db_config)
+          return {} unless db_config.is_a?(Hash)
+
+          # Create a copy to avoid modifying the original
+          sanitized = db_config.dup
+
+          # Remove sensitive information
+          %w[password username user].each do |key|
+            sanitized.delete(key)
+            sanitized.delete(key.to_sym)
+          end
+
+          # Keep only basic connection info
+          safe_keys = %w[adapter host port database pool timeout]
+          sanitized.select { |k, _| safe_keys.include?(k.to_s) }
+        rescue StandardError => e
+          log_error "Failed to sanitize database config: #{e.message}"
+          {}
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/dbwatcher/services/system_info/system_info_collector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "machine_info_collector"
+require_relative "database_info_collector"
+require_relative "runtime_info_collector"
+require_relative "../../logging"
+
+module Dbwatcher
+  module Services
+    module SystemInfo
+      # Main system information collector service
+      #
+      # Orchestrates the collection of system information from various sources
+      # including machine, database, and runtime information.
+      #
+      # @example
+      #   info = SystemInfo::SystemInfoCollector.call
+      #   puts info[:machine][:hostname]
+      #   puts info[:database][:adapter]
+      #   puts info[:runtime][:ruby_version]
+      class SystemInfoCollector
+        include Dbwatcher::Logging
+
+        # Class method to create instance and call
+        #
+        # @return [Hash] system information
+        def self.call
+          new.call
+        end
+
+        # Collect system information from all sources
+        #
+        # This method needs to be longer to properly handle all the collection
+        # steps and error handling in a consistent way.
+        #
+        # @return [Hash] collected system information
+        # rubocop:disable Metrics/MethodLength
+        def call
+          start_time = current_time
+          log_info "#{self.class.name}: Starting system information collection"
+
+          info = {
+            machine: collect_machine_info,
+            database: collect_database_info,
+            runtime: collect_runtime_info,
+            collected_at: current_time.iso8601,
+            collection_duration: nil
+          }
+
+          info[:collection_duration] = (current_time - start_time).round(3)
+          log_info "#{self.class.name}: Completed system information collection in #{info[:collection_duration]}s"
+
+          info
+        rescue StandardError => e
+          log_error "System information collection failed: #{e.message}"
+          {
+            machine: {},
+            database: {},
+            runtime: {},
+            collected_at: current_time.iso8601,
+            collection_duration: nil,
+            error: e.message
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        # Get current time, using Rails Time.current if available, otherwise Time.now
+        #
+        # @return [Time] current time
+        def current_time
+          defined?(Time.current) ? Time.current : Time.now
+        end
+
+        # Collect machine information safely
+        #
+        # @return [Hash] machine information or empty hash on error
+        def collect_machine_info
+          return {} unless Dbwatcher.configuration.collect_system_info
+
+          MachineInfoCollector.call
+        rescue StandardError => e
+          log_error "Machine info collection failed: #{e.message}"
+          { error: e.message }
+        end
+
+        # Collect database information safely
+        #
+        # @return [Hash] database information or empty hash on error
+        def collect_database_info
+          return {} unless Dbwatcher.configuration.collect_system_info
+
+          DatabaseInfoCollector.call
+        rescue StandardError => e
+          log_error "Database info collection failed: #{e.message}"
+          { error: e.message }
+        end
+
+        # Collect runtime information safely
+        #
+        # @return [Hash] runtime information or empty hash on error
+        def collect_runtime_info
+          return {} unless Dbwatcher.configuration.collect_system_info
+
+          RuntimeInfoCollector.call
+        rescue StandardError => e
+          log_error "Runtime info collection failed: #{e.message}"
+          { error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/timeline_data_service/enhancement_utilities.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    class TimelineDataService
+      # Module for enhancing timeline entries and utility methods
+      module EnhancementUtilities
+        private
+
+        # Enhance timeline entries with additional metadata
+        #
+        # @return [void]
+        def enhance_with_metadata
+          return if @timeline_entries.empty?
+
+          session_start_time = @timeline_entries.first[:raw_timestamp]
+
+          @timeline_entries.each_with_index do |entry, index|
+            entry[:relative_time] = calculate_relative_time(entry[:raw_timestamp], session_start_time)
+            entry[:duration_from_previous] = calculate_duration_from_previous(entry, index)
+            entry[:operation_group] = determine_operation_group(entry, index)
+          end
+        end
+
+        # Calculate relative time from session start
+        #
+        # @param timestamp [Float] entry timestamp
+        # @param session_start [Float] session start timestamp
+        # @return [String] formatted relative time
+        def calculate_relative_time(timestamp, session_start)
+          seconds = timestamp - session_start
+          format_duration(seconds)
+        end
+
+        # Calculate duration from previous operation
+        #
+        # @param entry [Hash] current entry
+        # @param index [Integer] entry index
+        # @return [Integer] duration in milliseconds
+        def calculate_duration_from_previous(entry, index)
+          return 0 if index.zero?
+
+          previous_entry = @timeline_entries[index - 1]
+          ((entry[:raw_timestamp] - previous_entry[:raw_timestamp]) * 1000).round
+        end
+
+        # Determine operation group for related operations
+        #
+        # @param entry [Hash] current entry
+        # @param index [Integer] entry index
+        # @return [String] operation group identifier
+        def determine_operation_group(entry, index)
+          # Group operations on same table within 1 second
+          return "single_op" if index.zero?
+
+          previous_entry = @timeline_entries[index - 1]
+          time_diff = entry[:raw_timestamp] - previous_entry[:raw_timestamp]
+
+          if time_diff <= 1.0 && entry[:table_name] == previous_entry[:table_name]
+            "#{entry[:table_name]}_batch_#{index / 10}" # Group every 10 operations
+          else
+            "single_op"
+          end
+        end
+
+        # Format duration in human-readable format
+        #
+        # @param seconds [Float] duration in seconds
+        # @return [String] formatted duration
+        def format_duration(seconds)
+          if seconds < 60
+            format("%<minutes>02d:%<seconds>02d", minutes: 0, seconds: seconds.to_i)
+          elsif seconds < 3600
+            minutes = seconds / 60
+            format("%<minutes>02d:%<seconds>02d", minutes: minutes.to_i, seconds: (seconds % 60).to_i)
+          else
+            hours = seconds / 3600
+            minutes = (seconds % 3600) / 60
+            format("%<hours>02d:%<minutes>02d:%<seconds>02d",
+                   hours: hours.to_i, minutes: minutes.to_i, seconds: (seconds % 60).to_i)
+          end
+        end
+
+        # Get model class for a table using the TableSummaryBuilder service
+        #
+        # @param table_name [String] database table name
+        # @return [String, nil] model class name or nil if not found
+        def get_model_class_for_table(table_name)
+          # Use cache to avoid repeated lookups
+          @model_class_cache ||= {}
+          return @model_class_cache[table_name] if @model_class_cache.key?(table_name)
+
+          # Delegate to TableSummaryBuilder for model class lookup
+          builder = Dbwatcher::Services::Analyzers::TableSummaryBuilder.new(@session)
+          @model_class_cache[table_name] = builder.send(:find_model_class, table_name)
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/timeline_data_service/entry_builder.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Dbwatcher
+  module Services
+    class TimelineDataService
+      # Module for building timeline entries
+      module EntryBuilder
+        private
+
+        # Create a timeline entry from change data
+        #
+        # @param change [Hash] change data
+        # @param sequence [Integer] sequence number
+        # @return [Hash] timeline entry
+        def create_timeline_entry(change, sequence)
+          timestamp = parse_timestamp(change[:timestamp])
+
+          {
+            id: generate_entry_id(change, sequence),
+            timestamp: timestamp,
+            sequence: sequence,
+            table_name: change[:table_name],
+            operation: change[:operation],
+            record_id: extract_record_id(change),
+            changes: format_changes(change),
+            metadata: extract_metadata(change),
+            model_class: get_model_class_for_table(change[:table_name]),
+            raw_timestamp: timestamp.to_f
+          }
+        end
+
+        # Generate unique ID for timeline entry
+        #
+        # @param change [Hash] change data
+        # @param sequence [Integer] sequence number
+        # @return [String] unique entry ID
+        def generate_entry_id(change, sequence)
+          data = "#{change[:table_name]}_#{change[:operation]}_#{sequence}"
+          hash = Digest::SHA1.hexdigest(data)[0..7]
+          "#{@session.id}_entry_#{sequence}_#{hash}"
+        end
+
+        # Parse timestamp from various formats
+        #
+        # @param timestamp [String, Time, Integer] timestamp value
+        # @return [Time] parsed timestamp
+        def parse_timestamp(timestamp)
+          case timestamp
+          when Time
+            timestamp
+          when String
+            Time.parse(timestamp)
+          when Integer, Float
+            Time.at(timestamp)
+          else
+            Time.current
+          end
+        rescue ArgumentError
+          Time.current
+        end
+
+        # Extract record ID from change data
+        #
+        # @param change [Hash] change data
+        # @return [String, nil] record ID if available
+        def extract_record_id(change)
+          change[:record_id] || change[:id] || change.dig(:changes, :id)
+        end
+
+        # Format changes for timeline display
+        #
+        # @param change [Hash] change data
+        # @return [Hash] formatted changes
+        def format_changes(change)
+          raw_changes = change[:changes] || change[:data] || {}
+          return {} unless raw_changes.is_a?(Hash)
+
+          raw_changes.transform_values do |value|
+            case value
+            when Hash
+              value # Already formatted as { from: x, to: y }
+            else
+              { to: value } # Simple value change
+            end
+          end
+        end
+
+        # Extract metadata from change data
+        #
+        # @param change [Hash] change data
+        # @return [Hash] metadata hash
+        def extract_metadata(change)
+          {
+            duration_ms: change[:duration_ms] || change[:duration],
+            affected_rows: change[:affected_rows] || change[:rows_affected] || 1,
+            query_fingerprint: change[:query_fingerprint] || change[:sql_fingerprint],
+            connection_id: change[:connection_id] || change[:connection],
+            query_type: determine_query_type(change[:operation])
+          }.compact
+        end
+
+        # Determine query type from operation
+        #
+        # @param operation [String] database operation
+        # @return [String] query type
+        def determine_query_type(operation)
+          case operation&.upcase
+          when "INSERT", "CREATE"
+            "write"
+          when "UPDATE", "MODIFY"
+            "update"
+          when "DELETE", "DROP"
+            "delete"
+          when "SELECT", "SHOW"
+            "read"
+          else
+            "unknown"
+          end
+        end
+      end
+    end
+  end
+end