appom 1.4.0 → 2.0.0

data/lib/appom/performance.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+# Performance monitoring for Appom automation framework
+# Tracks and analyzes performance metrics for test execution
+module Appom::Performance
+  # Performance monitoring and metrics collection
+  class Monitor
+    include Appom::Logging
+
+    attr_reader :metrics, :started_at
+
+    def initialize
+      @metrics = {}
+      @started_at = Time.now
+      @current_operations = {}
+      reset_session_metrics
+    end
+
+    # Start timing an operation
+    def start_timing(operation_name, context = {})
+      operation_id = generate_operation_id
+      @current_operations[operation_id] = {
+        name: operation_name,
+        start_time: Time.now,
+        context: context,
+      }
+
+      log_debug("Started timing: #{operation_name}", context)
+      operation_id
+    end
+
+    # End timing an operation
+    def end_timing(operation_id, success: true, additional_context: {})
+      operation = @current_operations.delete(operation_id)
+      return unless operation
+
+      duration = Time.now - operation[:start_time]
+
+      record_metric(
+        operation[:name],
+        duration,
+        success: success,
+        context: operation[:context].merge(additional_context),
+      )
+
+      log_debug("Completed timing: #{operation[:name]} (#{(duration * 1000).round(2)}ms)")
+      duration
+    end
+
+    # Time a block of code
+    def time_operation(operation_name, context = {})
+      operation_id = start_timing(operation_name, context)
+      Time.now
+      success = true
+      result = nil
+
+      begin
+        result = yield
+      rescue StandardError => e
+        success = false
+        raise e
+      ensure
+        end_timing(operation_id, success: success, additional_context: {
+                     exception: success ? nil : e&.class&.name,
+                   },)
+      end
+
+      result
+    end
+
+    # Record a metric manually
+    def record_metric(name, duration, success: true, context: {})
+      @metrics[name] ||= initialize_metric(name)
+      metric = @metrics[name]
+
+      metric[:total_calls] += 1
+      metric[:total_duration] += duration
+      metric[:successful_calls] += 1 if success
+      metric[:failed_calls] += 1 unless success
+
+      # Update min/max
+      metric[:min_duration] = [metric[:min_duration], duration].min
+      metric[:max_duration] = [metric[:max_duration], duration].max
+
+      # Calculate rolling averages (last 10 calls)
+      metric[:recent_durations] << duration
+      metric[:recent_durations] = metric[:recent_durations].last(10)
+
+      # Store context for analysis
+      metric[:contexts] << context.merge(success: success, duration: duration)
+      metric[:contexts] = metric[:contexts].last(50) # Keep last 50 contexts
+
+      # Update percentiles for larger samples
+      return unless (metric[:total_calls] % 10).zero?
+
+      update_percentiles(metric)
+    end
+
+    # Get performance statistics
+    def stats(operation_name = nil)
+      if operation_name
+        calculate_stats(@metrics[operation_name]) if @metrics[operation_name]
+      else
+        @metrics.transform_values { |metric| calculate_stats(metric) }
+      end
+    end
+
+    # Get performance summary
+    def summary
+      total_operations = @metrics.values.sum { |m| m[:total_calls] }
+      total_duration = @metrics.values.sum { |m| m[:total_duration] }
+
+      {
+        session_duration: Time.now - @started_at,
+        total_operations: total_operations,
+        total_duration: total_duration,
+        average_operation_time: total_operations.positive? ? total_duration / total_operations : 0,
+        operations_per_second: total_operations / (Time.now - @started_at),
+        slowest_operations: slowest_operations(5),
+        most_frequent_operations: most_frequent_operations(5),
+        success_rate: calculate_overall_success_rate,
+      }
+    end
+
+    # Get slowest operations
+    def slowest_operations(limit = 10)
+      operations = @metrics.map do |name, metric|
+        {
+          name: name,
+          max_duration: metric[:max_duration],
+          avg_duration: metric[:total_duration] / metric[:total_calls],
+          total_calls: metric[:total_calls],
+        }
+      end
+      operations.sort_by { |op| -op[:max_duration] }.first(limit)
+    end
+
+    # Get most frequent operations
+    def most_frequent_operations(limit = 10)
+      operations = @metrics.map do |name, metric|
+        {
+          name: name,
+          total_calls: metric[:total_calls],
+          avg_duration: metric[:total_duration] / metric[:total_calls],
+          success_rate: (metric[:successful_calls].to_f / metric[:total_calls] * 100).round(2),
+        }
+      end
+      operations.sort_by { |op| -op[:total_calls] }.first(limit)
+    end
+
+    # Export metrics to file
+    def export_metrics(format: :json, file_path: nil)
+      file_path ||= "appom_metrics_#{Time.now.strftime('%Y%m%d_%H%M%S')}.#{format}"
+
+      data = {
+        exported_at: Time.now,
+        session_started: @started_at,
+        summary: summary,
+        detailed_metrics: stats,
+      }
+
+      case format
+      when :json
+        File.write(file_path, JSON.pretty_generate(data))
+      when :yaml
+        File.write(file_path, YAML.dump(data))
+      when :csv
+        export_to_csv(file_path, data)
+      else
+        raise ArgumentError, "Unsupported format: #{format}"
+      end
+
+      log_info("Performance metrics exported to #{file_path}")
+      file_path
+    end
+
+    # Reset all metrics
+    def reset!
+      @metrics.clear
+      @started_at = Time.now
+      @current_operations.clear
+      reset_session_metrics
+      log_info('Performance metrics reset')
+    end
+
+    # Check for performance regressions
+    def check_regressions(baseline_file, threshold_percent = 20)
+      return {} unless File.exist?(baseline_file)
+
+      baseline = load_baseline(baseline_file)
+      regressions = {}
+
+      @metrics.each do |name, current_metric|
+        baseline_metric = baseline[name]
+        next unless baseline_metric
+
+        current_avg = current_metric[:total_duration] / current_metric[:total_calls]
+        baseline_avg = baseline_metric['avg_duration'] || baseline_metric[:avg_duration]
+
+        next unless current_avg > baseline_avg * (1 + (threshold_percent / 100.0))
+
+        regression_percent = ((current_avg - baseline_avg) / baseline_avg * 100).round(2)
+        regressions[name] = {
+          current_avg: current_avg,
+          baseline_avg: baseline_avg,
+          regression_percent: regression_percent,
+        }
+      end
+
+      regressions
+    end
+
+    private
+
+    def reset_session_metrics
+      @session_metrics = {
+        element_finds: 0,
+        wait_operations: 0,
+        interactions: 0,
+        screenshots: 0,
+      }
+    end
+
+    def generate_operation_id
+      "#{Time.now.to_f}_#{rand(1000)}"
+    end
+
+    def initialize_metric(name)
+      {
+        name: name,
+        total_calls: 0,
+        successful_calls: 0,
+        failed_calls: 0,
+        total_duration: 0.0,
+        min_duration: Float::INFINITY,
+        max_duration: 0.0,
+        recent_durations: [],
+        contexts: [],
+        percentiles: {},
+      }
+    end
+
+    def calculate_stats(metric)
+      return {} unless metric && metric[:total_calls].positive?
+
+      {
+        name: metric[:name],
+        total_calls: metric[:total_calls],
+        successful_calls: metric[:successful_calls],
+        failed_calls: metric[:failed_calls],
+        success_rate: (metric[:successful_calls].to_f / metric[:total_calls] * 100).round(2),
+        total_duration: metric[:total_duration],
+        avg_duration: metric[:total_duration] / metric[:total_calls],
+        min_duration: metric[:min_duration] == Float::INFINITY ? 0 : metric[:min_duration],
+        max_duration: metric[:max_duration],
+        recent_avg: metric[:recent_durations].empty? ? 0 : metric[:recent_durations].sum / metric[:recent_durations].size,
+        percentiles: metric[:percentiles],
+      }
+    end
+
+    def update_percentiles(metric)
+      all_durations = metric[:contexts].map { |c| c[:duration] }.sort
+      return if all_durations.empty?
+
+      metric[:percentiles] = {
+        p50: percentile(all_durations, 50),
+        p75: percentile(all_durations, 75),
+        p90: percentile(all_durations, 90),
+        p95: percentile(all_durations, 95),
+        p99: percentile(all_durations, 99),
+      }
+    end
+
+    def percentile(sorted_array, percentile)
+      return 0 if sorted_array.empty?
+
+      index = (percentile / 100.0 * (sorted_array.length - 1)).round
+      sorted_array[index]
+    end
+
+    def calculate_overall_success_rate
+      total_calls = @metrics.values.sum { |m| m[:total_calls] }
+      return 100.0 if total_calls.zero?
+
+      successful_calls = @metrics.values.sum { |m| m[:successful_calls] }
+      (successful_calls.to_f / total_calls * 100).round(2)
+    end
+
+    def export_to_csv(file_path, data)
+      require 'csv'
+
+      CSV.open(file_path, 'w') do |csv|
+        # Headers
+        csv << ['Operation', 'Total Calls', 'Success Rate', 'Avg Duration', 'Min Duration', 'Max Duration']
+
+        # Data rows
+        data[:detailed_metrics].each do |name, stats|
+          csv << [
+            name,
+            stats[:total_calls],
+            stats[:success_rate],
+            stats[:avg_duration],
+            stats[:min_duration],
+            stats[:max_duration],
+          ]
+        end
+      end
+    end
+
+    def load_baseline(file_path)
+      case File.extname(file_path)
+      when '.json'
+        JSON.parse(File.read(file_path))['detailed_metrics'] || {}
+      when '.yml', '.yaml'
+        YAML.load_file(file_path, permitted_classes: [Time])['detailed_metrics'] || {}
+      else
+        {}
+      end
+    rescue StandardError => e
+      log_error("Failed to load baseline from #{file_path}: #{e.message}")
+      {}
+    end
+  end
+
+  # Performance-aware method wrapper
+  module MethodInstrumentation
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    # Class methods for method instrumentation
+    module ClassMethods
+      # Instrument methods for performance monitoring
+      def instrument_method(method_name, operation_name: nil)
+        operation_name ||= "#{name}##{method_name}"
+
+        alias_method "#{method_name}_without_instrumentation", method_name
+
+        define_method(method_name) do |*args, &block|
+          Appom::Performance.monitor.time_operation(operation_name) do
+            send("#{method_name}_without_instrumentation", *args, &block)
+          end
+        end
+      end
+
+      # Instrument all methods matching pattern
+      def instrument_methods(pattern, operation_prefix: nil)
+        operation_prefix ||= name
+
+        instance_methods(false).grep(pattern).each do |method_name|
+          instrument_method(method_name, operation_name: "#{operation_prefix}##{method_name}")
+        end
+      end
+    end
+  end
+
+  # Global performance monitor
+  class << self
+    attr_writer :monitor
+
+    def monitor
+      @monitor ||= Monitor.new
+    end
+
+    # Convenience methods
+    def time_operation(name, context = {}, &)
+      monitor.time_operation(name, context, &)
+    end
+
+    def record_metric(name, duration, **)
+      monitor.record_metric(name, duration, **)
+    end
+
+    def stats(operation_name = nil)
+      monitor.stats(operation_name)
+    end
+
+    def summary
+      monitor.summary
+    end
+
+    def export_metrics(**)
+      monitor.export_metrics(**)
+    end
+
+    def reset!
+      monitor.reset!
+    end
+
+    def check_regressions(baseline_file, threshold_percent = 20)
+      monitor.check_regressions(baseline_file, threshold_percent)
+    end
+  end
+end

