solid_observer 0.3.0 → 0.5.0

data/lib/solid_observer/cable_metric_buffer.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "concurrent/timer_task"
+
+require_relative "services/flush_cable_metrics"
+
+module SolidObserver
+  class CableMetricBuffer
+    include Singleton
+
+    INITIAL_METRICS = {
+      flush_failures_count: 0,
+      drops_count: 0,
+      last_flush_at: nil,
+      last_flush_duration_ms: nil,
+      last_flush_error: nil
+    }.freeze
+
+    def initialize
+      @store = MetricStore.new
+      @timer_mutex = Mutex.new
+      @timer_task = nil
+    end
+
+    def increment(metric_data)
+      config = SolidObserver.config
+      return unless config.persistence_mode?
+
+      @store.add(metric_data)
+      ensure_timer_running
+      flush! if size >= config.buffer_size
+    end
+
+    def flush!
+      metrics_to_flush = @store.drain
+      return if metrics_to_flush.empty?
+
+      flush_metrics(metrics_to_flush, monotonic_ms)
+    end
+
+    def flush
+      flush!
+    end
+
+    def size
+      @store.size
+    end
+
+    def clear
+      @store.clear
+    end
+
+    def metrics
+      @store.metrics
+    end
+
+    def shutdown
+      stop_timer
+      flush!
+    end
+
+    private
+
+    def ensure_timer_running
+      timer_to_start, timer_to_stop = replace_timer_if_stopped
+      return unless timer_to_start
+
+      timer_to_stop&.shutdown
+      timer_to_start.execute
+    end
+
+    def replace_timer_if_stopped
+      @timer_mutex.synchronize do
+        current_timer_task = @timer_task
+        return [nil, nil] if current_timer_task && !current_timer_task.shuttingdown?
+
+        [build_timer_task, current_timer_task]
+      end
+    end
+
+    def stop_timer
+      timer_to_stop = @timer_mutex.synchronize do
+        current_timer = @timer_task
+        @timer_task = nil
+        current_timer
+      end
+
+      timer_to_stop&.shutdown
+    end
+
+    def build_timer_task
+      @timer_task = Concurrent::TimerTask.new(
+        execution_interval: SolidObserver.config.flush_interval,
+        run_now: false
+      ) { flush! }
+    end
+
+    def monotonic_ms
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
+    def flush_metrics(metrics_to_flush, started_at_ms)
+      Services::FlushCableMetrics.call(metrics_to_flush)
+      @store.record_flush_success(monotonic_ms - started_at_ms)
+    rescue => error
+      handle_flush_error(error, metrics_to_flush)
+    end
+
+    def handle_flush_error(error, metrics_to_flush)
+      @store.requeue(metrics_to_flush)
+      @store.record_flush_failure(error)
+      Rails.logger&.error("[SolidObserver] Cable metric buffer flush failed: #{error.message}") if defined?(Rails)
+    end
+
+    class MetricStore
+      COUNTERS = %i[
+        broadcasts_count
+        transmissions_count
+        confirmations_count
+        rejections_count
+        perform_actions_count
+        errors_count
+      ].freeze
+
+      def initialize
+        @mutex = Mutex.new
+        @buffer = {}
+        @metrics = INITIAL_METRICS.dup
+      end
+
+      def add(metric_data)
+        @mutex.synchronize { add_metric(metric_data) }
+      end
+
+      def drain
+        @mutex.synchronize do
+          drained = @buffer.values.map(&:dup)
+          @buffer.clear
+          drained
+        end
+      end
+
+      def requeue(metrics_to_flush)
+        @mutex.synchronize { add_metrics_with_capacity(metrics_to_flush + @buffer.values) }
+      end
+
+      def clear
+        @mutex.synchronize { @buffer.clear }
+      end
+
+      def size
+        @mutex.synchronize { @buffer.size }
+      end
+
+      def metrics
+        @mutex.synchronize do
+          {
+            size: @buffer.size,
+            max_buffer_size: SolidObserver.config.max_buffer_size
+          }.merge(@metrics.dup)
+        end
+      end
+
+      def record_flush_success(duration_ms)
+        @mutex.synchronize do
+          @metrics.merge!(
+            last_flush_at: Time.current,
+            last_flush_duration_ms: duration_ms,
+            last_flush_error: nil
+          )
+        end
+      end
+
+      def record_flush_failure(error)
+        @mutex.synchronize do
+          @metrics[:flush_failures_count] += 1
+          @metrics[:last_flush_error] = error.message
+        end
+      end
+
+      private
+
+      def add_metric(metric_data)
+        config = SolidObserver.config
+        key = metric_data.fetch(:period_start)
+        if @buffer.key?(key)
+          merge_metric(@buffer.fetch(key), metric_data)
+        elsif @buffer.size < config.max_buffer_size
+          @buffer[key] = metric_hash(metric_data)
+        else
+          handle_overflow(key, metric_data)
+        end
+      end
+
+      def add_metrics_with_capacity(metrics)
+        @buffer.clear
+        metrics.each { |metric| add_metric(metric) }
+      end
+
+      def handle_overflow(key, metric_data)
+        drop_count = if SolidObserver.config.buffer_overflow_strategy == :drop_old
+          replace_old_metric(key, metric_data)
+        else
+          COUNTERS.sum { |counter| metric_data.fetch(counter, 0).to_i }
+        end
+
+        @metrics[:drops_count] += drop_count
+      end
+
+      def replace_old_metric(key, metric_data)
+        dropped = @buffer.shift&.last
+        @buffer[key] = metric_hash(metric_data)
+        dropped ? COUNTERS.sum { |counter| dropped.fetch(counter, 0).to_i } : 0
+      end
+
+      def merge_metric(target, metric_data)
+        COUNTERS.each do |counter|
+          target[counter] += metric_data.fetch(counter, 0).to_i
+        end
+      end
+
+      def metric_hash(metric_data)
+        COUNTERS.each_with_object({period_start: metric_data.fetch(:period_start)}) do |counter, hash|
+          hash[counter] = metric_data.fetch(counter, 0).to_i
+        end
+      end
+    end
+  end
+end

