nats_wave 1.1.4 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bfb2eac0b9830d1f8dc6d13b2393760070b2736255d79625c650c11bda480f3
-  data.tar.gz: 391d0c565b7cb0e3000d36820558ac538db59f4ba6199b23dc1c5e6248d4952a
+  metadata.gz: 87bd7c130badc871675b1dee2a91bafc98c8d0f64c16fe114a6a4bb6b97387e3
+  data.tar.gz: 0e2ff399e1b408d64d832488f3a2c73316e58216ca4deda02282cde3de223134
 SHA512:
-  metadata.gz: 5e9cf9c585178821e015b57661ecee82b87d97672b0abeb72df096fcb00764ebc2d4f249c66fcdb183347f27b0d9b15de9bc7c01d804d61257bc9c51467e7d7e
-  data.tar.gz: 6be91c8236c2c23236408d0a3400516db0f8f5bd4d80b843a181a9d449dd75a64b2bf4a5d9ea851df7bdbf7cbb9a03deefc67fb7c32dae8cd3d0b9843c505384
+  metadata.gz: 01400fba320e5d11427dc593f6f15730627137c84aa4b320ddcd1a6dda5bb33f0257c46d5fd64455f0c205c74321bcbc5190759722fb52e8f606c1bb28283800
+  data.tar.gz: 33795a3661cfd98b0c24e68f0c95164e4b79c838822c3f345e66c03b3702c867e40f39bba29d9515d65d0b3de4780d3e3561d0dd3fedc35d746a7b482b1c9e19

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nats_wave (1.1.4)
+    nats_wave (1.1.5)
       activerecord (>= 6.1, < 8.0)
       activesupport (>= 6.1, < 8.0)
       concurrent-ruby (~> 1.1)

data/lib/generators/nats_wave/templates/initializer.rb

@@ -1,64 +1,56 @@
 # frozen_string_literal: true
-#
-NatsWave.configure do |config|
-    # Basic configuration
-    config.nats_url = ENV.fetch('NATS_URL', 'nats://localhost:4222')
-    config.service_name = ENV.fetch('NATS_SERVICE_NAME',
-                                    Rails.application.class.name.deconstantize.underscore)
-    config.environment = Rails.env
-    
-    # Publishing configuration
-    config.default_subject_prefix = "#{config.service_name}.events"
-    config.publishing_enabled = true
-    config.async_publishing = true
-    
-    # Subscription configuration
-    config.subscription_enabled = true
-    config.queue_group = "#{config.service_name}_consumers"
-    
-    # Model mappings (example)
-    # config.add_model_mapping('ExternalAsset', 'Catalog', {
-    #   'name' => 'title',
-    #   'description' => 'body',
-    #   'hammer_estimate' => 'cost'
-    # })
-    
-    # Subscriptions (example)
-    config.add_subscription('external.assets.*')
-    config.add_subscription('catalog.items.*')
-    
-    # Custom subscription with handler
-    # config.add_subscription('webhooks.external.*') do |message|
-    #   WebhookProcessor.process(message)
-    # end
-    
-    # Middleware
-    config.middleware_logging_enabled = true
-    config.log_level = Rails.env.production? ? 'info' : 'debug'
-    
-    # Authentication (optional)
-    # config.middleware_authentication_enabled = true
-    # config.auth_secret_key = ENV['NATS_AUTH_SECRET']
+
+begin
+    Rails.logger.info "Initializing NATS Wave with URL: #{ENV['NATS_URL']}"
+    
+    NatsWave.configure do |config|
+        config.nats_url = ENV.fetch('NATS_URL', 'nats://localhost:4222')
+        config.service_name = ENV.fetch('NATS_SERVICE_NAME',
+                                 Rails.application.class.name.deconstantize.underscore)
+        config.connection_pool_size = 10
+        config.reconnect_attempts = 3
+        
+        Rails.logger.info "NATS URL: #{config.nats_url}"
+        Rails.logger.info "Service Name: #{config.service_name}"
+        
+        # Publishing
+        config.publishing_enabled = !Rails.env.test?
+        config.async_publishing = Rails.env.production?
+        config.default_subject_prefix = config.service_name
+        
+        # Subscription
+        config.subscription_enabled = !Rails.env.test?
+        config.queue_group = "#{config.service_name}_consumers"
+        
+        # Error Handling
+        config.max_retries = 3
+        config.retry_delay = 5
+        config.dead_letter_queue = "failed_messages"
+        
+        # Authentication (optional)
+        # config.middleware_authentication_enabled = true
+        # config.auth_secret_key = ENV['NATS_AUTH_SECRET']
+        
+        # Validation (optional)
+        # config.middleware_validation_enabled = true
+        # config.schema_registry_url = ENV['SCHEMA_REGISTRY_URL']
+    end
     
