detector 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 666536fd481e1b7dbd4a1425eac6da54aa29a67a9e3cc6247b63de0752accf67
-  data.tar.gz: 4c06d6e51d8b60d10be5f2f126c65bd0d2cba9a815192c1c0ab7a37edd148974
+  metadata.gz: d21e960cc4220b3bf67a98d0ce5ef7f367710545173ff09cfcee580cc3895e64
+  data.tar.gz: dba6d148d06ea37444017539b0bb23fd43cb96c9deeedf6235fc8e5cfe3999b7
 SHA512:
-  metadata.gz: 14bdd91ff681914a3158dea8798e0a70c8ecc947e9a4be4172bdefb89996dcf3e658127d3d2251481b6f1ae6eaf749a60d152e524c2f4cccaee8135fd12eb68f
-  data.tar.gz: 28f3d5e64a8bec859a00bba960f5772289f9511d00c7106889b54dfd411428400b06ef3dcc4dce494c0216bc0a4fa929ae266c01239768a0e4e7c1bbc1d9e77c
+  metadata.gz: 19732b310f2f739e03c478103ebb1de34979145fd867d5beab4c82d8ef14c6405c7b4d9bac18849b79adba3dfc9e0e25c4dd0fcada4d6321e95a0822a9cc3efc
+  data.tar.gz: 318344d8e1f23196e5fe2eef8435aec32729fe488d41b0277bcf567117df1f3dbe105269777310a51344aba2453565adc1506c014d1c972a33b02c8f32d1afe5

data/bin/detector

@@ -7,10 +7,23 @@ if ARGV.empty?
   puts "Detector v#{Detector::VERSION}"
   puts "Usage: detector <URI>"
   puts "Example: detector \"postgres://user:pass@host:port/dbname\""
+  puts "Additional options:"
+  puts "  --table=TABLE_NAME [--database=DB_NAME] : Estimate row count for a specific table"
   exit 1
 end
 
 uri = ARGV[0]
+options = {}
+
+# Parse command-line options
+ARGV[1..-1].each do |arg|
+  if arg.start_with?('--table=')
+    options[:table] = arg.split('=', 2)[1]
+  elsif arg.start_with?('--database=')
+    options[:database] = arg.split('=', 2)[1]
+  end
+end
+
 detector = Detector.detect(uri)
 
 if detector.nil?
@@ -18,12 +31,27 @@ if detector.nil?
   exit 1
 end
 
+# If table is specified, show row count estimate and exit
+if options[:table]
+  count = detector.estimated_row_count(table: options[:table], database: options[:database])
+  if count
+    puts "Estimated row count for #{options[:table]}: #{count}"
+  else
+    puts "Unable to estimate row count for #{options[:table]}"
+  end
+  detector.close
+  exit 0
+end
+
 puts "Detector v#{Detector::VERSION}"
 puts "Detected: #{detector.kind}"
 puts "Version: #{detector.version}"
 puts "Host: #{detector.host}:#{detector.port}"
 
-if detector.connection_count && detector.connection_limit
+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]})"
+elsif detector.connection_count && detector.connection_limit
   usage = detector.connection_usage_percentage
   puts "Connections: #{detector.connection_count}/#{detector.connection_limit} (#{usage}%)"
 end
@@ -76,4 +104,7 @@ if detector.databases?
       end
     end
   end
-end 
+end
+
+# Make sure to close the connection
+detector.close 

data/lib/detector/addons/mariadb.rb

@@ -53,6 +53,27 @@ module Detector
         end
       end
       
+      def connection_info
+        return nil unless connection
+        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
+          
+          # If user limit is 0, it means no specific per-user limit (use global)
+          user_limit = global_limit if user_limit == 0
+          
+          {
+            connection_count: { user: user_count, global: global_count },
+            connection_limits: { user: user_limit, global: global_limit }
+          }
+        rescue => e
+          puts "Error getting connection info: #{e.message}"
+          nil
+        end
+      end
+      
       def tables(database_name)
         return [] unless connection
         
@@ -108,6 +129,11 @@ module Detector
         
         access_level
       end
+      
+      # MariaDB inherits the estimated_row_count method from MySQL, but we might want to override
+      # with MariaDB-specific optimizations or different statistics approaches in the future
+      
+      # MariaDB inherits the close method from MySQL
     end
   end
   

data/lib/detector/addons/mysql.rb

@@ -93,6 +93,26 @@ module Detector
         connection.query("SHOW VARIABLES LIKE 'max_connections'").first['Value'].to_i
       end
       
+      def connection_info
+        return nil unless connection
+        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
+          
+          # If user limit is 0, it means no specific per-user limit (use global)
+          user_limit = global_limit if user_limit == 0
+          
+          {
+            connection_count: { user: user_count, global: global_count },
+            connection_limits: { user: user_limit, global: global_limit }
+          }
+        rescue => e
+          nil
+        end
+      end
+      
       def cli_name
         "mysql"
       end
@@ -187,6 +207,33 @@ module Detector
           nil
         end
       end
