dbwatcher 0.1.5 → 1.0.0

data/lib/dbwatcher/storage.rb

@@ -1,109 +1,136 @@
 # frozen_string_literal: true
 
+require_relative "storage/base_storage"
+require_relative "storage/concerns/error_handler"
+require_relative "storage/concerns/timestampable"
+require_relative "storage/concerns/validatable"
+require_relative "storage/concerns/data_normalizer"
+require_relative "storage/session_storage"
+require_relative "storage/query_storage"
+require_relative "storage/table_storage"
+require_relative "storage/session_query"
+require_relative "storage/api/base_api"
+require_relative "storage/api/query_api"
+require_relative "storage/api/table_api"
+require_relative "storage/api/session_api"
+require_relative "storage/session"
+require_relative "storage/errors"
+
 module Dbwatcher
-  class Storage
+  # Storage module provides the main interface for database monitoring data persistence
+  #
+  # This module acts as a facade for different storage backends and provides
+  # clean API entry points for sessions, queries, and tables. It manages
+  # storage instances and provides cleanup operations.
+  #
+  # @example Basic usage
+  #   Dbwatcher::Storage.sessions.create("My Session")
+  #   Dbwatcher::Storage.sessions.recent.with_changes
+  #   Dbwatcher::Storage.queries.save(query_data)
+  #   Dbwatcher::Storage.tables.changes_for("users")
+  #
+  # @example Cleanup operations
+  #   Dbwatcher::Storage.cleanup_old_sessions
+  #   Dbwatcher::Storage.clear_all
+  # @see SessionAPI
+  # @see QueryAPI
+  # @see TableAPI
+  module Storage
     class << self
-      def save_session(session)
-        return unless session&.id
-
-        ensure_storage_directory
-
-        # Save individual session file
-        session_file = File.join(sessions_path, "#{session.id}.json")
-        File.write(session_file, JSON.pretty_generate(session.to_h))
-
-        # Update index
-        update_index(session)
-
-        # Clean old sessions if needed
-        cleanup_old_sessions
-      rescue StandardError => e
-        warn "Failed to save session #{session&.id}: #{e.message}"
+      # Provides access to session operations
+      #
+      # @return [SessionAPI] session API interface
+      # @example
+      #   Dbwatcher::Storage.sessions.create("My Session")
+      #   Dbwatcher::Storage.sessions.all
+      #   Dbwatcher::Storage.sessions.recent.with_changes
+      def sessions
+        @sessions ||= Api::SessionAPI.new(session_storage)
       end
 
-      def load_session(id)
-        return nil if id.nil? || id.empty?
-
-        session_file = File.join(sessions_path, "#{id}.json")
-        return nil unless File.exist?(session_file)
-
-        data = JSON.parse(File.read(session_file), symbolize_names: true)
-        Tracker::Session.new(data)
-      rescue JSON::ParserError => e
-        warn "Failed to parse session file #{id}: #{e.message}"
-        nil
-      rescue StandardError => e
-        warn "Failed to load session #{id}: #{e.message}"
-        nil
+      # Provides access to query operations
+      #
+      # @return [QueryAPI] query API interface
+      # @example
+      #   Dbwatcher::Storage.queries.save(query_data)
+      #   Dbwatcher::Storage.queries.for_date(Date.today)
+      def queries
+        @queries ||= Api::QueryAPI.new(query_storage)
       end
 
-      def all_sessions
-        index_file = File.join(storage_path, "index.json")
-        return [] unless File.exist?(index_file)
-
-        JSON.parse(File.read(index_file), symbolize_names: true)
-      rescue JSON::ParserError => e
-        warn "Failed to parse sessions index: #{e.message}"
-        []
-      rescue StandardError => e
-        warn "Failed to load sessions: #{e.message}"
-        []
+      # Provides access to table operations
+      #
+      # @return [TableAPI] table API interface
+      # @example
+      #   Dbwatcher::Storage.tables.changes_for("users")
+      #   Dbwatcher::Storage.tables.recent_changes
+      def tables
+        @tables ||= Api::TableAPI.new(table_storage)
       end
 
-      def reset!
-        FileUtils.rm_rf(storage_path)
-        ensure_storage_directory
+      # Resets all cached storage instances (primarily for testing)
+      #
+      # This method clears all memoized storage instances, forcing them
+      # to be recreated on next access. Useful for testing scenarios.
+      #
+      # @return [void]
+      # @example
+      #   Dbwatcher::Storage.reset_storage_instances!
+      def reset_storage_instances!
+        @session_storage = nil
+        @query_storage = nil
+        @table_storage = nil
+        @sessions = nil
+        @queries = nil
+        @tables = nil
       end
 
-      private
+      # Cleanup operations
 
