nats_wave 1.1.8 → 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
@@ -337,7 +728,6 @@ module NatsWave
             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

data/lib/nats_wave/version.rb

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

data/lib/nats_wave.rb

@@ -1,3 +1,102 @@
+# # frozen_string_literal: true
+#
+# require 'active_support/all'
+# require 'logger'
+# require 'socket'
+# require 'json'
+# require 'securerandom'
+#
+# require_relative "nats_wave/version"
+# require_relative "nats_wave/errors"
+# require_relative "nats_wave/configuration"
+# require_relative "nats_wave/client"
+# require_relative "nats_wave/publisher"
+# require_relative "nats_wave/subscriber"
+# require_relative "nats_wave/message_transformer"
+# require_relative "nats_wave/model_mapper"
+# require_relative "nats_wave/model_registry"
+# require_relative "nats_wave/concerns/mappable"
+# require_relative "nats_wave/adapters/datadog_metrics"
+# require_relative "nats_wave/database_connector"
+# require_relative "nats_wave/schema_registry"
+# require_relative "nats_wave/dead_letter_queue"
+# require_relative "nats_wave/metrics"
+#
+# # Middleware
+# require_relative "nats_wave/middleware/base"
+# require_relative "nats_wave/middleware/authentication"
+# require_relative "nats_wave/middleware/validation"
+# require_relative "nats_wave/middleware/logging"
+#
+# # Adapters
+# require_relative "nats_wave/adapters/active_record"
+#
+# # Rails integration
+# require_relative "nats_wave/railtie" if defined?(Rails)
+#
+# module NatsWave
+#     class << self
+#         attr_accessor :configuration
+#
+#         def client
+#             @client ||= Client.new
+#         end
+#
+#         def configure
+#             self.configuration ||= Configuration.new
+#             yield(configuration) if block_given?
+#             reset_client!
+#             configuration
+#         end
+#
+#         def reset_client!
+#             @client = nil
+#         end
+#
+#         def logger
+#             @logger ||= begin
+#                             if defined?(Rails) && Rails.logger
+#                                 Rails.logger
+#                             else
+#                                 Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+#                             end
+#                         end
+#         end
+#
+#         def logger=(logger)
+#             @logger = logger
+#         end
+#
+#         # Convenience methods
+#         def publish(subject:, model:, action:, data:, metadata: {})
+#             client.publish(
+#                     subject: subject,
+#                     model: model,
+#                     action: action,
+#                     data: data,
+#                     metadata: metadata
+#             )
+#         end
+#
+#         def subscribe(subjects:, model_mappings: {}, &block)
+#             client.subscribe(
+#                     subjects: subjects,
+#                     model_mappings: model_mappings,
+#                     &block
+#             )
+#             NatsWave.logger.info "Completely subscribed to #{subjects.size} subjects"
+#         end
+#
+#         def start_subscriber
+#             client.start_subscriber
+#         end
+#
+#         def health_check
+#             client.health_check
+#         end
+#     end
+# end
+
 # frozen_string_literal: true
 
 require 'active_support/all'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats_wave
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors:
 - Jeffrey Dabo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-24 00:00:00.000000000 Z
+date: 2025-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nats-pure
@@ -325,12 +325,12 @@ files:
 - lib/generators/nats_wave/templates/initializer.rb
 - lib/generators/nats_wave/templates/nats_wave.yml
 - lib/nats_wave.rb
+- lib/nats_wave/active_record_extension.rb
 - lib/nats_wave/adapters/active_record.rb
 - lib/nats_wave/adapters/datadog_metrics.rb
 - lib/nats_wave/auto_registration.rb
 - lib/nats_wave/client.rb
 - lib/nats_wave/concerns/mappable.rb
-- lib/nats_wave/concerns/publishable.rb
 - lib/nats_wave/configuration.rb
 - lib/nats_wave/database_connector.rb
 - lib/nats_wave/dead_letter_queue.rb