smart_message 0.0.12 → 0.0.16

data/examples/memory/08_custom_logger_demo.rb

@@ -4,7 +4,7 @@
 # Custom Logger Example: Comprehensive Message Logging
 #
 # This example demonstrates how to implement and use custom loggers in the SmartMessage
-# framework. It shows different logging strategies including file logging, structured 
+# framework. It shows different logging strategies including file logging, structured
 # logging, and audit trails for message processing workflows.
 #
 # IMPORTANT: Using the Default Logger or Custom Loggers
@@ -35,12 +35,12 @@
 #   end
 #
 # To create your own custom logger:
-#   1. Create a wrapper class that inherits from SmartMessage::Logger::Base
-#   2. Store the Ruby logger instance in your wrapper
+#   1. Create an adapter class that inherits from SmartMessage::Logger::Base
+#   2. Store the Ruby logger instance in your adapter
 #   3. Implement the SmartMessage logging methods using your Ruby logger
 #
 # To use Rails.logger directly (without the default logger):
-#   1. Create a wrapper that delegates to Rails.logger
+#   1. Create an adapter that delegates to Rails.logger
 #   2. Configure it at the class level: logger SmartMessage::Logger::RailsLogger.new
 #   3. All messages will be logged to your Rails application logs
 
@@ -53,18 +53,18 @@ puts "=== SmartMessage Example: Custom Logger Implementation ==="
 puts
 
 # Custom File Logger Implementation
-# This wrapper shows how to integrate Ruby's standard Logger class with SmartMessage.
+# This adapter shows how to integrate Ruby's standard Logger class with SmartMessage.
 # The same pattern works for Rails.logger, Semantic Logger, or any Ruby logger.
 class SmartMessage::Logger::FileLogger < SmartMessage::Logger::Base
   attr_reader :log_file_path, :logger
-  
+
   def initialize(log_file_path, level: Logger::INFO)
     @log_file_path = log_file_path
-    
+
     # Ensure log directory exists
     log_dir = File.dirname(@log_file_path)
     FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
-    
+
     # This is Ruby's standard Logger class from the 'logger' library
     # You could replace this with Rails.logger or any other logger:
     #   @logger = Rails.logger  # For Rails applications
@@ -76,24 +76,24 @@ class SmartMessage::Logger::FileLogger < SmartMessage::Logger::Base
       "[#{datetime.strftime('%Y-%m-%d %H:%M:%S.%3N')}] #{severity}: #{msg}\n"
     end
   end
-  
+
   # Standard logging methods
   def debug(message = nil, &block)
     @logger.debug(message || block.call)
   end
-  
+
   def info(message = nil, &block)
     @logger.info(message || block.call)
   end
-  
+
   def warn(message = nil, &block)
     @logger.warn(message || block.call)
   end
-  
+
   def error(message = nil, &block)
     @logger.error(message || block.call)
   end
-  
+
   def fatal(message = nil, &block)
     @logger.fatal(message || block.call)
   end
@@ -102,15 +102,15 @@ end
 # Structured JSON Logger Implementation
 class SmartMessage::Logger::JSONLogger < SmartMessage::Logger::Base
   attr_reader :log_file_path
-  
+
   def initialize(log_file_path)
     @log_file_path = log_file_path
-    
+
     # Ensure log directory exists
     log_dir = File.dirname(@log_file_path)
     FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
   end
-  
+
   # Standard logging methods with JSON output
   def debug(message = nil, &block)
     write_log_entry({
@@ -119,7 +119,7 @@ class SmartMessage::Logger::JSONLogger < SmartMessage::Logger::Base
       timestamp: Time.now.iso8601
     })
   end
-  
+
   def info(message = nil, &block)
     write_log_entry({
       level: 'INFO',
@@ -127,7 +127,7 @@ class SmartMessage::Logger::JSONLogger < SmartMessage::Logger::Base
       timestamp: Time.now.iso8601
     })
   end
-  
+
   def warn(message = nil, &block)
     write_log_entry({
       level: 'WARN',
@@ -135,7 +135,7 @@ class SmartMessage::Logger::JSONLogger < SmartMessage::Logger::Base
       timestamp: Time.now.iso8601
     })
   end
