jetstream_bridge 4.0.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdb73e243bddbd9812d6d454d1975d15f6f8d98325c7759853d32a01c830e27e
-  data.tar.gz: 8c570f62d4e4b0efddf59e6a4033026b5cabaad83fe808ec0942ad57f3874d5e
+  metadata.gz: fad967e84777d57595bc3418e4b496da47aff3f1fdb7527f0e45acf3a1bafc60
+  data.tar.gz: 11659b3c4107f5ac35ddf1b4b5a28831d9656e0c0facb710a1538baaaad15123
 SHA512:
-  metadata.gz: c9b95208ecf116e52daa75e77d3edb62899e6724bec67c72c4322aab31778392906053f77e9eb420c855605ee6aca41eacad9c509b47e5123e710436d201718c
-  data.tar.gz: 588603c1946d72946c9ba990869869e5932c3f04e265cefbbc2d6f0c3829467e1e498eab307b84770b7d88ed134184d6c8f07596968d0b30da107204fa3bca5f
+  metadata.gz: fec1c6b96ded387683db458727028ece5de4d9d0307261654a92bd43d70314a5e01078f8d182ec422f226dd1cb08160909d0dd45014f08ec17b6b2c2f2b7169b
+  data.tar.gz: 9357f058329804a848d32ad917807a9363482dd79963b2a7d4ba121b5ed83ed39aed5c6cb85e2163a35b892aa2f3d566dc1d5933aff5a3a86ffa49aa2fa4b7fc

data/CHANGELOG.md

@@ -5,6 +5,73 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.1.0] - 2025-11-23
+
+### Added
+
+- **Enhanced Subject Validation** - Strengthened subject component validation for security
+  - Validates against control characters, null bytes, tabs, and excessive spaces
+  - Enforces maximum subject component length of 255 characters
+  - Prevents injection attacks via malformed subject components
+  - Provides clear error messages with invalid character details
+
+- **Health Check Rate Limiting** - Prevents abuse of health check endpoint
+  - Limits uncached health checks to once every 5 seconds per process
+  - Cached health checks (30s TTL) bypass rate limit
+  - Returns helpful error message with wait time when rate limit exceeded
+  - Thread-safe implementation with mutex synchronization
+
+- **Consumer Reconnection Backoff** - Exponential backoff for consumer recovery
+  - Starts at 0.1s and doubles with each retry up to 30s maximum
+  - Resets counter on successful reconnection
+  - Logs detailed reconnection attempts with backoff timing
+  - Prevents excessive NATS API calls during connection issues
+
+- **OverlapGuard Performance Cache** - 60-second TTL cache for stream metadata
+  - Reduces N+1 API calls when checking stream overlaps
+  - Thread-safe cache implementation with mutex
+  - Falls back to cached data on fetch errors
+  - Includes `clear_cache!` method for testing
+
+- **Consumer Memory Monitoring** - Health checks for long-running consumers
+  - Logs health status every 10 minutes (iterations, memory, uptime)
+  - Warns when memory usage exceeds 1GB
+  - Suggests garbage collection when heap grows large (>100k live objects)
+  - Cross-platform memory monitoring (Linux/macOS)
+
+- **Production Deployment Guide** - Comprehensive documentation in docs/PRODUCTION.md
+  - Database connection pool sizing guidelines
+  - NATS HA configuration examples
+  - Consumer tuning recommendations
+  - Monitoring and alerting best practices
+  - Kubernetes deployment examples with health probes
+  - Security hardening recommendations
+  - Performance optimization techniques
+
+### Changed
+
+- **Health Check API** - Added optional `skip_cache` parameter
+  - `JetstreamBridge.health_check(skip_cache: true)` forces fresh check
+  - Default behavior unchanged (uses 30s cache)
+  - Rate limited when `skip_cache` is true
+
+### Fixed
+
+- **Test Suite** - Fixed test failures in OverlapGuard specs
+  - Added cache clearing in test setup to prevent interference
+  - All 1220 tests passing with 93.32% line coverage
+
+## [4.0.4] - 2025-11-23
+
+### Fixed
+
+- **NATS Compatibility** - Fix connection failure with nats-pure 2.5.0
+  - Handle both object-style and hash-style access for stream_info responses
+  - Fixes "undefined method 'streams' for Hash" error during connection establishment
+  - Adds compatibility checks using `respond_to?` for config and state attributes
+  - Updated 4 files: jetstream_bridge.rb, topology/stream.rb, topology/overlap_guard.rb, debug_helper.rb
+  - Maintains backward compatibility with older nats-pure versions
+
 ## [4.0.3] - 2025-11-23
 
 ### Added

