dbwatcher 0.1.5 → 1.0.0

data/lib/dbwatcher/services/query_filter_processor.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    # Service object for filtering and sorting queries based on criteria
+    # Implements the strategy pattern for different filter types
+    class QueryFilterProcessor
+      include Dbwatcher::Logging
+
+      attr_reader :queries, :filter_params
+
+      # @param queries [Array<Hash>] the queries to filter
+      # @param filter_params [Hash] filtering parameters
+      def initialize(queries, filter_params)
+        @queries = queries
+        @filter_params = filter_params
+      end
+
+      # @param queries [Array<Hash>] queries to filter
+      # @param filter_params [Hash] filtering parameters
+      # @return [Array<Hash>] filtered and sorted queries
+      def self.call(queries, filter_params)
+        new(queries, filter_params).call
+      end
+
+      def call
+        log_filtering_start
+        start_time = Time.current
+
+        result = apply_all_filters
+        log_filtering_completion(start_time, result)
+
+        result
+      end
+
+      private
+
+      def log_filtering_start
+        log_info "Starting query filtering", {
+          initial_count: queries.length,
+          filters: active_filters.join(", ")
+        }
+      end
+
+      def apply_all_filters
+        queries
+          .then { |q| apply_operation_filter(q) }
+          .then { |q| apply_table_filter(q) }
+          .then { |q| apply_duration_filter(q) }
+          .then { |q| sort_by_timestamp_descending(q) }
+      end
+
+      def log_filtering_completion(start_time, result)
+        duration = Time.current - start_time
+        log_info "Completed query filtering in #{duration.round(3)}s", {
+          final_count: result.length,
+          filtered_out: queries.length - result.length
+        }
+      end
+
+      def apply_operation_filter(queries)
+        return queries unless filter_params[:operation].present?
+
+        queries.select { |query| matches_operation?(query) }
+      end
+
+      def matches_operation?(query)
+        query[:operation] == filter_params[:operation]
+      end
+
+      def apply_table_filter(queries)
+        return queries unless filter_params[:table].present?
+
+        queries.select { |query| includes_table?(query) }
+      end
+
+      def includes_table?(query)
+        query[:tables]&.include?(filter_params[:table])
+      end
+
+      def apply_duration_filter(queries)
+        return queries unless filter_params[:min_duration].present?
+
+        min_duration_threshold = filter_params[:min_duration].to_f
+        queries.select { |query| exceeds_duration_threshold?(query, min_duration_threshold) }
+      end
+
+      def exceeds_duration_threshold?(query, threshold)
+        duration = query[:duration]
+        duration && duration >= threshold
+      end
+
+      def sort_by_timestamp_descending(queries)
+        queries.sort_by { |query| timestamp_for_sorting(query) }.reverse
+      end
+
+      def timestamp_for_sorting(query)
+        return 0 unless query[:timestamp]
+
+        Time.parse(query[:timestamp]).to_i
+      rescue ArgumentError
+        0
+      end
+
+      def active_filters
+        filters = []
+        filters << "operation=#{filter_params[:operation]}" if filter_params[:operation].present?
+        filters << "table=#{filter_params[:table]}" if filter_params[:table].present?
+        filters << "min_duration=#{filter_params[:min_duration]}" if filter_params[:min_duration].present?
+        filters.empty? ? ["none"] : filters
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/table_statistics_collector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    # Service object for collecting and organizing table statistics
+    # Follows the command pattern with self.call class method
+    class TableStatisticsCollector
+      include Dbwatcher::Logging
+
+      # @return [Array<Hash>] sorted array of table statistics
+      def self.call
+        new.call
+      end
+
+      def call
+        log_info "Starting table statistics collection"
+        start_time = Time.current
+
+        tables = build_initial_tables_hash
+        populate_change_statistics(tables)
+        result = sort_by_change_count(tables)
+
+        duration = Time.current - start_time
+        log_info "Completed table statistics collection in #{duration.round(3)}s", {
+          tables_count: result.length,
+          total_changes: result.sum { |t| t[:change_count] }
+        }
+
+        result
+      end
+
+      private
+
+      def build_initial_tables_hash
+        tables = {}
+        schema_tables_count = load_schema_tables(tables)
+        log_schema_loading_result(schema_tables_count)
+        tables
+      end
+
+      def load_schema_tables(tables)
+        return 0 unless schema_available?
+
+        schema_tables_count = 0
+        begin
+          ActiveRecord::Base.connection.tables.each do |table|
+            tables[table] = build_table_entry(table)
+            schema_tables_count += 1
+          end
+          schema_tables_count
+        rescue StandardError => e
+          log_warn "Could not load tables from schema: #{e.message}"
+          0
+        end
+      end
+
+      def schema_available?
+        defined?(ActiveRecord::Base)
+      end
+
+      def log_schema_loading_result(count)
+        if count.positive?
+          log_debug "Loaded #{count} tables from database schema"
+        else
+          log_debug "ActiveRecord not available, starting with empty tables hash"
+        end
+      end
+
+      def build_table_entry(table_name)
+        {
+          name: table_name,
+          change_count: 0,
+          last_change: nil
+        }
+      end
+
+      def populate_change_statistics(tables)
+        sessions_processed = 0
+        total_changes = 0
+
+        Storage.sessions.all.each do |session_info|
+          session = Storage.sessions.find(session_info[:id])
+          next unless session
+
+          session_changes_count = session.changes.length
+          update_tables_from_session(tables, session)
+          sessions_processed += 1
+          total_changes += session_changes_count
+        end
+
+        log_debug "Processed #{sessions_processed} sessions with #{total_changes} total changes"
+        tables
+      end
+
+      def update_tables_from_session(tables, session)
+        session.changes.each do |change|
+          table_name = change[:table_name]
+          next if table_name.nil? || table_name.empty?
+
+          tables[table_name] ||= build_table_entry(table_name)
+          update_table_change_statistics(tables[table_name], change)
+        end
+      end
+
+      def update_table_change_statistics(table_stats, change)
+        table_stats[:change_count] += 1
+        timestamp = change[:timestamp]
+
+        return unless table_stats[:last_change].nil? || timestamp > table_stats[:last_change]
+
+        table_stats[:last_change] = timestamp
+      end
+
+      def sort_by_change_count(tables)
+        tables.values.sort_by { |table| -table[:change_count] }
+      end
+    end
+  end
+end

