nats_wave 1.1.7 → 1.1.9

data/lib/nats_wave/subscriber.rb

@@ -1,3 +1,394 @@
+# # frozen_string_literal: true
+#
+# module NatsWave
+#     class Subscriber
+#         attr_reader :config, :client
+#
+#         def initialize(config, client, middleware_stack = [])
+#             @config = config
+#             @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)
+#
+#             @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
+#
+#         # 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}"
+#
+#             setup_subscriptions
+#
+#             NatsWave.logger.info "Started #{@registry_subscriptions.size} subscriptions from Model Registry"
+#
+#             # Keep the subscriber alive
+#             keep_alive
+#         end
+#
+#         def listen(subjects:, model_mappings: {}, handler: nil)
+#             subjects = Array(subjects)
+#
+#             subjects.each do |subject|
+#                 subscribe_to_subject(subject, handler, model_mappings)
+#                 NatsWave.logger.info "Subscribed to #{subject}"
+#             end
+#         end
+#
+#         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?
+#             @database_connector.connected?
+#         end
+#
+#         def disconnect
+#             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}"
+#
+#             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})"
+#
+#             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
+#                 custom_handler.call(message)
+#             else
+#                 handle_model_sync(message, model_mappings)
+#             end
+#
+#             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
+#
+#         def handle_model_sync(message, model_mappings)
+#             source_model = message['model']
+#             mapping = model_mappings[source_model] || @config.model_mappings[source_model]
+#
+#             return unless mapping
+#
+#             target_model = mapping[:target_model]
+#             field_mappings = mapping[:field_mappings] || {}
+#             transformations = mapping[:transformations] || {}
+#
+#             # Transform the data
+#             transformed_data = @model_mapper.transform_data(
+#                     message['data'],
+#                     field_mappings,
+#                     transformations
+#             )
+#
+#             # Apply to database
+#             @database_connector.apply_change(
+#                     model: target_model,
+#                     action: message['action'],
+#                     data: transformed_data,
+#                     metadata: message['metadata']
+#             )
+#
+#             NatsWave.logger.info "Synced #{source_model} -> #{target_model}: #{message['action']}"
+#         end
+#
+#         def handle_error(error, raw_message, parsed_message = nil)
+#             event_id = parsed_message&.dig('event_id') || 'unknown'
+#             subject = parsed_message&.dig('subject') || 'unknown'
+#
+#             NatsWave.logger.error("Error processing message #{event_id} from #{subject}: #{error.message}")
+#
+#             # Send to dead letter queue
+#             @dead_letter_queue.store_failed_message(
+#                     parsed_message || raw_message,
+#                     error,
+#                     0 # retry count
+#             )
+#
+#             # Continue processing - don't raise to avoid breaking subscription
+#         end
+#     end
+# end
+
+
 # frozen_string_literal: true
 
 module NatsWave
@@ -7,6 +398,7 @@ module NatsWave
         def initialize(config, client, middleware_stack = [])
             @config = config
             @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)
@@ -16,6 +408,17 @@ module NatsWave
             @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
+        
+        # Add method to store client factory for reconnection
+        def set_client_factory(factory_proc)
+            @original_client_factory = factory_proc
         end
         
         def begin
@@ -27,12 +430,7 @@ module NatsWave
             
             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 Model Registry"
             
@@ -56,18 +454,12 @@ module NatsWave
             # 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
-            @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
+            cleanup_subscriptions
             
             NatsWave.logger.info "🛑 Subscriber shutdown complete"
         end
@@ -82,27 +474,60 @@ module NatsWave
         
         private
         
-        def subscribe_to_subject(subject_pattern, custom_handler = nil, model_mappings = {})
-            NatsWave.logger.info "🔍 Attempting to subscribe to: #{subject_pattern}"
+        def setup_subscriptions
+            return unless @client&.connected?
+            
+            # Clear existing subscriptions first
+            cleanup_subscriptions
             
-            # Create the NATS subscription
-            nats_subscription = @client.subscribe(
-                    subject_pattern,
-                    queue: @config.queue_group
-            ) do |msg|
+            # 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
-                    NatsWave.logger.debug "📨 Received message on #{msg.subject}"
-                    process_message(msg.data, custom_handler, model_mappings)
+                    subscription.unsubscribe if subscription.respond_to?(:unsubscribe)
                 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
+                    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}"
+            
+            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
-            @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)
@@ -141,55 +566,168 @@ module NatsWave
         end
         
         def keep_alive
-            Rails.logger.info "🔄 Starting keep-alive thread for persistent JetStream connection"
+            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
                         
-                        if @client&.connected?
-                            Rails.logger.debug "💓 Subscriber connection healthy - #{@nats_subscriptions.size} active subscriptions"
+                        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
-                            Rails.logger.error "❌ Subscriber connection lost! Attempting reconnection..."
+                            @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
-                        Rails.logger.error "Error in keep_alive thread: #{e.message}"
+                        NatsWave.logger.error "Error in keep_alive thread: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
                         sleep 10
                     end
                 end
                 
-                Rails.logger.info "🛑 Keep-alive thread shutting down"
+                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
+            return if @shutdown || @reconnecting
             
-            NatsWave.logger.info "🔄 Attempting to reconnect to NATS..."
+            @reconnecting = true
+            @connection_stats[:reconnect_count] += 1
             
-            # Reset subscriptions
-            @nats_subscriptions.clear
+            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
             
-            # Try to reestablish subscriptions
-            sleep 5 # Wait before reconnecting
+            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"
             
-            if @client&.connected?
-                NatsWave.logger.info "✅ NATS reconnected, reestablishing subscriptions"
+            begin
+                # Force close everything
+                cleanup_subscriptions
+                @client&.close rescue nil
                 
-                @registry_subscriptions.each do |subscription|
-                    subscription[:subjects].each do |subject|
-                        subscribe_to_subject(subject, subscription[:handler])
-                    end
+                # 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
-        rescue => e
-            NatsWave.logger.error "Failed to reconnect: #{e.message}"
         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