dbviewer 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 628884438be23468b7910e2a13c14b2aa00cc6361f01cb09b53ecdcf1d8a0b78
-  data.tar.gz: e9952d0c11ae3669b2604ac208f1a4ae224c37eb4d5f2b1074c4f284bb0bc24a
+  metadata.gz: fff65e39ec4f823de37b99cf4b60c49d998e56bf2ff10cde22e9d664ea193fdc
+  data.tar.gz: 3ad5a045ab31b37c8f8d7ae410499f9f16a9a10fe8a52a8b3161e331cb3f0f6a
 SHA512:
-  metadata.gz: 369f106d728156712416e6d1f65c51e156ec1357e717c5cc4f95e9fe16dbe696e3a06b8c70a2ef2fd6ae559dd0e7ad7b73fc6a5b2e0ccc396a756633d733c2dd
-  data.tar.gz: 273df74ea6e69b327b01faecb4b3572983fbd461ee042c41ba2402729482ead2b9ebaed117c95158ff01def2e1a1373aaf0fed75d8268d8546b0f3e38d2ff2ae
+  metadata.gz: 72f824b283bd82504319fe5002d48d1f8a7cd29f4038773d4e75ff7c8e9ba250e27de2239eee36adac6ff10740e5779a5272f0c202f2bb1ccb32c586f94ea093
+  data.tar.gz: 655d0bd7d9ea5fc5c70e338b8bdea8dd000b8fd25984c267243598a02afcaff50ba185d80d123b9e2203148b82945f13ebc47d470ef900252887cdfe4134d3c6

data/README.md

@@ -7,7 +7,6 @@ It's designed for development, debugging, and database analysis, offering a clea
 
 <img width="1470" alt="image" src="https://github.com/user-attachments/assets/0d2719ad-f5b4-4818-891d-5bff7be6c5c3" />
 
-
 ## ✨ Features
 
 - **Dashboard**: View a comprehensive dashboard with database analytics, largest tables, most complex tables, and recent SQL queries
@@ -270,6 +269,70 @@ The simplest way to update is using Bundler:
   rails server
   ```
 
+## 🛠️ Development Setup
+
+To set up the development environment for contributing to DBViewer:
+
+### Quick Setup
+
+Run the setup script to automatically configure your development environment:
+
+```bash
+bin/setup
+```
+
+This script will:
+
+- Install bundler and gem dependencies
+- Set up the test dummy Rails application
+- Create and seed the development database
+- Prepare the test environment
+- Clean up old logs and temporary files
+
+### Manual Setup
+
+If you prefer to set up manually:
+
+```bash
+# Install dependencies
+bundle install
+
+# Set up the dummy app database
+cd test/dummy
+bin/rails db:prepare
+bin/rails db:migrate
+bin/rails db:seed
+cd ../..
+
+# Prepare test environment
+cd test/dummy && bin/rails db:test:prepare && cd ../..
+```
+
+### Development Commands
+
+```bash
+# Start the development server
+cd test/dummy && bin/rails server
+
+# Run tests
+bundle exec rspec
+
+# Run code quality checks
+bin/rubocop
+
+# Open an interactive console
+bin/console
+
+# Build the gem
+gem build dbviewer.gemspec
+```
+
+### Testing Your Changes
+
+1. Start the dummy Rails application: `cd test/dummy && bin/rails server`
+2. Visit `http://localhost:3000/dbviewer` to test your changes
+3. The dummy app includes sample data across multiple tables to test various DBViewer features
+
 ## 🤌🏻 Contributing
 
 Bug reports and pull requests are welcome.

data/app/controllers/concerns/dbviewer/database_operations.rb

@@ -5,7 +5,7 @@ module Dbviewer
     extend ActiveSupport::Concern
 
     included do
-      helper_method :current_table?, :get_database_name if respond_to?(:helper_method)
+      helper_method :current_table?, :get_database_name, :get_adapter_name if respond_to?(:helper_method)
     end
 
     # Initialize the database manager
@@ -44,9 +44,33 @@ module Dbviewer
       "Database"
     end
 
+    # Get the name of the current database adapter
+    def get_adapter_name
+      adapter = database_manager.connection.adapter_name
+
+      # Format the adapter name for better display
+      case adapter.downcase
+      when /mysql/
+        "MySQL"
+      when /postgres/
+        "PostgreSQL"
+      when /sqlite/
+        "SQLite"
+      when /oracle/
+        "Oracle"
+      when /sqlserver/, /mssql/
+        "SQL Server"
+      else
+        adapter.titleize # Fallback to titleized version
+      end
+    rescue => e
+      Rails.logger.error("Error retrieving adapter name: #{e.message}")
+      "Unknown"
+    end
+
     # Fetch all tables with their stats
     # By default, don't include record counts for better performance on sidebar
