nats_wave 1.1.4 → 1.1.7

data/lib/nats_wave/subscriber.rb

@@ -2,48 +2,74 @@
 
 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
-            @middleware_stack = middleware_stack
+            @client = client
             @database_connector = DatabaseConnector.new(config)
             @model_mapper = ModelMapper.new(config)
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config)
-            @subscriptions = []
+            
+            @registry_subscriptions = ModelRegistry.subscriptions
+            @nats_subscriptions = [] # NATS::Subscription objects
             @running = false
+            @shutdown = false
         end
         
-        def start
-            return if @running
+        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}"
             
-            @config.subscriptions.each do |subscription|
-                subscribe_to_subject(subscription[:subject],
-                                     subscription[:handler])
+            # Use ModelRegistry subscriptions
+            @registry_subscriptions.each do |subscription|
+                subscription[:subjects].each do |subject|
+                    subscribe_to_subject(subject, subscription[:handler])
+                end
             end
             
-            NatsWave.logger.info "Subscribed to #{@config.subscriptions.size} subjects"
+            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|
-                subscribe_to_subject(subject, handler,
-                                     model_mappings)
+                subscribe_to_subject(subject, handler, model_mappings)
+                NatsWave.logger.info "Subscribed to #{subject}"
             end
         end
         
-        def unsubscribe_all
-            @subscriptions.each(&:unsubscribe)
-            @subscriptions.clear
+        def reset
+            @shutdown = true
             @running = false
+            
+            # Stop keep alive thread
+            if @keep_alive_thread&.alive?
+                @keep_alive_thread.kill
+                @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
+            
+            NatsWave.logger.info "🛑 Subscriber shutdown complete"
         end
         
         def database_connected?
@@ -51,67 +77,121 @@ module NatsWave
         end
         
         def disconnect
-            unsubscribe_all
+            reset
         end
         
         private
         
         def subscribe_to_subject(subject_pattern, custom_handler = nil, model_mappings = {})
-            NatsWave.logger.info "Subscribing to: #{subject_pattern}"
+            NatsWave.logger.info "🔍 Attempting to subscribe to: #{subject_pattern}"
             
-            subscription = @nats_client.subscribe(
+            # Create the NATS subscription
+            nats_subscription = @client.subscribe(
                     subject_pattern,
                     queue: @config.queue_group
             ) do |msg|
-                process_message(msg,
-                                custom_handler, model_mappings)
+                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
             
-            @subscriptions << subscription
+            # Add to NATS subscriptions array
+            @nats_subscriptions << nats_subscription
+            NatsWave.logger.info "✅ Successfully subscribed to #{subject_pattern} (total: #{@nats_subscriptions.size})"
         end
         
         def process_message(raw_message, custom_handler, model_mappings)
             return unless should_process_message?(raw_message)
             
-            Metrics.track_processing_time(raw_message) do
-                message = parse_message(raw_message)
-                processed_message = apply_middleware(message)
-                
-                if custom_handler
-                    custom_handler.call(processed_message)
-                else
-                    handle_model_sync(
-                            processed_message, model_mappings
-                    )
-                end
+            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')
+            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)
-            # Skip messages from same service instance
-            message = JSON.parse(raw_message)
+        def should_process_message?(raw_message_data)
+            message = JSON.parse(raw_message_data)
             source = message['source'] || {}
             
-            return false if source['service'] == @config.service_name &&
-                    source['instance_id'] == @config.instance_id
+            # 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
+        rescue JSON::ParserError => e
+            NatsWave.logger.error "Failed to parse message for filtering: #{e.message}"
             false
         end
         
-        def parse_message(raw_message)
-            @message_transformer.parse_message(raw_message)
+        def keep_alive
+            Rails.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"
+                        else
+                            Rails.logger.error "❌ Subscriber connection lost! Attempting reconnection..."
+                            attempt_reconnection
+                        end
+                    
+                    rescue => e
+                        Rails.logger.error "Error in keep_alive thread: #{e.message}"
+                        sleep 10
+                    end
+                end
+                
+                Rails.logger.info "🛑 Keep-alive thread shutting down"
+            end
         end
         
-        def apply_middleware(message)
-            @middleware_stack.reduce(message) do |msg, middleware|
-                middleware.call(msg)
+        def attempt_reconnection
+            return if @shutdown
+            
+            NatsWave.logger.info "🔄 Attempting to reconnect to NATS..."
+            
+            # Reset subscriptions
+            @nats_subscriptions.clear
+            
+            # Try to reestablish subscriptions
+            sleep 5 # Wait before reconnecting
+            
+            if @client&.connected?
+                NatsWave.logger.info "✅ NATS reconnected, reestablishing subscriptions"
+                
+                @registry_subscriptions.each do |subscription|
+                    subscription[:subjects].each do |subject|
+                        subscribe_to_subject(subject, subscription[:handler])
+                    end
+                end
             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
         
         def handle_model_sync(message, model_mappings)
@@ -158,4 +238,4 @@ module NatsWave
             # Continue processing - don't raise to avoid breaking subscription
         end
     end
-end
+end

data/lib/nats_wave/version.rb

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

data/lib/nats_wave.rb

@@ -82,8 +82,9 @@ module NatsWave
             client.subscribe(
                     subjects: subjects,
                     model_mappings: model_mappings,
-                    handler: block
+                    &block
             )
+            NatsWave.logger.info "Completely subscribed to #{subjects.size} subjects"
         end
         
         def start_subscriber

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats_wave
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.7
 platform: ruby
 authors:
 - Jeffrey Dabo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-17 00:00:00.000000000 Z