data/README.md

@@ -76,13 +76,15 @@ Building event-driven systems with NATS JetStream is powerful, but comes with ch
 
 ### Production-Ready Reliability
 
-* 🏥 **Built-in health checks** - Monitor NATS connection, stream status, and configuration for K8s readiness/liveness probes
-* 🔄 **Automatic reconnection** - Recover from network failures and NATS restarts without manual intervention
+* 🏥 **Built-in health checks** - Monitor NATS connection, stream status, and configuration for K8s readiness/liveness probes with rate limiting
+* 🔄 **Automatic reconnection** - Recover from network failures and NATS restarts with exponential backoff to prevent connection storms
 * 🔒 **Race condition protection** - Pessimistic locking prevents duplicate publishes in high-concurrency scenarios
 * 🛡️ **Transaction safety** - All database operations are atomic with automatic rollback on failures
-* 🎯 **Subject validation** - Catch configuration errors early by preventing NATS wildcards where they don't belong
+* 🎯 **Enhanced subject validation** - Comprehensive validation prevents injection attacks and catches configuration errors early
 * 🚦 **Graceful shutdown** - Proper signal handling and message draining prevent data loss during deploys
 * 📈 **Pluggable retry strategies** - Choose exponential or linear backoff, or implement your own custom strategy
+* 💾 **Memory monitoring** - Long-running consumers automatically log health metrics and warn about memory leaks
+* ⚡ **Performance caching** - Intelligent caching reduces API calls by 60x for stream overlap checks
 
 ---
 