-    def fetch_tables_with_stats(include_record_counts = false)
+    def fetch_tables(include_record_counts = false)
       database_manager.tables.map do |table_name|
         table_stats = {
           name: table_name
@@ -62,7 +86,7 @@ module Dbviewer
     # Gather database analytics information
     def fetch_database_analytics
       # For analytics, we do need record counts
-      tables = fetch_tables_with_stats(include_record_counts: true)
+      tables = fetch_tables(include_record_counts: true)
 
       # Calculate overall statistics
       analytics = {
@@ -77,48 +101,6 @@ module Dbviewer
       analytics
     end
 
-    # Calculate approximate schema size
-    def calculate_schema_size
-      adapter = database_manager.connection.adapter_name.downcase
-
-      case adapter
-      when /mysql/
-        query = <<-SQL
-          SELECT
-            SUM(data_length + index_length) AS size
-          FROM
-            information_schema.TABLES
-          WHERE
-            table_schema = DATABASE()
-        SQL
-        result = database_manager.execute_query(query).first
-        result ? result["size"].to_i : nil
-      when /postgres/
-        query = <<-SQL
-          SELECT pg_database_size(current_database()) AS size
-        SQL
-        result = database_manager.execute_query(query).first
-        result ? result["size"].to_i : nil
-      when /sqlite/
-        # For SQLite, we need to use the special PRAGMA method without LIMIT
-        # Get page count
-        page_count_result = database_manager.execute_sqlite_pragma("page_count")
-        page_count = page_count_result.first.values.first.to_i
-
-        # Get page size
-        page_size_result = database_manager.execute_sqlite_pragma("page_size")
-        page_size = page_size_result.first.values.first.to_i
-
-        # Calculate total size
-        page_count * page_size
-      else
-        nil # Unsupported database type for size calculation
-      end
-    rescue => e
-      Rails.logger.error("Error calculating database size: #{e.message}")
-      nil
-    end
-
     # Get column information for a specific table
     def fetch_table_columns(table_name)
       database_manager.table_columns(table_name)

data/app/controllers/dbviewer/api/database_controller.rb

@@ -2,12 +2,8 @@ module Dbviewer
   module Api
     class DatabaseController < BaseController
       def size
-        begin
-          size = calculate_schema_size
-          render_success(schema_size: size)
-        rescue => e
-          render_error("Error calculating schema size: #{e.message}")
-        end
+        size = database_manager.fetch_schema_size
+        render_success(schema_size: size)
       end
     end
   end

data/app/controllers/dbviewer/api/queries_controller.rb

@@ -2,17 +2,27 @@ module Dbviewer
   module Api
     class QueriesController < BaseController
       def recent
-        @recent_queries = if Dbviewer.configuration.enable_query_logging
-          Dbviewer::Logger.instance.recent_queries(limit: 10)
-        else
-          []
-        end
-
         render_success({
-          enabled: Dbviewer.configuration.enable_query_logging,
-          queries: @recent_queries
+          enabled: query_logging_enabled?,
+          queries: fetch_recent_queries
         })
       end
+
+      private
+
+      def fetch_recent_queries
+        return [] unless query_logging_enabled?
+
+        Dbviewer::Logger.instance.recent_queries(limit: queries_limit)
+      end
+
+      def query_logging_enabled?
+        Dbviewer.configuration.enable_query_logging
+      end
+
+      def queries_limit
+        10
+      end
     end
   end
 end

data/app/controllers/dbviewer/api/tables_controller.rb

@@ -2,38 +2,63 @@ module Dbviewer
   module Api
     class TablesController < BaseController
       def index
-        tables = fetch_tables_with_stats(include_record_counts: false)
-        render_success(total_tables: tables.size)
+        tables_count = fetch_tables_count
+        render_success(total_tables: tables_count)
       end
 
       def records
-        tables = fetch_tables_with_stats(include_record_counts: true)
+        tables_stats = fetch_tables_stats
+        render_success(tables_stats)
+      end
 
-        records_data = {
-          total_records: tables.sum { |t| t[:record_count] },
-          largest_tables: tables.sort_by { |t| -t[:record_count] }.first(10),
-          empty_tables: tables.select { |t| t[:record_count] == 0 },
-          avg_records_per_table: tables.any? ? (tables.sum { |t| t[:record_count] }.to_f / tables.size).round(1) : 0
-        }
+      def relationships_count
+        total_relationships = calculate_total_relationships
+        render_success(total_relationships: total_relationships)
+      end
+
+      private
 
-        render_success(records_data)
+      def fetch_tables_count
+        fetch_tables(include_record_counts: false).size
       end
 
-      def relationships_count
-        begin
-          tables = fetch_tables_with_stats(include_record_counts: false)
-          total_relationships = 0
-
-          tables.each do |table|
-            metadata = fetch_table_metadata(table[:name])
-            total_relationships += metadata[:foreign_keys].size if metadata && metadata[:foreign_keys]
-          end
-
-          render_success(total_relationships: total_relationships)
-        rescue => e
-          render_error("Error calculating relationship count: #{e.message}")
+      def fetch_tables_stats
+        tables = fetch_tables(include_record_counts: true)
+
+        {
+          total_records: calculate_total_records(tables),
+          largest_tables: find_largest_tables(tables),
+          empty_tables: find_empty_tables(tables),
+          avg_records_per_table: calculate_average_records(tables)
+        }
+      end
+
+      def calculate_total_relationships
+        tables = fetch_tables(include_record_counts: false)
+
+        tables.sum do |table|
+          metadata = fetch_table_metadata(table[:name])
+          metadata&.dig(:foreign_keys)&.size || 0
         end
       end
+
+      def calculate_total_records(tables)
+        tables.sum { |table| table[:record_count] }
+      end
+
+      def find_largest_tables(tables, limit = 10)
+        tables.sort_by { |table| -table[:record_count] }.first(limit)
+      end
+
+      def find_empty_tables(tables)
+        tables.select { |table| table[:record_count] == 0 }
+      end
+
+      def calculate_average_records(tables)
+        return 0 if tables.empty?
+
+        (calculate_total_records(tables).to_f / tables.size).round(1)
+      end
     end
   end
 end

data/app/controllers/dbviewer/application_controller.rb

@@ -19,7 +19,7 @@ module Dbviewer
     end
 
     def set_tables
-      @tables = fetch_tables_with_stats
+      @tables = fetch_tables
     end
   end
 end

data/app/controllers/dbviewer/home_controller.rb

@@ -6,7 +6,7 @@ module Dbviewer
     private
 
     def set_tables
-      @tables = fetch_tables_with_stats(include_record_counts: true)
+      @tables = fetch_tables(include_record_counts: true)
     end
   end
 end

data/app/controllers/dbviewer/tables_controller.rb

@@ -7,7 +7,7 @@ module Dbviewer
     before_action :set_global_filters, only: [ :show, :export_csv ]
 
     def index
-      @tables = fetch_tables_with_stats(include_record_counts: true)
+      @tables = fetch_tables(include_record_counts: true)
     end
 
     def show
@@ -60,7 +60,7 @@ module Dbviewer
     def query
       @read_only_mode = true # Flag to indicate we're in read-only mode
       @columns = fetch_table_columns(@table_name)
-      @tables = fetch_tables_with_stats  # Fetch tables for sidebar
+      @tables = fetch_tables  # Fetch tables for sidebar
 
       prepare_query
       execute_query

data/app/views/dbviewer/home/index.html.erb

@@ -3,7 +3,7 @@
     <div class="col">
       <h1 class="h3 mb-2">Database Overview</h1>
       <p class="database-connection-info">
-        Connected to database: <span class="badge rounded-pill database-name-badge"><%= get_database_name %></span>
+        Connected to <%= get_adapter_name %> database: <span class="badge rounded-pill database-name-badge"><%= get_database_name %></span>
       </p>
     </div>
   </div>

data/lib/dbviewer/database_manager.rb

@@ -180,8 +180,48 @@ module Dbviewer
       @cache_manager.clear_all
     end
 
+    # Calculate the total size of the database schema
+    # @return [Integer, nil] Database size in bytes or nil if unsupported
+    def fetch_schema_size
+      case adapter_name
+      when /mysql/
+        fetch_mysql_size
+      when /postgres/
+        fetch_postgres_size
+      when /sqlite/
+        fetch_sqlite_size
+      else
+        nil # Unsupported database type for size calculation
+      end
+    end
+
     private
 
+    def fetch_mysql_size
+      query = "SELECT SUM(data_length + index_length) AS size FROM information_schema.TABLES WHERE table_schema = DATABASE()"
+      fetch_size_from_query(query)
+    end
+
+    def fetch_postgres_size
+      query = "SELECT pg_database_size(current_database()) AS size"
+      fetch_size_from_query(query)
+    end
+
+    def fetch_sqlite_size
+      page_count = fetch_sqlite_pragma_value("page_count")
+      page_size = fetch_sqlite_pragma_value("page_size")
+      page_count * page_size
+    end
+
+    def fetch_sqlite_pragma_value(pragma_name)
+      execute_sqlite_pragma(pragma_name).first.values.first.to_i
+    end
+
+    def fetch_size_from_query(query)
+      result = execute_query(query).first
+      result ? result["size"].to_i : nil
+    end
+
     # Ensure we have a valid database connection
     # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter] The database connection
     def ensure_connection

data/lib/dbviewer/engine.rb

@@ -2,9 +2,10 @@ module Dbviewer
   class Engine < ::Rails::Engine
     isolate_namespace Dbviewer
 
-    # Ensure lib directory is in the autoload path
-    config.autoload_paths << File.expand_path("../../", __FILE__)
-    config.eager_load_paths << File.expand_path("../../", __FILE__)
+    # Autoload lib directory
+    lib_path = File.expand_path("..", __dir__)
+    config.autoload_paths << lib_path
+    config.eager_load_paths << lib_path
 
     # Register generators
     config.app_generators do |g|
@@ -18,10 +19,27 @@ module Dbviewer
     end
 
     initializer "dbviewer.notifications" do
+      return unless Rails.env.development?
+
       ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
         event = ActiveSupport::Notifications::Event.new(*args)
-        Logger.instance.add(event)
+
+        next if skip_internal_query?(event)
+
+        Dbviewer::Logger.instance.add(event)
+      end
+    end
+
+    private
+
+    def skip_internal_query?(event)
+      caller_locations = caller_locations(1)
+      return false unless caller_locations
+
+      excluded_caller_locations = caller_locations.filter do |caller_location|
+        !caller_location.path.include?("lib/dbviewer/engine.rb")
       end
+      excluded_caller_locations.any? { |l| l.path.include?("dbviewer") }
     end
   end
 end

data/lib/dbviewer/logger.rb

@@ -21,7 +21,7 @@ module Dbviewer
         timestamp: current_time,
         duration_ms: event.duration.round(2),
         binds: QueryParser.format_binds(event.payload[:binds]),
-        request_id: event.transaction_id || current_time.to_i,
+        request_id: ActiveSupport::Notifications.instrumenter.id,
         thread_id: Thread.current.object_id.to_s,
         caller: event.payload[:caller]
       })