data/lib/dbwatcher/sql_logger.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  class SqlLogger
+    include Singleton
+
+    attr_reader :queries
+
+    def initialize
+      @queries = []
+      @mutex = Mutex.new
+      setup_subscriber if Dbwatcher.configuration.track_queries
+    end
+
+    def log_query(sql, name, binds, _type_casted_binds, duration)
+      return unless Dbwatcher.configuration.track_queries
+
+      @mutex.synchronize do
+        query = create_query_record(sql, name, binds, duration)
+        store_query(query)
+      end
+    end
+
+    def create_query_record(sql, name, binds, duration)
+      {
+        id: SecureRandom.uuid,
+        sql: sql,
+        name: name,
+        binds: binds,
+        duration: duration,
+        timestamp: Time.current,
+        session_id: current_session_id,
+        backtrace: filtered_backtrace,
+        tables: extract_tables(sql),
+        operation: extract_operation(sql)
+      }
+    end
+
+    def store_query(query)
+      @queries << query
+      Storage.queries.create(query)
+    end
+
+    def clear_queries
+      @mutex.synchronize do
+        @queries.clear
+      end
+    end
+
+    private
+
+    def setup_subscriber
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |_name, start, finish, _id, payload|
+        next if skip_query?(payload)
+
+        duration = (finish - start) * 1000.0
+        log_query(
+          payload[:sql],
+          payload[:name],
+          payload[:binds],
+          payload[:type_casted_binds],
+          duration
+        )
+      end
+    end
+
+    def skip_query?(payload)
+      skip_schema_query?(payload) || skip_internal_query?(payload)
+    end
+
+    def skip_schema_query?(payload)
+      payload[:name]&.include?("SCHEMA")
+    end
+
+    def skip_internal_query?(payload)
+      return true if payload[:sql]&.include?("sqlite_master")
+      return true if payload[:sql]&.include?("PRAGMA")
+      return true if payload[:sql]&.include?("information_schema")
+
+      false
+    end
+
+    def extract_tables(sql)
+      # Extract table names from SQL
+      tables = []
+      # Match FROM, JOIN, INTO, UPDATE, DELETE FROM patterns
+      sql.scan(/(?:FROM|JOIN|INTO|UPDATE|DELETE\s+FROM)\s+["`]?(\w+)["`]?/i) do |match|
+        tables << match[0]
+      end
+      tables.uniq
+    end
+
+    def extract_operation(sql)
+      sql.strip.split(/\s+/).first.upcase
+    end
+
+    def filtered_backtrace
+      caller.select { |line| line.include?(Rails.root.to_s) }
+            .reject { |line| line.include?("dbwatcher") }
+            .first(5)
+    end
+
+    def current_session_id
+      Tracker.current_session&.id
+    end
+  end
+end

data/lib/dbwatcher/storage/api/base_api.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Storage
+    module Api
+      # Base class for all storage API classes
+      #
+      # This class provides common functionality and patterns for all
+      # storage API implementations (SessionAPI, QueryAPI, TableAPI).
+      # It establishes the foundation for the fluent interface pattern
+      # and shared filtering capabilities.
+      #
+      # @abstract Subclass and implement specific API methods
+      # @example
+      #   class MyAPI < BaseAPI
+      #     def my_filter(value)
+      #       @filters[:my_key] = value
+      #       self
+      #     end
+      #   end
+      class BaseAPI
+        include Storage::Concerns::DataNormalizer
+
+        # Initialize the API with a storage backend
+        #
+        # @param storage [Object] storage backend instance
+        def initialize(storage)
+          @storage = storage
+          @filters = {}
+          @limit_value = nil
+        end
+
+        # Apply limit to results
+        #
+        # @param count [Integer] maximum number of results
+        # @return [BaseAPI] self for method chaining
+        def limit(count)
+          @limit_value = count
+          self
+        end
+
+        # Filter by conditions
+        #
+        # @param conditions [Hash] filtering conditions
+        # @return [BaseAPI] self for method chaining
+        def where(conditions)
+          @filters.merge!(conditions)
+          self
+        end
+
+        # Get all results after applying filters
+        #
+        # @return [Array] filtered results
+        # @abstract Subclasses should implement this method
+        def all
+          raise NotImplementedError, "Subclasses must implement #all"
+        end
+
+        # Create a new record
+        #
+        # @param data [Hash] record data
+        # @return [Hash] created record
+        # @abstract Subclasses should implement this method if creation is supported
+        def create(data)
+          @storage.save(data)
+        end
+
+        protected
+
+        attr_reader :storage, :filters, :limit_value
+
+        # Apply common filters to a result set
+        #
+        # @param results [Array] raw results
+        # @return [Array] filtered results
+        def apply_common_filters(results)
+          result = results
+
+          # Apply limit if specified
+          result = result.first(limit_value) if limit_value
+
+          result
+        end
+
+        # Apply time-based filtering
+        #
+        # @param results [Array] results to filter
+        # @param time_field [Symbol] field containing timestamp
+        # @return [Array] filtered results
+        def apply_time_filter(results, time_field)
+          return results unless filters[:started_after]
+
+          cutoff = filters[:started_after]
+          results.select do |item|
+            timestamp = item[time_field]
+            next false unless timestamp
+
+            begin
+              Time.parse(timestamp.to_s) >= cutoff
+            rescue ArgumentError
+              false
+            end
+          end
+        end
+
+        # Apply pattern matching filter
+        #
+        # @param results [Array] results to filter
+        # @param fields [Array<Symbol>] fields to search in
+        # @param pattern [String] pattern to match
+        # @return [Array] filtered results
+        def apply_pattern_filter(results, fields, pattern)
+          return results unless pattern
+
+          results.select do |item|
+            fields.any? do |field|
+              value = item[field]
+              value&.to_s&.include?(pattern)
+            end
+          end
+        end
+
+        # Safe value extraction with normalization
+        #
+        # @param item [Hash] item to extract from
+        # @param key [Symbol] key to extract
+        # @return [Object] extracted value
+        def safe_extract(item, key)
+          extract_value(item, key.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/storage/api/concerns/table_analyzer.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Storage
+    module Api
+      module Concerns
+        # Provides reusable table analysis functionality for API classes
+        #
+        # This concern extracts common table analysis logic used by API classes
+        # to avoid duplication and provide consistent table analysis capabilities.
+        #
+        # @example
+        #   class MyAPI < BaseAPI
+        #     include Api::Concerns::TableAnalyzer
+        #
+        #     def analyze(session)
+        #       build_tables_summary(session)
+        #     end
+        #   end
+        module TableAnalyzer
+          # Build tables summary from session changes
+          #
+          # @param session [Session] session to analyze
+          # @return [Hash] tables summary hash
+          def build_tables_summary(session)
+            tables = {}
+            process_session_changes(session, tables)
+            tables
+          end
+
+          # Process all changes in a session
+          #
+          # @param session [Session] session with changes
+          # @param tables [Hash] tables hash to populate
+          # @return [void]
+          def process_session_changes(session, tables)
+            return unless session&.changes.respond_to?(:each)
+
+            session.changes.each do |change|
+              table_name = extract_table_name(change)
+              next unless table_name
+
+              initialize_table_data(tables, table_name)
+              update_table_data(tables[table_name], change)
+              update_sample_record(tables[table_name], change)
+            end
+          end
+
+          # Extract table name from change data
+          #
+          # @param change [Hash] change data
+          # @return [String, nil] table name or nil
+          def extract_table_name(change)
+            return nil unless change.is_a?(Hash)
+
+            # Only use symbols since data is normalized
+            change[:table_name]
+          end
+
+          # Initialize table data structure
+          #
+          # @param tables [Hash] tables hash
+          # @param table_name [String] table name
+          # @return [void]
+          def initialize_table_data(tables, table_name)
+            tables[table_name] ||= {
+              name: table_name,
+              operations: { "INSERT" => 0, "UPDATE" => 0, "DELETE" => 0 },
+              changes: [],
+              sample_record: nil,
+              records: {},
+              relationships: []
+            }
+          end
+
+          # Update table data with change information
+          #
+          # @param table_data [Hash] table data hash
+          # @param change [Hash] change data
+          # @return [void]
+          def update_table_data(table_data, change)
+            # Count operations
+            operation = extract_operation(change)
+            table_data[:operations][operation] ||= 0
+            table_data[:operations][operation] += 1
+
+            # Add change to the list
+            table_data[:changes] << change
+          end
+
+          # Update sample record if not already set
+          #
+          # @param table_data [Hash] table data hash
+          # @param change [Hash] change data
+          # @return [void]
+          def update_sample_record(table_data, change)
+            return unless table_data[:sample_record].nil?
+
+            snapshot = extract_record_snapshot(change)
+            table_data[:sample_record] = snapshot if snapshot
+          end
+
+          # Update record history for analysis
+          #
+          # @param table_data [Hash] table data hash
+          # @param change [Hash] change data
+          # @return [void]
+          def update_record_history(table_data, change)
+            record_id = extract_record_id(change)
+            return unless record_id
+
+            table_data[:records][record_id] ||= []
+            table_data[:records][record_id] << {
+              operation: extract_operation(change),
+              timestamp: extract_timestamp(change),
+              changes: extract_field_changes(change)
+            }
+          end
+
+          private
+
+          # Extract operation from change data
+          #
+          # @param change [Hash] change data
+          # @return [String] operation string
+          def extract_operation(change)
+            # Only use symbols since data is normalized
+            operation = change[:operation] || "UNKNOWN"
+            operation.to_s.upcase
+          end
+
+          # Extract record snapshot from change data
+          #
+          # @param change [Hash] change data
+          # @return [Hash, nil] record snapshot or nil
+          def extract_record_snapshot(change)
+            # Only use symbols since data is normalized
+            change[:record_snapshot]
+          end
+
+          # Extract record ID from change data
+          #
+          # @param change [Hash] change data
+          # @return [String, nil] record ID or nil
+          def extract_record_id(change)
+            # Only use symbols since data is normalized
+            id = change[:record_id]
+            id&.to_s
+          end
+
+          # Extract timestamp from change data
+          #
+          # @param change [Hash] change data
+          # @return [String, nil] timestamp string or nil
+          def extract_timestamp(change)
+            # Only use symbols since data is normalized
+            change[:timestamp]
+          end
+
+          # Extract field changes from change data
+          #
+          # @param change [Hash] change data
+          # @return [Hash] field changes hash
+          def extract_field_changes(change)
+            # Only use symbols since data is normalized
+            change[:changes] || {}
+          end
+        end
+      end
+    end
+  end
+end