dbwatcher 1.1.1 → 1.1.3

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    class TimelineDataService
+      # Module for building timeline metadata
+      module MetadataBuilder
+        private
+
+        # Build timeline metadata
+        #
+        # @return [Hash] timeline metadata
+        def build_timeline_metadata
+          return {} if @timeline_entries.empty?
+
+          {
+            total_operations: @timeline_entries.length,
+            time_range: calculate_time_range,
+            session_duration: calculate_session_duration,
+            tables_affected: extract_affected_tables,
+            operation_counts: count_operations_by_type,
+            peak_activity_periods: find_peak_activity_periods
+          }
+        end
+
+        # Calculate time range for the session
+        #
+        # @return [Hash] time range with start and end
+        def calculate_time_range
+          return {} if @timeline_entries.empty?
+
+          start_time = Time.at(@timeline_entries.first[:raw_timestamp])
+          end_time = Time.at(@timeline_entries.last[:raw_timestamp])
+
+          {
+            start: start_time.iso8601,
+            end: end_time.iso8601
+          }
+        end
+
+        # Calculate total session duration
+        #
+        # @return [String] formatted session duration
+        def calculate_session_duration
+          return "00:00" if @timeline_entries.length < 2
+
+          duration = @timeline_entries.last[:raw_timestamp] - @timeline_entries.first[:raw_timestamp]
+          format_duration(duration)
+        end
+
+        # Extract list of affected tables
+        #
+        # @return [Array<String>] unique table names
+        def extract_affected_tables
+          @timeline_entries.map { |entry| entry[:table_name] }.uniq.sort
+        end
+
+        # Count operations by type
+        #
+        # @return [Hash] operation counts
+        def count_operations_by_type
+          @timeline_entries.group_by { |entry| entry[:operation] }
+                           .transform_values(&:count)
+        end
+
+        # Find peak activity periods
+        #
+        # @return [Array<Hash>] peak activity periods
+        def find_peak_activity_periods
+          return [] if @timeline_entries.length < 10
+
+          # Group operations by 1-minute windows
+          windows = @timeline_entries.group_by do |entry|
+            timestamp = Time.at(entry[:raw_timestamp])
+            Time.new(timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.min, 0)
+          end
+
+          # Find windows with more than average activity
+          average_ops = @timeline_entries.length / windows.length.to_f
+
+          windows.select { |_, ops| ops.length > average_ops * 1.5 }
+                 .map do |window_start, ops|
+            {
+              start: window_start.iso8601,
+              end: (window_start + 1.minute).iso8601,
+              operations_count: ops.length
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/timeline_data_service.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "timeline_data_service/metadata_builder"
+require_relative "timeline_data_service/entry_builder"
+require_relative "timeline_data_service/enhancement_utilities"
+
+module Dbwatcher
+  module Services
+    # Timeline Data Service for processing session data into chronological timeline format
+    #
+    # This service transforms session changes into a chronologically ordered timeline
+    # with enhanced metadata for visualization and filtering.
+    #
+    # @example
+    #   service = TimelineDataService.new(session)
+    #   result = service.call
+    #   timeline = result[:timeline]
+    #   metadata = result[:metadata]
+    class TimelineDataService
+      include MetadataBuilder
+      include EntryBuilder
+      include EnhancementUtilities
+      # Initialize the timeline data service
+      #
+      # @param session [Session] session object containing changes data
+      def initialize(session)
+        @session = session
+        @timeline_entries = []
+        @start_time = Time.current
+      end
+
+      # Process session data into timeline format
+      #
+      # @return [Hash] processed timeline data with metadata
+      def call
+        Rails.logger.info("Processing timeline data for session #{@session.id}")
+
+        validate_session_data
+        build_timeline_entries
+        sort_chronologically
+        enhance_with_metadata
+        result = build_result
+
+        Rails.logger.info(
+          "Timeline processing completed for session #{@session.id} (#{@timeline_entries.length} entries)"
+        )
+
+        result
+      rescue StandardError => e
+        Rails.logger.error("Timeline processing failed for session #{@session.id}: #{e.message}")
+        build_error_result(e)
+      end
+
+      private
+
+      # Validate session data before processing
+      #
+      # @raise [ArgumentError] if session data is invalid
+      def validate_session_data
+        raise ArgumentError, "Session is required" unless @session
+        raise ArgumentError, "Session ID is required" unless @session.id
+        raise ArgumentError, "Session changes are required" unless @session.changes
+      end
+
+      # Build timeline entries from session changes
+      #
+      # @return [void]
+      def build_timeline_entries
+        @session.changes.each_with_index do |change, index|
+          next unless valid_change?(change)
+
+          @timeline_entries << create_timeline_entry(change, index)
+        end
+      end
+
+      # Check if a change is valid for timeline processing
+      #
+      # @param change [Hash] change data
+      # @return [Boolean] true if change is valid
+      def valid_change?(change)
+        change.is_a?(Hash) &&
+          change[:table_name] &&
+          change[:operation] &&
+          change[:timestamp]
+      end
+
+      # Sort timeline entries chronologically
+      #
+      # @return [void]
+      def sort_chronologically
+        @timeline_entries.sort_by! { |entry| entry[:raw_timestamp] }
+      end
+
+      # Build final result hash
+      #
+      # @return [Hash] complete timeline result
+      def build_result
+        {
+          timeline: @timeline_entries,
+          metadata: build_timeline_metadata,
+          summary: build_timeline_summary,
+          errors: []
+        }
+      end
+
+      # Build timeline summary
+      #
+      # @return [Hash] timeline summary
+      def build_timeline_summary
+        {
+          total_entries: @timeline_entries.length,
+          processing_time: (Time.current - @start_time).round(3)
+        }
+      end
+
+      # Build error result
+      #
+      # @param error [StandardError] error that occurred
+      # @return [Hash] error result
+      def build_error_result(error)
+        {
+          timeline: [],
+          metadata: {},
+          summary: { error: error.message },
+          errors: [{ type: "processing_error", message: error.message }]
+        }
+      end
+    end
+  end
+end

data/lib/dbwatcher/storage/api/concerns/table_analyzer.rb

@@ -24,7 +24,7 @@ module Dbwatcher
           # @return [Hash] tables summary hash
           def build_tables_summary(session)
             # Delegate to new service while maintaining interface compatibility
-            Dbwatcher::Services::Analyzers::TableSummaryBuilder.call(session)
+            Dbwatcher::Services::Analyzers::TableSummaryBuilder.new(session).call
           end
 
           # Process all changes in a session (legacy method for backward compatibility)

data/lib/dbwatcher/storage/concerns/error_handler.rb

@@ -28,16 +28,16 @@ module Dbwatcher
         def safe_operation(operation_name, default_value = nil, &block)
           block.call
         rescue JSON::ParserError => e
-          log_error("JSON parsing failed in #{operation_name}", e)
+          log_error_with_exception("JSON parsing failed in #{operation_name}", e)
           default_value
         rescue Errno::ENOENT => e
-          log_error("File not found in #{operation_name}", e)
+          log_error_with_exception("File not found in #{operation_name}", e)
           default_value
         rescue Errno::EACCES => e
-          log_error("Permission denied in #{operation_name}", e)
+          log_error_with_exception("Permission denied in #{operation_name}", e)
           raise StorageError, "Permission denied: #{e.message}"
         rescue StandardError => e
-          log_error("#{operation_name} failed", e)
+          log_error_with_exception("#{operation_name} failed", e)
           default_value
         end
 
@@ -51,7 +51,7 @@ module Dbwatcher
           block.call
         rescue StandardError => e
           error_message = "Storage #{operation} failed: #{e.message}"
-          log_error(error_message, e)
+          log_error_with_exception(error_message, e)
           raise StorageError, error_message
         end
 
@@ -62,7 +62,7 @@ module Dbwatcher
         # @param message [String] the error message
         # @param error [Exception] the exception that occurred
         # @return [void]
-        def log_error(message, error)
+        def log_error_with_exception(message, error)
           if defined?(Rails) && Rails.logger
             Rails.logger.warn("#{message}: #{error.message}")
           else

data/lib/dbwatcher/storage/session.rb

@@ -28,6 +28,11 @@ module Dbwatcher
         }
       end
 