-  
+
   def error(message = nil, &block)
     write_log_entry({
       level: 'ERROR',
@@ -143,7 +143,7 @@ class SmartMessage::Logger::JSONLogger < SmartMessage::Logger::Base
       timestamp: Time.now.iso8601
     })
   end
-  
+
   def fatal(message = nil, &block)
     write_log_entry({
       level: 'FATAL',
@@ -151,9 +151,9 @@ class SmartMessage::Logger::JSONLogger < SmartMessage::Logger::Base
       timestamp: Time.now.iso8601
     })
   end
-  
+
   private
-  
+
   def write_log_entry(data)
     File.open(@log_file_path, 'a') do |file|
       file.puts(JSON.generate(data))
@@ -166,56 +166,56 @@ class SmartMessage::Logger::EmojiConsoleLogger < SmartMessage::Logger::Base
   def debug(message = nil, &block)
     puts "🐛 DEBUG: #{message || block&.call}"
   end
-  
+
   def info(message = nil, &block)
     puts "ℹ️  INFO: #{message || block&.call}"
   end
-  
+
   def warn(message = nil, &block)
     puts "⚠️  WARN: #{message || block&.call}"
   end
-  
+
   def error(message = nil, &block)
     puts "❌ ERROR: #{message || block&.call}"
   end
-  
+
   def fatal(message = nil, &block)
     puts "💀 FATAL: #{message || block&.call}"
   end
 end
 
-# Example: Simple Ruby Logger Wrapper
-# This demonstrates the minimal wrapper needed for Ruby's standard Logger.
+# Example: Simple Ruby Logger
+# This demonstrates the minimal adapter needed for Ruby's standard Logger.
 # Use this pattern when you want to integrate with existing logging infrastructure.
-class SmartMessage::Logger::RubyLoggerWrapper < SmartMessage::Logger::Base
+class SmartMessage::Logger::RubyLogger < SmartMessage::Logger::Base
   def initialize(ruby_logger = nil)
     # Accept any Ruby logger instance, or create a default one
     @logger = ruby_logger || Logger.new(STDOUT)
   end
-  
+
   # Standard logging methods that delegate to the Ruby logger
   def debug(message = nil, &block)
     @logger.debug(message, &block)
   end
-  
+
   def info(message = nil, &block)
     @logger.info(message, &block)
   end
-  
+
   def warn(message = nil, &block)
     @logger.warn(message, &block)
   end
-  
+
   def error(message = nil, &block)
     @logger.error(message, &block)
   end
-  
+
   def fatal(message = nil, &block)
     @logger.fatal(message, &block)
   end
 end
 
-# Example: Rails Logger Wrapper (for Rails applications)
+# Example: Rails Logger (for Rails applications)
 # Uncomment and use this in your Rails application
 # class SmartMessage::Logger::RailsLogger < SmartMessage::Logger::Base
 #   def debug(message = nil, &block)
@@ -223,25 +223,25 @@ end
 #       Rails.logger.debug(message || block&.call)
 #     end
 #   end
-#   
+#
 #   def info(message = nil, &block)
 #     Rails.logger.tagged('SmartMessage') do
 #       Rails.logger.info(message || block&.call)
 #     end
 #   end
-#   
+#
 #   def warn(message = nil, &block)
 #     Rails.logger.tagged('SmartMessage') do
 #       Rails.logger.warn(message || block&.call)
 #     end
 #   end
-#   
+#
 #   def error(message = nil, &block)
 #     Rails.logger.tagged('SmartMessage') do
 #       Rails.logger.error(message || block&.call)
 #     end
 #   end
-#   
+#
 #   def fatal(message = nil, &block)
 #     Rails.logger.tagged('SmartMessage') do
 #       Rails.logger.fatal(message || block&.call)
@@ -254,23 +254,23 @@ class SmartMessage::Logger::MultiLogger < SmartMessage::Logger::Base
   def initialize(*loggers)
     @loggers = loggers
   end
-  
+
   def debug(message = nil, &block)
     @loggers.each { |logger| logger.debug(message, &block) }
   end
-  
+
   def info(message = nil, &block)
     @loggers.each { |logger| logger.info(message, &block) }
   end
-  
+
   def warn(message = nil, &block)
     @loggers.each { |logger| logger.warn(message, &block) }
   end
-  
+
   def error(message = nil, &block)
     @loggers.each { |logger| logger.error(message, &block) }
   end