data/lib/dbviewer/query_parser.rb

@@ -22,36 +22,6 @@ module Dbviewer
          .gsub(/"[^"]*"/, '"X"')
     end
 
-    # Check if the query is from the DBViewer library
-    def self.from_dbviewer?(event)
-      # Check if the SQL itself references DBViewer tables
-      if event.payload[:sql].match(/\b(from|join|update|into)\s+["`']?dbviewer_/i)
-        return true
-      end
-
-      # Check the caller information if available
-      caller = event.payload[:caller]
-      if caller.is_a?(String) && caller.include?("/dbviewer/")
-        return true
-      end
-
-      # Check if query name indicates it's from DBViewer
-      if event.payload[:name].is_a?(String) &&
-         (event.payload[:name].include?("Dbviewer") || event.payload[:name].include?("DBViewer") || event.payload[:name] == "SQL")
-        return true
-      end
-
-      # Check for common DBViewer operations
-      sql = event.payload[:sql].downcase
-      if sql.include?("table_structure") ||
-         sql.include?("schema_migrations") ||
-         sql.include?("database_analytics")
-        return true
-      end
-
-      false
-    end
-
     # Format bind parameters for storage
     def self.format_binds(binds)
       return [] unless binds.respond_to?(:map)
@@ -70,13 +40,14 @@ module Dbviewer
     end
 
     # Determine if a query should be skipped based on content
+    # Rails and ActiveRecord often run internal queries that are not useful for logging
     def self.should_skip_query?(event)
       event.payload[:name] == "SCHEMA" ||
       event.payload[:sql].include?("SHOW TABLES") ||
       event.payload[:sql].include?("sqlite_master") ||
       event.payload[:sql].include?("information_schema") ||
-      event.payload[:sql].include?("pg_catalog") ||
-      from_dbviewer?(event)
+      event.payload[:sql].include?("schema_migrations") ||
+      event.payload[:sql].include?("pg_catalog")
     end
   end
 end

data/lib/dbviewer/version.rb

@@ -1,3 +1,3 @@
 module Dbviewer
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dbviewer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Wailan Tirajoh
@@ -100,7 +100,6 @@ files:
 - lib/dbviewer/table_query_params.rb
 - lib/dbviewer/version.rb
 - lib/generators/dbviewer/initializer_generator.rb
-- lib/generators/dbviewer/structured_api_generator.rb
 - lib/generators/dbviewer/templates/initializer.rb
 - lib/tasks/dbviewer_tasks.rake
 homepage: https://github.com/wailantirajoh/dbviewer

data/lib/generators/dbviewer/structured_api_generator.rb

@@ -1,11 +0,0 @@
-module Dbviewer
-  module Generators
-    class StructuredApiGenerator < Rails::Generators::Base
-      source_root File.expand_path("../templates", __FILE__)
-
-      def create_initializer
-        template "structured_api_initializer.rb", "config/initializers/dbviewer_structured_api.rb"
-      end
-    end
-  end
-end