-      def storage_path
-        Dbwatcher.configuration.storage_path
-      end
-
-      def sessions_path
-        File.join(storage_path, "sessions")
+      # Removes old session files based on configuration
+      #
+      # Automatically removes session files that exceed the configured
+      # retention period. This helps manage storage space usage.
+      #
+      # @return [void]
+      # @see Configuration#auto_clean_after_days
+      def cleanup_old_sessions
+        session_storage.cleanup_old_sessions
       end
 
-      def ensure_storage_directory
-        FileUtils.mkdir_p(sessions_path)
+      # Direct access to storage instances (for internal use)
 
-        # Create index if it doesn't exist
-        index_file = File.join(storage_path, "index.json")
-        File.write(index_file, "[]") unless File.exist?(index_file)
+      # Returns the session storage instance
+      #
+      # @return [SessionStorage] the session storage instance
+      # @api private
+      def session_storage
+        @session_storage ||= SessionStorage.new
       end
 
-      def update_index(session)
-        index_file = File.join(storage_path, "index.json")
-        index = JSON.parse(File.read(index_file), symbolize_names: true)
-
-        # Add new session summary to index
-        index.unshift({
-                        id: session.id,
-                        name: session.name,
-                        started_at: session.started_at,
-                        ended_at: session.ended_at,
-                        change_count: session.changes.count
-                      })
-
-        # Keep only max_sessions
-        index = index.first(Dbwatcher.configuration.max_sessions)
-
-        File.write(index_file, JSON.pretty_generate(index))
-      rescue StandardError => e
-        warn "Failed to update sessions index: #{e.message}"
+      # Returns the query storage instance
+      #
+      # @return [QueryStorage] the query storage instance
+      # @api private
+      def query_storage
+        @query_storage ||= QueryStorage.new
       end
 
-      def cleanup_old_sessions
-        return unless Dbwatcher.configuration.auto_clean_after_days
-
-        cutoff_date = Time.now - (Dbwatcher.configuration.auto_clean_after_days * 24 * 60 * 60)
+      # Returns the table storage instance
+      #
+      # @return [TableStorage] the table storage instance
+      # @api private
+      def table_storage
+        @table_storage ||= TableStorage.new(session_storage)
+      end
 
-        Dir.glob(File.join(sessions_path, "*.json")).each do |file|
-          File.delete(file) if File.mtime(file) < cutoff_date
-        end
-      rescue StandardError => e
-        warn "Failed to cleanup old sessions: #{e.message}"
+      # Clears all storage data
+      #
+      # @return [Integer] total number of files removed
+      def clear_all
+        session_count = session_storage.clear_all
+        query_count = query_storage.clear_all
+        session_count + query_count
       end
     end
   end

data/lib/dbwatcher/tracker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "storage/session"
+
 module Dbwatcher
   class Tracker
     class << self
@@ -30,7 +32,7 @@ module Dbwatcher
       private
 
       def create_session(name, metadata)