-    # Validation (optional)
-    # config.middleware_validation_enabled = true
-    # config.schema_registry_url = ENV['SCHEMA_REGISTRY_URL']
+    Rails.logger.info "NATS Wave configuration completed successfully"
+rescue => e
+    Rails.logger.error "Failed to configure NATS Wave: #{e.message}"
+    Rails.logger.error e.backtrace.join("\n")
 end
 
-# Configure metrics backend if available
-NatsWave::Metrics.metrics_backend = StatsD if defined?(StatsD)
-
-# Auto-start subscriber in development
-if Rails.env.development?
-    Rails.application.config.after_initialize do
-        Thread.new do
-            sleep 2 # Give Rails time to boot
-            begin
-                NatsWave.start_subscriber
-                Rails.logger.info 'NatsWave subscriber started automatically'
-            rescue StandardError => e
-                Rails.logger.error "Failed to start NatsWave subscriber: #{e.message}"
-            end
+Rails.application.config.after_initialize do
+    Thread.new do
+        sleep 2 # Give Rails time to boot
+        begin
+            NatsWave.start_subscriber
+            Rails.logger.info "✅ NatsWave subscriber started successfully"
+        rescue StandardError => e
+            Rails.logger.error "Failed to start NatsWave subscriber: #{e.message}"
+            Rails.logger.error e.backtrace.join("\n")
         end
     end
-end
+end

data/lib/nats_wave/adapters/datadog_metrics.rb

@@ -77,7 +77,7 @@ module NatsWave
                 {
                         service: @service_name,
                         environment: ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown',
-                        version: ENV['APP_VERSION'] || '1.1.4'
+                        version: ENV['APP_VERSION'] || '1.1.5'
                 }
             end
             

data/lib/nats_wave/client.rb

@@ -37,7 +37,7 @@ module NatsWave
             @subscriber.subscribe(
                     subjects: subjects,
                     model_mappings: model_mappings,
-                    handler: block
+                    &block
             )
         end
         

data/lib/nats_wave/configuration.rb

@@ -16,9 +16,9 @@ module NatsWave
                       :subscriptions, :publications
         
         def initialize(options = {})
-            @nats_url = ENV['NATS_URL']
-            @service_name = ENV['NATS_NATS_SERVICE_NAME']
-            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.4"
+            @nats_url = ENV['NATS_URL'] || "nats://localhost:4222"
+            @service_name = ENV['NATS_SERVICE_NAME'] || "purplewave"
+            @version = ENV['NATS_SERVICE_VERSION'] || "1.1.5"
             @instance_id = ENV['NATS_INSTANCE_ID'] || Socket.gethostname
             @database_url = ENV['NATS_DATABASE_URL'] || nil
             @connection_pool_size = (ENV['NATS_CONNECTION_POOL_SIZE'] || 10).to_i
@@ -80,6 +80,7 @@ module NatsWave
         
         def nats_server_url
             # This is the URL other teams can use to subscribe to your events
+            return nil if @nats_url.nil?
             uri = URI.parse(@nats_url)
             "#{uri.scheme}://#{uri.host}:#{uri.port}"
         end

data/lib/nats_wave/publisher.rb

@@ -44,10 +44,9 @@ module NatsWave
     class Publisher
         attr_reader :config, :nats_client
         
-        def initialize(config, nats_client, middleware_stack)
+        def initialize(config, nats_client, middleware_stack = [])
             @config = config
             @nats_client = nats_client
-            @middleware_stack = middleware_stack
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config) if config.dead_letter_queue
         end
@@ -56,17 +55,15 @@ module NatsWave
             return unless @config.publishing_enabled
             
             message = build_message(subject, model, action, data, metadata)
-            processed_message = apply_middleware(message)
             full_subject = build_full_subject(subject)
             
             if @config.async_publishing && defined?(Concurrent)
-                publish_async(full_subject, processed_message)
+                publish_async(full_subject, message)
             else
-                publish_sync(full_subject, processed_message)
+                publish_sync(full_subject, message)
             end
             
-            Metrics.increment_published_messages(full_subject)
-            NatsWave.logger.debug("Published message to #{full_subject}")
+            # Metrics.increment_published_messages(full_subject)
         rescue => e
             NatsWave.logger.error("Failed to publish message: #{e.message}")
             @dead_letter_queue&.store_failed_message(message, e, 0)
@@ -81,12 +78,11 @@ module NatsWave
                     source: build_source_info
             }
             
-            processed_message = apply_middleware(batch_message)
             subject = "#{@config.default_subject_prefix}.batch"
             
-            @nats_client.publish(subject, processed_message.to_json)
+            @nats_client.publish(subject, batch_message.to_json)
             
