rubydb 0.1.4 → 0.1.5

data/lib/rubydb/monitoring/performance.rb

@@ -1,176 +1,176 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Monitoring
-    # Performance - Performance monitoring
-    class Performance
-      attr_reader :stats
-
-      def initialize(engine, config = {})
-        @engine = engine
-        @config = config
-        @statistics = Statistics.new
-        @metrics = {
-          query_times: [],
-          transaction_times: [],
-          connection_times: [],
-          wal_write_times: [],
-          checkpoint_times: [],
-          replication_lag: []
-        }
-        @query_counts = {}
-        @slow_queries = []
-        @max_slow_queries = config[:max_slow_queries] || 100
-        @slow_query_threshold = config[:slow_query_threshold] || 1000
-        @stats = {
-          total_queries: 0,
-          total_transactions: 0,
-          avg_query_time: 0,
-          slow_query_count: 0,
-          transaction_throughput: 0,
-          query_throughput: 0
-        }
-        @lock = Mutex.new
-        @start_time = Time.now
-      end
-
-      def record_query(query, time_ms)
-        @lock.synchronize do
-          @stats[:total_queries] += 1
-          @metrics[:query_times] << time_ms
-
-          # Track query type
-          type = extract_query_type(query)
-          @query_counts[type] ||= 0
-          @query_counts[type] += 1
-
-          # Record slow queries
-          if time_ms > @slow_query_threshold
-            @slow_queries << {
-              query: query,
-              time_ms: time_ms,
-              timestamp: Time.now.iso8601
-            }
-            @slow_queries = @slow_queries.last(@max_slow_queries)
-            @stats[:slow_query_count] += 1
-          end
-
-          update_stats
-        end
-      end
-
-      def record_transaction(time_ms)
-        @lock.synchronize do
-          @stats[:total_transactions] += 1
-          @metrics[:transaction_times] << time_ms
-          update_stats
-        end
-      end
-
-      def record_connection(time_ms)
-        @lock.synchronize do
-          @metrics[:connection_times] << time_ms
-          update_stats
-        end
-      end
-
-      def record_wal_write(time_ms)
-        @lock.synchronize do
-          @metrics[:wal_write_times] << time_ms
-          update_stats
-        end
-      end
-
-      def record_checkpoint(time_ms)
-        @lock.synchronize do
-          @metrics[:checkpoint_times] << time_ms
-          update_stats
-        end
-      end
-
-      def record_replication_lag(lag_ms)
-        @lock.synchronize do
-          @metrics[:replication_lag] << lag_ms
-          update_stats
-        end
-      end
-
-      def query_performance
-        @lock.synchronize do
-          times = @metrics[:query_times]
-          {
-            total: @stats[:total_queries],
-            avg: @statistics.mean(times),
-            median: @statistics.median(times),
-            p95: @statistics.percentile(times, 95),
-            p99: @statistics.percentile(times, 99),
-            min: @statistics.min(times),
-            max: @statistics.max(times)
-          }
-        end
-      end
-
-      def transaction_performance
-        @lock.synchronize do
-          times = @metrics[:transaction_times]
-          {
-            total: @stats[:total_transactions],
-            avg: @statistics.mean(times),
-            median: @statistics.median(times),
-            p95: @statistics.percentile(times, 95),
-            p99: @statistics.percentile(times, 99),
-            min: @statistics.min(times),
-            max: @statistics.max(times)
-          }
-        end
-      end
-
-      def slow_queries
-        @slow_queries.dup
-      end
-
-      def query_counts
-        @query_counts.dup
-      end
-
-      def throughput
-        @lock.synchronize do
-          elapsed = (Time.now - @start_time).to_f
-          {
-            queries_per_second: @stats[:total_queries] / elapsed,
-            transactions_per_second: @stats[:total_transactions] / elapsed
-          }
-        end
-      end
-
-      def stats
-        @lock.synchronize do
-          elapsed = (Time.now - @start_time).to_f
-          @stats.merge({
-            uptime_seconds: elapsed.round(2),
-            query_stats: query_performance,
-            transaction_stats: transaction_performance,
-            throughput: throughput,
-            slow_query_count: @slow_queries.size,
-            query_types: @query_counts
-          })
-        end
-      end
-
-      private
-
-      def extract_query_type(query)
-        query.strip.split.first&.upcase || "UNKNOWN"
-      end
-
-      def update_stats
-        times = @metrics[:query_times]
-        @stats[:avg_query_time] = @statistics.mean(times) if times.any?
-
-        elapsed = (Time.now - @start_time).to_f
-        @stats[:query_throughput] = @stats[:total_queries] / elapsed if elapsed > 0
-        @stats[:transaction_throughput] = @stats[:total_transactions] / elapsed if elapsed > 0
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Monitoring
+    # Performance - Performance monitoring
+    class Performance
+      attr_reader :stats
+
+      def initialize(engine, config = {})
+        @engine = engine
+        @config = config
+        @statistics = Statistics.new
+        @metrics = {
+          query_times: [],
+          transaction_times: [],
+          connection_times: [],
+          wal_write_times: [],
+          checkpoint_times: [],
+          replication_lag: []
+        }
+        @query_counts = {}
+        @slow_queries = []
+        @max_slow_queries = config[:max_slow_queries] || 100
+        @slow_query_threshold = config[:slow_query_threshold] || 1000
+        @stats = {
+          total_queries: 0,
+          total_transactions: 0,
+          avg_query_time: 0,
+          slow_query_count: 0,
+          transaction_throughput: 0,
+          query_throughput: 0
+        }
+        @lock = Mutex.new
+        @start_time = Time.now
+      end
+
+      def record_query(query, time_ms)
+        @lock.synchronize do
+          @stats[:total_queries] += 1
+          @metrics[:query_times] << time_ms
+
+          # Track query type
+          type = extract_query_type(query)
+          @query_counts[type] ||= 0
+          @query_counts[type] += 1
+
+          # Record slow queries
+          if time_ms > @slow_query_threshold
+            @slow_queries << {
+              query: query,
+              time_ms: time_ms,
+              timestamp: Time.now.iso8601
+            }
+            @slow_queries = @slow_queries.last(@max_slow_queries)
+            @stats[:slow_query_count] += 1
+          end
+
+          update_stats
+        end
+      end
+
+      def record_transaction(time_ms)
+        @lock.synchronize do
+          @stats[:total_transactions] += 1
+          @metrics[:transaction_times] << time_ms
+          update_stats
+        end
+      end
+
+      def record_connection(time_ms)
+        @lock.synchronize do
+          @metrics[:connection_times] << time_ms
+          update_stats
+        end
+      end
+
+      def record_wal_write(time_ms)
+        @lock.synchronize do
+          @metrics[:wal_write_times] << time_ms
+          update_stats
+        end
+      end
+
+      def record_checkpoint(time_ms)
+        @lock.synchronize do
+          @metrics[:checkpoint_times] << time_ms
+          update_stats
+        end
+      end
+
+      def record_replication_lag(lag_ms)
+        @lock.synchronize do
+          @metrics[:replication_lag] << lag_ms
+          update_stats
+        end
+      end
+
+      def query_performance
+        @lock.synchronize do
+          times = @metrics[:query_times]
+          {
+            total: @stats[:total_queries],
+            avg: @statistics.mean(times),
+            median: @statistics.median(times),
+            p95: @statistics.percentile(times, 95),
+            p99: @statistics.percentile(times, 99),
+            min: @statistics.min(times),
+            max: @statistics.max(times)
+          }
+        end
+      end
+
+      def transaction_performance
+        @lock.synchronize do
+          times = @metrics[:transaction_times]
+          {
+            total: @stats[:total_transactions],
+            avg: @statistics.mean(times),
+            median: @statistics.median(times),
+            p95: @statistics.percentile(times, 95),
+            p99: @statistics.percentile(times, 99),
+            min: @statistics.min(times),
+            max: @statistics.max(times)
+          }
+        end
+      end
+
+      def slow_queries
+        @slow_queries.dup
+      end
+
+      def query_counts
+        @query_counts.dup
+      end
+
+      def throughput
+        @lock.synchronize do
+          elapsed = (Time.now - @start_time).to_f
+          {
+            queries_per_second: @stats[:total_queries] / elapsed,
+            transactions_per_second: @stats[:total_transactions] / elapsed
+          }
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          elapsed = (Time.now - @start_time).to_f
+          @stats.merge({
+            uptime_seconds: elapsed.round(2),
+            query_stats: query_performance,
+            transaction_stats: transaction_performance,
+            throughput: throughput,
+            slow_query_count: @slow_queries.size,
+            query_types: @query_counts
+          })
+        end
+      end
+
+      private
+
+      def extract_query_type(query)
+        query.strip.split.first&.upcase || "UNKNOWN"
+      end
+
+      def update_stats
+        times = @metrics[:query_times]
+        @stats[:avg_query_time] = @statistics.mean(times) if times.any?
+
+        elapsed = (Time.now - @start_time).to_f
+        @stats[:query_throughput] = @stats[:total_queries] / elapsed if elapsed > 0
+        @stats[:transaction_throughput] = @stats[:total_transactions] / elapsed if elapsed > 0
+      end
+    end
+  end
+end