-  
+
   def fatal(message = nil, &block)
     @loggers.each { |logger| logger.fatal(message, &block) }
   end
@@ -279,51 +279,50 @@ end
 # Sample message class with comprehensive logging
 class OrderProcessingMessage < SmartMessage::Base
   description "Order processing messages with comprehensive multi-logger configuration"
-  
-  property :order_id, 
+
+  property :order_id,
     description: "Unique identifier for the customer order"
-  property :customer_id, 
+  property :customer_id,
     description: "Identifier of the customer placing the order"
-  property :amount, 
+  property :amount,
     description: "Total monetary amount of the order"
-  property :status, 
+  property :status,
     description: "Current processing status of the order"
-  property :items, 
+  property :items,
     description: "Array of items included in the order"
-  
+
   config do
-    transport SmartMessage::Transport::StdoutTransport.new(loopback: true)
-    serializer SmartMessage::Serializer::Json.new
-    
+    transport SmartMessage::Transport::MemoryTransport.new
+
     # Configure multi-logger to demonstrate different logging approaches
     logger SmartMessage::Logger::MultiLogger.new(
       SmartMessage::Logger::EmojiConsoleLogger.new,
-      SmartMessage::Logger::FileLogger.new('logs/order_processing.log', level: Logger::DEBUG),
-      SmartMessage::Logger::JSONLogger.new('logs/order_processing.json')
+      SmartMessage::Logger::FileLogger.new('log/order_processing.log', level: Logger::DEBUG),
+      SmartMessage::Logger::JSONLogger.new('log/order_processing.json')
     )
   end
-  
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
+
+  def process(message)
+    message_header, message_payload = message
     # Simulate the logger being called during processing
     if logger
       logger.info { "[SmartMessage] Received: #{self.name} (#{message_payload.bytesize} bytes)" }
     end
-    
+
     # Process the message
     order_data = JSON.parse(message_payload)
     result = "Order #{order_data['order_id']} processed successfully"
-    
+
     puts "💼 OrderProcessing: #{result}"
-    
+
     # Log processing completion
     if logger
       logger.info { "[SmartMessage] Processed: #{self.name} - #{result}" }
     end
-    
+
     result
   end
-  
+
   # Override publish to demonstrate logging hooks
   def publish
     # Log message creation
@@ -331,13 +330,13 @@ class OrderProcessingMessage < SmartMessage::Base
     if logger_instance
       logger_instance.debug { "[SmartMessage] Created: #{self.class.name}" }
     end
-    
+
     # Log publishing
     transport_instance = transport || self.class.transport
     if logger_instance
       logger_instance.info { "[SmartMessage] Published: #{self.class.name} via #{transport_instance.class.name.split('::').last}" }
     end
-    
+
     # Call original publish method
     super
   rescue => error
@@ -352,39 +351,38 @@ end
 # Notification message with different logger configuration
 class NotificationMessage < SmartMessage::Base
   description "User notifications with file-based logging configuration"
-  
-  property :recipient, 
+
+  property :recipient,
     description: "Target recipient for the notification"
-  property :subject, 
+  property :subject,
     description: "Subject line or title of the notification"
-  property :body, 
+  property :body,
     description: "Main content body of the notification"
-  property :priority, 
+  property :priority,
     description: "Priority level of the notification (low, normal, high, urgent)"
-  
+
   config do
-    transport SmartMessage::Transport::StdoutTransport.new(loopback: true)
-    serializer SmartMessage::Serializer::Json.new
-    
+    transport SmartMessage::Transport::MemoryTransport.new
+
     # Use only file logger for notifications
-    logger SmartMessage::Logger::FileLogger.new('logs/notifications.log', level: Logger::WARN)
+    logger SmartMessage::Logger::FileLogger.new('log/notifications.log', level: Logger::WARN)
   end
-  
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
+
+  def process(message)
+    message_header, message_payload = message
     if logger
       logger.info { "[SmartMessage] Received: #{self.name} (#{message_payload.bytesize} bytes)" }
     end
-    
+
     notification_data = JSON.parse(message_payload)
     result = "Notification sent to #{notification_data['recipient']}"
-    
+
     puts "📬 Notification: #{result}"
-    
+
     if logger
       logger.info { "[SmartMessage] Processed: #{self.name} - #{result}" }
     end
-    
+
     result
   end
 end