+      # Used by Rails URL helpers to convert the object to a URL parameter
+      def to_param
+        id.to_s
+      end
+
       def summary
         return {} unless changes.is_a?(Array)
 

data/lib/dbwatcher/storage/system_info_storage.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require_relative "../services/system_info/system_info_collector"
+require_relative "../logging"
+
+module Dbwatcher
+  module Storage
+    # System information storage class
+    #
+    # Handles storage, caching, and retrieval of system information data.
+    # Provides intelligent caching with configurable TTL and refresh capabilities.
+    #
+    # @example
+    #   storage = SystemInfoStorage.new
+    #   info = storage.cached_info
+    #   storage.refresh_info
+    #
+    # This class is necessarily complex due to the comprehensive system information
+    # storage and retrieval functionality it provides.
+    # rubocop:disable Metrics/ClassLength
+    class SystemInfoStorage < BaseStorage
+      include Dbwatcher::Logging
+      # Initialize system info storage
+      def initialize
+        super
+        @info_file = File.join(storage_path, "system_info.json")
+      end
+
+      # Save system information to storage
+      #
+      # @param info [Hash] system information data
+      # @return [Boolean] true if successful
+      def save_info(info)
+        # Convert all keys to strings before saving to ensure consistent format
+        info_with_string_keys = convert_keys_to_strings(info)
+        safe_write_json(@info_file, info_with_string_keys)
+      end
+
+      # Load system information from storage
+      #
+      # @return [Hash] system information data or empty hash
+      def load_info
+        # Override the base class default to return {} instead of []
+        safe_operation("read JSON from #{@info_file}", {}) do
+          result = file_manager.read_json(@info_file)
+          result = {} if result.is_a?(Array) && result.empty?
+          # Convert string keys back to symbols for consistent access in the app
+          convert_keys_to_symbols(result)
+        end
+      end
+
+      # Refresh system information by collecting new data
+      #
+      # @return [Hash] refreshed system information
+      def refresh_info
+        log_info "Refreshing system information"
+
+        info = Services::SystemInfo::SystemInfoCollector.call
+        save_info(info)
+
+        log_info "System information refreshed successfully"
+        # Return the info with symbol keys for consistent access
+        convert_keys_to_symbols(info)
+      rescue StandardError => e
+        log_error "Failed to refresh system information: #{e.message}"
+
+        # Return cached info if available, otherwise empty hash with error
+        cached_info = load_info
+        cached_info.empty? ? { error: e.message } : cached_info
+      end
+
+      # Get cached system information with TTL support
+      #
+      # @param max_age [Integer] maximum age in seconds (default: from config)
+      # @return [Hash] cached or refreshed system information
+      def cached_info(max_age: nil)
+        max_age ||= Dbwatcher.configuration.system_info_cache_duration
+
+        info = load_info
+
+        # If no cached info exists, collect new data
+        return refresh_info if info.empty?
+
+        # Check if cached info is expired
+        if info_expired?(info, max_age)
+          log_info "System information cache expired, refreshing"
+          return refresh_info
+        end
+
+        log_info "Using cached system information"
+        info
+      rescue StandardError => e
+        log_error "Failed to get cached system information: #{e.message}"
+        { error: e.message }
+      end
+
+      # Check if system information is available
+      #
+      # @return [Boolean] true if system information exists
+      def info_available?
+        !load_info.empty?
+      rescue StandardError => e
+        log_error "Failed to check info availability: #{e.message}"
+        false
+      end
+
+      # Get system information age in seconds
+      #
+      # @return [Integer, nil] age in seconds or nil if not available
+      def info_age
+        info = load_info
+        return nil if info.empty? || !info[:collected_at]
+
+        collected_at = info[:collected_at]
+        current_time - Time.parse(collected_at)
+      rescue StandardError => e
+        log_error "Failed to get info age: #{e.message}"
+        nil
+      end
+
+      # Clear cached system information
+      #
+      # @return [Boolean] true if successful
+      def clear_cache
+        log_info "Clearing system information cache"
+        safe_delete_file(@info_file)
+      end
+
+      # Get system information summary for dashboard
+      #
+      # @return [Hash] summary information
+      # rubocop:disable Metrics/MethodLength
+      def summary
+        info = cached_info
+        return {} if info.empty? || info[:error]
+
+        {
+          hostname: dig_with_indifferent_access(info, :machine, :hostname),
+          os: dig_with_indifferent_access(info, :machine, :os, :name),
+          ruby_version: dig_with_indifferent_access(info, :runtime, :ruby_version),
+          rails_version: dig_with_indifferent_access(info, :runtime, :rails_version),
+          database_adapter: dig_with_indifferent_access(info, :database, :adapter, :name),
+          memory_usage: dig_with_indifferent_access(info, :machine, :memory, :usage_percent),
+          cpu_load: dig_with_indifferent_access(info, :machine, :load_average, "1min") ||
+            dig_with_indifferent_access(info, :machine, :cpu, :load_average, "1min") ||
+            dig_with_indifferent_access(info, :machine, :load, :one_minute),
+          active_connections: dig_with_indifferent_access(info, :database, :active_connections) ||
+            dig_with_indifferent_access(info, :database, :connection_pool, :connections),
+          collected_at: info[:collected_at],
+          collection_duration: info[:collection_duration]
+        }
+      rescue StandardError => e
+        log_error "Failed to get system info summary: #{e.message}"
+        {}
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      # Check if system information is expired
+      #
+      # @param info [Hash] system information data
+      # @param max_age [Integer] maximum age in seconds
+      # @return [Boolean] true if expired
+      def info_expired?(info, max_age)
+        collected_at = info[:collected_at]
+        return true unless collected_at
+
+        (current_time - Time.parse(collected_at)) > max_age
+      rescue StandardError => e
+        log_error "Failed to check info expiration: #{e.message}"
+        true # Assume expired on error
+      end
+
+      # Get current time, using Rails method if available
+      #
+      # @return [Time] current time
+      def current_time
+        defined?(Time.current) ? Time.current : Time.now
+      end
+
+      # Convert all hash keys to strings recursively
+      #
+      # @param hash [Hash] hash to convert
+      # @return [Hash] hash with string keys
+      def convert_keys_to_strings(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), result|
+          string_key = key.to_s
+          result[string_key] = if value.is_a?(Hash)
+                                 convert_keys_to_strings(value)
+                               elsif value.is_a?(Array)
+                                 value.map { |v| v.is_a?(Hash) ? convert_keys_to_strings(v) : v }
+                               else
+                                 value
+                               end
+        end
+      end
+
+      # Convert all hash keys to symbols recursively
+      #
+      # @param hash [Hash] hash to convert
+      # @return [Hash] hash with symbol keys
+      def convert_keys_to_symbols(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), result|
+          symbol_key = key.to_s.to_sym
+          result[symbol_key] = if value.is_a?(Hash)
+                                 convert_keys_to_symbols(value)
+                               elsif value.is_a?(Array)
+                                 value.map { |v| v.is_a?(Hash) ? convert_keys_to_symbols(v) : v }
+                               else
+                                 value
+                               end
+        end
+      end
+
+      # Safe access to nested hash values with indifferent access
+      #
+      # @param hash [Hash] hash to access
+      # @param keys [Array] keys to access
+      # @return [Object, nil] value or nil if not found
+      def dig_with_indifferent_access(hash, *keys)
+        return nil unless hash.is_a?(Hash)
+
+        current = hash
+        keys.each do |key|
+          key_sym = key.to_s.to_sym
+          key_str = key.to_s
+          return nil unless current.is_a?(Hash)
+
+          current = current[key_sym] || current[key_str]
+          return nil if current.nil?
+        end
+        current
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/dbwatcher/storage.rb

