nats_wave 1.1.5 → 1.1.8

data/lib/nats_wave/subscriber.rb

@@ -2,40 +2,52 @@
 
 module NatsWave
     class Subscriber
-        attr_reader :config, :nats_client
+        attr_reader :config, :client
         
-        def initialize(config, nats_client, middleware_stack = [])
+        def initialize(config, client, middleware_stack = [])
             @config = config
-            @nats_client = nats_client
+            @client = client
+            @original_client_factory = nil # Store how to recreate the client
             @database_connector = DatabaseConnector.new(config)
             @model_mapper = ModelMapper.new(config)
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config)
             
-            # Separate the two types of subscriptions
-            @registry_subscriptions = ModelRegistry.subscriptions  # Hash objects
-            @nats_subscriptions = []                               # NATS::Subscription objects
+            @registry_subscriptions = ModelRegistry.subscriptions
+            @nats_subscriptions = [] # NATS::Subscription objects
             @running = false
+            @shutdown = false
+            @reconnecting = false
+            @connection_stats = {
+                    reconnect_count: 0,
+                    last_successful_connection: Time.current,
+                    consecutive_failures: 0
+            }
         end
         
-        def start
-            return if @running
+        # Add method to store client factory for reconnection
+        def set_client_factory(factory_proc)
+            @original_client_factory = factory_proc
+        end
+        
+        def begin
+            return if @running || @shutdown
             return unless @config.subscription_enabled
             
             @running = true
+            @shutdown = false
+            
             NatsWave.logger.info "Starting NATS subscriber for #{@config.service_name}"
             
-            # Use ModelRegistry subscriptions
-            @registry_subscriptions.each do |subscription|
-                subscription[:subjects].each do |subject|
-                    subscribe_to_subject(subject, subscription[:handler])
-                end
-            end
+            setup_subscriptions
             
-            NatsWave.logger.info "Started #{@registry_subscriptions.size} subscriptions from ModelRegistry"
+            NatsWave.logger.info "Started #{@registry_subscriptions.size} subscriptions from Model Registry"
+            
+            # Keep the subscriber alive
+            keep_alive
         end
         
-        def subscribe(subjects:, model_mappings: {}, handler: nil)
+        def listen(subjects:, model_mappings: {}, handler: nil)
             subjects = Array(subjects)
             
             subjects.each do |subject|
@@ -44,11 +56,21 @@ module NatsWave
             end
         end
         
-        def unsubscribe_all
-            # Unsubscribe from NATS subscriptions (the actual NATS::Subscription objects)
-            @nats_subscriptions.each(&:unsubscribe)
-            @nats_subscriptions.clear
+        def reset
+            @shutdown = true
             @running = false
+            
+            # Stop keep alive thread
+            if @keep_alive_thread&.alive?
+                @keep_alive_thread.kill
+                @keep_alive_thread.join(5) # Wait up to 5 seconds for graceful shutdown
+                @keep_alive_thread = nil
+            end
+            
+            # Unsubscribe from all subscriptions
+            cleanup_subscriptions
+            
+            NatsWave.logger.info "🛑 Subscriber shutdown complete"
         end
         
         def database_connected?
@@ -56,29 +78,72 @@ module NatsWave
         end
         
         def disconnect
-            unsubscribe_all
+            reset
         end
         
         private
         
+        def setup_subscriptions
+            return unless @client&.connected?
+            
+            # Clear existing subscriptions first
+            cleanup_subscriptions
+            
+            # Use ModelRegistry subscriptions
+            @registry_subscriptions.each do |subscription|
+                subscription[:subjects].each do |subject|
+                    subscribe_to_subject(subject, subscription[:handler])
+                end
+            end
+        end
+        
+        def cleanup_subscriptions
+            @nats_subscriptions.each do |subscription|
+                begin
+                    subscription.unsubscribe if subscription.respond_to?(:unsubscribe)
+                rescue => e
+                    NatsWave.logger.error "Error unsubscribing: #{e.message}"
+                end
+            end
+            @nats_subscriptions.clear
+        end
+        
         def subscribe_to_subject(subject_pattern, custom_handler = nil, model_mappings = {})
+            return unless @client&.connected?
+            
             NatsWave.logger.info "🔍 Attempting to subscribe to: #{subject_pattern}"
             