+date: 2025-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nats-pure
@@ -318,9 +318,6 @@ files:
 - README.md
 - Rakefile
 - config/nats_wave.yml
-- examples/catalog_model.rb
-- examples/configuration_examples.rb
-- examples/user_model.rb
 - lib/generators/nats_wave/install_generator.rb
 - lib/generators/nats_wave/templates/README
 - lib/generators/nats_wave/templates/create_nats_wave_failed_messages.rb

data/examples/catalog_model.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-class Catalog < ApplicationRecord
-    include NatsWave::NatsPublishable
-    
-    nats_publishable(
-            actions: %i[create update], # Don't publish deletes
-            skip_attributes: %i[view_count search_vector internal_notes],
-            include_associations: %i[category variants]
-    )
-    
-    # Custom serializer support
-    def self.nats_wave_attribute_transformations
-        {
-                hammer_estimate: ->(value, _action) { value.to_f.round(2) },
-                name: :sanitize_name,
-                description: lambda { |value, _action|
-                    ActionView::Base.full_sanitizer.sanitize(value)
-                }
-        }
-    end
-    
-    private
-    
-    def sanitize_name(name, _action)
-        name&.strip&.titleize
-    end
-    
-    def nats_wave_metadata
-        {
-                organization: organization&.name,
-                make:,
-                catalog_tracked: track_catalog?
-        }
-    end
-end

data/examples/configuration_examples.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-# Basic configuration
-NatsWave.configure do |config|
-    config.nats_url = 'nats://localhost:4222'
-    config.service_name = 'ecommerce_api'
-    config.default_subject_prefix = 'ecommerce.events'
-end
-
-# Advanced configuration with model mappings
-NatsWave.configure do |config|
-    config.nats_url = ENV.fetch('NATS_URL', 'nats://localhost:4222')
-    config.service_name = 'catalog_service'
-    config.environment = Rails.env
-    
-    # Subscribe to other team's events
-    config.add_subscription('warehouse.assets.*')
-    config.add_subscription('external.catalogs.*')
-    config.add_subscription('payments.transactions.*')
-    
-    # Map external models to local models
-    config.add_model_mapping('WarehouseAsset', 'Catalog', {
-            'asset_name' => 'name',
-            'asset_description' => 'description',
-            'asset_value' => 'hammer_estimate',
-            'asset_id' => 'external_icn',
-            'model' => 'category'
-    })
-    
-    config.add_model_mapping('ExternalCatalog', 'Catalog', {
-            'package_name' => 'name',
-            'package_cost' => 'hammer_estimate',
-            'external_vin' => 'vin'
-    })
-    
-    # Custom transformation rules
-    config.transformation_rules = {
-            'hammer_estimate' => ->(value) { value.to_f.round(2) },
-            'name' => ->(value) { value&.titleize },
-            'email' => ->(value) { value&.downcase }
-    }
-    
-    # Custom subscription with handler
-    config.add_subscription('payments.failed.*') do |message|
-        PaymentFailureHandler.process(message)
-    end
-    
-    # Middleware configuration
-    config.middleware_authentication_enabled = Rails.env.production?
-    config.auth_secret_key = ENV['NATS_AUTH_SECRET']
-    config.middleware_validation_enabled = true
-    config.middleware_logging_enabled = true
-    config.log_level = Rails.env.production? ? 'info' : 'debug'
-end
-
-# Catalogion configuration
-if Rails.env.production?
-    NatsWave.configure do |config|
-        config.nats_url = ENV.fetch('NATS_CLUSTER_URL')
-        config.connection_pool_size = 20
-        config.async_publishing = true
-        config.middleware_authentication_enabled = true
-        config.auth_secret_key = ENV.fetch('NATS_AUTH_SECRET')
-        config.schema_registry_url = ENV['SCHEMA_REGISTRY_URL']
-        config.max_retries = 5
-        config.retry_delay = 10
-    end
-end

data/examples/user_model.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-class User < ApplicationRecord
-    include NatsWave::NatsPublishable
-    
-    # Configure NATS publishing
-    nats_publishable(
-            actions: %i[create update destroy],
-            skip_attributes: %i[password_digest remember_token password_reset_token],
-            include_associations: %i[profile organization],
-            subject_prefix: 'users',
-            metadata: { tenant_id: 'main' },
-            if: -> { active? },
-            unless: -> { system_user? }
-    )
-    
-    # Define unique attributes for syncing
-    def self.nats_wave_unique_attributes
-        %i[email external_icn username]
-    end
-    
-    # Define attributes that shouldn't be synced from other instances
-    def self.nats_wave_skip_sync_attributes
-        %i[last_login_at login_count password_digest]
-    end
-    
-    # Custom attribute transformations
-    def self.nats_wave_attribute_transformations
-        {
-                email: ->(value, _action) { value&.downcase&.strip },
-                phone: :format_phone_number
-        }
-    end
-    
-    private
-    
-    # Custom metadata for NATS messages
-    def nats_wave_metadata
-        {
-                tenant_id: organization&.tenant_id,
-                user_type: account_type,
-                subscription_level: subscription&.level
-        }
-    end
-    
-    def format_phone_number(phone, _action)
-        # Custom transformation logic
-        phone&.gsub(/\D/, '')
-    end
-    
-    def active?
-        status == 'active'
-    end
-    
-    def system_user?
-        email&.ends_with?('@system.internal')
-    end
-end