@@ -9,6 +9,7 @@ require_relative "storage/session_storage"
 require_relative "storage/query_storage"
 require_relative "storage/table_storage"
 require_relative "storage/session_query"
+require_relative "storage/system_info_storage"
 require_relative "storage/api/base_api"
 require_relative "storage/api/query_api"
 require_relative "storage/api/table_api"
@@ -68,6 +69,16 @@ module Dbwatcher
         @tables ||= Api::TableAPI.new(table_storage)
       end
 
+      # Provides access to system information operations
+      #
+      # @return [SystemInfoStorage] system info storage instance
+      # @example
+      #   Dbwatcher::Storage.system_info.cached_info
+      #   Dbwatcher::Storage.system_info.refresh_info
+      def system_info
+        @system_info ||= SystemInfoStorage.new
+      end
+
       # Resets all cached storage instances (primarily for testing)
       #
       # This method clears all memoized storage instances, forcing them
@@ -80,6 +91,7 @@ module Dbwatcher
         @session_storage = nil
         @query_storage = nil
         @table_storage = nil
+        @system_info = nil
         @sessions = nil
         @queries = nil
         @tables = nil

data/lib/dbwatcher/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dbwatcher
-  VERSION = "1.1.1"
+  VERSION = "1.1.3"
 end

data/lib/dbwatcher.rb

