nats_wave 1.1.0

data/lib/nats_wave/adapters/datadog_metrics.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'datadog/statsd'
+
+module NatsWave
+    module Adapters
+        class DatadogMetrics
+            def initialize(config = {})
+                @statsd = Datadog::Statsd.new(
+                        config[:host] || ENV['DD_AGENT_HOST'] || 'localhost',
+                        config[:port] || ENV['DD_AGENT_PORT'] || 8125,
+                        tags: default_tags.merge(config[:tags] || {}),
+                        namespace: config[:namespace] || 'nats_wave'
+                )
+                @service_name = config[:service_name] || 'unknown'
+            end
+            
+            def increment(metric_name, tags: [], value: 1)
+                formatted_tags = format_tags(tags)
+                
+                case metric_name
+                    when 'nats_wave.messages.published'
+                        @statsd.increment('messages.published', value, tags: formatted_tags)
+                    when 'nats_wave.messages.received'
+                        @statsd.increment('messages.received', value, tags: formatted_tags)
+                    when 'nats_wave.messages.failed'
+                        @statsd.increment('messages.failed', value, tags: formatted_tags)
+                    when 'nats_wave.errors'
+                        @statsd.increment('errors', value, tags: formatted_tags)
+                    when 'nats_wave.retries'
+                        @statsd.increment('retries', value, tags: formatted_tags)
+                end
+            end
+            
+            def histogram(metric_name, value, tags: [])
+                formatted_tags = format_tags(tags)
+                
+                case metric_name
+                    when 'nats_wave.processing_time'
+                        @statsd.histogram('processing_time', value, tags: formatted_tags)
+                    when 'nats_wave.message_size'
+                        @statsd.histogram('message_size', value, tags: formatted_tags)
+                    when 'nats_wave.queue_depth'
+                        @statsd.histogram('queue_depth', value, tags: formatted_tags)
+                end
+            end
+            
+            def gauge(metric_name, value, tags: [])
+                formatted_tags = format_tags(tags)
+                
+                case metric_name
+                    when 'nats_wave.connection_status'
+                        @statsd.gauge('connection_status', value, tags: formatted_tags)
+                    when 'nats_wave.subscriber_count'
+                        @statsd.gauge('subscriber_count', value, tags: formatted_tags)
+                    when 'nats_wave.failed_messages_count'
+                        @statsd.gauge('failed_messages_count', value, tags: formatted_tags)
+                end
+            end
+            
+            def timing(metric_name, &block)
+                formatted_tags = format_tags([])
+                
+                case metric_name
+                    when 'nats_wave.operation_time'
+                        @statsd.time('operation_time', tags: formatted_tags, &block)
+                end
+            end
+            
+            def close
+                @statsd.close if @statsd.respond_to?(:close)
+            end
+            
+            private
+            
+            def default_tags
+                {
+                        service: @service_name,
+                        environment: ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'unknown',
+                        version: ENV['APP_VERSION'] || '1.1.0'
+                }
+            end
+            
+            def format_tags(tags)
+                # Convert ["subject:user.create", "status:success"] to ["subject:user.create", "status:success"]
+                # Datadog expects this format
+                Array(tags).map do |tag|
+                    tag.is_a?(String) ? tag : "#{tag[:key]}:#{tag[:value]}"
+                end
+            end
+        end
+    end
+end