-            # Create the NATS subscription
-            nats_subscription = @nats_client.subscribe(
-                    subject_pattern,
-                    queue: @config.queue_group
-            ) do |msg|
-                NatsWave.logger.info "📨 Received message on #{msg.subject}: #{msg.data}"
-                process_message(msg.data, custom_handler, model_mappings)
-            end
+            begin
+                # Create the NATS subscription
+                nats_subscription = @client.subscribe(
+                        subject_pattern,
+                        queue: @config.queue_group
+                ) do |msg|
+                    begin
+                        NatsWave.logger.debug "📨 Received message on #{msg.subject}"
+                        process_message(msg.data, custom_handler, model_mappings)
+                    rescue => e
+                        NatsWave.logger.error "Error in subscription handler: #{e.message}"
+                        NatsWave.logger.error e.backtrace.join("\n")
+                        # Don't re-raise - this would kill the subscription
+                    end
+                end
+                
+                # Add to NATS subscriptions array
+                @nats_subscriptions << nats_subscription
+                NatsWave.logger.info "✅ Successfully subscribed to #{subject_pattern} (total: #{@nats_subscriptions.size})"
             
-            # Add to NATS subscriptions array (not the registry subscriptions)
-            @nats_subscriptions << nats_subscription
-            NatsWave.logger.info "✅ Successfully subscribed to #{subject_pattern} (total: #{@nats_subscriptions.size})"
+            rescue => e
+                NatsWave.logger.error "Failed to subscribe to #{subject_pattern}: #{e.message}"
+                raise
+            end
         end
         
         def process_message(raw_message, custom_handler, model_mappings)
+            return unless should_process_message?(raw_message)
+            
+            NatsWave.logger.debug "🔄 Processing message: #{raw_message[0..200]}..."
+            
             message = parse_message(raw_message)
             
             if custom_handler
@@ -87,11 +152,192 @@ module NatsWave
                 handle_model_sync(message, model_mappings)
             end
             
-            NatsWave.logger.debug('Successfully processed message')
+            NatsWave.logger.debug('✅ Successfully processed message')
         rescue StandardError => e
             handle_error(e, raw_message, message)