-        Session.new(
+        Storage::Session.new(
           id: SecureRandom.uuid,
           name: name || "Session #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}",
           metadata: metadata || {},
@@ -50,63 +52,10 @@ module Dbwatcher
 
       def finalize_session(session)
         session.ended_at = Time.now.strftime("%Y-%m-%dT%H:%M:%S%z")
-        Storage.save_session(session)
+        Storage.sessions.create(session)
       rescue StandardError
         nil
       end
     end
-
-    class Session
-      attr_accessor :id, :name, :metadata, :started_at, :ended_at, :changes
-
-      def initialize(attrs = {})
-        # Set default values
-        @changes = []
-        @metadata = {}
-
-        # Set provided attributes
-        attrs.each do |key, value|
-          setter_method = "#{key}="
-          send(setter_method, value) if respond_to?(setter_method)
-        end
-      end
-
-      def to_h
-        {
-          id: id,
-          name: name,
-          metadata: metadata,
-          started_at: started_at,
-          ended_at: ended_at,
-          changes: changes
-        }
-      end
-
-      def summary
-        return {} unless changes.is_a?(Array)
-
-        valid_changes = filter_valid_changes
-        group_changes_by_operation(valid_changes)
-      rescue StandardError => e
-        warn "Failed to calculate session summary: #{e.message}"
-        {}
-      end
-
-      private
-
-      def filter_valid_changes
-        changes.select { |change| valid_change?(change) }
-      end
-
-      def valid_change?(change)
-        change.is_a?(Hash) && change[:table_name] && change[:operation]
-      end
-
-      def group_changes_by_operation(valid_changes)
-        valid_changes
-          .group_by { |change| "#{change[:table_name]},#{change[:operation]}" }
-          .transform_values(&:count)
-      end
-    end
   end
 end

data/lib/dbwatcher/version.rb

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

data/lib/dbwatcher.rb

@@ -3,12 +3,19 @@
 require "json"
 require "fileutils"
 require "securerandom"
+require "singleton"
+require "logger"
 require_relative "dbwatcher/version"
 require_relative "dbwatcher/configuration"
+require_relative "dbwatcher/logging"
 require_relative "dbwatcher/tracker"
 require_relative "dbwatcher/storage"
+require_relative "dbwatcher/sql_logger"
 require_relative "dbwatcher/model_extension"
 require_relative "dbwatcher/middleware"
+require_relative "dbwatcher/services/table_statistics_collector"
+require_relative "dbwatcher/services/dashboard_data_aggregator"
+require_relative "dbwatcher/services/query_filter_processor"
 require_relative "dbwatcher/engine" if defined?(Rails)
 
 module Dbwatcher
@@ -33,8 +40,11 @@ module Dbwatcher
       Tracker.current_session
     end
 
-    def reset!
-      Storage.reset!
+    # Clears all stored data (sessions and queries)
+    #
+    # @return [Integer] total number of files removed
+    def clear_all
+      Storage.clear_all
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dbwatcher
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Huy Nguyen
@@ -149,9 +149,28 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
+- app/controllers/dbwatcher/base_controller.rb
+- app/controllers/dbwatcher/dashboard_controller.rb
+- app/controllers/dbwatcher/queries_controller.rb
 - app/controllers/dbwatcher/sessions_controller.rb
+- app/controllers/dbwatcher/tables_controller.rb
+- app/helpers/dbwatcher/application_helper.rb
+- app/helpers/dbwatcher/formatting_helper.rb
+- app/helpers/dbwatcher/session_helper.rb
+- app/views/dbwatcher/dashboard/index.html.erb
+- app/views/dbwatcher/queries/index.html.erb
 - app/views/dbwatcher/sessions/index.html.erb
 - app/views/dbwatcher/sessions/show.html.erb
+- app/views/dbwatcher/shared/_badge.html.erb
+- app/views/dbwatcher/shared/_data_table.html.erb
+- app/views/dbwatcher/shared/_header.html.erb
+- app/views/dbwatcher/shared/_page_layout.html.erb
+- app/views/dbwatcher/shared/_section_panel.html.erb
+- app/views/dbwatcher/shared/_stats_card.html.erb
+- app/views/dbwatcher/shared/_tab_bar.html.erb
+- app/views/dbwatcher/tables/changes.html.erb
+- app/views/dbwatcher/tables/index.html.erb
+- app/views/dbwatcher/tables/show.html.erb
 - app/views/layouts/dbwatcher/application.html.erb
 - bin/console
 - bin/release
@@ -160,9 +179,36 @@ files:
 - lib/dbwatcher.rb
 - lib/dbwatcher/configuration.rb
 - lib/dbwatcher/engine.rb
+- lib/dbwatcher/logging.rb
 - lib/dbwatcher/middleware.rb
 - lib/dbwatcher/model_extension.rb
+- lib/dbwatcher/services/dashboard_data_aggregator.rb
+- lib/dbwatcher/services/query_filter_processor.rb
+- lib/dbwatcher/services/table_statistics_collector.rb
+- lib/dbwatcher/sql_logger.rb
 - lib/dbwatcher/storage.rb
+- lib/dbwatcher/storage/api/base_api.rb
+- lib/dbwatcher/storage/api/concerns/table_analyzer.rb
+- lib/dbwatcher/storage/api/query_api.rb
+- lib/dbwatcher/storage/api/session_api.rb
+- lib/dbwatcher/storage/api/table_api.rb
+- lib/dbwatcher/storage/base_storage.rb
+- lib/dbwatcher/storage/change_processor.rb
+- lib/dbwatcher/storage/concerns/data_normalizer.rb
+- lib/dbwatcher/storage/concerns/error_handler.rb
+- lib/dbwatcher/storage/concerns/timestampable.rb
+- lib/dbwatcher/storage/concerns/validatable.rb
+- lib/dbwatcher/storage/date_helper.rb
+- lib/dbwatcher/storage/errors.rb
+- lib/dbwatcher/storage/file_manager.rb
+- lib/dbwatcher/storage/null_session.rb
+- lib/dbwatcher/storage/query_storage.rb
+- lib/dbwatcher/storage/query_validator.rb
+- lib/dbwatcher/storage/session.rb
+- lib/dbwatcher/storage/session_operations.rb
+- lib/dbwatcher/storage/session_query.rb
+- lib/dbwatcher/storage/session_storage.rb
+- lib/dbwatcher/storage/table_storage.rb
 - lib/dbwatcher/tracker.rb
 - lib/dbwatcher/version.rb
 homepage: https://github.com/patrick204nqh/dbwatcher