data/lib/nats_wave/auto_registration.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module NatsWave
+    class AutoRegistration
+        class << self
+            def register_all_models!
+                return unless defined?(Rails)
+                
+                Rails.logger.info "🔍 Auto-registering NatsWave models..."
+                
+                # Load all models
+                load_all_models
+                
+                # Find models with NatsWave mappings
+                mappable_models = find_mappable_models
+                
+                Rails.logger.info "📋 Found #{mappable_models.size} models with NatsWave mappings"
+                
+                # Register their subscriptions with the client
+                register_model_subscriptions(mappable_models)
+                
+                # Log registration summary
+                log_registration_summary
+            end
+            
+            private
+            
+            def load_all_models
+                # Ensure all models are loaded
+                Rails.application.eager_load! if Rails.env.development?
+                
+                # Also try to load models manually
+                Dir[Rails.root.join('app/models/**/*.rb')].each do |file|
+                    require_dependency file
+                rescue => e
+                    Rails.logger.warn "Could not load model file #{file}: #{e.message}"
+                end
+            end
+            
+            def find_mappable_models
+                models = []
+                
+                ActiveRecord::Base.descendants.each do |model_class|
+                    next unless model_class.respond_to?(:nats_wave_subscribed_subjects)
+                    next if model_class.nats_wave_subscribed_subjects.empty?
+                    
+                    models << model_class
+                end
+                
+                models
+            end
+            
+            def register_model_subscriptions(models)
+                models.each do |model_class|
+                    begin
+                        register_model_subscription(model_class)
+                    rescue => e
+                        Rails.logger.error "Failed to register subscriptions for #{model_class.name}: #{e.message}"
+                    end
+                end
+            end
+            
+            def register_model_subscription(model_class)
+                subjects = model_class.nats_wave_subscribed_subjects
+                return if subjects.empty?
+                
+                Rails.logger.debug "📡 Registering #{model_class.name} subscriptions: #{subjects.join(', ')}"
+                
+                # Register with NATS client
+                NatsWave.client.subscribe(
+                        subjects: subjects,
+                        model_mappings: build_model_mappings_for(model_class)
+                )
+            end
+            
+            def build_model_mappings_for(model_class)
+                mappings = {}
+                
+                model_class.nats_wave_external_models.each do |external_model|
+                    mapping_config = model_class.nats_wave_mapping_for(external_model)
+                    
+                    mappings[external_model] = {
+                            target_model: model_class.name,
+                            field_mappings: mapping_config[:field_mappings] || {},
+                            transformations: mapping_config[:transformations] || {},
+                            conditions: mapping_config[:conditions] || {},
+                            sync_strategy: mapping_config[:sync_strategy] || :upsert,
+                            unique_fields: mapping_config[:unique_fields] || [:id]
+                    }
+                end
+                
+                mappings
+            end
+            
+            def log_registration_summary
+                stats = ModelRegistry.subscription_stats
+                
+                Rails.logger.info "📊 NatsWave Registration Summary:"
+                Rails.logger.info "   Total Subscriptions: #{stats[:total_subscriptions]}"
+                Rails.logger.info "   Unique Subjects: #{stats[:unique_subjects]}"
+                Rails.logger.info "   Models with Subscriptions: #{stats[:models_with_subscriptions]}"
+                
+                stats[:subscription_breakdown].each do |model, count|
+                    Rails.logger.info "   #{model}: #{count} subscription(s)"
+                end
+            end
+        end
+    end
+end

data/lib/nats_wave/client.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module NatsWave
+    class Client
+        attr_reader :config, :publisher, :subscriber, :nats_client
+        
+        def initialize(options = {})
+            @config = Configuration.new(options)
+            @nats_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)
+            ensure_connected!
+            @subscriber.subscribe(
+                    subjects: subjects,
+                    model_mappings: model_mappings,
+                    handler: block
+            )
+        end
+        
+        def start_subscriber
+            ensure_connected!
+            @subscriber.start 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?
+            @nats_client && @nats_client.connected?
+        end
+        
+        def disconnect!
+            @subscriber&.unsubscribe_all
+            @nats_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: 2,
+                    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, @nats_client, @middleware_stack)
+            end
+            
+            if @config.subscription_enabled
+                @subscriber = Subscriber.new(@config, @nats_client, @middleware_stack)
+            end
+        end
+        
+        def establish_nats_connection
+            @nats_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