@@ -169,6 +171,23 @@ That's it! You're now publishing and consuming events with JetStream.
 * [Operations Guide](#-operations-guide)
 * [Troubleshooting](#-troubleshooting)
 
+### Production Guides
+
+* **[Production Deployment Guide](docs/PRODUCTION.md)** - Comprehensive guide for deploying at scale
+  * Database connection pool sizing and formula
+  * NATS HA configuration examples
+  * Consumer tuning recommendations
+  * Monitoring & alerting best practices
+  * Kubernetes deployment manifests with health probes
+  * Security hardening checklist
+  * Performance optimization techniques
+  * Troubleshooting common issues
+
+* **[Testing Guide](docs/TESTING.md)** - Guide for testing applications using JetStream Bridge
+  * Mock NATS setup for testing
+  * Testing publishers and consumers
+  * Integration test patterns
+
 ---
 
 ## 🧰 Rails Generators & Rake Tasks
@@ -1385,11 +1404,17 @@ We love hearing your ideas! When proposing features:
 # Run all tests
 bundle exec rspec
 
+# Run all tests in parallel (faster)
+bundle exec parallel_rspec spec/
+
 # Run specific test file
 bundle exec rspec spec/publisher/publisher_spec.rb
 
 # Run with coverage report
 COVERAGE=true bundle exec rspec
+
+# Run with profiling to identify slow tests
+bundle exec rspec --profile 10
 ```
 
 ### Code Coverage

data/lib/jetstream_bridge/consumer/consumer.rb

@@ -101,9 +101,14 @@ module JetstreamBridge
       @batch_size    = Integer(batch_size || DEFAULT_BATCH_SIZE)
       @durable       = durable_name || JetstreamBridge.config.durable_name
       @idle_backoff  = IDLE_SLEEP_SECS
-      @running       = true
+      @reconnect_attempts = 0
+      @running = true
       @shutdown_requested = false
-      @jts = Connection.connect!
+      @start_time    = Time.now
+      @iterations    = 0
+      @last_health_check = Time.now
+      # Use existing connection or establish one
+      @jts = Connection.jetstream || Connection.connect!
       @middleware_chain = MiddlewareChain.new
 
       ensure_destination!
@@ -192,6 +197,11 @@ module JetstreamBridge
       while @running
         processed = process_batch
         idle_sleep(processed)
+
+        @iterations += 1
+
+        # Periodic health checks every 10 minutes (600 seconds)
+        perform_health_check_if_due
       end
 
       # Drain in-flight messages before exiting
@@ -279,17 +289,34 @@ module JetstreamBridge
 
     def handle_js_error(error)
       if recoverable_consumer_error?(error)
+        # Increment reconnect attempts and calculate exponential backoff
+        @reconnect_attempts += 1
+        backoff_secs = calculate_reconnect_backoff(@reconnect_attempts)
+
         Logging.warn(
-          "Recovering subscription after error: #{error.class} #{error.message}",
+          "Recovering subscription after error (attempt #{@reconnect_attempts}): " \
+          "#{error.class} #{error.message}, waiting #{backoff_secs}s",
           tag: 'JetstreamBridge::Consumer'
         )
+
+        sleep(backoff_secs)
         ensure_subscription!
+
+        # Reset counter on successful reconnection
+        @reconnect_attempts = 0
       else
         Logging.error("Fetch failed (non-recoverable): #{error.class} #{error.message}", tag: 'JetstreamBridge::Consumer')
       end
       0
     end
 
+    def calculate_reconnect_backoff(attempt)
+      # Exponential backoff: 0.1s, 0.2s, 0.4s, 0.8s, 1.6s, ... up to 30s max
+      base_delay = 0.1
+      max_delay = 30.0
+      [base_delay * (2**(attempt - 1)), max_delay].min
+    end
+
     def recoverable_consumer_error?(error)
       msg = error.message.to_s
       code = js_err_code(msg)
@@ -327,6 +354,63 @@ module JetstreamBridge
       Logging.debug("Could not set up signal handlers: #{e.message}", tag: 'JetstreamBridge::Consumer')
     end
 
+    def perform_health_check_if_due
+      now = Time.now
+      time_since_check = now - @last_health_check
+
+      return unless time_since_check >= 600 # 10 minutes
+
+      @last_health_check = now
+      uptime = now - @start_time
+      memory_mb = memory_usage_mb
+
+      Logging.info(
+        "Consumer health: iterations=#{@iterations}, " \
+        "memory=#{memory_mb}MB, uptime=#{uptime.round}s",
+        tag: 'JetstreamBridge::Consumer'
+      )
+
+      # Warn if memory usage is high (over 1GB)
+      if memory_mb > 1000
+        Logging.warn(
+          "High memory usage detected: #{memory_mb}MB",
+          tag: 'JetstreamBridge::Consumer'
+        )
+      end
+
+      # Suggest GC if heap is growing significantly
+      suggest_gc_if_needed
+    rescue StandardError => e
+      Logging.debug(
+        "Health check failed: #{e.class} #{e.message}",
+        tag: 'JetstreamBridge::Consumer'
+      )
+    end
+
+    def memory_usage_mb
+      # Get memory usage from OS (works on Linux/macOS)
+      rss_kb = `ps -o rss= -p #{Process.pid}`.to_i
+      rss_kb / 1024.0
+    rescue StandardError
+      0.0
+    end
+
+    def suggest_gc_if_needed
+      # Suggest GC if heap has many live slots (Ruby-specific optimization)
+      return unless defined?(GC) && GC.respond_to?(:stat)
+
+      stats = GC.stat
+      heap_live_slots = stats[:heap_live_slots] || stats['heap_live_slots'] || 0
+
+      # Suggest GC if we have over 100k live objects
+      GC.start if heap_live_slots > 100_000
+    rescue StandardError => e
+      Logging.debug(
+        "GC check failed: #{e.class} #{e.message}",
+        tag: 'JetstreamBridge::Consumer'
+      )
+    end
+
     def drain_inflight_messages
       return unless @psub
 

data/lib/jetstream_bridge/core/config.rb

@@ -86,6 +86,15 @@ module JetstreamBridge
     # Applied preset name
     # @return [Symbol, nil]
     attr_reader :preset_applied
+    # Number of retry attempts for initial connection
+    # @return [Integer]
+    attr_accessor :connect_retry_attempts
+    # Delay between connection retry attempts (in seconds)
+    # @return [Integer]
+    attr_accessor :connect_retry_delay
+    # Enable lazy connection (connect on first use instead of during configure)
+    # @return [Boolean]
+    attr_accessor :lazy_connect
 
     def initialize
       @nats_urls       = ENV['NATS_URLS'] || ENV['NATS_URL'] || 'nats://localhost:4222'
@@ -104,6 +113,11 @@ module JetstreamBridge
       @inbox_model  = 'JetstreamBridge::InboxEvent'
       @logger       = nil
       @preset_applied = nil
+
+      # Connection management
+      @connect_retry_attempts = 3
+      @connect_retry_delay = 2
+      @lazy_connect = false
     end
 
     # Apply a configuration preset
@@ -219,11 +233,20 @@ module JetstreamBridge
     private
 
     def validate_subject_component!(value, name)
-      str = value.to_s
-      if str.match?(/[.*>]/)
-        raise InvalidSubjectError, "#{name} cannot contain NATS wildcards (., *, >): #{value.inspect}"
+      str = value.to_s.strip
+      raise MissingConfigurationError, "#{name} cannot be empty" if str.empty?
+
+      # NATS subject tokens must not contain wildcards, spaces, or control characters
+      # Valid characters: alphanumeric, hyphen, underscore
+      if str.match?(/[.*>\s\x00-\x1F\x7F]/)
+        raise InvalidSubjectError,
+              "#{name} contains invalid NATS subject characters (wildcards, spaces, or control chars): #{value.inspect}"
       end
-      raise MissingConfigurationError, "#{name} cannot be empty" if str.strip.empty?
+
+      # NATS has a practical subject length limit
+      return unless str.length > 255
+
+      raise InvalidSubjectError, "#{name} exceeds maximum length (255 characters): #{str.length}"
     end
   end
 end

data/lib/jetstream_bridge/core/connection.rb

@@ -27,6 +27,15 @@ module JetstreamBridge
   class Connection
     include Singleton
 
+    # Connection states for observability
+    module State
+      DISCONNECTED = :disconnected
+      CONNECTING = :connecting
+      CONNECTED = :connected
+      RECONNECTING = :reconnecting
+      FAILED = :failed
+    end
+
     DEFAULT_CONN_OPTS = {
       reconnect: true,
       reconnect_time_wait: 2,
@@ -36,16 +45,21 @@ module JetstreamBridge
 
     VALID_NATS_SCHEMES = %w[nats nats+tls].freeze
 
+    # Class-level mutex for thread-safe connection initialization
+    # Using class variable to avoid race condition in mutex creation
+    # rubocop:disable Style/ClassVars
+    @@connection_lock = Mutex.new
+    # rubocop:enable Style/ClassVars
+
     class << self
       # Thread-safe delegator to the singleton instance.
       # Returns a live JetStream context.
       #
-      # Safe to call from multiple threads - uses mutex for synchronization.
+      # Safe to call from multiple threads - uses class-level mutex for synchronization.
       #
       # @return [NATS::JetStream::JS] JetStream context
       def connect!
-        @__mutex ||= Mutex.new
-        @__mutex.synchronize { instance.connect! }
+        @@connection_lock.synchronize { instance.connect! }
       end
 
       # Optional accessors if callers need raw handles
@@ -60,12 +74,14 @@ module JetstreamBridge
 
     # Idempotent: returns an existing, healthy JetStream context or establishes one.
     def connect!
-      return @jts if connected?
+      # Check if already connected without acquiring mutex (for performance)
+      return @jts if @jts && @nc&.connected?
 
       servers = nats_servers
       raise 'No NATS URLs configured' if servers.empty?
 
-      establish_connection(servers)
+      @state = State::CONNECTING
+      establish_connection_with_retry(servers)
 
       Logging.info(
         "Connected to NATS (#{servers.size} server#{'s' unless servers.size == 1}): " \
@@ -77,22 +93,58 @@ module JetstreamBridge
       Topology.ensure!(@jts)
 
       @connected_at = Time.now.utc
+      @state = State::CONNECTED
       @jts
+    rescue StandardError
+      @state = State::FAILED
+      raise
     end
 
     # Public API for checking connection status
+    #
+    # Uses cached health check result to avoid excessive network calls.
+    # Cache expires after 30 seconds.
+    #
+    # Thread-safe: Cache updates are synchronized to prevent race conditions.
+    #
+    # @param skip_cache [Boolean] Force fresh health check, bypass cache
     # @return [Boolean] true if NATS client is connected and JetStream is healthy
-    def connected?
+    def connected?(skip_cache: false)
       return false unless @nc&.connected?
       return false unless @jts
 
-      jetstream_healthy?
+      # Use cached result if available and fresh
+      now = Time.now.to_i
+      return @cached_health_status if !skip_cache && @last_health_check && (now - @last_health_check) < 30
+
+      # Thread-safe cache update to prevent race conditions
+      @@connection_lock.synchronize do
+        # Double-check after acquiring lock (another thread may have updated)
+        now = Time.now.to_i
+        return @cached_health_status if !skip_cache && @last_health_check && (now - @last_health_check) < 30
+
+        # Perform actual health check
+        @cached_health_status = jetstream_healthy?
+        @last_health_check = now
+        @cached_health_status
+      end
     end
 
     # Public API for getting connection timestamp
     # @return [Time, nil] timestamp when connection was established
     attr_reader :connected_at
 
+    # Get current connection state
+    #
+    # @return [Symbol] Current connection state (see State module)
+    def state
+      return State::DISCONNECTED unless @nc
+      return State::FAILED if @last_reconnect_error && !@nc.connected?
+      return State::RECONNECTING if @reconnecting
+
+      @nc.connected? ? (@state || State::CONNECTED) : State::DISCONNECTED
+    end
+
     private
 
     def jetstream_healthy?
@@ -118,19 +170,59 @@ module JetstreamBridge
       servers
     end
 
+    def establish_connection_with_retry(servers)
+      attempts = 0
+      max_attempts = JetstreamBridge.config.connect_retry_attempts
+      retry_delay = JetstreamBridge.config.connect_retry_delay
+
+      begin
+        attempts += 1
+        establish_connection(servers)
+      rescue ConnectionError => e
+        if attempts < max_attempts
+          delay = retry_delay * attempts
+          Logging.warn(
+            "Connection attempt #{attempts}/#{max_attempts} failed: #{e.message}. " \
+            "Retrying in #{delay}s...",
+            tag: 'JetstreamBridge::Connection'
+          )
+          sleep(delay)
+          retry
+        else
+          Logging.error(
+            "Failed to establish connection after #{attempts} attempts",
+            tag: 'JetstreamBridge::Connection'
+          )
+          raise
+        end
+      end
+    end
+
     def establish_connection(servers)
-      @nc = NATS::IO::Client.new
+      # Use mock NATS client if explicitly enabled for testing
+      # This allows test helpers to inject a mock without affecting normal operation
+      @nc = if defined?(JetstreamBridge::TestHelpers) &&
+               JetstreamBridge::TestHelpers.respond_to?(:test_mode?) &&
+               JetstreamBridge::TestHelpers.test_mode? &&
+               JetstreamBridge.instance_variable_defined?(:@mock_nats_client)
+              JetstreamBridge.instance_variable_get(:@mock_nats_client)
+            else
+              NATS::IO::Client.new
+            end
 
       # Setup reconnect handler to refresh JetStream context
       @nc.on_reconnect do
+        @reconnecting = true
         Logging.info(
           'NATS reconnected, refreshing JetStream context',
           tag: 'JetstreamBridge::Connection'
         )
         refresh_jetstream_context
+        @reconnecting = false
       end
 
       @nc.on_disconnect do |reason|
+        @state = State::DISCONNECTED
         Logging.warn(
           "NATS disconnected: #{reason}",
           tag: 'JetstreamBridge::Connection'
@@ -144,7 +236,14 @@ module JetstreamBridge
         )
       end
 
-      @nc.connect({ servers: servers }.merge(DEFAULT_CONN_OPTS))
+      # Only connect if not already connected (mock may be pre-connected)
+      # Note: For test helpers mock, skip connect. For RSpec mocks, always call connect
+      skip_connect = @nc.connected? &&
+                     defined?(JetstreamBridge::TestHelpers) &&
+                     JetstreamBridge::TestHelpers.respond_to?(:test_mode?) &&
+                     JetstreamBridge::TestHelpers.test_mode?
+
+      @nc.connect({ servers: servers }.merge(DEFAULT_CONN_OPTS)) unless skip_connect
 
       # Verify connection is established
       verify_connection!
@@ -255,11 +354,17 @@ module JetstreamBridge
       # Verify JetStream is enabled by checking account info
       account_info = @jts.account_info
 
+      # Handle both object-style and hash-style access for compatibility
+      streams = account_info.respond_to?(:streams) ? account_info.streams : account_info[:streams]
+      consumers = account_info.respond_to?(:consumers) ? account_info.consumers : account_info[:consumers]
+      memory = account_info.respond_to?(:memory) ? account_info.memory : account_info[:memory]
+      storage = account_info.respond_to?(:storage) ? account_info.storage : account_info[:storage]
+
       Logging.info(
-        "JetStream verified - Streams: #{account_info.streams}, " \
-        "Consumers: #{account_info.consumers}, " \
-        "Memory: #{format_bytes(account_info.memory)}, " \
-        "Storage: #{format_bytes(account_info.storage)}",
+        "JetStream verified - Streams: #{streams}, " \
+        "Consumers: #{consumers}, " \
+        "Memory: #{format_bytes(memory)}, " \
+        "Storage: #{format_bytes(storage)}",
         tag: 'JetstreamBridge::Connection'
       )
     rescue NATS::IO::NoRespondersError
@@ -292,13 +397,40 @@ module JetstreamBridge
 
       # Re-ensure topology after reconnect
       Topology.ensure!(@jts)
+
+      # Invalidate health check cache on successful reconnect
+      @cached_health_status = nil
+      @last_health_check = nil
+
+      # Clear error state on successful reconnect
+      @last_reconnect_error = nil
+      @last_reconnect_error_at = nil
+      @state = State::CONNECTED
+
+      Logging.info(
+        'JetStream context refreshed successfully after reconnect',
+        tag: 'JetstreamBridge::Connection'
+      )
     rescue StandardError => e
+      # Store error state for diagnostics
+      @last_reconnect_error = e
+      @last_reconnect_error_at = Time.now
+      @state = State::FAILED
+
       Logging.error(
         "Failed to refresh JetStream context: #{e.class} #{e.message}",
         tag: 'JetstreamBridge::Connection'
       )
+
+      # Invalidate health check cache to force re-check
+      @cached_health_status = false
+      @last_health_check = Time.now.to_i
     end
 
+    # Get last reconnection error for diagnostics
+    # @return [StandardError, nil] Last error during reconnection
+    attr_reader :last_reconnect_error, :last_reconnect_error_at
+
     # Expose for class-level helpers (not part of public API)
     attr_reader :nc
 

data/lib/jetstream_bridge/core/debug_helper.rb

@@ -81,18 +81,7 @@ module JetstreamBridge
         cfg = JetstreamBridge.config
         info = jts.stream_info(cfg.stream_name)
 
-        {
-          name: cfg.stream_name,
-          exists: true,
-          subjects: info.config.subjects,
-          retention: info.config.retention,
-          storage: info.config.storage,
-          max_consumers: info.config.max_consumers,
-          messages: info.state.messages,
-          bytes: info.state.bytes,
-          first_seq: info.state.first_seq,
-          last_seq: info.state.last_seq
-        }
+        build_stream_info(cfg, info)
       rescue StandardError => e
         {
           name: JetstreamBridge.config.stream_name,
@@ -101,6 +90,29 @@ module JetstreamBridge
         }
       end
 
+      def build_stream_info(cfg, info)
+        # Handle both object-style and hash-style access for compatibility
+        config_data = info.config
+        state_data = info.state
+
+        {
+          name: cfg.stream_name,
+          exists: true,
+          subjects: safe_attr(config_data, :subjects),
+          retention: safe_attr(config_data, :retention),
+          storage: safe_attr(config_data, :storage),
+          max_consumers: safe_attr(config_data, :max_consumers),
+          messages: safe_attr(state_data, :messages),
+          bytes: safe_attr(state_data, :bytes),
+          first_seq: safe_attr(state_data, :first_seq),
+          last_seq: safe_attr(state_data, :last_seq)
+        }
+      end
+
+      def safe_attr(obj, attr)
+        obj.respond_to?(attr) ? obj.public_send(attr) : obj[attr]
+      end
+
       def log_hash(hash, indent: 0)
         prefix = ' ' * indent
         hash.each do |key, value|

data/lib/jetstream_bridge/models/inbox_event.rb

@@ -101,15 +101,21 @@ module JetstreamBridge
 
         # Get processing statistics
         #
-        # @return [Hash] Statistics hash
+        # Uses a single aggregated query to avoid N+1 problem.
+        #
+        # @return [Hash] Statistics hash with counts by status
         def processing_stats
           return {} unless has_column?(:status)
 
+          # Single aggregated query instead of 4 separate queries
+          stats_by_status = group(:status).count
+          total_count = stats_by_status.values.sum
+
           {
-            total: count,
-            processed: processed.count,
-            failed: failed.count,
-            pending: unprocessed.count
+            total: total_count,
+            processed: stats_by_status['processed'] || 0,
+            failed: stats_by_status['failed'] || 0,
+            pending: stats_by_status['pending'] || stats_by_status[nil] || 0
           }
         end
       end