detector 0.8.1 → 0.8.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 160f91ff5337a5e65db122754c58acf167ea6c92a2628b6c4cae37dfbebbd2e9
-  data.tar.gz: '0691d5918ca772909057ebf059947f4f1b08cd8b5388f0cc7836842d980bf677'
+  metadata.gz: cc4e247924e74260a5c977c3dd3aedfe4ede09cf38533b0491b7194aaf9e9978
+  data.tar.gz: ecf78188a1bb18159c419c5ea7791a67f1c144c10785d765eb06f33ba51c727c
 SHA512:
-  metadata.gz: a192f06a2497b21ac4475d2686615450eb800a888367a02eefb36dcf3ae5f7959712a49f4a33012aaa554fabd4d18390aac08e9671dddef38f6f4d8d97c9e561
-  data.tar.gz: f9426467573fae22f8fb192b342d376cc1fd04036079821c62c354f3dc0fe426417cdf34a8e3a18e7b09bda36ee2478176fcd1d70d2ac4c3642ea4b10aaa69e6
+  metadata.gz: f131b6e65f64ec7283f34b86464ea63e1605c41f46d74987693158ec3b6a24f2e599d2bb512b111a1815afedafcfe8852a0ceda776e3780aaac2090a7d3960df
+  data.tar.gz: 82a1ebf34a59ecdb8efc97ca8ac66edf115f601bcc77845b2abaddedbc298d1f88c865f55a07584974b915c0b82ec0ba66f1ec3390f4275d1a1e4b0295c89760

data/bin/detector

@@ -45,15 +45,42 @@ end
 
 puts "Detector v#{Detector::VERSION}"
 puts "Detected: #{detector.kind}"
-puts "Version: #{detector.version}"
+
+if ENV['DETECTOR_DEBUG']
+  puts "Database: #{detector.uri.path ? detector.uri.path.sub(/^\//, '') : 'none'}"
+  
+  # In debug mode, if the detector has connection_error method, show error details
+  if detector.respond_to?(:connection_error) && detector.connection_error
+    error = detector.connection_error
+    puts "CONNECTION ERROR: #{error[:message]} (#{error[:type]}, code: #{error[:error_number]})"
+  end
+end
+
+if detector.version
+  puts "Version: #{detector.version}"
+else
+  puts "Database connection issue: please check credentials and database name"
+  # Check if we have a max_user_connections error
+  if ENV['DETECTOR_DEBUG'] && detector&.connection.nil?
+    puts "Debug: connection method returned nil, trying connection directly for diagnostics..."
+    puts "Credentials: #{detector.uri.user}:**** @ #{detector.host}:#{detector.port}"
+  end
+end
 puts "Host: #{detector.host}:#{detector.port}"
 
 if detector.respond_to?(:connection_info) && detector.connection_info
   conn_info = detector.connection_info
-  puts "Connections: global #{conn_info[:connection_count][:global]}/#{conn_info[:connection_limits][:global]} (user #{conn_info[:connection_count][:user]}/#{conn_info[:connection_limits][:user]})"
+  if conn_info[:error]
+    puts "Connections: #{conn_info[:error]}"
+  else
+    puts "Connections: global #{conn_info[:connection_count][:global]}/#{conn_info[:connection_limits][:global]} (user #{conn_info[:connection_count][:user]}/#{conn_info[:connection_limits][:user]})"
+  end
 elsif detector.connection_count && detector.connection_limit
   usage = detector.connection_usage_percentage
   puts "Connections: #{detector.connection_count}/#{detector.connection_limit} (#{usage}%)"
+else
+  # No connection info available
+  puts "Connections: Unable to retrieve connection information"
 end
 
 if detector.respond_to?(:replication_available?) && !detector.replication_available?.nil?
@@ -82,26 +109,44 @@ end
 
 if detector.databases?
   db_count = detector.database_count
-  puts "\nDatabases: #{db_count}"
+  puts "\nDatabases: #{db_count || 'Unknown'}"
   
   if db_count && db_count > 0
