nats_wave 1.1.4 → 1.1.7

data/lib/nats_wave/client.rb

@@ -1,15 +1,478 @@
+# # # # frozen_string_literal: true
+# # #
+# # # module NatsWave
+# # #     class Client
+# # #         attr_reader :config, :publisher, :subscriber, :client
+# # #
+# # #         def initialize(options = {})
+# # #             @config = Configuration.new(options)
+# # #             @client = nil
+# # #             @publisher = nil
+# # #             @subscriber = nil
+# # #             @middleware_stack = []
+# # #
+# # #             setup_connection_pool
+# # #             setup_middleware
+# # #             establish_connections
+# # #         end
+# # #
+# # #         def publish(subject:, model:, action:, data:, metadata: {})
+# # #             ensure_connected!
+# # #             @publisher.publish(
+# # #                     subject: subject,
+# # #                     model: model,
+# # #                     action: action,
+# # #                     data: data,
+# # #                     metadata: metadata
+# # #             )
+# # #         end
+# # #
+# # #         def publish_batch(events)
+# # #             ensure_connected!
+# # #             @publisher.publish_batch(events)
+# # #         end
+# # #
+# # #         def subscribe(subjects:, model_mappings: {}, &block)
+# # #             NatsWave.logger.info "Ensuring connection..."
+# # #             ensure_connected!
+# # #             raise "Subscriber not initialized" unless @subscriber
+# # #
+# # #             NatsWave.logger.info "Subscribing to subjects: #{subjects.inspect}"
+# # #             NatsWave.logger.info "Subscribing with model mapping: #{model_mappings.inspect}"
+# # #             # puts "Subscribing to subjects: #{subjects.inspect}"
+# # #             @subscriber.listen(
+# # #                     subjects: subjects,
+# # #                     model_mappings: model_mappings,
+# # #                     &block
+# # #             )
+# # #         end
+# # #
+# # #
+# # #         def start_subscriber
+# # #             ensure_connected!
+# # #             @subscriber.begin if @subscriber
+# # #         end
+# # #
+# # #         def health_check
+# # #             {
+# # #                     nats_connected: connected?,
+# # #                     database_connected: database_connected?,
+# # #                     nats_url: @config.nats_url,
+# # #                     nats_server_url: @config.nats_server_url,
+# # #                     service_name: @config.service_name,
+# # #                     version: @config.version,
+# # #                     instance_id: @config.instance_id,
+# # #                     published_subjects: @config.subject_patterns,
+# # #                     timestamp: Time.current.iso8601,
+# # #             }
+# # #         end
+# # #
+# # #         def connected?
+# # #             @client && @client.connected?
+# # #         end
+# # #
+# # #         def disconnect!
+# # #             @subscriber&.reset
+# # #             @client&.close
+# # #             @connection_pool&.shutdown
+# # #             @connection_pool&.wait_for_termination(5)
+# # #         end
+# # #
+# # #         private
+# # #
+# # #         def setup_connection_pool
+# # #             return unless defined?(Concurrent)
+# # #
+# # #             @connection_pool = Concurrent::ThreadPoolExecutor.new(
+# # #                     min_threads: 5,
+# # #                     max_threads: @config.connection_pool_size
+# # #             )
+# # #         end
+# # #
+# # #         def setup_middleware
+# # #             @middleware_stack = []
+# # #
+# # #             if @config.middleware_authentication_enabled
+# # #                 @middleware_stack << Middleware::Authentication.new(@config)
+# # #             end
+# # #
+# # #             if @config.middleware_validation_enabled
+# # #                 @middleware_stack << Middleware::Validation.new(@config)
+# # #             end
+# # #
+# # #             if @config.middleware_logging_enabled
+# # #                 @middleware_stack << Middleware::Logging.new(@config)
+# # #             end
+# # #         end
+# # #
+# # #         def establish_connections
+# # #             return unless nats_available?
+# # #
+# # #             establish_nats_connection
+# # #
+# # #             if @config.publishing_enabled
+# # #                 @publisher = Publisher.new(@config, @client, @middleware_stack)
+# # #             end
+# # #
+# # #             if @config.subscription_enabled
+# # #                 @subscriber = Subscriber.new(@config, @client, @middleware_stack)
+# # #             end
+# # #         end
+# # #
+# # #         def establish_nats_connection
+# # #             @client = NATS.connect(
+# # #                     @config.nats_url,
+# # #                     reconnect_time_wait: @config.retry_delay,
+# # #                     max_reconnect_attempts: @config.reconnect_attempts
+# # #             )
+# # #             NatsWave.logger.info("Connected to NATS at #{@config.nats_url}")
+# # #         rescue => e
+# # #             NatsWave.logger.error("Failed to connect to NATS: #{e.message}")
+# # #             raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+# # #         end
+# # #
+# # #         def ensure_connected!
+# # #             raise ConnectionError, "Not connected to NATS" unless connected?
+# # #         end
+# # #
+# # #         def database_connected?
+# # #             return false unless @subscriber
+# # #             @subscriber.database_connected?
+# # #         end
+# # #
+# # #         def nats_available?
+# # #             defined?(NATS)
+# # #         rescue LoadError
+# # #             false
+# # #         end
+# # #     end
+# # # end
+# #
+# #
+# # # frozen_string_literal: true
+# #
+# # module NatsWave
+# #     class Client
+# #         attr_reader :config, :publisher, :subscriber, :client
+# #
+# #         def initialize(options = {})
+# #             @config = Configuration.new(options)
+# #             @client = nil
+# #             @publisher = nil
+# #             @subscriber = nil
+# #             @middleware_stack = []
+# #             @shutdown = false
+# #
+# #             setup_connection_pool
+# #             setup_middleware
+# #             establish_connections
+# #             setup_signal_handlers
+# #         end
+# #
+# #         def start_subscriber
+# #             ensure_connected!
+# #             return unless @subscriber
+# #
+# #             @subscriber.begin
+# #
+# #             # Keep the main thread alive in console/rake tasks
+# #             if defined?(Rails::Console) || $PROGRAM_NAME.include?('rake')
+# #                 keep_main_thread_alive
+# #             end
+# #         end
+# #
+# #         def disconnect!
+# #             @shutdown = true
+# #
+# #             NatsWave.logger.info "🛑 Shutting down NatsWave client..."
+# #
+# #             @subscriber&.reset
+# #             @client&.close if @client&.connected?
+# #             @connection_pool&.shutdown
+# #             @connection_pool&.wait_for_termination(5)
+# #
+# #             NatsWave.logger.info "✅ NatsWave client shutdown complete"
+# #         end
+# #
+# #         private
+# #
+# #         def setup_signal_handlers
+# #             # Handle graceful shutdown
+# #             ['INT', 'TERM'].each do |signal|
+# #                 Signal.trap(signal) do
+# #                     NatsWave.logger.info "🛑 Received #{signal}, shutting down gracefully..."
+# #                     disconnect!
+# #                     exit(0)
+# #                 end
+# #             end
+# #         end
+# #
+# #         def keep_main_thread_alive
+# #             # This prevents the main thread from exiting in console/rake tasks
+# #             Thread.new do
+# #                 while !@shutdown
+# #                     sleep 1
+# #                 end
+# #             end.join
+# #         rescue Interrupt
+# #             NatsWave.logger.info "🛑 Interrupted, shutting down..."
+# #             disconnect!
+# #         end
+# #
+# #         def setup_connection_pool
+# #             return unless defined?(Concurrent)
+# #
+# #             @connection_pool = Concurrent::ThreadPoolExecutor.new(
+# #                     min_threads: 5,
+# #                     max_threads: @config.connection_pool_size
+# #             )
+# #         end
+# #
+# #         def setup_middleware
+# #             @middleware_stack = []
+# #
+# #             if @config.middleware_authentication_enabled
+# #                 @middleware_stack << Middleware::Authentication.new(@config)
+# #             end
+# #
+# #             if @config.middleware_validation_enabled
+# #                 @middleware_stack << Middleware::Validation.new(@config)
+# #             end
+# #
+# #             if @config.middleware_logging_enabled
+# #                 @middleware_stack << Middleware::Logging.new(@config)
+# #             end
+# #         end
+# #
+# #         def establish_connections
+# #             return unless nats_available?
+# #
+# #             establish_nats_connection
+# #
+# #             if @config.publishing_enabled
+# #                 @publisher = Publisher.new(@config, @client, @middleware_stack)
+# #             end
+# #
+# #             if @config.subscription_enabled
+# #                 @subscriber = Subscriber.new(@config, @client, @middleware_stack)
+# #             end
+# #         end
+# #
+# #         def establish_nats_connection
+# #             @client = NATS.connect(
+# #                     @config.nats_url,
+# #                     reconnect_time_wait: @config.retry_delay,
+# #                     max_reconnect_attempts: @config.reconnect_attempts
+# #             )
+# #             NatsWave.logger.info("Connected to NATS at #{@config.nats_url}")
+# #         rescue => e
+# #             NatsWave.logger.error("Failed to connect to NATS: #{e.message}")
+# #             raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+# #         end
+# #
+# #         def ensure_connected!
+# #             raise ConnectionError, "Not connected to NATS" unless connected?
+# #         end
+# #
+# #         def database_connected?
+# #             return false unless @subscriber
+# #             @subscriber.database_connected?
+# #         end
+# #
+# #         def nats_available?
+# #             defined?(NATS)
+# #         rescue LoadError
+# #             false
+# #         end
+# #     end
+# # end
+#
+# # frozen_string_literal: true
+#
+# module NatsWave
+#     class Client
+#         attr_reader :config, :publisher, :subscriber, :client
+#
+#         def initialize(options = {})
+#             @config = Configuration.new(options)
+#             @client = nil
+#             @publisher = nil
+#             @subscriber = nil
+#             @middleware_stack = []
+#             @shutdown = false
+#
+#             setup_connection_pool
+#             setup_middleware
+#             establish_connections
+#         end
+#
+#         def publish(subject:, model:, action:, data:, metadata: {})
+#             ensure_connected!
+#             @publisher.publish(
+#                     subject: subject,
+#                     model: model,
+#                     action: action,
+#                     data: data,
+#                     metadata: metadata
+#             )
+#         end
+#
+#         def publish_batch(events)
+#             ensure_connected!
+#             @publisher.publish_batch(events)
+#         end
+#
+#         def subscribe(subjects:, model_mappings: {}, &block)
+#             NatsWave.logger.info "Ensuring connection..."
+#             ensure_connected!
+#             raise "Subscriber not initialized" unless @subscriber
+#
+#             NatsWave.logger.info "Subscribing to subjects: #{subjects.inspect}"
+#             NatsWave.logger.info "Subscribing with model mapping: #{model_mappings.inspect}"
+#             @subscriber.listen(
+#                     subjects: subjects,
+#                     model_mappings: model_mappings,
+#                     &block
+#             )
+#         end
+#
+#         def start_subscriber
+#             ensure_connected!
+#             @subscriber.begin if @subscriber
+#         end
+#
+#         # ✅ ADD THIS METHOD
+#         def connected?
+#             @client && @client.respond_to?(:connected?) && @client.connected?
+#         end
+#
+#         def health_check
+#             {
+#                     nats_connected: connected?,
+#                     database_connected: database_connected?,
+#                     nats_url: @config.nats_url,
+#                     nats_server_url: @config.nats_server_url,
+#                     service_name: @config.service_name,
+#                     version: @config.version,
+#                     instance_id: @config.instance_id,
+#                     published_subjects: @config.subject_patterns,
+#                     timestamp: Time.current.iso8601,
+#                     model_registry_stats: NatsWave::ModelRegistry.subscription_stats
+#             }
+#         end
+#
+#         def disconnect!
+#             @shutdown = true
+#
+#             NatsWave.logger.info "🛑 Shutting down NatsWave client..."
+#
+#             @subscriber&.reset
+#
+#             if @client&.respond_to?(:close)
+#                 @client.close
+#             elsif @client&.respond_to?(:disconnect)
+#                 @client.disconnect
+#             end
+#
+#             @connection_pool&.shutdown
+#             @connection_pool&.wait_for_termination(5)
+#
+#             NatsWave.logger.info "✅ NatsWave client shutdown complete"
+#         end
+#
+#         private
+#
+#         def setup_connection_pool
+#             return unless defined?(Concurrent)
+#
+#             @connection_pool = Concurrent::ThreadPoolExecutor.new(
+#                     min_threads: 5,
+#                     max_threads: @config.connection_pool_size
+#             )
+#         end
+#
+#         def setup_middleware
+#             @middleware_stack = []
+#
+#             if @config.middleware_authentication_enabled
+#                 @middleware_stack << Middleware::Authentication.new(@config)
+#             end
+#
+#             if @config.middleware_validation_enabled
+#                 @middleware_stack << Middleware::Validation.new(@config)
+#             end
+#
+#             if @config.middleware_logging_enabled
+#                 @middleware_stack << Middleware::Logging.new(@config)
+#             end
+#         end
+#
+#         def establish_connections
+#             return unless nats_available?
+#
+#             establish_nats_connection
+#
+#             if @config.publishing_enabled
+#                 @publisher = Publisher.new(@config, @client, @middleware_stack)
+#             end
+#
+#             if @config.subscription_enabled
+#                 @subscriber = Subscriber.new(@config, @client, @middleware_stack)
+#             end
+#         end
+#
+#         def establish_nats_connection
+#             @client = NATS.connect(
+#                     @config.nats_url,
+#                     reconnect_time_wait: @config.retry_delay,
+#                     max_reconnect_attempts: @config.reconnect_attempts
+#             )
+#             NatsWave.logger.info("Connected to NATS at #{@config.nats_url}")
+#         rescue => e
+#             NatsWave.logger.error("Failed to connect to NATS: #{e.message}")
+#             raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+#         end
+#
+#         # ✅ UPDATE THIS METHOD
+#         def ensure_connected!
+#             unless connected?
+#                 raise ConnectionError, "Not connected to NATS. NATS client: #{@client.class rescue 'nil'}"
+#             end
+#         end
+#
+#         def database_connected?
+#             return false unless @subscriber
+#             @subscriber.database_connected?
+#         end
+#
+#         def nats_available?
+#             defined?(NATS)
+#         rescue LoadError
+#             false
+#         end
+#     end
+# end
+
 # frozen_string_literal: true
 
