dbwatcher 1.1.1 → 1.1.3

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative "../../logging"
+
+module Dbwatcher
+  module Services
+    module SystemInfo
+      # Database information collector service
+      #
+      # Collects database-specific information including adapter, version,
+      # connection pool stats, table counts, and schema information.
+      #
+      # @example
+      #   info = SystemInfo::DatabaseInfoCollector.call
+      #   puts info[:adapter]
+      #   puts info[:version]
+      #   puts info[:tables].count
+      #
+      # This class is necessarily complex due to the comprehensive database information
+      # it needs to collect across different database systems.
+      # rubocop:disable Metrics/ClassLength
+      class DatabaseInfoCollector
+        include Dbwatcher::Logging
+
+        # Class method to create instance and call
+        #
+        # @return [Hash] database information
+        def self.call
+          new.call
+        end
+
+        def call
+          log_info "#{self.class.name}: Collecting database information"
+
+          {
+            adapter: collect_adapter_info,
+            version: collect_database_version,
+            connection_pool: collect_connection_pool_info,
+            tables: collect_table_info,
+            schema: collect_schema_info,
+            indexes: collect_index_info,
+            query_stats: collect_query_stats
+          }
+        rescue StandardError => e
+          log_error "Database info collection failed: #{e.message}"
+          { error: e.message }
+        end
+
+        private
+
+        # Collect database adapter information
+        #
+        # @return [Hash] adapter information
+        def collect_adapter_info
+          return {} unless active_record_available?
+
+          connection = ActiveRecord::Base.connection
+          adapter_name = connection.adapter_name.downcase
+
+          {
+            name: adapter_name,
+            pool_size: ActiveRecord::Base.connection_pool.size,
+            checkout_timeout: ActiveRecord::Base.connection_pool.checkout_timeout
+          }
+        rescue StandardError => e
+          log_error "Failed to get adapter info: #{e.message}"
+          {}
+        end
+
+        # Collect database version information
+        #
+        # @return [String] database version
+        # rubocop:disable Metrics/MethodLength
+        def collect_database_version
+          return nil unless active_record_available?
+
+          connection = ActiveRecord::Base.connection
+          adapter_name = connection.adapter_name.downcase
+
+          case adapter_name
+          when /mysql/
+            connection.select_value("SELECT VERSION()")
+          when /postgresql/
+            connection.select_value("SELECT version()")
+          when /sqlite/
+            connection.select_value("SELECT sqlite_version()")
+          else
+            "unknown"
+          end
+        rescue StandardError => e
+          log_error "Failed to get database version: #{e.message}"
+          nil
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Collect connection pool information
+        #
+        # @return [Hash] connection pool statistics
+        def collect_connection_pool_info
+          return {} unless active_record_available?
+
+          pool = ActiveRecord::Base.connection_pool
+          {
+            size: pool.size,
+            connections: pool.connections.size,
+            active: pool.active_connection?,
+            checkout_timeout: pool.checkout_timeout,
+            reaper_frequency: pool.reaper&.frequency
+          }
+        rescue StandardError => e
+          log_error "Failed to get connection pool info: #{e.message}"
+          {}
+        end
+
+        # Collect table information
+        #
+        # @return [Hash] table statistics
+        # rubocop:disable Metrics/MethodLength
+        def collect_table_info
+          return {} unless active_record_available?
+
+          connection = ActiveRecord::Base.connection
+          tables = connection.tables
+
+          # Skip detailed table info if performance metrics are disabled
+          return { count: tables.size } unless Dbwatcher.configuration.system_info_include_performance_metrics
+
+          table_info = { count: tables.size, tables: [] }
+
+          tables.each do |table|
+            count = connection.select_value("SELECT COUNT(*) FROM #{connection.quote_table_name(table)}").to_i
+            table_info[:tables] << {
+              name: table,
+              count: count,
+              has_primary_key: connection.primary_key(table).present?
+            }
+          rescue StandardError => e
+            log_error "Failed to get info for table #{table}: #{e.message}"
+            table_info[:tables] << { name: table, error: e.message }
+          end
+
+          table_info
+        rescue StandardError => e
+          log_error "Failed to get table info: #{e.message}"
+          {}
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Collect schema information
+        #
+        # @return [Hash] schema statistics
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def collect_schema_info
+          return {} unless active_record_available?
+
+          # Skip schema info if performance metrics are disabled
+          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics
+
+          connection = ActiveRecord::Base.connection
+          schema_info = {}
+
+          # Get schema migrations if available
+          if connection.table_exists?("schema_migrations")
+            begin
+              versions = connection.select_values("SELECT version FROM schema_migrations ORDER BY version DESC")
+              schema_info[:migrations] = {
+                count: versions.size,
+                latest: versions.first
+              }
+            rescue StandardError => e
+              log_error "Failed to get schema migrations: #{e.message}"
+            end
+          end
+
+          # Get schema information if available
+          if defined?(ActiveRecord::InternalMetadata) && connection.table_exists?(ActiveRecord::InternalMetadata.table_name)
+            begin
+              # Split the long line to avoid line length issues
+              query = "SELECT value FROM #{ActiveRecord::InternalMetadata.table_name} " \
+                      "WHERE key = 'environment'"
+              environment = connection.select_value(query)
+              schema_info[:environment] = environment
+            rescue StandardError => e
+              log_error "Failed to get schema environment: #{e.message}"
+            end
+          end
+
+          schema_info
+        rescue StandardError => e
+          log_error "Failed to get schema info: #{e.message}"
+          {}
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # Collect index information
+        #
+        # @return [Hash] index statistics
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def collect_index_info
+          return {} unless active_record_available?
+
+          # Skip index info if performance metrics are disabled
+          return {} unless Dbwatcher.configuration.system_info_include_performance_metrics
+
+          connection = ActiveRecord::Base.connection
+          tables = connection.tables
+          index_info = { count: 0, tables: [] }
+
+          tables.each do |table|
+            indexes = connection.indexes(table)
+            table_indexes = indexes.map do |index|
+              {
+                name: index.name,
+                columns: index.columns,
+                unique: index.unique
+              }
+            end
+
+            index_info[:tables] << {
+              name: table,
+              indexes: table_indexes
+            }
+            index_info[:count] += indexes.size
+          rescue StandardError => e
+            log_error "Failed to get indexes for table #{table}: #{e.message}"
+            index_info[:tables] << { name: table, error: e.message }
+          end
+
+          index_info
+        rescue StandardError => e
+          log_error "Failed to get index info: #{e.message}"
+          {}
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        # Collect query statistics if available
+        #
+        # @return [Hash] query statistics
+        def collect_query_stats
+          return {} unless active_record_available?
+
+          # This would be implementation-specific and could be expanded
+          # based on the database adapter and monitoring tools available
+          {}
+        rescue StandardError => e
+          log_error "Failed to get query stats: #{e.message}"
+          {}
+        end
+
+        # Check if ActiveRecord is available and connected
+        #
+        # @return [Boolean] true if ActiveRecord is available and connected
+        def active_record_available?
+          defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+        rescue StandardError => e
+          log_error "Failed to check ActiveRecord availability: #{e.message}"
+          false
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

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

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+require "socket"
+require "rbconfig"
+require_relative "../../logging"
+
+module Dbwatcher
+  module Services
+    module SystemInfo
+      # Machine information collector service
+      #
+      # Collects system-level information about the machine including CPU, memory,
+      # disk usage, and process information.
+      #
+      # @example
+      #   info = SystemInfo::MachineInfoCollector.call
+      #   puts info[:cpu][:model]
+      #   puts info[:memory][:total]
+      #   puts info[:disk][:total]
+      #
+      # This class is necessarily complex due to the comprehensive machine information
+      # it needs to collect across different operating systems.
+      # rubocop:disable Metrics/ClassLength
+      class MachineInfoCollector
+        include Dbwatcher::Logging
+
+        # Class method to create instance and call
+        #
+        # @return [Hash] machine information
+        def self.call
+          new.call
+        end
+
+        def call
+          log_info "#{self.class.name}: Collecting machine information"
+
+          {
+            hostname: collect_hostname,
+            os: collect_os_info,
+            cpu: collect_cpu_info,
+            memory: collect_memory_info,
+            disk: collect_disk_info,
+            process: collect_process_info,
+            load: collect_load_info,
+            uptime: collect_uptime
+          }
+        rescue StandardError => e
+          log_error "Machine info collection failed: #{e.message}"
+          { error: e.message }
+        end
+
+        private
+
+        # Collect hostname information
+        #
+        # @return [String] hostname
+        def collect_hostname
+          Socket.gethostname
+        rescue StandardError => e
+          log_error "Failed to get hostname: #{e.message}"
+          "unknown"
+        end
+
+        # Collect operating system information
+        #
+        # @return [Hash] operating system information
+        def collect_os_info
+          {
+            name: RbConfig::CONFIG["host_os"],
+            version: collect_os_version,
+            kernel: collect_kernel_version
+          }
+        rescue StandardError => e
+          log_error "Failed to get OS info: #{e.message}"
+          { name: "unknown", version: "unknown", kernel: "unknown" }
+        end
+
+        # Collect operating system version
+        #
+        # @return [String] operating system version
+        # rubocop:disable Metrics/MethodLength
+        def collect_os_version
+          case RbConfig::CONFIG["host_os"]
+          when /darwin/
+            `sw_vers -productVersion`.strip
+          when /linux/
+            if File.exist?("/etc/os-release")
+              # Extract version from os-release file safely
+              os_release = File.read("/etc/os-release")
+              match = os_release.match(/VERSION="?([^"]+)"?/)
+              match ? match[1] : "unknown"
+            else
+              "unknown"
+            end
+          when /mswin|mingw/
+            `ver`.strip
+          else
+            "unknown"
+          end
+        rescue StandardError => e
+          log_error "Failed to get OS version: #{e.message}"
+          "unknown"
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Collect kernel version
+        #
+        # @return [String] kernel version
+        def collect_kernel_version
+          `uname -r`.strip
+        rescue StandardError => e
+          log_error "Failed to get kernel version: #{e.message}"
+          "unknown"
+        end
+
+        # Collect CPU information
+        #
+        # @return [Hash] CPU information
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def collect_cpu_info
+          cpu_info = {
+            model: "unknown",
+            architecture: RbConfig::CONFIG["host_cpu"],
+            cores: 1,
+            speed: "unknown",
+            load_average: [0.0, 0.0, 0.0]
+          }
+
+          # Try to get CPU model from /proc/cpuinfo on Linux
+          if File.exist?("/proc/cpuinfo")
+            cpuinfo = File.read("/proc/cpuinfo")
+
+            # Count cores
+            cpu_info[:cores] = cpuinfo.scan(/^processor\s*:/).length
+
+            # Get model name
+            model_line = cpuinfo.lines.grep(/^model name\s*:/).first
+            cpu_info[:model] = model_line.split(":", 2).last.strip if model_line
+          end
+
+          # Get load average
+          if File.exist?("/proc/loadavg")
+            loadavg = File.read("/proc/loadavg").strip.split
+            cpu_info[:load_average] = [
+              loadavg[0].to_f,
+              loadavg[1].to_f,
+              loadavg[2].to_f
+            ]
+          end
+
+          cpu_info
+        rescue StandardError => e
+          log_error "Failed to get CPU info: #{e.message}"
+          {
+            model: "unknown",
+            architecture: "unknown",
+            cores: 1,
+            speed: "unknown",
+            load_average: [0.0, 0.0, 0.0]
+          }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        # Collect memory information
+        #
+        # @return [Hash] memory information
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def collect_memory_info
+          mem_info = {
+            total: 0,
+            free: 0,
+            available: 0,
+            used: 0
+          }
+
+          if File.exist?("/proc/meminfo")
+            mem_data = File.read("/proc/meminfo")
+
+            # Fix safe navigation chain length issues by breaking them up
+            match = mem_data.match(/MemTotal:\s+(\d+)/i)
+            total = match ? match.captures.first.to_i : 0
+
+            match = mem_data.match(/MemFree:\s+(\d+)/i)
+            free = match ? match.captures.first.to_i : 0
+
+            match = mem_data.match(/MemAvailable:\s+(\d+)/i)
+            available = match ? match.captures.first.to_i : 0
+
+            mem_info[:total] = total * 1024 # Convert KB to bytes
+            mem_info[:free] = free * 1024
+            mem_info[:available] = available * 1024
+            mem_info[:used] = mem_info[:total] - mem_info[:free]
+          else
+            # For non-Linux systems, try to get memory info from platform-specific commands
+            case RbConfig::CONFIG["host_os"]
+            when /darwin/
+              # macOS
+              begin
+                mem_data = `sysctl hw.memsize hw.physmem`.strip.split("\n")
+                total = mem_data.grep(/hw.memsize/).first&.split(":")&.last.to_i
+                mem_info[:total] = total if total&.positive?
+              rescue StandardError => e
+                log_error "Failed to get macOS memory info: #{e.message}"
+              end
+            end
+          end
+
+          mem_info
+        rescue StandardError => e
+          log_error "Failed to get memory info: #{e.message}"
+          { total: 0, free: 0, available: 0, used: 0 }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # Collect disk information
+        #
+        # @return [Hash] disk information
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def collect_disk_info
+          disk_info = {
+            total: 0,
+            free: 0,
+            used: 0,
+            filesystems: []
+          }
+
+          # Use df command to get disk usage
+          begin
+            df_output = `df -k`.strip.split("\n")
+            df_output.shift # Remove header line
+
+            df_output.each do |line|
+              parts = line.split(/\s+/)
+              next if parts.size < 6 # Skip invalid lines
+
+              filesystem = {
+                device: parts[0],
+                mount_point: parts[5],
+                total: parts[1].to_i * 1024, # Convert KB to bytes
+                used: parts[2].to_i * 1024,
+                free: parts[3].to_i * 1024,
+                usage_percent: parts[4].to_i
+              }
+
+              disk_info[:filesystems] << filesystem
+
+              # Only count real filesystems (not special ones)
+              next if filesystem[:device].start_with?("tmpfs", "devtmpfs", "none")
+
+              disk_info[:total] += filesystem[:total]
+              disk_info[:used] += filesystem[:used]
+              disk_info[:free] += filesystem[:free]
+            end
+          rescue StandardError => e
+            log_error "Failed to get disk info: #{e.message}"
+          end
+
+          disk_info
+        rescue StandardError => e
+          log_error "Failed to get disk info: #{e.message}"
+          { total: 0, free: 0, used: 0, filesystems: [] }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        # Collect process information
+        #
+        # @return [Hash] process information
+        def collect_process_info
+          {
+            pid: Process.pid,
+            ppid: Process.ppid,
+            uid: Process.uid,
+            gid: Process.gid,
+            working_directory: Dir.pwd
+          }
+        rescue StandardError => e
+          log_error "Failed to get process info: #{e.message}"
+          { pid: 0, ppid: 0, uid: 0, gid: 0, working_directory: "unknown" }
+        end
+
+        # Collect load average information
+        #
+        # @return [Hash] load average information
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def collect_load_info
+          load_avg = [0.0, 0.0, 0.0]
+          load_info = {
+            "1min" => 0.0,
+            "5min" => 0.0,
+            "15min" => 0.0
+          }
+
+          # Try to get load average from /proc/loadavg
+          if File.exist?("/proc/loadavg")
+            begin
+              loadavg = File.read("/proc/loadavg").strip.split
+              load_avg = [loadavg[0].to_f, loadavg[1].to_f, loadavg[2].to_f]
+            rescue StandardError => e
+              log_error "Failed to read /proc/loadavg: #{e.message}"
+            end
+          else
+            # Try to get load average using uptime command
+            begin
+              uptime = `uptime`.strip
+              if uptime =~ /load average:?\s+([\d.]+),?\s+([\d.]+),?\s+([\d.]+)/
+                load_avg = [::Regexp.last_match(1).to_f, ::Regexp.last_match(2).to_f,
+                            ::Regexp.last_match(3).to_f]
+              end
+            rescue StandardError => e
+              log_error "Failed to get load average from uptime: #{e.message}"
+            end
+          end
+
+          load_info["1min"] = load_avg[0]
+          load_info["5min"] = load_avg[1]
+          load_info["15min"] = load_avg[2]
+          load_info
+        rescue StandardError => e
+          log_error "Failed to get load info: #{e.message}"
+          { "1min" => 0.0, "5min" => 0.0, "15min" => 0.0 }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        # Collect system uptime
+        #
+        # @return [Hash] uptime information
+        # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+        def collect_uptime
+          uptime_seconds = 0
+          uptime_info = {
+            seconds: 0,
+            formatted: "0 days, 0 hours, 0 minutes"
+          }
+
+          if File.exist?("/proc/uptime")
+            begin
+              uptime_seconds = File.read("/proc/uptime").strip.split.first.to_f
+            rescue StandardError => e
+              log_error "Failed to read /proc/uptime: #{e.message}"
+            end
+          else
+            # Try to get uptime using uptime command
+            begin
+              uptime_output = `uptime`.strip
+              if uptime_output =~ /up\s+(\d+)\s+days?,\s+(\d+):(\d+)/
+                days = ::Regexp.last_match(1).to_i
+                hours = ::Regexp.last_match(2).to_i
+                minutes = ::Regexp.last_match(3).to_i
+                uptime_seconds = (days * 86_400) + (hours * 3600) + (minutes * 60)
+              elsif uptime_output =~ /up\s+(\d+):(\d+)/
+                hours = ::Regexp.last_match(1).to_i
+                minutes = ::Regexp.last_match(2).to_i
+                uptime_seconds = (hours * 3600) + (minutes * 60)
+              end
+            rescue StandardError => e
+              log_error "Failed to get uptime from uptime command: #{e.message}"
+            end
+          end
+
+          uptime_info[:seconds] = uptime_seconds.to_i
+          uptime_info[:formatted] = format_uptime(uptime_seconds)
+          uptime_info
+        rescue StandardError => e
+          log_error "Failed to get uptime: #{e.message}"
+          { seconds: 0, formatted: "0 days, 0 hours, 0 minutes" }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+
+        # Format uptime seconds into a human-readable string
+        #
+        # @param seconds [Float] uptime in seconds
+        # @return [String] formatted uptime
+        def format_uptime(seconds)
+          seconds = seconds.to_i
+          days = seconds / 86_400
+          seconds %= 86_400
+          hours = seconds / 3600
+          seconds %= 3600
+          minutes = seconds / 60
+
+          "#{days} days, #{hours} hours, #{minutes} minutes"
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end