@@ -393,35 +391,34 @@ end
 # This demonstrates how to use Ruby's standard Logger in production code
 class StandardLoggerMessage < SmartMessage::Base
   description "Demonstrates integration with standard Ruby Logger for production logging"
-  
-  property :content, 
+
+  property :content,
     description: "Main content of the message to be logged"
-  property :level, 
+  property :level,
     description: "Logging level for the message (debug, info, warn, error)"
-  
+
   config do
-    transport SmartMessage::Transport::StdoutTransport.new(loopback: true)
-    serializer SmartMessage::Serializer::Json.new
-    
+    transport SmartMessage::Transport::MemoryTransport.new
+
     # Example 1: Using Ruby's standard Logger directly
     # Create a standard Ruby logger that logs to STDOUT
     ruby_logger = Logger.new(STDOUT)
     ruby_logger.level = Logger::INFO
     ruby_logger.progname = 'SmartMessage'
-    
+
     # Wrap it in our adapter
-    logger SmartMessage::Logger::RubyLoggerWrapper.new(ruby_logger)
-    
+    logger SmartMessage::Logger::RubyLogger.new(ruby_logger)
+
     # Example 2: Using a file-based Ruby logger (commented out)
     # file_logger = Logger.new('application.log', 'daily')  # Rotate daily
-    # logger SmartMessage::Logger::RubyLoggerWrapper.new(file_logger)
-    
+    # logger SmartMessage::Logger::RubyLogger.new(file_logger)
+
     # Example 3: In Rails, you would use Rails.logger (commented out)
-    # logger SmartMessage::Logger::RubyLoggerWrapper.new(Rails.logger)
+    # logger SmartMessage::Logger::RubyLogger.new(Rails.logger)
   end
-  
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
+
+  def process(message)
+    message_header, message_payload = message
     data = JSON.parse(message_payload)
     puts "📝 Processing: #{data['content']}"
     "Processed"
@@ -431,22 +428,21 @@ end
 # Example: Message using the built-in Default Logger
 class DefaultLoggerMessage < SmartMessage::Base
   description "Demonstrates SmartMessage's built-in default logger with auto-detection"
-  
-  property :message, 
+
+  property :message,
     description: "The message content to be logged using default logger"
-  property :level, 
+  property :level,
     description: "Log level (debug, info, warn, error, fatal)"
-  
+
   config do
-    transport SmartMessage::Transport::StdoutTransport.new(loopback: true)
-    serializer SmartMessage::Serializer::Json.new
-    
+    transport SmartMessage::Transport::MemoryTransport.new
+
     # Use the built-in default logger - simplest option!
     logger SmartMessage::Logger::Default.new
   end
-  
-  def self.process(wrapper)
-    message_header, message_payload = wrapper.split
+
+  def process(message)
+    message_header, message_payload = message
     data = JSON.parse(message_payload)
     puts "🎯 DefaultLogger: Processing #{data['message']}"
     "Processed with default logger"
@@ -457,19 +453,19 @@ end
 class PriorityOrderService
   def initialize
     puts "🚀 PriorityOrderService: Starting with custom logger..."
-    
+
     # Create a priority-specific logger
     @priority_logger = SmartMessage::Logger::FileLogger.new(
-      'logs/priority_orders.log', 
+      'log/priority_orders.log',
       level: Logger::DEBUG
     )
   end
-  
+
   def process_priority_order(order_data)
     # Use class-level logger override for this specific processing
     original_logger = OrderProcessingMessage.logger
     OrderProcessingMessage.logger(@priority_logger)
-    
+
     begin
       message = OrderProcessingMessage.new(**order_data, from: 'PriorityOrderService')
       puts "⚡ Processing priority order with dedicated logger"
@@ -486,22 +482,22 @@ end
 class LoggerDemo
   def run
     puts "🚀 Starting Custom Logger Demo\n"
-    
+
     # Clean up any existing log files for a fresh demo
     FileUtils.rm_rf('logs') if Dir.exist?('logs')
-    
+
     # Subscribe to messages
     OrderProcessingMessage.subscribe
     NotificationMessage.subscribe
-    
+
     puts "\n" + "="*70
     puts "Demonstrating Different Logger Configurations"
     puts "="*70