+begin
+    require 'nats/client'
+rescue LoadError => e
+    # NATS gem not available
+    puts "Warning: NATS gem not available: #{e.message}"
+end
+
 module NatsWave
     class Client
-        attr_reader :config, :publisher, :subscriber, :nats_client
+        attr_reader :config, :publisher, :subscriber, :client
         
         def initialize(options = {})
             @config = Configuration.new(options)
-            @nats_client = nil
+            @client = nil
             @publisher = nil
             @subscriber = nil
             @middleware_stack = []
+            @shutdown = false
             
             setup_connection_pool
             setup_middleware
@@ -33,17 +496,26 @@ module NatsWave
         end
         
         def subscribe(subjects:, model_mappings: {}, &block)
+            NatsWave.logger.info "Ensuring connection..."
             ensure_connected!
-            @subscriber.subscribe(
+            raise "Subscriber not initialized" unless @subscriber
+            
+            NatsWave.logger.info "Subscribing to subjects: #{subjects.inspect}"
+            NatsWave.logger.info "Subscribing with model mapping: #{model_mappings.inspect}"
+            @subscriber.listen(
                     subjects: subjects,
                     model_mappings: model_mappings,
-                    handler: block
+                    &block
             )
         end
         
         def start_subscriber
             ensure_connected!
-            @subscriber.start if @subscriber
+            @subscriber.begin if @subscriber
+        end
+        
+        def connected?
+            @client && @client.respond_to?(:connected?) && @client.connected?
         end
         
         def health_check
@@ -51,24 +523,31 @@ module NatsWave
                     nats_connected: connected?,
                     database_connected: database_connected?,
                     nats_url: @config.nats_url,
-                    nats_server_url: @config.nats_server_url,
                     service_name: @config.service_name,
                     version: @config.version,
                     instance_id: @config.instance_id,
-                    published_subjects: @config.subject_patterns,
                     timestamp: Time.current.iso8601,
+                    model_registry_stats: NatsWave::ModelRegistry.subscription_stats
             }
         end
         