+      
+      def estimated_row_count(table:, database: nil)
+        return nil unless connection
+        
+        # Use current database if none specified
+        db_name = database || info['database']
+        return nil unless db_name
+        
+        begin
+          # Query information_schema.tables for the statistics-based row estimate
+          result = connection.query("SELECT table_rows AS estimate 
+                                   FROM information_schema.tables 
+                                   WHERE table_schema = '#{db_name}' 
+                                   AND table_name = '#{table}'").first
+          
+          result ? result['estimate'].to_i : nil
+        rescue => e
+          nil
+        end
+      end
+      
+      def close
+        if @conn
+          @conn.close rescue nil
+          @conn = nil
+        end
+      end
     end
   end
   

data/lib/detector/addons/postgres.rb

@@ -146,6 +146,28 @@ module Detector
         connection.exec("SELECT current_setting('max_connections')").first['current_setting'].to_i
       end
       
+      def connection_info
+        return nil unless connection
+        begin
+          global_limit = connection.exec("SELECT current_setting('max_connections')").first['current_setting'].to_i
+          global_count = connection.exec("SELECT count(*) FROM pg_stat_activity").first['count'].to_i
+          
+          # For PostgreSQL user connections - depends on per-user limits if set
+          user_limit_result = connection.exec("SELECT rolconnlimit FROM pg_roles WHERE rolname = current_user").first
+          user_limit = user_limit_result['rolconnlimit'].to_i
+          user_limit = global_limit if user_limit <= 0 # If unlimited, use global limit
+          
+          user_count = connection.exec("SELECT count(*) FROM pg_stat_activity WHERE usename = current_user").first['count'].to_i
+          
+          {
+            connection_count: { user: user_count, global: global_count },
+            connection_limits: { user: user_limit, global: global_limit }
+          }
+        rescue => e
+          nil
+        end
+      end
+      
       def cli_name
         "psql"
       end
@@ -204,6 +226,46 @@ module Detector
           nil
         end
       end
+      
+      def estimated_row_count(table:, database: nil)
+        return nil unless connection
+        
+        # Use the current database if none is specified
+        db_name = database || current_database
+        
+        begin
+          # If we need to query a different database, temporarily connect to it
+          if db_name != current_database
+            # Create a temporary connection to the specified database
+            temp_conn = PG::Connection.new(host: host, port: port, user: uri.user, 
+                                         password: uri.password, dbname: db_name) rescue nil
+            return nil unless temp_conn
+            
+            # Use pg_class.reltuples for a fast, statistics-based row estimate
+            count = temp_conn.exec("SELECT reltuples::bigint AS estimate 
+                                  FROM pg_class 
+                                  WHERE relname = '#{table}'").first
+            temp_conn.close
+            return count ? count['estimate'].to_i : nil
+          end
+          
+          # Query the current database using pg_class.reltuples
+          count = connection.exec("SELECT reltuples::bigint AS estimate 
+                                FROM pg_class 
+                                WHERE relname = '#{table}'").first
+          
+          count ? count['estimate'].to_i : nil
+        rescue => e
+          nil
+        end
+      end
+      
+      def close
+        if @conn
+          @conn.close rescue nil
+          @conn = nil
+        end
+      end
     end
   end
   

data/lib/detector/addons/redis.rb

@@ -1,4 +1,5 @@
 require 'redis'
+require 'timeout'
 
 module Detector
   module Addons
@@ -68,6 +69,22 @@ module Detector
         info['maxclients'].to_i rescue 0
       end
       
+      def connection_info
+        return nil unless info
+        begin
+          # Redis doesn't have per-user connection limits, so user = global
+          global_count = info['connected_clients'].to_i rescue 0
+          global_limit = info['maxclients'].to_i rescue 0
+          
+          {
+            connection_count: { user: global_count, global: global_count },
+            connection_limits: { user: global_limit, global: global_limit }
+          }
+        rescue => e
+          nil
+        end
+      end
+      
       def cli_name
         "redis-cli"
       end
@@ -171,6 +188,52 @@ module Detector
           nil
         end
       end
+      
+      def estimated_row_count(table:, database: nil)
+        return nil unless connection
+        
+        # In Redis, the database is a number (0-15 typically) and "table" concept is closest to key patterns
+        # We'll interpret table parameter as a key pattern
+        
+        begin
+          # Set the database if specified
+          if database
+            # Redis db numbers are integers
+            db_num = database.to_s.gsub(/[^0-9]/, '').to_i
+            connection.select(db_num) rescue nil
+          end
+          
+          # Count keys matching the pattern (consider this a heuristic approximation)
+          # Use SCAN for larger datasets, as it doesn't block the server
+          count = 0
+          cursor = "0"
+          
+          begin
+            # Timeout after a reasonable time to prevent long-running operations
+            Timeout.timeout(5) do
+              loop do
+                cursor, keys = connection.scan(cursor, match: table, count: 1000)
+                count += keys.size
+                break if cursor == "0"
+              end
+            end
+          rescue Timeout::Error
+            # If we time out, return the partial count with a note
+            return count
+          end
+          
+          count
+        rescue => e
+          nil
+        end
+      end
+      
+      def close
+        if @conn
+          @conn.quit rescue nil
+          @conn = nil
+        end
+      end
     end
   end
   

data/lib/detector/base.rb

@@ -232,5 +232,23 @@ module Detector
       return nil unless connection_count && connection_limit && connection_limit > 0
       (connection_count.to_f / connection_limit.to_f * 100).round(1)
     end
+    
+    def connection_info
+      # Default implementation for databases without user-specific limits
+      return nil unless connection_count && connection_limit
+      {
+        connection_count: { user: connection_count, global: connection_count },
+        connection_limits: { user: connection_limit, global: connection_limit }
+      }
+    end
+    
+    def estimated_row_count(table:, database: nil)
+      nil
+    end
+    
+    def close
+      # Default implementation does nothing
+      # Subclasses should override to close any open connections
+    end
   end
 end 

data/lib/detector/version.rb

@@ -1,3 +1,3 @@
 module Detector
-  VERSION = "0.5.0"
+  VERSION = "0.8.0"
 end 

metadata

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