data/lib/solid_observer/cable_subscriber.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CableSubscriber
+    EVENTS = %w[
+      broadcast.action_cable
+      transmit.action_cable
+      transmit_subscription_confirmation.action_cable
+      transmit_subscription_rejection.action_cable
+      perform_action.action_cable
+    ].freeze
+
+    class << self
+      attr_reader :subscriptions
+
+      def subscribe
+        return unless subscription_allowed?
+
+        self.subscriptions = EVENTS.map { |event_name| subscribe_to(event_name) }
+      end
+
+      def unsubscribe
+        return unless subscriptions
+
+        subscriptions.each { |subscription| ActiveSupport::Notifications.unsubscribe(subscription) }
+        self.subscriptions = []
+      end
+
+      def subscribe!
+        subscribe
+      end
+
+      def unsubscribe!
+        unsubscribe
+      end
+
+      def subscribed?
+        !!subscriptions&.any?
+      end
+
+      private
+
+      attr_writer :subscriptions
+
+      def subscription_allowed?
+        SolidObserver.config.solid_cable_enabled? && !subscribed? && defined?(ActiveSupport::Notifications)
+      end
+
+      def subscribe_to(event_name)
+        ActiveSupport::Notifications.subscribe(event_name) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          Services::RecordCableEvent.call(event: event, buffer: CableEventBuffer.instance)
+        end
+      end
+    end
+  end
+end

data/lib/solid_observer/cache_event_buffer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+require_relative "event_buffer_core"
+
+module SolidObserver
+  class CacheEventBuffer
+    include Singleton
+    include EventBufferCore
+
+    INITIAL_METRICS = EventBufferCore::INITIAL_METRICS
+
+    def initialize
+      initialize_event_buffer
+    end
+
+    private
+
+    def flush_service
+      Services::FlushCacheEventBuffer
+    end
+
+    def log_label
+      "Cache buffer"
+    end
+  end
+end