-        def connected?
-            @nats_client && @nats_client.connected?
-        end
-        
         def disconnect!
-            @subscriber&.unsubscribe_all
-            @nats_client&.close
+            @shutdown = true
+            
+            NatsWave.logger.info "🛑 Shutting down NatsWave client..."
+            
+            @subscriber&.reset
+            
+            if @client&.respond_to?(:close)
+                @client.close
+            elsif @client&.respond_to?(:disconnect)
+                @client.disconnect
+            end
+            
             @connection_pool&.shutdown
             @connection_pool&.wait_for_termination(5)
+            
+            NatsWave.logger.info "✅ NatsWave client shutdown complete"
         end
         
         private
@@ -77,7 +556,7 @@ module NatsWave
             return unless defined?(Concurrent)
             
             @connection_pool = Concurrent::ThreadPoolExecutor.new(
-                    min_threads: 2,
+                    min_threads: 5,
                     max_threads: @config.connection_pool_size
             )
         end
@@ -99,33 +578,134 @@ module NatsWave
         end
         
         def establish_connections
-            return unless nats_available?
+            unless nats_available?
+                NatsWave.logger.warn "NATS gem not available, skipping connection"
+                return
+            end
+            
+            unless test_nats_connectivity
+                NatsWave.logger.error "Cannot reach NATS server, skipping connection"
+                return
+            end
             