-    dbs = detector.databases.first(3)
-    dbs.each do |db|
-      db_name = db[:name]
-      puts "\nDatabase: #{db_name} (#{db[:size]})"
-      
-      if detector.tables?
-        if db[:table_count]
-          puts "  Tables: #{db[:table_count]}"
-        else
-          puts "  Tables: #{detector.table_count(db_name)}"
-        end
-        
-        tables = detector.tables(db_name).first(3) 
-        tables.each do |table|
-          puts "    - #{table[:name]}: #{table[:row_count]} rows (#{table[:size]})"
+    begin
+      dbs = detector.databases.first(3)
+      if dbs.empty?
+        puts "  No databases found or access denied"
+      else
+        dbs.each do |db|
+          db_name = db[:name]
+          puts "\nDatabase: #{db_name} (#{db[:size]})"
+          
+          if detector.tables?
+            if db[:table_count]
+              puts "  Tables: #{db[:table_count]}"
+            else
+              puts "  Tables: #{detector.table_count(db_name) || 'Unknown'}"
+            end
+            
+            begin
+              tables = detector.tables(db_name).first(3)
+              if tables.empty?
+                puts "    No tables found or access denied"
+              else
+                tables.each do |table|
+                  puts "    - #{table[:name]}: #{table[:row_count]} rows (#{table[:size]})"
+                end
+              end
+            rescue => e
+              puts "    Error retrieving tables: #{e.message}" if ENV['DETECTOR_DEBUG']
+              puts "    No tables available (access error)"
+            end
+          end
         end
       end
+    rescue => e
+      puts "  Error retrieving databases: #{e.message}" if ENV['DETECTOR_DEBUG']
+      puts "  No database information available (access error)"
     end
   end
 end

data/lib/detector/addons/mariadb.rb

@@ -10,43 +10,233 @@ module Detector
       def self.capabilities_for(url)
         { sql: true, kv: true, url: url, kind: :mariadb, databases: true, tables: true }
       end
+      
+      # Determine if an error is retriable
+      def retriable_error?(error_number)
+        # List of error codes that might be temporary and worth retrying
+        retriable_codes = [
+          1040, # Too many connections
+          1053, # Server shutdown in progress
+          1077, # Connection refused
+          2002, # Connection refused
+          2003, # Can't connect to MySQL server
+          2006, # MySQL server has gone away
+          2008, # Client ran out of memory
+          2013, # Lost connection during query
+          2026, # SSL connection error
+          2055  # Lost connection to MySQL server at '%s', system error: %d
+        ]
+        
+        retriable_codes.include?(error_number)
+      end
+      
+      # Retry a connection with exponential backoff
+      def with_retry(max_retries = 3)
+        retries = 0
+        
+        begin
+          yield
+        rescue Mysql2::Error => e
+          if retriable_error?(e.error_number) && retries < max_retries
+            retries += 1
+            wait_time = 0.5 * (2 ** retries) # Exponential backoff: 1s, 2s, 4s, etc.
+            
+            puts "Connection error (#{e.error_number}): #{e.message}. Retrying in #{wait_time}s (attempt #{retries}/#{max_retries})..." if ENV['DETECTOR_DEBUG']
+            
+            sleep(wait_time)
+            retry
+          else
+            # Not retriable or max retries reached
+            raise
+          end
+        end
+      end
     