-            Metrics.increment_published_messages(subject)
+            # Metrics.increment_published_messages(subject)
             NatsWave.logger.info("Published batch with #{events.size} events")
         end
         
@@ -128,20 +124,16 @@ module NatsWave
             end
         end
         
-        def apply_middleware(message)
-            @middleware_stack.reduce(message) do |msg, middleware|
-                middleware.call(msg)
-            end
-        end
-        
         def publish_sync(subject, message)
             @nats_client.publish(subject, message.to_json)
+            NatsWave.logger.debug("Published sync message to #{subject}")
         end
         
         def publish_async(subject, message)
             if defined?(Concurrent)
                 Concurrent::Future.execute do
                     @nats_client.publish(subject, message.to_json)
+                    NatsWave.logger.debug("Published async message to #{subject}")
                 end
             else
                 publish_sync(subject, message)

data/lib/nats_wave/railtie.rb

@@ -20,7 +20,9 @@ module NatsWave
             config_file = Rails.root.join('config', 'nats_wave.yml')
             if File.exist?(config_file)
                 begin
-                    yaml_config = YAML.load_file(config_file)[Rails.env]
+                    erb_content = ERB.new(File.read(config_file)).result
+                    yaml_data = YAML.safe_load(erb_content)
+                    yaml_config = yaml_data&.dig(Rails.env.to_s) || yaml_data&.dig(Rails.env) || {}
                     
                     NatsWave.configure do |config|
                         # NATS Configuration
@@ -95,11 +97,10 @@ module NatsWave
             Rails.application.config.after_initialize do
                 if NatsWave.configuration&.publishing_enabled || NatsWave.configuration&.subscription_enabled
                     Thread.new do
-                        sleep 1 # Give Rails time to fully boot
+                        sleep 2 # Give Rails time to fully boot
                         begin
                             NatsWave.client
                             NatsWave.logger.info "NatsWave client initialized"
-                            NatsWave.logger.info "NATS URL #{@nats_url}"
                         rescue => e
                             NatsWave.logger.error "Failed to initialize NatsWave client: #{e.message}"
                         end

data/lib/nats_wave/subscriber.rb

@@ -4,15 +4,17 @@ module NatsWave
     class Subscriber
         attr_reader :config, :nats_client
         
-        def initialize(config, nats_client, middleware_stack)
+        def initialize(config, nats_client, middleware_stack = [])
             @config = config
             @nats_client = nats_client
-            @middleware_stack = middleware_stack
             @database_connector = DatabaseConnector.new(config)
             @model_mapper = ModelMapper.new(config)
             @message_transformer = MessageTransformer.new(config)
             @dead_letter_queue = DeadLetterQueue.new(config)
-            @subscriptions = []
+            
+            # Separate the two types of subscriptions
+            @registry_subscriptions = ModelRegistry.subscriptions  # Hash objects
+            @nats_subscriptions = []                               # NATS::Subscription objects
             @running = false
         end
         
@@ -23,26 +25,29 @@ module NatsWave
             @running = true
             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 ModelRegistry"
         end
         
         def subscribe(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
+            # Unsubscribe from NATS subscriptions (the actual NATS::Subscription objects)
+            @nats_subscriptions.each(&:unsubscribe)
+            @nats_subscriptions.clear
             @running = false
         end
         
@@ -57,33 +62,29 @@ module NatsWave
         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 = @nats_client.subscribe(
                     subject_pattern,
                     queue: @config.queue_group
             ) do |msg|
-                process_message(msg,
-                                custom_handler, model_mappings)
+                NatsWave.logger.info "📨 Received message on #{msg.subject}: #{msg.data}"
+                process_message(msg.data, custom_handler, model_mappings)
             end
             
-            @subscriptions << subscription
+            # 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})"
         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
+            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')
@@ -91,29 +92,10 @@ module NatsWave
             handle_error(e, raw_message, message)
         end
         
-        def should_process_message?(raw_message)
-            # Skip messages from same service instance
-            message = JSON.parse(raw_message)
-            source = message['source'] || {}
-            
-            return false if source['service'] == @config.service_name &&
-                    source['instance_id'] == @config.instance_id
-            
-            true
-        rescue JSON::ParserError
-            false
-        end
-        
         def parse_message(raw_message)
             @message_transformer.parse_message(raw_message)
         end
         
-        def apply_middleware(message)
-            @middleware_stack.reduce(message) do |msg, middleware|
-                middleware.call(msg)
-            end
-        end
-        
         def handle_model_sync(message, model_mappings)
             source_model = message['model']
             mapping = model_mappings[source_model] || @config.model_mappings[source_model]
@@ -158,4 +140,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.5'
 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.5
 platform: ruby
 authors:
 - Jeffrey Dabo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-17 00:00:00.000000000 Z
+date: 2025-07-18 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