solid_observer 0.4.0 → 0.6.0

data/lib/solid_observer/services/flush_cable_event_buffer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class FlushCableEventBuffer
+      BATCH_SIZE = 100
+
+      def self.call(events)
+        new(events).call
+      end
+
+      def initialize(events)
+        @events = events
+      end
+
+      def call
+        return 0 if @events.empty?
+
+        insert_all_events
+        @events.size
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => error
+        fallback_insert_count(error)
+      end
+
+      private
+
+      def insert_all_events
+        CableEvent.transaction { CableEvent.insert_all!(@events) }
+      end
+
+      def fallback_insert_count(error)
+        Rails.logger&.error("[SolidObserver] Cable bulk insert failed, retrying in batches: #{error.message}") if defined?(Rails)
+        @events.each_slice(BATCH_SIZE).sum { |batch| insert_batch(batch) }
+      end
+
+      def insert_batch(batch)
+        size = batch.size
+        CableEvent.insert_all(batch, returning: false)
+        size
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => error
+        handle_batch_insert_error(size, error)
+      end
+
+      def log_batch_warning(size, error)
+        Rails.logger&.warn("[SolidObserver] Failed to insert cable batch of #{size} events: #{error.message}") if defined?(Rails)
+      end
+
+      def handle_batch_insert_error(size, error)
+        log_batch_warning(size, error)
+        0
+      end
+    end
+  end
+end

data/lib/solid_observer/services/flush_cable_metrics.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class FlushCableMetrics
+      def self.call(metrics)
+        new(metrics).call
+      end
+
+      def initialize(metrics)
+        @metrics = metrics
+      end
+
+      def call
+        return 0 if @metrics.empty?
+
+        flush_metrics
+        @metrics.size
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      private
+
+      def flush_metrics
+        SolidObserver::CableMetric.transaction do
+          @metrics.each { |metric_data| increment_metric(metric_data) }
+        end
+      end
+
+      def increment_metric(metric_data)
+        period_start = metric_data.fetch(:period_start)
+        metric = SolidObserver::CableMetric.find_or_create_by!(period_start: period_start)
+
+        SolidObserver::CableMetric.where(id: metric.id).update_counters(update_values(metric_data))
+      end
+
+      def update_values(metric_data)
+        {
+          broadcasts_count: increment_expression(:broadcasts_count, metric_data),
+          transmissions_count: increment_expression(:transmissions_count, metric_data),
+          confirmations_count: increment_expression(:confirmations_count, metric_data),
+          rejections_count: increment_expression(:rejections_count, metric_data),
+          perform_actions_count: increment_expression(:perform_actions_count, metric_data),
+          errors_count: increment_expression(:errors_count, metric_data)
+        }
+      end
+
+      def increment_expression(column, metric_data)
+        metric_data.fetch(column, 0)
+      end
+    end
+  end
+end

data/lib/solid_observer/services/flush_cache_metrics.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class FlushCacheMetrics
+      def self.call(metrics)
+        new(metrics).call
+      end
+
+      def initialize(metrics)
+        @metrics = metrics
+      end
+
+      def call
+        return 0 if @metrics.empty?
+
+        flush_metrics
+        @metrics.size
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      private
+
+      def flush_metrics
+        SolidObserver::CacheMetric.transaction do
+          @metrics.each { |metric_data| increment_metric(metric_data) }
+        end
+      end
+
+      def increment_metric(metric_data)
+        event_type, period_start = metric_data.values_at(:event_type, :period_start)
+        metric = SolidObserver::CacheMetric.find_or_create_by!(
+          event_type: event_type,
+          period_start: period_start
+        )
+
+        SolidObserver::CacheMetric.where(id: metric.id).update_counters(update_values(metric_data))
+      end
+
+      def update_values(metric_data)
+        {
+          operations_count: increment_expression(:operations_count, metric_data),
+          hits_count: increment_expression(:hits_count, metric_data),
+          misses_count: increment_expression(:misses_count, metric_data),
+          errors_count: increment_expression(:errors_count, metric_data),
+          duration_total: increment_expression(:duration_total, metric_data)
+        }
+      end
+
+      def increment_expression(column, metric_data)
+        metric_data.fetch(column, 0)
+      end
+    end
+  end
+end