+            # Don't re-raise - this would kill the subscription
+        end
+        
+        def should_process_message?(raw_message_data)
+            message = JSON.parse(raw_message_data)
+            source = message['source'] || {}
+            
+            # Skip messages from same service instance
+            if source['service'] == @config.service_name && source['instance_id'] == @config.instance_id
+                NatsWave.logger.debug "🔄 Skipping message from same service instance"
+                return false
+            end
+            
+            true
+        rescue JSON::ParserError => e
+            NatsWave.logger.error "Failed to parse message for filtering: #{e.message}"
+            false
+        end
+        
+        def keep_alive
+            NatsWave.logger.info "🔄 Starting keep-alive thread for persistent JetStream connection"
+            
+            @keep_alive_thread = Thread.new do
+                while @running && !@shutdown
+                    begin
+                        sleep 30 # Check every 30 seconds
+                        
+                        connection_healthy = check_connection_health
+                        
+                        if connection_healthy
+                            NatsWave.logger.debug "💓 Subscriber connection healthy - #{@nats_subscriptions.size} active subscriptions"
+                            @connection_stats[:consecutive_failures] = 0
+                            @connection_stats[:last_successful_connection] = Time.current
+                        else
+                            @connection_stats[:consecutive_failures] += 1
+                            time_since_last_good = Time.current - @connection_stats[:last_successful_connection]
+                            
+                            NatsWave.logger.error "❌ Subscriber connection lost! (failure ##{@connection_stats[:consecutive_failures]}, last good: #{time_since_last_good.to_i}s ago)"
+                            
+                            log_connection_diagnostics
+                            attempt_reconnection
+                        end
+                        
+                        # If too many consecutive failures, escalate
+                        if @connection_stats[:consecutive_failures] > 5
+                            NatsWave.logger.error "🚨 Too many consecutive failures. Performing full reset."
+                            perform_full_reset
+                        end
+                    
+                    rescue => e
+                        NatsWave.logger.error "Error in keep_alive thread: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
+                        sleep 10
+                    end
+                end
+                
+                NatsWave.logger.info "🛑 Keep-alive thread shutting down"
+            end
+        end
+        
+        def check_connection_health
+            return false unless @client
+            
+            begin
+                # First check basic connectivity
+                return false unless @client.connected?
+                
+                # Try to perform a simple operation with timeout
+                Timeout.timeout(5) do
+                    @client.flush
+                    return true
+                end
+            rescue Timeout::Error
+                NatsWave.logger.warn "⏰ Connection health check timed out"
+                return false
+            rescue => e
+                NatsWave.logger.warn "🔍 Health check failed: #{e.message}"
+                return false
+            end
+        end
+        
+        def log_connection_diagnostics
+            begin
+                NatsWave.logger.info "🔍 Connection Diagnostics:"
+                NatsWave.logger.info "  - Client connected?: #{@client&.connected? rescue 'unknown'}"
+                NatsWave.logger.info "  - Active subscriptions: #{@nats_subscriptions.size}"
+                NatsWave.logger.info "  - Reconnect count: #{@connection_stats[:reconnect_count]}"
+                NatsWave.logger.info "  - Thread count: #{Thread.list.count}"
+                NatsWave.logger.info "  - Last successful: #{@connection_stats[:last_successful_connection]}"
+                
+                # Check if subscriptions are actually valid
+                valid_subs = @nats_subscriptions.count { |sub| sub.respond_to?(:unsubscribe) }
+                NatsWave.logger.info "  - Valid subscriptions: #{valid_subs}/#{@nats_subscriptions.size}"
+            
+            rescue => e
+                NatsWave.logger.error "Failed to gather diagnostics: #{e.message}"
+            end
+        end
+        
+        def attempt_reconnection
+            return if @shutdown || @reconnecting
+            
+            @reconnecting = true
+            @connection_stats[:reconnect_count] += 1
+            
+            begin
+                NatsWave.logger.info "🔄 Attempting to reconnect to NATS... (attempt ##{@connection_stats[:reconnect_count]})"
+                
+                # First, clean up existing connection and subscriptions
+                cleanup_subscriptions
+                
+                # Close the existing client connection
+                begin
+                    @client&.close if @client&.connected?
+                rescue => e
+                    NatsWave.logger.debug "Error closing existing connection: #{e.message}"
+                end
+                
+                # Wait before attempting to reconnect
+                sleep_time = [2 ** [@connection_stats[:consecutive_failures] - 1, 4].min, 30].min
+                NatsWave.logger.debug "⏱️  Waiting #{sleep_time}s before reconnection attempt"
+                sleep sleep_time
+                
+                # Attempt to recreate the client connection
+                if @original_client_factory
+                    @client = @original_client_factory.call
+                    NatsWave.logger.info "🔄 Created new NATS client using factory"
+                else
+                    NatsWave.logger.warn "⚠️  No client factory available, hoping existing client recovers"
+                end
+                
+                # Check if we have a working connection
+                if @client&.connected?
+                    NatsWave.logger.info "✅ NATS client reconnected successfully"
+                    
+                    # Re-establish all subscriptions
+                    setup_subscriptions
+                    
+                    NatsWave.logger.info "✅ Subscriptions restored (#{@nats_subscriptions.size} active)"
+                    @connection_stats[:consecutive_failures] = 0
+                    @connection_stats[:last_successful_connection] = Time.current
+                    
+                    return true
+                else
+                    raise "Connection failed - client not connected"
+                end
+            
+            rescue => e
+                NatsWave.logger.error "Reconnection failed: #{e.message}"
+                return false
+            ensure
+                @reconnecting = false
+            end
+        end
+        
+        def perform_full_reset
+            NatsWave.logger.info "🔄 Performing full connection reset"
+            
+            begin
+                # Force close everything
+                cleanup_subscriptions
+                @client&.close rescue nil
+                
+                # Clear connection stats
+                @connection_stats[:consecutive_failures] = 0
+                
+                # Force garbage collection
+                GC.start
+                
+                # Wait longer before attempting reset
+                sleep 10
+                
+                # Try to recreate everything
+                if @original_client_factory
+                    @client = @original_client_factory.call
+                    setup_subscriptions if @client&.connected?
+                end
+            
+            rescue => e
+                NatsWave.logger.error "Full reset failed: #{e.message}"
+            end
         end
         
+        # ... rest of your existing methods (parse_message, handle_model_sync, handle_error)
         def parse_message(raw_message)
             @message_transformer.parse_message(raw_message)
         end

data/lib/nats_wave/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NatsWave
-    VERSION = '1.1.5'
+    VERSION = '1.1.8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats_wave
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.8
 platform: ruby
 authors:
 - Jeffrey Dabo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-18 00:00:00.000000000 Z
+date: 2025-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nats-pure