solid_observer 0.3.0 → 0.5.0

data/lib/solid_observer/services/database_size.rb

@@ -7,14 +7,15 @@ module SolidObserver
     # SQLite uses whole-database page accounting; PostgreSQL and MySQL/Trilogy
     # use table + index size from adapter-native system functions.
     class DatabaseSize
-      TABLE_NAME = "solid_observer_queue_events"
+      DEFAULT_TABLE_NAME = "solid_observer_queue_events"
 
-      def self.call(connection:)
-        new(connection).call
+      def self.call(connection:, table_name: DEFAULT_TABLE_NAME)
+        new(connection, table_name: table_name).call
       end
 
-      def initialize(connection)
+      def initialize(connection, table_name:)
         @connection = connection
+        @table_name = table_name
       end
 
       def call
@@ -26,7 +27,7 @@ module SolidObserver
 
       private
 
-      attr_reader :connection
+      attr_reader :connection, :table_name
 
       def adapter_key
         case connection.adapter_name.to_s.downcase
@@ -52,16 +53,20 @@ module SolidObserver
       end
 
       def sqlite_size
-        connection.query_value("SELECT pragma_page_count() * pragma_page_size()")&.to_i
+        page_count = connection.query_value("PRAGMA page_count")
+        page_size = connection.query_value("PRAGMA page_size")
+        return unless page_count && page_size
+
+        page_count.to_i * page_size.to_i
       end
 
       def postgresql_size
-        quoted_table = connection.quote(TABLE_NAME)
+        quoted_table = connection.quote(table_name)
         connection.query_value("SELECT pg_total_relation_size(#{quoted_table})")&.to_i
       end
 
       def mysql_size
-        quoted_table = connection.quote(TABLE_NAME)
+        quoted_table = connection.quote(table_name)
 
         connection.query_value(<<~SQL)&.to_i
           SELECT COALESCE(data_length + index_length, 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_event_buffer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class FlushCacheEventBuffer
+      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
+        CacheEvent.transaction { CacheEvent.insert_all!(@events) }
+      end
+
+      def fallback_insert_count(error)
+        Rails.logger&.error("[SolidObserver] Cache 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
+        CacheEvent.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 cache 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_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/record_cable_event.rb

@@ -0,0 +1,114 @@
+# 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"),
+          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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module SolidObserver
+  module Services
+    class RecordCacheEvent
+      INTERNAL_CACHE_KEY_PREFIX = "solid_observer/"
+
+      def self.call(event:, buffer:)
+        new(event, buffer).call
+      end
+
+      def initialize(event, buffer)
+        @event = event
+        @buffer = buffer
+      end
+
+      def call
+        return if internal_cache_event?
+
+        record_metric_and_event
+      rescue => error
+        raise error if error.is_a?(NameError)
+        Rails.logger&.warn("[SolidObserver] Cache event recording failed: #{error.message}") if defined?(Rails)
+      end
+
+      private
+
+      def record_metric_and_event
+        SolidObserver::Services::RecordCacheMetric.call(event: @event)
+        return unless should_store_event?
+
+        @buffer.push(build_event_data)
+      end
+
+      def should_store_event?
+        sampled? || slow? || errored?
+      end
+
+      def sampled?
+        rand <= SolidObserver.config.cache_sampling_rate
+      end
+
+      def slow?
+        duration_in_seconds && duration_in_seconds >= SolidObserver.config.cache_slow_threshold
+      end
+
+      def errored?
+        return false unless SolidObserver.config.cache_store_errors
+
+        !exception_data.compact.empty?
+      end
+
+      def build_event_data
+        {
+          event_type: cache_operation,
+          key_digest: key_digest,
+          hit: hit_value,
+          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 cache_operation
+        @event.name.delete_suffix(".active_support")
+      end
+
+      def duration_in_seconds
+        @event.duration&./(1000.0)
+      end
+
+      def key_digest
+        Digest::SHA256.hexdigest(normalized_key_string)
+      end
+
+      def normalized_key_string
+        key = payload[:key]
+
+        case key
+        when Hash
+          key.keys.map(&:to_s).sort.join(",")
+        when Array
+          key.map(&:to_s).sort.join(",")
+        else
+          key.to_s
+        end
+      end
+
+      def hit_value
+        hit = payload[:hit]
+        hits = payload[:hits]
+
+        return hit unless hit.nil?
+        return nil unless hits.is_a?(Array)
+
+        hits.any?
+      end
+
+      def metadata
+        {
+          super_operation: payload[:super_operation]&.to_s,
+          key_size: key_size,
+          hits_count: hits_count
+        }.compact.merge(exception_data).compact
+      end
+
+      def key_size
+        key = payload[:key]
+        return key.keys.size if key.is_a?(Hash)
+        return key.size if key.is_a?(Array)
+
+        key.to_s.bytesize
+      end
+
+      def hits_count
+        hits = payload[:hits]
+        return nil unless hits.is_a?(Array)
+
+        hits.size
+      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
+
+      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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../cache_metric_buffer"
+
+module SolidObserver
+  module Services
+    class RecordCacheMetric
+      def self.call(event:, buffer: SolidObserver::CacheMetricBuffer.instance)
+        new(event, buffer).call
+      end
+
+      def initialize(event, buffer)
+        @event = event
+        @buffer = buffer
+      end
+
+      def call
+        @buffer.increment(
+          event_type: event_type,
+          period_start: period_start,
+          operations_count: 1,
+          hits_count: hit_increment,
+          misses_count: miss_increment,
+          errors_count: error_increment,
+          duration_total: duration_in_seconds
+        )
+      rescue => error
+        Rails.logger&.warn("[SolidObserver] Cache metric recording failed: #{error.message}") if defined?(Rails)
+      end
+
+      private
+
+      def period_start
+        Time.current.beginning_of_minute
+      end
+
+      def event_type
+        @event.name.delete_suffix(".active_support")
+      end
+
+      def hit_increment
+        (payload[:hit] == true) ? 1 : 0
+      end
+
+      def miss_increment
+        (payload[:hit] == false) ? 1 : 0
+      end
+
+      def error_increment
+        exception_present? ? 1 : 0
+      end
+
+      def exception_present?
+        payload[:exception_object].present? || payload[:exception].is_a?(Array)
+      end
+
+      def duration_in_seconds
+        (@event.duration || 0).to_f / 1000.0
+      end
+
+      def payload
+        @event.payload || {}
+      end
+    end
+  end
+end