data/lib/rubydb/monitoring/statistics.rb

@@ -1,170 +1,168 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Monitoring
-    # Statistics - Statistical calculations
-    class Statistics
-      attr_reader :stats
-
-      def initialize
-        @stats = {
-          calculations: 0,
-          errors: 0
-        }
-        @lock = Mutex.new
-      end
-
-      def mean(values)
-        return 0 if values.empty?
-        values.sum / values.size.to_f
-      end
-
-      def median(values)
-        return 0 if values.empty?
-        sorted = values.sort
-        mid = sorted.size / 2
-        if sorted.size.even?
-          (sorted[mid - 1] + sorted[mid]) / 2.0
-        else
-          sorted[mid]
-        end
-      end
-
-      def mode(values)
-        return nil if values.empty?
-        freq = values.each_with_object(Hash.new(0)) { |v, h| h[v] += 1 }
-        max_freq = freq.values.max
-        freq.select { |_, f| f == max_freq }.keys
-      end
-
-      def variance(values)
-        return 0 if values.size < 2
-        m = mean(values)
-        values.sum { |v| (v - m) ** 2 } / (values.size - 1).to_f
-      end
-
-      def standard_deviation(values)
-        Math.sqrt(variance(values))
-      end
-
-      def percentile(values, p)
-        return 0 if values.empty?
-        sorted = values.sort
-        index = (p / 100.0) * (sorted.size - 1)
-        if index.to_i == index
-          sorted[index.to_i]
-        else
-          lower = sorted[index.floor]
-          upper = sorted[index.ceil]
-          lower + (upper - lower) * (index - index.floor)
-        end
-      end
-
-      def min(values)
-        values.min || 0
-      end
-
-      def max(values)
-        values.max || 0
-      end
-
-      def sum(values)
-        values.sum
-      end
-
-      def count(values)
-        values.size
-      end
-
-      def histogram(values, bins = 10)
-        return {} if values.empty?
-        min_val = min(values)
-        max_val = max(values)
-        range = max_val - min_val
-        bin_width = range / bins.to_f
-
-        histogram = {}
-        bins.times do |i|
-          low = min_val + i * bin_width
-          high = low + bin_width
-          key = "#{low.round(2)}-#{high.round(2)}"
-          histogram[key] = values.count { |v| v >= low && v < high }
-        end
-
-        histogram
-      end
-
-      def moving_average(values, window = 10)
-        return [] if values.empty?
-        result = []
-        values.each_with_index do |v, i|
-          start_idx = [0, i - window + 1].max
-          window_values = values[start_idx..i]
-          result << mean(window_values)
-        end
-        result
-      end
-
-      def exponential_moving_average(values, alpha = 0.1)
-        return [] if values.empty?
-        result = []
-        ema = values.first
-        values.each do |v|
-          ema = alpha * v + (1 - alpha) * ema
-          result << ema
-        end
-        result
-      end
-
-      def z_score(values, value)
-        return 0 if values.empty?
-        m = mean(values)
-        sd = standard_deviation(values)
-        return 0 if sd == 0
-        (value - m) / sd
-      end
-
-      def correlation(x_values, y_values)
-        return 0 if x_values.size != y_values.size || x_values.empty?
-        n = x_values.size
-        sum_x = x_values.sum
-        sum_y = y_values.sum
-        sum_xy = x_values.zip(y_values).sum { |x, y| x * y }
-        sum_x2 = x_values.sum { |x| x * x }
-        sum_y2 = y_values.sum { |y| y * y }
-
-        numerator = n * sum_xy - sum_x * sum_y
-        denominator = Math.sqrt((n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y))
-        return 0 if denominator == 0
-        numerator / denominator
-      end
-
-      def calculate_summary(values)
-        @stats[:calculations] += 1
-        {
-          count: count(values),
-          sum: sum(values),
-          mean: mean(values),
-          median: median(values),
-          min: min(values),
-          max: max(values),
-          variance: variance(values),
-          std_dev: standard_deviation(values),
-          p25: percentile(values, 25),
-          p50: percentile(values, 50),
-          p75: percentile(values, 75),
-          p90: percentile(values, 90),
-          p95: percentile(values, 95),
-          p99: percentile(values, 99)
-        }
-      rescue => e
-        @stats[:errors] += 1
-        {}
-      end
-
-      def stats
-        @stats
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Monitoring
+    # Statistics - Statistical calculations
+    class Statistics
+      attr_reader :stats
+
+      def initialize
+        @stats = {
+          calculations: 0,
+          errors: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def mean(values)
+        return 0 if values.empty?
+        values.sum / values.size.to_f
+      end
+
+      def median(values)
+        return 0 if values.empty?
+        sorted = values.sort
+        mid = sorted.size / 2
+        if sorted.size.even?
+          (sorted[mid - 1] + sorted[mid]) / 2.0
+        else
+          sorted[mid]
+        end
+      end
+
+      def mode(values)
+        return nil if values.empty?
+        freq = values.each_with_object(Hash.new(0)) { |v, h| h[v] += 1 }
+        max_freq = freq.values.max
+        freq.select { |_, f| f == max_freq }.keys
+      end
+
+      def variance(values)
+        return 0 if values.size < 2
+        m = mean(values)
+        values.sum { |v| (v - m)**2 } / (values.size - 1).to_f
+      end
+
+      def standard_deviation(values)
+        Math.sqrt(variance(values))
+      end
+
+      def percentile(values, p)
+        return 0 if values.empty?
+        sorted = values.sort
+        index = (p / 100.0) * (sorted.size - 1)
+        if index.to_i == index
+          sorted[index.to_i]
+        else
+          lower = sorted[index.floor]
+          upper = sorted[index.ceil]
+          lower + (upper - lower) * (index - index.floor)
+        end
+      end
+
+      def min(values)
+        values.min || 0
+      end
+
+      def max(values)
+        values.max || 0
+      end
+
+      def sum(values)
+        values.sum
+      end
+
+      def count(values)
+        values.size
+      end
+
+      def histogram(values, bins = 10)
+        return {} if values.empty?
+        min_val = min(values)
+        max_val = max(values)
+        range = max_val - min_val
+        bin_width = range / bins.to_f
+
+        histogram = {}
+        bins.times do |i|
+          low = min_val + i * bin_width
+          high = low + bin_width
+          key = "#{low.round(2)}-#{high.round(2)}"
+          histogram[key] = values.count { |v| v >= low && v < high }
+        end
+
+        histogram
+      end
+
+      def moving_average(values, window = 10)
+        return [] if values.empty?
+        result = []
+        values.each_with_index do |v, i|
+          start_idx = [0, i - window + 1].max
+          window_values = values[start_idx..i]
+          result << mean(window_values)
+        end
+        result
+      end
+
+      def exponential_moving_average(values, alpha = 0.1)
+        return [] if values.empty?
+        result = []
+        ema = values.first
+        values.each do |v|
+          ema = alpha * v + (1 - alpha) * ema
+          result << ema
+        end
+        result
+      end
+
+      def z_score(values, value)
+        return 0 if values.empty?
+        m = mean(values)
+        sd = standard_deviation(values)
+        return 0 if sd == 0
+        (value - m) / sd
+      end
+
+      def correlation(x_values, y_values)
+        return 0 if x_values.size != y_values.size || x_values.empty?
+        n = x_values.size
+        sum_x = x_values.sum
+        sum_y = y_values.sum
+        sum_xy = x_values.zip(y_values).sum { |x, y| x * y }
+        sum_x2 = x_values.sum { |x| x * x }
+        sum_y2 = y_values.sum { |y| y * y }
+
+        numerator = n * sum_xy - sum_x * sum_y
+        denominator = Math.sqrt((n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y))
+        return 0 if denominator == 0
+        numerator / denominator
+      end
+
+      def calculate_summary(values)
+        @stats[:calculations] += 1
+        {
+          count: count(values),
+          sum: sum(values),
+          mean: mean(values),
+          median: median(values),
+          min: min(values),
+          max: max(values),
+          variance: variance(values),
+          std_dev: standard_deviation(values),
+          p25: percentile(values, 25),
+          p50: percentile(values, 50),
+          p75: percentile(values, 75),
+          p90: percentile(values, 90),
+          p95: percentile(values, 95),
+          p99: percentile(values, 99)
+        }
+      rescue
+        @stats[:errors] += 1
+        {}
+      end
+
+      attr_reader :stats
+    end
+  end
+end