data/lib/solid_observer/services/health_score.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/time"
+
+module SolidObserver
+  module Services
+    class HealthScore
+      STATUS_RANK = {stable: 0, degraded: 1, critical: 2}.freeze
+      UNAVAILABLE = {status: :degraded, available: false}.freeze
+      WINDOW = 15.minutes
+
+      def self.call
+        new.call
+      end
+
+      def call
+        components = collect_components
+        {
+          overall: overall_status(components.values.map { |entry| entry[:status] }),
+          components: components
+        }
+      end
+
+      private
+
+      # :reek:FeatureEnvy
+      # :reek:TooManyStatements
+      def collect_components
+        config = SolidObserver.config
+        components = {}
+
+        components[:queue] = queue_component if config.solid_queue_enabled?
+
+        unless config.realtime_mode?
+          components[:cache] = stats_component(:cache, CacheStats) if config.solid_cache_enabled?
+          components[:cable] = stats_component(:cable, CableStats) if config.solid_cable_enabled?
+        end
+
+        components
+      end
+
+      def queue_component
+        snapshot = SolidObserver::QueueStats.snapshot
+        return UNAVAILABLE.dup unless snapshot[:available]
+
+        {status: queue_stability(snapshot), available: true}
+      rescue => error
+        degrade(:queue, error)
+      end
+
+      def queue_stability(snapshot)
+        return :critical if snapshot[:failed_last_hour].to_i.positive?
+        return :degraded if snapshot[:failed_last_24h].to_i.positive?
+
+        :stable
+      end
+
+      def stats_component(name, stats_class)
+        stability = stats_class.call(window: WINDOW)[:stability]
+        return UNAVAILABLE.dup unless stability&.[](:available)
+
+        {status: stability[:state] || :degraded, available: true}
+      rescue => error
+        degrade(name, error)
+      end
+
+      def overall_status(statuses)
+        return :stable if statuses.empty?
+
+        statuses.max_by { |status| STATUS_RANK.fetch(status, 1) }
+      end
+
+      def degrade(name, error)
+        log_component_error(name, error)
+        UNAVAILABLE.dup
+      end
+
+      def log_component_error(name, error)
+        return unless defined?(Rails)
+
+        Rails.logger&.warn("HealthScore #{name} error: #{error.message}")
+      end
+    end
+  end
+end

data/lib/solid_observer/services/record_cable_event.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module SolidObserver
+  module Services
+    class RecordCableEvent
+      def self.call(event:, buffer:)
+        new(event, buffer).call
+      end
+
+      def initialize(event, buffer)
+        @event = event
+        @buffer = buffer
+      end
+
+      def call
+        record_metric_and_event
+      rescue => error
+        raise error if error.is_a?(NameError)
+        Rails.logger&.warn("[SolidObserver] Cable event recording failed: #{error.message}") if defined?(Rails)
+      end
+
+      private
+
+      def record_metric_and_event
+        SolidObserver::Services::RecordCableMetric.call(event: @event)
+        return unless should_store_event?
+
+        @buffer.push(build_event_data)
+      end
+
+      def should_store_event?
+        case @event.name
+        when "broadcast.action_cable"
+          sampled? || errored?
+        when "transmit_subscription_rejection.action_cable"
+          true
+        else
+          false
+        end
+      end
+
+      def sampled?
+        rand <= SolidObserver.config.cable_sampling_rate
+      end
+
+      def errored?
+        !exception_data.compact.empty?
+      end
+
+      def build_event_data
+        {
+          event_type: @event.name.delete_suffix(".action_cable"),
+          correlation_id: CorrelationIdResolver.resolve(@event),
+          channel_class: channel_class,
+          broadcasting_digest: broadcasting_digest,
+          duration: duration_in_seconds,
+          error_class: exception_data[:error_class],
+          error_message: exception_data[:error_message],
+          metadata: metadata.to_json,
+          recorded_at: Time.current
+        }
+      end
+
+      def broadcasting_digest
+        return nil unless @event.name == "broadcast.action_cable"
+
+        Digest::SHA256.hexdigest(payload[:broadcasting].to_s)
+      end
+
+      def channel_class
+        class_name = payload[:channel_class]
+        return class_name if class_name
+
+        channel = payload[:channel]
+        return nil unless channel
+
+        channel.class.name || channel.to_s
+      end
+
+      def duration_in_seconds
+        @event.duration&./(1000.0)
+      end
+
+      def metadata
+        {
+          action: payload[:action]&.to_s,
+          via: payload[:via]&.to_s,
+          data_size: payload[:data]&.to_s&.bytesize,
+          message_size: payload[:message]&.to_s&.bytesize
+        }.compact
+      end
+
+      def exception_data
+        @exception_data ||= begin
+          exception_obj = payload[:exception_object]
+          exception = payload[:exception]
+
+          if exception_obj
+            {error_class: exception_obj.class.name, error_message: exception_obj.message}
+          elsif exception.is_a?(Array)
+            {error_class: exception.first, error_message: exception.last}
+          else
+            {}
+          end
+        end
+      end
+
+      def payload
+        @event.payload || {}
+      end
+    end
+  end
+end