data/lib/appom/retry.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+# Retry functionality for Appom automation framework
+# Provides exponential backoff retry logic for flaky operations
+module Appom::Retry
+  # Default retry configuration
+  DEFAULT_RETRY_COUNT = 3
+  DEFAULT_RETRY_DELAY = 0.5
+  DEFAULT_BACKOFF_MULTIPLIER = 1.5
+
+  # Configuration class for retry operations
+  class RetryConfig
+    attr_accessor :max_attempts, :base_delay, :backoff_multiplier, :max_delay,
+                  :retry_on_exceptions, :retry_if, :on_retry
+
+    def initialize
+      @max_attempts = DEFAULT_RETRY_COUNT
+      @base_delay = DEFAULT_RETRY_DELAY
+      @backoff_multiplier = DEFAULT_BACKOFF_MULTIPLIER
+      @max_delay = 30 # seconds
+      @retry_on_exceptions = [Appom::ElementNotFoundError, Appom::ElementStateError,
+                              Appom::WaitError, StandardError,]
+      @retry_if = nil
+      @on_retry = nil
+    end
+  end
+
+  class << self
+    # Execute a block with retry logic
+    def with_retry(config = RetryConfig.new)
+      return unless block_given?
+
+      attempt = 1
+      delay = config.base_delay
+
+      begin
+        yield
+      rescue *config.retry_on_exceptions => e
+        # Check if we should retry based on custom condition
+        raise e if config.retry_if && !config.retry_if.call(e, attempt)
+
+        raise e unless attempt < config.max_attempts
+
+        # Call retry callback if provided
+        config.on_retry&.call(e, attempt, delay)
+
+        Kernel.sleep(delay)
+        attempt += 1
+        delay = [delay * config.backoff_multiplier, config.max_delay].min
+        retry
+      end
+    end
+
+    # Configure retry behavior for element operations
+    def configure_element_retry
+      config = RetryConfig.new
+      yield(config) if block_given?
+      config
+    end
+  end
+
+  # Mixin for adding retry capabilities to classes
+  module RetryMethods
+    # Retry element finding with exponential backoff
+    def find_with_retry(element_name, **retry_options)
+      config = build_retry_config(retry_options)
+
+      Appom::Retry.with_retry(config) do
+        send(element_name)
+      end
+    end
+
+    # Retry element interaction (tap, click, etc.)
+    def interact_with_retry(element_name, action = :tap, **retry_options)
+      config = build_retry_config(retry_options)
+
+      Appom::Retry.with_retry(config) do
+        element = send(element_name)
+        perform_element_action(element, action, retry_options)
+        element
+      end
+    end
+
+    # Retry getting element text
+    def get_text_with_retry(element_name, **retry_options)
+      config = build_retry_config(retry_options)
+
+      Appom::Retry.with_retry(config) do
+        element = send(element_name)
+        text = element.text
+
+        # Validate text if validation block provided
+        raise Appom::ElementStateError.new(element_name, 'valid text', text) if retry_options[:validate_text] && !retry_options[:validate_text].call(text)
+
+        text
+      end
+    end
+
+    # Retry waiting for element state
+    def wait_for_state_with_retry(element_name, state = :displayed, **retry_options)
+      config = build_retry_config(retry_options)
+
+      Appom::Retry.with_retry(config) do
+        element = send(element_name)
+        validate_element_state(element, element_name, state)
+        element
+      end
+    end
+
+    private
+
+    def perform_element_action(element, action, options)
+      case action
+      when :tap, :click
+        element.tap
+      when :clear
+        element.clear
+      when :send_keys
+        element.send_keys(options[:text] || '')
+      else
+        element.send(action)
+      end
+    end
+
+    def validate_element_state(element, element_name, state)
+      case state
+      when :displayed
+        validate_displayed_state(element, element_name)
+      when :enabled
+        validate_enabled_state(element, element_name)
+      when :not_displayed
+        validate_not_displayed_state(element, element_name)
+      else
+        raise Appom::ConfigurationError.new('element_state', state, 'Unknown state')
+      end
+    end
+
+    def validate_displayed_state(element, element_name)
+      return if element.displayed?
+
+      raise Appom::ElementStateError.new(element_name, 'displayed', 'not displayed')
+    end
+
+    def validate_enabled_state(element, element_name)
+      return if element.enabled?
+
+      raise Appom::ElementStateError.new(element_name, 'enabled', 'disabled')
+    end
+
+    def validate_not_displayed_state(element, element_name)
+      return unless element.displayed?
+
+      raise Appom::ElementStateError.new(element_name, 'not displayed', 'displayed')
+    end
+
+    def build_retry_config(options)
+      config = Appom::Retry::RetryConfig.new
+      config.max_attempts = options.fetch(:max_attempts, DEFAULT_RETRY_COUNT)
+      config.base_delay = options.fetch(:base_delay, DEFAULT_RETRY_DELAY)
+      config.backoff_multiplier = options.fetch(:backoff_multiplier, DEFAULT_BACKOFF_MULTIPLIER)
+      config.max_delay = options.fetch(:max_delay, 30)
+
+      config.retry_on_exceptions = Array(options[:retry_on]) if options[:retry_on]
+
+      config.retry_if = options[:retry_if] if options[:retry_if]
+
+      if options[:on_retry]
+        config.on_retry = options[:on_retry]
+      elsif respond_to?(:log_warn)
+        config.on_retry = lambda { |error, attempt, delay|
+          log_warn("Retry attempt #{attempt}/#{config.max_attempts}: #{error.message} (delay: #{delay}s)")
+        }
+      end
+
+      config
+    end
+  end
+end