data/lib/solid_observer/cache_metric_buffer.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "concurrent/timer_task"
+
+require_relative "services/flush_cache_metrics"
+
+module SolidObserver
+  class CacheMetricBuffer
+    include Singleton
+
+    INITIAL_METRICS = {
+      flush_failures_count: 0,
+      drops_count: 0,
+      last_flush_at: nil,
+      last_flush_duration_ms: nil,
+      last_flush_error: nil
+    }.freeze
+
+    def initialize
+      @store = MetricStore.new
+      @timer_mutex = Mutex.new
+      @timer_task = nil
+    end
+
+    def increment(metric_data)
+      config = SolidObserver.config
+      return unless config.persistence_mode?
+
+      @store.add(metric_data)
+      ensure_timer_running
+      flush! if size >= config.buffer_size
+    end
+
+    def flush!
+      metrics_to_flush = @store.drain
+      return if metrics_to_flush.empty?
+
+      flush_metrics(metrics_to_flush, monotonic_ms)
+    end
+
+    def flush
+      flush!
+    end
+
+    def size
+      @store.size
+    end
+
+    def clear
+      @store.clear
+    end
+
+    def metrics
+      @store.metrics
+    end
+
+    def shutdown
+      stop_timer
+      flush!
+    end
+
+    private
+
+    def ensure_timer_running
+      timer_to_start, timer_to_stop = replace_timer_if_stopped
+      return unless timer_to_start
+
+      timer_to_stop&.shutdown
+      timer_to_start.execute
+    end
+
+    def replace_timer_if_stopped
+      @timer_mutex.synchronize do
+        current_timer_task = @timer_task
+        return [nil, nil] if current_timer_task && !current_timer_task.shuttingdown?
+
+        [build_timer_task, current_timer_task]
+      end
+    end
+
+    def stop_timer
+      timer_to_stop = @timer_mutex.synchronize do
+        current_timer = @timer_task
+        @timer_task = nil
+        current_timer
+      end
+
+      timer_to_stop&.shutdown
+    end
+
+    def build_timer_task
+      @timer_task = Concurrent::TimerTask.new(
+        execution_interval: SolidObserver.config.flush_interval,
+        run_now: false
+      ) { flush! }
+    end
+
+    def monotonic_ms
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
+    def flush_metrics(metrics_to_flush, started_at_ms)
+      Services::FlushCacheMetrics.call(metrics_to_flush)
+      @store.record_flush_success(monotonic_ms - started_at_ms)
+    rescue => error
+      handle_flush_error(error, metrics_to_flush)
+    end
+
+    def handle_flush_error(error, metrics_to_flush)
+      @store.requeue(metrics_to_flush)
+      @store.record_flush_failure(error)
+      Rails.logger&.error("[SolidObserver] Cache metric buffer flush failed: #{error.message}") if defined?(Rails)
+    end
+
+    class MetricStore
+      def initialize
+        @mutex = Mutex.new
+        @buffer = {}
+        @metrics = INITIAL_METRICS.dup
+      end
+
+      def add(metric_data)
+        @mutex.synchronize { add_metric(metric_data) }
+      end
+
+      def drain
+        @mutex.synchronize do
+          drained = @buffer.values.map(&:dup)
+          @buffer.clear
+          drained
+        end
+      end
+
+      def requeue(metrics_to_flush)
+        @mutex.synchronize { add_metrics_with_capacity(metrics_to_flush + @buffer.values) }
+      end
+
+      def clear
+        @mutex.synchronize { @buffer.clear }
+      end
+
+      def size
+        @mutex.synchronize { @buffer.size }
+      end
+
+      def metrics
+        @mutex.synchronize do
+          {
+            size: @buffer.size,
+            max_buffer_size: SolidObserver.config.max_buffer_size
+          }.merge(@metrics.dup)
+        end
+      end
+
+      def record_flush_success(duration_ms)
+        @mutex.synchronize do
+          @metrics.merge!(
+            last_flush_at: Time.current,
+            last_flush_duration_ms: duration_ms,
+            last_flush_error: nil
+          )
+        end
+      end
+
+      def record_flush_failure(error)
+        @mutex.synchronize do
+          @metrics[:flush_failures_count] += 1
+          @metrics[:last_flush_error] = error.message
+        end
+      end
+
+      private
+
+      def add_metric(metric_data)
+        config = SolidObserver.config
+        key = [metric_data.fetch(:event_type), metric_data.fetch(:period_start)]
+        if @buffer.key?(key)
+          merge_metric(@buffer.fetch(key), metric_data)
+        elsif @buffer.size < config.max_buffer_size
+          @buffer[key] = metric_hash(metric_data)
+        else
+          handle_overflow(key, metric_data)
+        end
+      end
+
+      def add_metrics_with_capacity(metrics)
+        @buffer.clear
+        metrics.each { |metric| add_metric(metric) }
+      end
+
+      def handle_overflow(key, metric_data)
+        drop_count = if SolidObserver.config.buffer_overflow_strategy == :drop_old
+          replace_old_metric(key, metric_data)
+        else
+          metric_data.fetch(:operations_count, 1).to_i
+        end
+
+        @metrics[:drops_count] += drop_count
+      end
+
+      def replace_old_metric(key, metric_data)
+        dropped = @buffer.shift&.last
+        @buffer[key] = metric_hash(metric_data)
+        dropped ? dropped.fetch(:operations_count, 1).to_i : 0
+      end
+
+      def merge_metric(target, metric_data)
+        target[:operations_count] += metric_data.fetch(:operations_count, 1).to_i
+        target[:hits_count] += metric_data.fetch(:hits_count, 0).to_i
+        target[:misses_count] += metric_data.fetch(:misses_count, 0).to_i
+        target[:errors_count] += metric_data.fetch(:errors_count, 0).to_i
+        target[:duration_total] += metric_data.fetch(:duration_total, 0.0).to_f
+      end
+
+      def metric_hash(metric_data)
+        {
+          event_type: metric_data.fetch(:event_type),
+          period_start: metric_data.fetch(:period_start),
+          operations_count: metric_data.fetch(:operations_count, 1).to_i,
+          hits_count: metric_data.fetch(:hits_count, 0).to_i,
+          misses_count: metric_data.fetch(:misses_count, 0).to_i,
+          errors_count: metric_data.fetch(:errors_count, 0).to_i,
+          duration_total: metric_data.fetch(:duration_total, 0.0).to_f
+        }
+      end
+    end
+  end
+end

data/lib/solid_observer/cache_subscriber.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CacheSubscriber
+    EVENTS = %w[
+      cache_read.active_support
+      cache_write.active_support
+      cache_delete.active_support
+      cache_exist?.active_support
+      cache_read_multi.active_support
+      cache_write_multi.active_support
+      cache_delete_multi.active_support
+    ].freeze
+
+    class << self
+      def subscribe!
+        return unless subscription_allowed?
+
+        @subscriptions = EVENTS.map { |event_name| subscribe_to(event_name) }
+      end
+
+      def unsubscribe!
+        return unless @subscriptions
+
+        @subscriptions.each { |subscription| ActiveSupport::Notifications.unsubscribe(subscription) }
+        @subscriptions = []
+      end
+
+      def subscribed?
+        !!@subscriptions&.any?
+      end
+
+      private
+
+      def subscription_allowed?
+        SolidObserver.config.solid_cache_enabled? && !subscribed? && defined?(ActiveSupport::Notifications)
+      end
+
+      def subscribe_to(event_name)
+        ActiveSupport::Notifications.subscribe(event_name) do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          Services::RecordCacheEvent.call(event: event, buffer: CacheEventBuffer.instance)
+        end
+      end
+    end
+  end
+end