+            # Always try to establish NATS connection
             establish_nats_connection
             
-            if @config.publishing_enabled
-                @publisher = Publisher.new(@config, @nats_client, @middleware_stack)
+            # Verify connection was successful before creating publisher/subscriber
+            unless connected?
+                NatsWave.logger.error "NATS connection failed, cannot initialize publisher/subscriber"
+                return
+            end
+            
+            # Only create publisher/subscriber if we have a valid connection
+            if @config.publishing_enabled && connected?
+                @publisher = Publisher.new(@config, @client, @middleware_stack)
+                NatsWave.logger.debug "Publisher initialized"
             end
             
-            if @config.subscription_enabled
-                @subscriber = Subscriber.new(@config, @nats_client, @middleware_stack)
+            if @config.subscription_enabled && connected?
+                @subscriber = Subscriber.new(@config, @client, @middleware_stack)
+                NatsWave.logger.debug "Subscriber initialized"
             end
         end
         
+        # def establish_nats_connection
+        #     NatsWave.logger.info "Attempting to connect to NATS at #{@config.nats_url}"
+        #
+        #     @client = NATS.connect(
+        #             @config.nats_url,
+        #             reconnect_time_wait: @config.retry_delay,
+        #             max_reconnect_attempts: @config.reconnect_attempts
+        #     )
+        #
+        #     # Verify the connection actually worked
+        #     if @client&.connected?
+        #         NatsWave.logger.info "✅ Successfully connected to NATS at #{@config.nats_url}"
+        #     else
+        #         NatsWave.logger.error "❌ NATS client created but not connected"
+        #         @client = nil
+        #     end
+        #
+        # rescue => e
+        #     NatsWave.logger.error "❌ Failed to connect to NATS: #{e.message}"
+        #     NatsWave.logger.error "NATS URL: #{@config.nats_url}"
+        #     NatsWave.logger.error "Error class: #{e.class}"
+        #
+        #     @client = nil
+        #
+        #     # Re-raise in development to catch issues early
+        #     if defined?(Rails) && Rails.env.development?
+        #         raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+        #     end
+        # end
+        
         def establish_nats_connection