@@ -13,12 +13,12 @@ require_relative "dbwatcher/logging"
 
 # Storage layer
 require_relative "dbwatcher/storage"
+require_relative "dbwatcher/middleware"
 
 # Tracking and SQL monitoring
 require_relative "dbwatcher/tracker"
 require_relative "dbwatcher/sql_logger"
 require_relative "dbwatcher/model_extension"
-require_relative "dbwatcher/middleware"
 
 # Base services
 require_relative "dbwatcher/services/base_service"
@@ -28,6 +28,12 @@ require_relative "dbwatcher/services/table_statistics_collector"
 require_relative "dbwatcher/services/dashboard_data_aggregator"
 require_relative "dbwatcher/services/query_filter_processor"
 
+# System info services
+require_relative "dbwatcher/services/system_info/machine_info_collector"
+require_relative "dbwatcher/services/system_info/database_info_collector"
+require_relative "dbwatcher/services/system_info/runtime_info_collector"
+require_relative "dbwatcher/services/system_info/system_info_collector"
+
 # General analyzers
 require_relative "dbwatcher/services/analyzers/session_data_processor"
 require_relative "dbwatcher/services/analyzers/table_summary_builder"
@@ -68,23 +74,31 @@ require_relative "dbwatcher/services/diagram_system"
 
 # API services
 require_relative "dbwatcher/services/api/base_api_service"
-require_relative "dbwatcher/services/api/changes_data_service"
+require_relative "dbwatcher/services/api/tables_data_service"
 require_relative "dbwatcher/services/api/summary_data_service"
 require_relative "dbwatcher/services/api/diagram_data_service"
 
 # Rails engine
 require_relative "dbwatcher/engine" if defined?(Rails)
 
+# DBWatcher module
 module Dbwatcher
   class Error < StandardError; end
 
   class << self
     attr_writer :configuration
 
+    # Get configuration
+    #
+    # @return [Configuration] configuration
     def configuration
       @configuration ||= Configuration.new
     end
 
+    # Configure DBWatcher
+    #
+    # @yield [configuration] configuration
+    # @return [Configuration] configuration
     def configure
       yield(configuration)
     end