data/lib/nats_wave/concerns/mappable.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module NatsWave
+    module Concerns
+        module Mappable
+            extend ActiveSupport::Concern
+            
+            included do
+                class_attribute :nats_wave_mapping_config, :nats_wave_subscription_config
+                self.nats_wave_mapping_config = {}
+                self.nats_wave_subscription_config = {}
+            end
+            
+            class_methods do
+                # Configure how this model maps to external models
+                def nats_wave_maps_to(external_models)
+                    self.nats_wave_mapping_config = external_models
+                    
+                    # Register this mapping globally
+                    NatsWave::ModelRegistry.register_mapping(self.name, external_models)
+                end
+                
+                # Configure how external models map to this model AND what subjects to subscribe to
+                def nats_wave_maps_from(external_model, options = {})
+                    mapping = {
+                            field_mappings: options[:field_mappings] || {},
+                            transformations: options[:transformations] || {},
+                            conditions: options[:conditions] || {},
+                            sync_strategy: options[:sync_strategy] || :upsert,
+                            unique_fields: options[:unique_fields] || [:id],
+                            skip_fields: options[:skip_fields] || [],
+                            # NEW: Subscription configuration
+                            subjects: options[:subjects] || [],
+                            handler: options[:handler],
+                            queue_group: options[:queue_group]
+                    }
+                    
+                    self.nats_wave_mapping_config[external_model] = mapping
+                    
+                    # Register this mapping globally
+                    NatsWave::ModelRegistry.register_reverse_mapping(external_model, self.name, mapping)
+                    
+                    # Register subscription if subjects are provided
+                    if mapping[:subjects].any?
+                        NatsWave::ModelRegistry.register_subscription(
+                                subjects: mapping[:subjects],
+                                model: self.name,
+                                external_model: external_model,
+                                handler: mapping[:handler],
+                                queue_group: mapping[:queue_group]
+                        )
+                    end
+                end
+                
+                # Configure subscriptions without model mapping (for custom handlers)
+                def nats_wave_subscribes_to(*subjects, handler: nil, queue_group: nil, &block)
+                    handler ||= block
+                    
+                    subscription_config = {
+                            subjects: subjects.flatten,
+                            handler: handler,
+                            queue_group: queue_group,
+                            model: self.name
+                    }
+                    
+                    self.nats_wave_subscription_config[:custom] = subscription_config
+                    
+                    # Register subscription
+                    NatsWave::ModelRegistry.register_subscription(
+                            subjects: subjects.flatten,
+                            model: self.name,
+                            handler: handler,
+                            queue_group: queue_group
+                    )
+                end
+                
+                # Auto-generate subjects based on external model pattern
+                def nats_wave_auto_subjects_for(external_model, service_prefix: nil, actions: [:create, :update, :destroy])
+                    model_name = external_model.underscore
+                    
+                    if service_prefix
+                        subjects = actions.map { |action| "#{service_prefix}.#{model_name}.#{action}" }
+                        subjects << "#{service_prefix}.#{model_name}.*" # Wildcard for all actions
+                    else
+                        # Try to infer from common patterns
+                        subjects = [
+                                "#{model_name}.*", # Simple pattern
+                                "events.#{model_name}.*", # Events pattern
+                                "*.#{model_name}.*", # Service.model pattern
+                                "*.events.#{model_name}.*" # Service.events.model pattern
+                        ]
+                    end
+                    
+                    subjects
+                end
+                
+                # Get mapping configuration for an external model
+                def nats_wave_mapping_for(external_model)
+                    nats_wave_mapping_config[external_model]
+                end
+                
+                # Check if this model can sync from an external model
+                def nats_wave_can_sync_from?(external_model)
+                    nats_wave_mapping_config.key?(external_model)
+                end
+                
+                # Get all external models this model can sync from
+                def nats_wave_external_models
+                    nats_wave_mapping_config.keys
+                end
+                
+                # Get all subjects this model subscribes to
+                def nats_wave_subscribed_subjects
+                    subjects = []
+                    
+                    # From model mappings
+                    nats_wave_mapping_config.each do |_, config|
+                        subjects.concat(config[:subjects] || [])
+                    end
+                    
+                    # From custom subscriptions
+                    if nats_wave_subscription_config[:custom]
+                        subjects.concat(nats_wave_subscription_config[:custom][:subjects] || [])
+                    end
+                    
+                    subjects.uniq
+                end
+            end
+            
+            # Instance methods remain the same...
+            def nats_wave_mapped_attributes_for(target_model)
+                mapping = self.class.nats_wave_mapping_config[target_model]
+                return attributes unless mapping
+                
+                mapped_attrs = {}
+                field_mappings = mapping[:field_mappings] || {}
+                skip_fields = mapping[:skip_fields] || []
+                
+                attributes.each do |key, value|
+                    next if skip_fields.include?(key.to_s) || skip_fields.include?(key.to_sym)
+                    
+                    mapped_key = field_mappings[key] || field_mappings[key.to_sym] || key
+                    mapped_attrs[mapped_key] = transform_value(value, mapped_key, mapping[:transformations] || {})
+                end
+                
+                mapped_attrs
+            end
+            
+            def nats_wave_unique_identifier_for(external_model)
+                mapping = self.class.nats_wave_mapping_config[external_model]
+                unique_fields = mapping&.dig(:unique_fields) || [:id]
+                
+                unique_fields.map { |field| [field, send(field)] }.to_h
+            end
+            
+            private
+            
+            def transform_value(value, field, transformations)
+                transformation = transformations[field] || transformations[field.to_sym]
+                
+                case transformation
+                    when Proc
+                        transformation.call(value)
+                    when Symbol
+                        send(transformation, value) if respond_to?(transformation, true)
+                    else
+                        value
+                end
+            end
+        end
+    end
+end