-            @nats_client = NATS.connect(
-                    @config.nats_url,
+            NatsWave.logger.info "Attempting to connect to NATS at #{@config.nats_url}"
+            
+            # Add more detailed connection options for debugging
+            connection_options = {
                     reconnect_time_wait: @config.retry_delay,
-                    max_reconnect_attempts: @config.reconnect_attempts
-            )
-            NatsWave.logger.info("Connected to NATS at #{@config.nats_url}")
+                    max_reconnect_attempts: @config.reconnect_attempts,
+                    dont_randomize_servers: true,
+                    verbose: true,
+                    pedantic: false
+            }
+            
+            NatsWave.logger.info "Connection options: #{connection_options}"
+            
+            @client = NATS.connect(@config.nats_url, connection_options)
+            
+            # Wait a moment for connection to establish
+            sleep 0.5
+            
+            # Check connection status with more detail
+            if @client
+                NatsWave.logger.info "NATS client created: #{@client.class}"
+                NatsWave.logger.info "NATS client connected?: #{@client.connected?}"
+                NatsWave.logger.info "NATS client status: #{@client.status rescue 'unknown'}"
+                
+                if @client.connected?
+                    NatsWave.logger.info "✅ Successfully connected to NATS at #{@config.nats_url}"
+                else
+                    NatsWave.logger.error "❌ NATS client created but not connected"
+                    NatsWave.logger.error "Client last error: #{@client.last_error rescue 'none'}"
+                    @client = nil
+                end
+            else
+                NatsWave.logger.error "❌ NATS client is nil after connection attempt"
+            end
+        
         rescue => e
