dbwatcher 1.1.2 → 1.1.4

data/lib/dbwatcher/services/timeline_data_service/enhancement_utilities.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    class TimelineDataService
+      # Module for enhancing timeline entries and utility methods
+      module EnhancementUtilities
+        private
+
+        # Enhance timeline entries with additional metadata
+        #
+        # @return [void]
+        def enhance_with_metadata
+          return if @timeline_entries.empty?
+
+          session_start_time = @timeline_entries.first[:raw_timestamp]
+
+          @timeline_entries.each_with_index do |entry, index|
+            entry[:relative_time] = calculate_relative_time(entry[:raw_timestamp], session_start_time)
+            entry[:duration_from_previous] = calculate_duration_from_previous(entry, index)
+            entry[:operation_group] = determine_operation_group(entry, index)
+          end
+        end
+
+        # Calculate relative time from session start
+        #
+        # @param timestamp [Float] entry timestamp
+        # @param session_start [Float] session start timestamp
+        # @return [String] formatted relative time
+        def calculate_relative_time(timestamp, session_start)
+          seconds = timestamp - session_start
+          format_duration(seconds)
+        end
+
+        # Calculate duration from previous operation
+        #
+        # @param entry [Hash] current entry
+        # @param index [Integer] entry index
+        # @return [Integer] duration in milliseconds
+        def calculate_duration_from_previous(entry, index)
+          return 0 if index.zero?
+
+          previous_entry = @timeline_entries[index - 1]
+          ((entry[:raw_timestamp] - previous_entry[:raw_timestamp]) * 1000).round
+        end
+
+        # Determine operation group for related operations
+        #
+        # @param entry [Hash] current entry
+        # @param index [Integer] entry index
+        # @return [String] operation group identifier
+        def determine_operation_group(entry, index)
+          # Group operations on same table within 1 second
+          return "single_op" if index.zero?
+
+          previous_entry = @timeline_entries[index - 1]
+          time_diff = entry[:raw_timestamp] - previous_entry[:raw_timestamp]
+
+          if time_diff <= 1.0 && entry[:table_name] == previous_entry[:table_name]
+            "#{entry[:table_name]}_batch_#{index / 10}" # Group every 10 operations
+          else
+            "single_op"
+          end
+        end
+
+        # Format duration in human-readable format
+        #
+        # @param seconds [Float] duration in seconds
+        # @return [String] formatted duration
+        def format_duration(seconds)
+          if seconds < 60
+            format("%<minutes>02d:%<seconds>02d", minutes: 0, seconds: seconds.to_i)
+          elsif seconds < 3600
+            minutes = seconds / 60
+            format("%<minutes>02d:%<seconds>02d", minutes: minutes.to_i, seconds: (seconds % 60).to_i)
+          else
+            hours = seconds / 3600
+            minutes = (seconds % 3600) / 60
+            format("%<hours>02d:%<minutes>02d:%<seconds>02d",
+                   hours: hours.to_i, minutes: minutes.to_i, seconds: (seconds % 60).to_i)
+          end
+        end
+
+        # Get model class for a table using the TableSummaryBuilder service
+        #
+        # @param table_name [String] database table name
+        # @return [String, nil] model class name or nil if not found
+        def get_model_class_for_table(table_name)
+          # Use cache to avoid repeated lookups
+          @model_class_cache ||= {}
+          return @model_class_cache[table_name] if @model_class_cache.key?(table_name)
+
+          # Delegate to TableSummaryBuilder for model class lookup
+          builder = Dbwatcher::Services::Analyzers::TableSummaryBuilder.new(@session)
+          @model_class_cache[table_name] = builder.send(:find_model_class, table_name)
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/timeline_data_service/entry_builder.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Dbwatcher
+  module Services
+    class TimelineDataService
+      # Module for building timeline entries
+      module EntryBuilder
+        private
+
+        # Create a timeline entry from change data
+        #
+        # @param change [Hash] change data
+        # @param sequence [Integer] sequence number
+        # @return [Hash] timeline entry
+        def create_timeline_entry(change, sequence)
+          timestamp = parse_timestamp(change[:timestamp])
+
+          {
+            id: generate_entry_id(change, sequence),
+            timestamp: timestamp,
+            sequence: sequence,
+            table_name: change[:table_name],
+            operation: change[:operation],
+            record_id: extract_record_id(change),
+            changes: format_changes(change),
+            metadata: extract_metadata(change),
+            model_class: get_model_class_for_table(change[:table_name]),
+            raw_timestamp: timestamp.to_f
+          }
+        end
+
+        # Generate unique ID for timeline entry
+        #
+        # @param change [Hash] change data
+        # @param sequence [Integer] sequence number
+        # @return [String] unique entry ID
+        def generate_entry_id(change, sequence)
+          data = "#{change[:table_name]}_#{change[:operation]}_#{sequence}"
+          hash = Digest::SHA1.hexdigest(data)[0..7]
+          "#{@session.id}_entry_#{sequence}_#{hash}"
+        end
+
+        # Parse timestamp from various formats
+        #
+        # @param timestamp [String, Time, Integer] timestamp value
+        # @return [Time] parsed timestamp
+        def parse_timestamp(timestamp)
+          case timestamp
+          when Time
+            timestamp
+          when String
+            Time.parse(timestamp)
+          when Integer, Float
+            Time.at(timestamp)
+          else
+            Time.current
+          end
+        rescue ArgumentError
+          Time.current
+        end
+
+        # Extract record ID from change data
+        #
+        # @param change [Hash] change data
+        # @return [String, nil] record ID if available
+        def extract_record_id(change)
+          change[:record_id] || change[:id] || change.dig(:changes, :id)
+        end
+
+        # Format changes for timeline display
+        #
+        # @param change [Hash] change data
+        # @return [Hash] formatted changes
+        def format_changes(change)
+          raw_changes = change[:changes] || change[:data] || {}
+          return {} unless raw_changes.is_a?(Hash)
+
+          raw_changes.transform_values do |value|
+            case value
+            when Hash
+              value # Already formatted as { from: x, to: y }
+            else
+              { to: value } # Simple value change
+            end
+          end
+        end
+
+        # Extract metadata from change data
+        #
+        # @param change [Hash] change data
+        # @return [Hash] metadata hash
+        def extract_metadata(change)
+          {
+            duration_ms: change[:duration_ms] || change[:duration],
+            affected_rows: change[:affected_rows] || change[:rows_affected] || 1,
+            query_fingerprint: change[:query_fingerprint] || change[:sql_fingerprint],
+            connection_id: change[:connection_id] || change[:connection],
+            query_type: determine_query_type(change[:operation])
+          }.compact
+        end
+
+        # Determine query type from operation
+        #
+        # @param operation [String] database operation
+        # @return [String] query type
+        def determine_query_type(operation)
+          case operation&.upcase
+          when "INSERT", "CREATE"
+            "write"
+          when "UPDATE", "MODIFY"
+            "update"
+          when "DELETE", "DROP"
+            "delete"
+          when "SELECT", "SHOW"
+            "read"
+          else
+            "unknown"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/timeline_data_service/metadata_builder.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    class TimelineDataService
+      # Module for building timeline metadata
+      module MetadataBuilder
+        private
+
+        # Build timeline metadata
+        #
+        # @return [Hash] timeline metadata
+        def build_timeline_metadata
+          return {} if @timeline_entries.empty?
+
+          {
+            total_operations: @timeline_entries.length,
+            time_range: calculate_time_range,
+            session_duration: calculate_session_duration,
+            tables_affected: extract_affected_tables,
+            operation_counts: count_operations_by_type,
+            peak_activity_periods: find_peak_activity_periods
+          }
+        end
+
+        # Calculate time range for the session
+        #
+        # @return [Hash] time range with start and end
+        def calculate_time_range
+          return {} if @timeline_entries.empty?
+
+          start_time = Time.at(@timeline_entries.first[:raw_timestamp])
+          end_time = Time.at(@timeline_entries.last[:raw_timestamp])
+
+          {
+            start: start_time.iso8601,
+            end: end_time.iso8601
+          }
+        end
+
+        # Calculate total session duration
+        #
+        # @return [String] formatted session duration
+        def calculate_session_duration
+          return "00:00" if @timeline_entries.length < 2
+
+          duration = @timeline_entries.last[:raw_timestamp] - @timeline_entries.first[:raw_timestamp]
+          format_duration(duration)
+        end
+
+        # Extract list of affected tables
+        #
+        # @return [Array<String>] unique table names
+        def extract_affected_tables
+          @timeline_entries.map { |entry| entry[:table_name] }.uniq.sort
+        end
+
+        # Count operations by type
+        #
+        # @return [Hash] operation counts
+        def count_operations_by_type
+          @timeline_entries.group_by { |entry| entry[:operation] }
+                           .transform_values(&:count)
+        end
+
+        # Find peak activity periods
+        #
+        # @return [Array<Hash>] peak activity periods
+        def find_peak_activity_periods
+          return [] if @timeline_entries.length < 10
+
+          # Group operations by 1-minute windows
+          windows = @timeline_entries.group_by do |entry|
+            timestamp = Time.at(entry[:raw_timestamp])
+            Time.new(timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.min, 0)
+          end
+
+          # Find windows with more than average activity
+          average_ops = @timeline_entries.length / windows.length.to_f
+
+          windows.select { |_, ops| ops.length > average_ops * 1.5 }
+                 .map do |window_start, ops|
+            {
+              start: window_start.iso8601,
+              end: (window_start + 1.minute).iso8601,
+              operations_count: ops.length
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/timeline_data_service.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "timeline_data_service/metadata_builder"
+require_relative "timeline_data_service/entry_builder"
+require_relative "timeline_data_service/enhancement_utilities"
+
+module Dbwatcher
+  module Services
+    # Timeline Data Service for processing session data into chronological timeline format
+    #
+    # This service transforms session changes into a chronologically ordered timeline
+    # with enhanced metadata for visualization and filtering.
+    #
+    # @example
+    #   service = TimelineDataService.new(session)
+    #   result = service.call
+    #   timeline = result[:timeline]
+    #   metadata = result[:metadata]
+    class TimelineDataService
+      include MetadataBuilder
+      include EntryBuilder
+      include EnhancementUtilities
+      # Initialize the timeline data service
+      #
+      # @param session [Session] session object containing changes data
+      def initialize(session)
+        @session = session
+        @timeline_entries = []
+        @start_time = Time.current
+      end
+
+      # Process session data into timeline format
+      #
+      # @return [Hash] processed timeline data with metadata
+      def call
+        Rails.logger.info("Processing timeline data for session #{@session.id}")
+
+        validate_session_data
+        build_timeline_entries
+        sort_chronologically
+        enhance_with_metadata
+        result = build_result
+
+        Rails.logger.info(
+          "Timeline processing completed for session #{@session.id} (#{@timeline_entries.length} entries)"
+        )
+
+        result
+      rescue StandardError => e
+        Rails.logger.error("Timeline processing failed for session #{@session.id}: #{e.message}")
+        build_error_result(e)
+      end
+
+      private
+
+      # Validate session data before processing
+      #
+      # @raise [ArgumentError] if session data is invalid
+      def validate_session_data
+        raise ArgumentError, "Session is required" unless @session
+        raise ArgumentError, "Session ID is required" unless @session.id
+        raise ArgumentError, "Session changes are required" unless @session.changes
+      end
+
+      # Build timeline entries from session changes
+      #
+      # @return [void]
+      def build_timeline_entries
+        @session.changes.each_with_index do |change, index|
+          next unless valid_change?(change)
+
+          @timeline_entries << create_timeline_entry(change, index)
+        end
+      end
+
+      # Check if a change is valid for timeline processing
+      #
+      # @param change [Hash] change data
+      # @return [Boolean] true if change is valid
+      def valid_change?(change)
+        change.is_a?(Hash) &&
+          change[:table_name] &&
+          change[:operation] &&
+          change[:timestamp]
+      end
+
+      # Sort timeline entries chronologically
+      #
+      # @return [void]
+      def sort_chronologically
+        @timeline_entries.sort_by! { |entry| entry[:raw_timestamp] }
+      end
+
+      # Build final result hash
+      #
+      # @return [Hash] complete timeline result
+      def build_result
+        {
+          timeline: @timeline_entries,
+          metadata: build_timeline_metadata,
+          summary: build_timeline_summary,
+          errors: []
+        }
+      end
+
+      # Build timeline summary
+      #
+      # @return [Hash] timeline summary
+      def build_timeline_summary
+        {
+          total_entries: @timeline_entries.length,
+          processing_time: (Time.current - @start_time).round(3)
+        }
+      end
+
+      # Build error result
+      #
+      # @param error [StandardError] error that occurred
+      # @return [Hash] error result
+      def build_error_result(error)
+        {
+          timeline: [],
+          metadata: {},
+          summary: { error: error.message },
+          errors: [{ type: "processing_error", message: error.message }]
+        }
+      end
+    end
+  end
+end

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

@@ -24,7 +24,7 @@ module Dbwatcher
           # @return [Hash] tables summary hash
           def build_tables_summary(session)
             # Delegate to new service while maintaining interface compatibility
-            Dbwatcher::Services::Analyzers::TableSummaryBuilder.call(session)
+            Dbwatcher::Services::Analyzers::TableSummaryBuilder.new(session).call
           end
 
           # Process all changes in a session (legacy method for backward compatibility)

data/lib/dbwatcher/version.rb

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

data/lib/dbwatcher.rb

@@ -74,7 +74,7 @@ require_relative "dbwatcher/services/diagram_system"
 
 # API services
 require_relative "dbwatcher/services/api/base_api_service"
-require_relative "dbwatcher/services/api/changes_data_service"
+require_relative "dbwatcher/services/api/tables_data_service"
 require_relative "dbwatcher/services/api/summary_data_service"
 require_relative "dbwatcher/services/api/diagram_data_service"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbwatcher
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.4
 platform: ruby
 authors:
 - Huy Nguyen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-09 00:00:00.000000000 Z
+date: 2025-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -172,6 +172,7 @@ files:
 - app/assets/javascripts/dbwatcher/components/dashboard.js
 - app/assets/javascripts/dbwatcher/components/diagrams.js
 - app/assets/javascripts/dbwatcher/components/summary.js
+- app/assets/javascripts/dbwatcher/components/timeline.js
 - app/assets/javascripts/dbwatcher/core/alpine_store.js
 - app/assets/javascripts/dbwatcher/core/api_client.js
 - app/assets/javascripts/dbwatcher/core/component_loader.js
@@ -190,6 +191,7 @@ files:
 - app/assets/stylesheets/dbwatcher/components/_forms.scss
 - app/assets/stylesheets/dbwatcher/components/_navigation.scss
 - app/assets/stylesheets/dbwatcher/components/_tabulator.scss
+- app/assets/stylesheets/dbwatcher/components/_timeline.scss
 - app/assets/stylesheets/dbwatcher/core/_base.scss
 - app/assets/stylesheets/dbwatcher/core/_variables.scss
 - app/assets/stylesheets/dbwatcher/vendor/_tabulator_overrides.scss
@@ -212,11 +214,12 @@ files:
 - app/views/dbwatcher/dashboard/_system_info_content.html.erb
 - app/views/dbwatcher/dashboard/index.html.erb
 - app/views/dbwatcher/queries/index.html.erb
-- app/views/dbwatcher/sessions/_changes.html.erb
 - app/views/dbwatcher/sessions/_diagrams.html.erb
 - app/views/dbwatcher/sessions/_layout.html.erb
 - app/views/dbwatcher/sessions/_session_header.html.erb
 - app/views/dbwatcher/sessions/_summary.html.erb
+- app/views/dbwatcher/sessions/_tables.html.erb
+- app/views/dbwatcher/sessions/_timeline.html.erb
 - app/views/dbwatcher/sessions/index.html.erb
 - app/views/dbwatcher/sessions/show.html.erb
 - app/views/dbwatcher/shared/_badge.html.erb
@@ -244,9 +247,9 @@ files:
 - lib/dbwatcher/services/analyzers/session_data_processor.rb
 - lib/dbwatcher/services/analyzers/table_summary_builder.rb
 - lib/dbwatcher/services/api/base_api_service.rb
-- lib/dbwatcher/services/api/changes_data_service.rb
 - lib/dbwatcher/services/api/diagram_data_service.rb
 - lib/dbwatcher/services/api/summary_data_service.rb
+- lib/dbwatcher/services/api/tables_data_service.rb
 - lib/dbwatcher/services/base_service.rb
 - lib/dbwatcher/services/dashboard_data_aggregator.rb
 - lib/dbwatcher/services/diagram_analyzers/base_analyzer.rb
@@ -263,8 +266,10 @@ files:
 - lib/dbwatcher/services/diagram_generator.rb
 - lib/dbwatcher/services/diagram_strategies/base_diagram_strategy.rb
 - lib/dbwatcher/services/diagram_strategies/class_diagram_strategy.rb
+- lib/dbwatcher/services/diagram_strategies/diagram_strategy_helpers.rb
 - lib/dbwatcher/services/diagram_strategies/erd_diagram_strategy.rb
 - lib/dbwatcher/services/diagram_strategies/flowchart_diagram_strategy.rb
+- lib/dbwatcher/services/diagram_strategies/standard_diagram_strategy.rb
 - lib/dbwatcher/services/diagram_system.rb
 - lib/dbwatcher/services/diagram_type_registry.rb
 - lib/dbwatcher/services/mermaid_syntax/base_builder.rb
@@ -281,6 +286,10 @@ files:
 - lib/dbwatcher/services/system_info/runtime_info_collector.rb
 - lib/dbwatcher/services/system_info/system_info_collector.rb
 - lib/dbwatcher/services/table_statistics_collector.rb
+- lib/dbwatcher/services/timeline_data_service.rb
+- lib/dbwatcher/services/timeline_data_service/enhancement_utilities.rb
+- lib/dbwatcher/services/timeline_data_service/entry_builder.rb
+- lib/dbwatcher/services/timeline_data_service/metadata_builder.rb
 - lib/dbwatcher/sql_logger.rb
 - lib/dbwatcher/storage.rb
 - lib/dbwatcher/storage/api/base_api.rb