-    
+
     # Demo 1: Using the built-in Default Logger (NEW!)
     puts "\n--- Demo 1: Using SmartMessage Default Logger ---"
     puts "The Default logger automatically uses Rails.logger or Ruby Logger"
-    
+
     # Use the DefaultLoggerMessage class defined above
     DefaultLoggerMessage.subscribe
     default_msg = DefaultLoggerMessage.new(
@@ -511,7 +507,7 @@ class LoggerDemo
     )
     default_msg.publish
     sleep(0.5)
-    
+
     # Demo 2: Standard order with multi-logger
     puts "\n--- Demo 2: Standard Order (Multi-Logger) ---"
     order1 = OrderProcessingMessage.new(
@@ -524,7 +520,7 @@ class LoggerDemo
     )
     order1.publish
     sleep(0.5)
-    
+
     # Demo 3: Notification with file-only logger
     puts "\n--- Demo 3: Notification (File Logger Only) ---"
     notification = NotificationMessage.new(
@@ -536,7 +532,7 @@ class LoggerDemo
     )
     notification.publish
     sleep(0.5)
-    
+
     # Demo 4: Priority order with instance-level logger override
     puts "\n--- Demo 4: Priority Order (Instance Logger Override) ---"
     priority_service = PriorityOrderService.new
@@ -549,27 +545,27 @@ class LoggerDemo
       from: 'PriorityOrderService'
     )
     sleep(0.5)
-    
+
     # Demo 5: Using standard Ruby logger
     puts "\n--- Demo 5: Using Standard Ruby Logger ---"
-    
+
     # Use the StandardLoggerMessage class that demonstrates Ruby's standard logger
     StandardLoggerMessage.subscribe
-    
+
     # Create and send a message - watch for the Ruby logger output
     msg = StandardLoggerMessage.new(
       content: "Testing with Ruby's standard logger",
       level: "info",
       from: 'LoggerDemo'
     )
-    
+
     # The logger will output to STDOUT using Ruby's standard format
     msg.publish
     sleep(0.5)
-    
+
     puts "\nNote: The above used Ruby's standard Logger class wrapped for SmartMessage"
     puts "You can use ANY Ruby logger this way: Logger.new, Rails.logger, etc."
-    
+
     # Demo 6: Error handling with logging
     puts "\n--- Demo 6: Error Handling with Logging ---"
     begin
@@ -581,24 +577,24 @@ class LoggerDemo
         status: "error_demo",
         from: 'LoggerDemo'
       )
-      
+
       # Simulate an error during processing
       if OrderProcessingMessage.logger
         error = StandardError.new("Invalid order data provided")
         OrderProcessingMessage.logger.error { "[SmartMessage] Error: Simulated error for demo - #{error.class.name}: #{error.message}" }
       end
-      
+
     rescue => error
       puts "🔍 Caught demonstration error: #{error.message}"
     end
-    
+
     # Show log file contents
     puts "\n" + "="*70
     puts "📋 Log File Contents"
     puts "="*70
-    
+
     show_log_contents
-    
+
     puts "\n✨ Demo completed!"
     puts "\nThis example demonstrated:"
     puts "• SmartMessage::Logger::Default - Built-in logger that auto-detects Rails/Ruby"
@@ -612,18 +608,18 @@ class LoggerDemo
     puts "\nKEY TAKEAWAY: Use SmartMessage::Logger::Default.new for instant logging!"
     puts "It automatically uses Rails.logger in Rails or creates a Ruby Logger otherwise."
   end
-  
+
   private
-  
+
   def show_log_contents
-    log_files = Dir.glob('logs/*.log') + Dir.glob('logs/*.json')
-    
+    log_files = Dir.glob('log/*.log') + Dir.glob('log/*.json')
+
     log_files.each do |log_file|
       next unless File.exist?(log_file)
-      
+
       puts "\n📁 #{log_file}:"
       puts "-" * 50
-      
+
       content = File.read(log_file)
       if content.length > 500
         puts content[0..500] + "\n... (truncated, #{content.length} total characters)"
@@ -631,7 +627,7 @@ class LoggerDemo
         puts content
       end
     end
-    
+
     if log_files.empty?
       puts "⚠️  No log files found (they may not have been created yet)"
     end
@@ -642,4 +638,4 @@ end
 if __FILE__ == $0
   demo = LoggerDemo.new
   demo.run
-end
+end