+      # Cache for database requests
+      def initialize(url)
+        super
+        @cache = {}
+      end
+    
+      def connection
+        # Return cached connection if already established
+        return @conn if @conn && @conn.ping
+        
+        # Override the MySQL connection method with MariaDB-specific settings
+        # Handle URI path correctly - strip leading slash if present
+        db_name = uri.path ? uri.path.sub(/^\//, '') : nil
+        
+        begin
+          # Try with retry for retriable errors
+          with_retry do
+            # MariaDB-specific connection with fixed init command syntax
+            conn = Mysql2::Client.new(
+              host: host,
+              username: uri.user,
+              password: uri.password,
+              database: db_name,
+              port: port,
+              connect_timeout: 15,
+              read_timeout: 30,
+              write_timeout: 30,
+              reconnect: true
+              # No init_command - caused issues with MariaDB
+            )
+            
+            # Test the connection with a simple query
+            conn.query("SELECT 1")
+            @conn = conn
+          end
+          
+          @conn
+        rescue Mysql2::Error => e
+          error_message = "MariaDB connection error: #{e.message}"
+          error_type = case
+            when e.error_number == 1226 then "max_user_connections exceeded"
+            when e.error_number == 1045 then "access denied (auth failure)"
+            when e.error_number == 1049 then "unknown database '#{db_name}'"
+            when e.error_number == 2003 then "server unavailable or network error"
+            when e.error_number == 2005 then "unknown host"
+            when e.error_number == 2006 then "server gone away"
+            when e.error_number == 2013 then "connection lost"
+            else "general error"
+          end
+          
+          puts "#{error_message} [#{error_type}]" if ENV['DETECTOR_DEBUG']
+          
+          # Store the error information
+          @cache[:connection_error] = {
+            message: e.message,
+            type: error_type,
+            error_number: e.error_number,
+            retriable: retriable_error?(e.error_number)
+          }
+          
+          nil
+        rescue => e
+          # For non-MySQL errors, still capture them
+          puts "General connection error: #{e.class} - #{e.message}" if ENV['DETECTOR_DEBUG']
+          @cache[:connection_error] = {
+            message: e.message,
+            type: "general error",
+            error_number: 0,
+            retriable: false
+          }
+          nil
+        end
+      end
+      
+      # Method to execute queries with retry for retriable errors
+      def execute_query(query)
+        return nil unless connection
+        
+        begin
+          with_retry do
+            connection.query(query)
+          end
+        rescue => e
+          puts "Query execution error: #{e.message}" if ENV['DETECTOR_DEBUG']
+          nil
+        end
+      end
+      
+      def connection_error
+        @cache[:connection_error]
+      end
+      
+      def info
+        # Cache the info to avoid repeated queries
+        return @cache[:info] if @cache[:info]
+        
+        # If we have a database and user but no connection, return basic info with error details
+        if connection.nil? && uri.path && uri.user
+          db_name = uri.path.sub(/^\//, '')
+          error_msg = connection_error ? " (#{connection_error[:type]})" : " (connection issue)"
+          
+          @cache[:info] = {
+            'version' => "Unknown#{error_msg}",
+            'database' => db_name,
+            'user' => "#{uri.user}@remote"
+          }
+          return @cache[:info]
+        end
+        
+        # Otherwise try to get info from connection
+        return nil unless connection
+        begin
+          result = execute_query("SELECT VERSION() AS version, DATABASE() AS `database`, USER() AS user")
+          @cache[:info] = result ? result.first : nil
+          return @cache[:info]
+        rescue Mysql2::Error => e
+          error_type = case
+            when e.error_number == 1226 then "max_user_connections exceeded"
+            else "query error"
+          end
+          
+          puts "MariaDB info error: #{e.message} [#{error_type}]" if ENV['DETECTOR_DEBUG']
+          
+          db_name = uri.path ? uri.path.sub(/^\//, '') : 'unknown'
+          {
+            'version' => "Unknown (#{error_type})",
+            'database' => db_name,
+            'user' => "#{uri.user}@error"
+          }
+        rescue => e
+          puts "General info error: #{e.message}" if ENV['DETECTOR_DEBUG']
+          nil
+        end
+      end
+      
       def version
+        # Cache the version to avoid repeated queries
+        return @cache[:version] if @cache[:version]
+        
         return nil unless info
-        "MariaDB #{info['version']} on #{info['database']} (#{info['user']})"
+        begin
+          @cache[:version] = "MariaDB #{info['version']} on #{info['database']} (#{info['user']})"
+          return @cache[:version]
+        rescue => e
+          @cache[:version] = "MariaDB (connection error: #{e.message})"
+          return @cache[:version]
+        end
       end
       
       def databases
+        # Cache the databases to avoid repeated queries
+        return @cache[:databases] if @cache[:databases]
+        
         return [] unless connection
         begin
-          # First get all databases
-          db_list = connection.query("SELECT schema_name AS name 
-                                     FROM information_schema.SCHEMATA 
-                                     WHERE schema_name NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')").map do |row|
-            row['name']
-          end
+          # Get all databases at once to reduce connections
+          query = "SELECT 
+                    s.schema_name AS name,
+                    IFNULL(FORMAT(SUM(t.data_length + t.index_length) / 1024 / 1024, 2), '0.00') AS size_mb,
+                    IFNULL(SUM(t.data_length + t.index_length), 0) AS raw_size,
+                    COUNT(t.table_name) AS table_count
+                  FROM information_schema.SCHEMATA s
+                  LEFT JOIN information_schema.TABLES t ON t.table_schema = s.schema_name
+                  WHERE s.schema_name NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
+                  GROUP BY s.schema_name
+                  ORDER BY raw_size DESC"
+                  
+          result = execute_query(query)
           
-          # For each database, get its size
-          result = []
-          db_list.each do |db_name|
-            size_query = "SELECT 
-                            IFNULL(FORMAT(SUM(data_length + index_length) / 1024 / 1024, 2), '0.00') AS size_mb,
-                            IFNULL(SUM(data_length + index_length), 0) AS raw_size,
-                            COUNT(table_name) AS table_count
-                          FROM information_schema.TABLES 
-                          WHERE table_schema = '#{db_name}'"
+          if result
+            db_list = result.map do |row|
+              { 
+                name: row['name'], 
+                size: "#{row['size_mb']} MB", 
+                raw_size: row['raw_size'].to_i,
+                table_count: row['table_count'].to_i
+              }
+            end
             
-            size_data = connection.query(size_query).first
-            result << { 
-              name: db_name, 
-              size: "#{size_data['size_mb']} MB", 
-              raw_size: size_data['raw_size'].to_i,
-              table_count: size_data['table_count'].to_i
-            }
+            # Sort by size
+            @cache[:databases] = db_list.sort_by { |db| -db[:raw_size] }
+            return @cache[:databases]
+          else
+            return []
           end
-          
-          # Sort by size
-          @databases = result.sort_by { |db| -db[:raw_size] }
         rescue => e
           puts "Error getting databases: #{e.message}"
           []
@@ -54,48 +244,175 @@ module Detector
       end
       
       def connection_info
-        return nil unless connection
+        # Cache connection info to avoid repeated queries
+        return @cache[:connection_info] if @cache[:connection_info]
+        
+        # If no connection is available, provide error information
+        if connection.nil?
+          error_msg = connection_error ? connection_error[:type] : "unknown error"
+          
+          @cache[:connection_info] = {
+            connection_count: { user: "ERROR", global: "ERROR" },
+            connection_limits: { user: "ERROR", global: "ERROR" },
+            error: "Connection error: #{error_msg}"
+          }
+          return @cache[:connection_info]
+        end
+        
+        # If connection is available, get actual connection info
         begin
-          user_limit = connection.query("SELECT @@max_user_connections AS `limit`").first['limit'].to_i
-          user_count = connection.query("SELECT COUNT(*) AS count FROM information_schema.PROCESSLIST WHERE user = USER()").first['count'].to_i
-          global_limit = connection.query("SELECT @@max_connections AS `limit`").first['limit'].to_i
-          global_count = connection.query("SELECT COUNT(*) AS count FROM information_schema.PROCESSLIST").first['count'].to_i
+          user_limit_result = execute_query("SELECT @@max_user_connections AS `limit`")
+          user_count_result = execute_query("SELECT COUNT(*) AS count FROM information_schema.PROCESSLIST WHERE user = USER()")
+          global_limit_result = execute_query("SELECT @@max_connections AS `limit`")
+          global_count_result = execute_query("SELECT COUNT(*) AS count FROM information_schema.PROCESSLIST")
+          
+          # Check if any query failed
+          if !user_limit_result || !user_count_result || !global_limit_result || !global_count_result
+            return {
+              connection_count: { user: "ERROR", global: "ERROR" },
+              connection_limits: { user: "ERROR", global: "ERROR" },
+              error: "Error executing connection info queries"
+            }
+          end
+          
+          user_limit = user_limit_result.first['limit'].to_i
+          user_count = user_count_result.first['count'].to_i
+          global_limit = global_limit_result.first['limit'].to_i
+          global_count = global_count_result.first['count'].to_i
           
           # If user limit is 0, it means no specific per-user limit (use global)
           user_limit = global_limit if user_limit == 0
           
-          {
+          @cache[:connection_info] = {
             connection_count: { user: user_count, global: global_count },
             connection_limits: { user: user_limit, global: global_limit }
           }
+          return @cache[:connection_info]
+        rescue Mysql2::Error => e
+          error_type = case
+            when e.error_number == 1226 then "max_user_connections exceeded"
+            else "query error"
+          end
+          
+          puts "MariaDB connection_info error: #{e.message} [#{error_type}]" if ENV['DETECTOR_DEBUG']
+          
+          @cache[:connection_info] = {
+            connection_count: { user: "ERROR", global: "ERROR" },
+            connection_limits: { user: "ERROR", global: "ERROR" },
+            error: "Connection error: #{error_type}"
+          }
+          return @cache[:connection_info]
+        rescue => e
+          puts "General connection_info error: #{e.message}" if ENV['DETECTOR_DEBUG']
+          nil
+        end
+      end
+      
+      def database_count
+        # Cache database count to avoid repeated queries
+        return @cache[:database_count] if @cache[:database_count]
+        
+        # If we have databases from cache, use the count
+        if @cache[:databases]
+          @cache[:database_count] = @cache[:databases].size
+          return @cache[:database_count]
+        end
+        
+        # If no connection is available but we know the database name
+        if connection.nil? && uri.path
+          @cache[:database_count] = 1
+          return @cache[:database_count]
+        end
+        
+        # Try to query the database
+        return nil unless connection
+        
+        begin
+          result = execute_query("SELECT COUNT(*) AS count FROM information_schema.SCHEMATA WHERE schema_name NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')")
+          
+          if result && result.first
+            @cache[:database_count] = result.first['count']
+            return @cache[:database_count]
+          else
+            return 0
+          end
+        rescue Mysql2::Error => e
+          puts "Error getting database count: #{e.message} [#{e.error_number}]" if ENV['DETECTOR_DEBUG']
+          
+          # If this is an authentication or permission error, return 0
+          if e.error_number == 1045 || e.error_number == 1044
+            return 0
+          end
+          
+          # For max connections error, assume at least 1 database
+          if e.error_number == 1226 && uri.path
+            return 1
+          end
+          
+          nil
         rescue => e
-          puts "Error getting connection info: #{e.message}"
+          puts "General error getting database count: #{e.message}" if ENV['DETECTOR_DEBUG']
           nil
         end
       end
       
       def tables(database_name)
+        # Cache tables to avoid repeated queries
+        @tables ||= {}
+        return @tables[database_name] if @tables[database_name]
+        
+        # If no connection, try to provide at least some basic info from known values
+        if connection.nil? && uri.path && uri.path.sub(/^\//, '') == database_name
+          # We know this is the database in the URL, so return some hardcoded data
+          if @cache[:dummy_tables]
+            return @cache[:dummy_tables]
+          else
+            # No tables data available
+            return []
+          end
+        end
+        
         return [] unless connection
         
         begin
-          @tables ||= {}
-          @tables[database_name] ||= connection.query("SELECT 
-                                                 table_name AS name, 
-                                                 IFNULL(FORMAT((data_length + index_length) / 1024 / 1024, 2), '0.00') AS size_mb,
-                                                 IFNULL((data_length + index_length), 0) AS raw_size,
-                                                 IFNULL(table_rows, 0) AS row_count
-                                                 FROM information_schema.TABLES 
-                                                 WHERE table_schema = '#{database_name}'
-                                                 ORDER BY raw_size DESC").map do |row|
-            { 
-              name: row['name'], 
-              size: "#{row['size_mb']} MB", 
-              raw_size: row['raw_size'].to_i, 
-              row_count: row['row_count'].to_i 
-            }
+          result = execute_query("SELECT 
+                                table_name AS name, 
+                                IFNULL(FORMAT((data_length + index_length) / 1024 / 1024, 2), '0.00') AS size_mb,
+                                IFNULL((data_length + index_length), 0) AS raw_size,
+                                IFNULL(table_rows, 0) AS row_count
+                                FROM information_schema.TABLES 
+                                WHERE table_schema = '#{database_name}'
+                                ORDER BY raw_size DESC")
+                                
+          if result
+            @tables[database_name] = result.map do |row|
+              { 
+                name: row['name'], 
+                size: "#{row['size_mb']} MB", 
+                raw_size: row['raw_size'].to_i, 
+                row_count: row['row_count'].to_i 
+              }
+            end
+            return @tables[database_name]
+          else
+            @tables[database_name] = []
+            return []
           end
+        rescue Mysql2::Error => e
+          error_type = case
+            when e.error_number == 1044 then "access denied to information_schema"
+            when e.error_number == 1045 then "authentication failure"
+            when e.error_number == 1226 then "max_user_connections exceeded"
+            else "query error (#{e.error_number})"
+          end
+          
+          puts "Error getting tables for #{database_name}: #{e.message} [#{error_type}]" if ENV['DETECTOR_DEBUG']
+          
+          # Store the error for debugging
+          @tables[database_name] = []
+          return []
         rescue => e
-          puts "Error getting tables for #{database_name}: #{e.message}"
+          puts "General error getting tables for #{database_name}: #{e.message}" if ENV['DETECTOR_DEBUG']
           []
         end
       end

data/lib/detector/addons/mysql.rb

@@ -13,13 +13,29 @@ module Detector
     
       def connection
         # Create a new connection each time without caching
-        Mysql2::Client.new(
-          host: host,
-          username: uri.user,
-          password: uri.password,
-          database: uri.path[1..-1],
-          port: port
-        ) rescue nil
+        # Handle URI path correctly - strip leading slash if present
+        db_name = uri.path ? uri.path.sub(/^\//, '') : nil
+        
+        begin
+          # Try connection with longer timeouts - fix for MariaDB syntax
+          Mysql2::Client.new(
+            host: host,
+            username: uri.user,
+            password: uri.password,
+            database: db_name,
+            port: port,
+            connect_timeout: 15,
+            read_timeout: 30,
+            write_timeout: 30,
+            init_command: "SET wait_timeout=900; SET interactive_timeout=900"
+          )
+        rescue Mysql2::Error => e
+          puts "MySQL connection error: #{e.message}" if ENV['DETECTOR_DEBUG']
+          nil
+        rescue => e
+          puts "General connection error: #{e.class} - #{e.message}" if ENV['DETECTOR_DEBUG']
+          nil
+        end
       end
       
       def info
@@ -109,6 +125,16 @@ module Detector
             connection_count: { user: user_count, global: global_count },
             connection_limits: { user: user_limit, global: global_limit }
           }
+        rescue Mysql2::Error => e
+          if e.error_number == 1226 # User has exceeded max_user_connections
+            {
+              connection_count: { user: "LIMIT EXCEEDED", global: "N/A" },
+              connection_limits: { user: "EXCEEDED", global: "N/A" },
+              error: "Error: User has exceeded max_user_connections limit"
+            }
+          else
+            nil
+          end
         rescue => e
           nil
         end

data/lib/detector/version.rb

@@ -1,3 +1,3 @@
 module Detector
-  VERSION = "0.8.1"
+  VERSION = "0.8.12"
 end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: detector
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.12
 platform: ruby
 authors:
 - Jonathan Siegel