-            NatsWave.logger.error("Failed to connect to NATS: #{e.message}")
-            raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+            NatsWave.logger.error "❌ Failed to connect to NATS: #{e.message}"
+            NatsWave.logger.error "Error class: #{e.class}"
+            NatsWave.logger.error "Error backtrace: #{e.backtrace.first(5).join('\n')}"
+            NatsWave.logger.error "NATS URL: #{@config.nats_url}"
+            NatsWave.logger.error "Retry delay: #{@config.retry_delay}"
+            NatsWave.logger.error "Max reconnect attempts: #{@config.reconnect_attempts}"
+            
+            @client = nil
+            
+            # Re-raise in development to catch issues early
+            if defined?(Rails) && Rails.env.development?
+                raise ConnectionError, "Failed to connect to NATS: #{e.message}"
+            end
         end
         
         def ensure_connected!
-            raise ConnectionError, "Not connected to NATS" unless connected?
+            unless connected?
+                error_msg = if @client.nil?
+                                "NATS client is nil - connection failed during initialization"
+                            else
+                                "NATS client exists but not connected (#{@client.class})"
+                            end
+                
+                NatsWave.logger.error "🔴 Connection check failed: #{error_msg}"
+                NatsWave.logger.error "🔧 NATS URL: #{@config.nats_url}"
+                NatsWave.logger.error "🔧 Publishing enabled: #{@config.publishing_enabled}"
+                NatsWave.logger.error "🔧 Subscription enabled: #{@config.subscription_enabled}"
+                
+                raise ConnectionError, error_msg
+            end
         end
         
         def database_connected?
@@ -134,9 +714,38 @@ module NatsWave
         end
         
         def nats_available?
+            # First, try to require the NATS gem if it's not already loaded
+            begin
+                require 'nats/client' unless defined?(NATS)
+            rescue LoadError
+                NatsWave.logger.error "❌ NATS gem not found. Add 'gem \"nats\"' to your Gemfile"
+                return false
+            end
+            
+            # Then check if the NATS constant is defined
             defined?(NATS)
-        rescue LoadError
-            false
+        end
+        
+        def test_nats_connectivity
+            require 'socket'
+            require 'uri'
+            
+            begin
+                uri = URI.parse(@config.nats_url)
+                host = uri.host || 'localhost'
+                port = uri.port || 4222
+                
+                NatsWave.logger.info "Testing TCP connectivity to #{host}:#{port}"
+                
+                socket = TCPSocket.new(host, port)
+                socket.close
+                
+                NatsWave.logger.info "✅ TCP connection to NATS server successful"
+                true
+            rescue => e
+                NatsWave.logger.error "❌ Cannot reach NATS server: #{e.message}"
+                false
+            end
         end
     end
 end