dbwatcher 0.1.5 → 1.1.0

data/lib/dbwatcher/services/mermaid_syntax_builder.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "set"
+require "digest"
+
+module Dbwatcher
+  module Services
+    # Builder for generating validated Mermaid diagram syntax
+    #
+    # Provides methods for building different types of Mermaid diagrams with
+    # syntax validation, error checking, and consistent formatting.
+    #
+    # @example
+    #   builder = MermaidSyntaxBuilder.new
+    #   content = builder.build_erd_diagram_from_dataset(dataset)
+    #   # => "erDiagram\n    USERS ||--o{ ORDERS : user_id"
+    class MermaidSyntaxBuilder
+      # Custom error classes
+      class SyntaxValidationError < StandardError; end
+      class UnsupportedDiagramTypeError < StandardError; end
+
+      # Supported Mermaid diagram types
+      SUPPORTED_DIAGRAM_TYPES = %w[erDiagram classDiagram flowchart graph].freeze
+
+      # Maximum content length to prevent memory issues
+      MAX_CONTENT_LENGTH = 100_000
+
+      # Initialize builder
+      #
+      # @param config [Hash] builder configuration (optional)
+      # @option config [Logger] :logger logger instance
+      def initialize(config = {})
+        @config = config
+        @logger = config[:logger] || Rails.logger
+      end
+
+      # Build ERD diagram from dataset
+      #
+      # @param dataset [DiagramData::Dataset] dataset to render
+      # @param options [Hash] generation options
+      # @return [String] Mermaid ERD syntax
+      def build_erd_diagram_from_dataset(dataset, options = {})
+        @logger.debug "Building ERD diagram from dataset with #{dataset.entities.size} entities and " \
+                      "#{dataset.relationships.size} relationships"
+
+        builder = MermaidSyntax::ErdBuilder.new(@config.merge(options))
+        builder.build_from_dataset(dataset)
+      end
+
+      # Build class diagram from dataset
+      #
+      # @param dataset [DiagramData::Dataset] dataset to render
+      # @param options [Hash] generation options
+      # @return [String] Mermaid class diagram syntax
+      def build_class_diagram_from_dataset(dataset, options = {})
+        @logger.debug "Building class diagram from dataset with #{dataset.entities.size} entities and " \
+                      "#{dataset.relationships.size} relationships"
+
+        builder = MermaidSyntax::ClassDiagramBuilder.new(@config.merge(options))
+        builder.build_from_dataset(dataset)
+      end
+
+      # Build flowchart diagram from dataset
+      #
+      # @param dataset [DiagramData::Dataset] dataset to render
+      # @param options [Hash] generation options
+      # @return [String] Mermaid flowchart syntax
+      def build_flowchart_diagram_from_dataset(dataset, options = {})
+        @logger.debug "Building flowchart diagram from dataset with #{dataset.entities.size} entities and " \
+                      "#{dataset.relationships.size} relationships"
+
+        builder = MermaidSyntax::FlowchartBuilder.new(@config.merge(options))
+        builder.build_from_dataset(dataset)
+      end
+
+      # Build empty ERD diagram with message
+      #
+      # @param message [String] message to display
+      # @return [String] Mermaid ERD syntax
+      def build_empty_erd(message)
+        builder = MermaidSyntax::ErdBuilder.new(@config)
+        builder.build_empty(message)
+      end
+
+      # Build empty flowchart diagram with message
+      #
+      # @param message [String] message to display
+      # @return [String] Mermaid flowchart syntax
+      def build_empty_flowchart(message)
+        builder = MermaidSyntax::FlowchartBuilder.new(@config)
+        builder.build_empty(message)
+      end
+
+      # Build empty class diagram with message
+      #
+      # @param message [String] message to display
+      # @return [String] Mermaid class diagram syntax
+      def build_empty_class_diagram(message)
+        builder = MermaidSyntax::ClassDiagramBuilder.new(@config)
+        builder.build_empty(message)
+      end
+
+      # Build empty diagram of specified type
+      #
+      # @param message [String] message to display
+      # @param diagram_type [String] type of diagram
+      # @return [String] Mermaid syntax
+      # @raise [UnsupportedDiagramTypeError] if type unsupported
+      def build_empty_diagram(message, diagram_type)
+        case diagram_type
+        when "erDiagram", "erd"
+          build_empty_erd(message)
+        when "classDiagram", "class"
+          build_empty_class_diagram(message)
+        when "flowchart", "graph"
+          build_empty_flowchart(message)
+        else
+          raise UnsupportedDiagramTypeError, "Unsupported diagram type: #{diagram_type}"
+        end
+      end
+
+      # Build ERD diagram with isolated tables
+      #
+      # @param entities [Array<Entity>] isolated table entities
+      # @param options [Hash] generation options
+      # @return [String] Mermaid ERD syntax
+      def build_erd_diagram_with_tables(entities, options = {})
+        @logger.debug "Building ERD diagram with #{entities.size} isolated tables"
+
+        dataset = Dbwatcher::Services::DiagramData::Dataset.new
+        entities.each { |entity| dataset.add_entity(entity) }
+
+        build_erd_diagram_from_dataset(dataset, options)
+      end
+
+      # Build flowchart diagram with isolated nodes
+      #
+      # @param entities [Array<Entity>] isolated node entities
+      # @param options [Hash] generation options
+      # @return [String] Mermaid flowchart syntax
+      def build_flowchart_with_nodes(entities, options = {})
+        @logger.debug "Building flowchart diagram with #{entities.size} isolated nodes"
+
+        dataset = Dbwatcher::Services::DiagramData::Dataset.new
+        entities.each { |entity| dataset.add_entity(entity) }
+
+        build_flowchart_diagram_from_dataset(dataset, options)
+      end
+
+      # For backward compatibility with legacy code
+      alias build_erd_diagram build_erd_diagram_from_dataset
+      alias build_flowchart_diagram build_flowchart_diagram_from_dataset
+    end
+  end
+end

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,59 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Storage
+    module Api
+      module Concerns
+        # Provides reusable table analysis functionality for API classes
+        #
+        # This concern now acts as a facade, delegating specific responsibilities
+        # to specialized service classes while maintaining backward compatibility.
+        #
+        # @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)
+            # Delegate to new service while maintaining interface compatibility
+            Dbwatcher::Services::Analyzers::TableSummaryBuilder.call(session)
+          end
+
+          # Process all changes in a session (legacy method for backward compatibility)
+          #
+          # @param session [Session] session with changes
+          # @param _tables [Hash] tables hash to populate (unused but kept for compatibility)
+          # @return [void]
+          def process_session_changes(session, _tables)
+            # Use new service for processing but maintain yield interface
+            processor = Dbwatcher::Services::Analyzers::SessionDataProcessor.new(session)
+            processor.process_changes do |table_name, change, _|
+              yield(table_name, change) if block_given?
+            end
+          end
+
+          # Legacy methods maintained for backward compatibility
+          # These now delegate to the new service classes
+
+          # Extract table name from change data (legacy compatibility)
+          #
+          # @param change [Hash] change data
+          # @return [String, nil] table name or nil
+          def extract_table_name(change)
+            return nil unless change.is_a?(Hash)
+
+            change[:table_name]
+          end
+        end
+      end
+    end
+  end
+end