data/lib/solid_observer/services/record_cable_metric.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../cable_metric_buffer"
+
+module SolidObserver
+  module Services
+    class RecordCableMetric
+      COUNTERS = %i[
+        broadcasts_count
+        transmissions_count
+        confirmations_count
+        rejections_count
+        perform_actions_count
+        errors_count
+      ].freeze
+
+      EVENT_COUNTER_MAP = {
+        "broadcast.action_cable" => :broadcasts_count,
+        "transmit.action_cable" => :transmissions_count,
+        "transmit_subscription_confirmation.action_cable" => :confirmations_count,
+        "transmit_subscription_rejection.action_cable" => :rejections_count,
+        "perform_action.action_cable" => :perform_actions_count
+      }.freeze
+
+      def self.call(event:, buffer: SolidObserver::CableMetricBuffer.instance)
+        new(event, buffer).call
+      end
+
+      def initialize(event, buffer)
+        @event = event
+        @buffer = buffer
+      end
+
+      def call
+        @buffer.increment(metric_data)
+      rescue => error
+        Rails.logger&.warn("[SolidObserver] Cable metric recording failed: #{error.message}") if defined?(Rails)
+      end
+
+      private
+
+      def metric_data
+        COUNTERS.each_with_object({period_start: period_start}) do |counter, data|
+          data[counter] = (counter == target_counter) ? 1 : 0
+        end.merge(errors_count: error_increment)
+      end
+
+      def target_counter
+        EVENT_COUNTER_MAP.fetch(event_name, :broadcasts_count)
+      end
+
+      def period_start
+        Time.current.beginning_of_minute
+      end
+
+      def event_name
+        @event.name
+      end
+
+      def error_increment
+        exception_present? ? 1 : 0
+      end
+
+      def exception_present?
+        payload[:exception_object].present? || payload[:exception].is_a?(Array)
+      end
+
+      def payload
+        @event.payload || {}
+      end
+    end
+  end
+end

data/lib/solid_observer/services/record_cache_event.rb

@@ -5,6 +5,8 @@ require "digest"
 module SolidObserver
   module Services
     class RecordCacheEvent
+      INTERNAL_CACHE_KEY_PREFIX = "solid_observer/"
+
       def self.call(event:, buffer:)
         new(event, buffer).call
       end
@@ -15,6 +17,8 @@ module SolidObserver
       end
 
       def call
+        return if internal_cache_event?
+
         record_metric_and_event
       rescue => error
         raise error if error.is_a?(NameError)
@@ -51,6 +55,7 @@ module SolidObserver
       def build_event_data
         {
           event_type: cache_operation,
+          correlation_id: CorrelationIdResolver.resolve(@event),
           key_digest: key_digest,
           hit: hit_value,
           duration: duration_in_seconds,
@@ -137,6 +142,25 @@ module SolidObserver
       def payload
         @event.payload || {}
       end
+
+      def internal_cache_event?
+        internal_cache_key?(payload[:key])
+      end
+
+      def internal_cache_key?(key)
+        case key
+        when Array
+          nested_internal_cache_key?(key)
+        when Hash
+          nested_internal_cache_key?(key.flatten(1))
+        else
+          key.to_s.start_with?(INTERNAL_CACHE_KEY_PREFIX)
+        end
+      end
+
+      def nested_internal_cache_key?(entries)
+        entries.any? { |entry| internal_cache_key?(entry) }
+      end
     end
   end
 end

data/lib/solid_observer/services/record_cache_metric.rb

@@ -1,27 +1,29 @@
 # frozen_string_literal: true
 
+require_relative "../cache_metric_buffer"
+
 module SolidObserver
   module Services
     class RecordCacheMetric
-      def self.call(event:)
-        new(event).call
+      def self.call(event:, buffer: SolidObserver::CacheMetricBuffer.instance)
+        new(event, buffer).call
       end
 
-      def initialize(event)
+      def initialize(event, buffer)
         @event = event
+        @buffer = buffer
       end
 
       def call
-        metric = SolidObserver::CacheMetric.find_or_create_by!(
+        @buffer.increment(
           event_type: event_type,
-          period_start: period_start
+          period_start: period_start,
+          operations_count: 1,
+          hits_count: hit_increment,
+          misses_count: miss_increment,
+          errors_count: error_increment,
+          duration_total: duration_in_seconds
         )
-
-        SolidObserver::CacheMetric
-          .where(id: metric.id)
-          .update_all(update_values)
-      rescue ActiveRecord::RecordNotUnique
-        retry
       rescue => error
         Rails.logger&.warn("[SolidObserver] Cache metric recording failed: #{error.message}") if defined?(Rails)
       end
@@ -36,16 +38,6 @@ module SolidObserver
         @event.name.delete_suffix(".active_support")
       end
 
-      def update_values
-        {
-          operations_count: Arel.sql("operations_count + 1"),
-          hits_count: Arel.sql("hits_count + #{hit_increment}"),
-          misses_count: Arel.sql("misses_count + #{miss_increment}"),
-          errors_count: Arel.sql("errors_count + #{error_increment}"),
-          duration_total: Arel.sql("duration_total + #{duration_in_seconds}")
-        }
-      end
-
       def hit_increment
         (payload[:hit] == true) ? 1 : 0
       end