smart_message 0.0.2 → 0.0.4

data/docs/transports.md

@@ -125,6 +125,194 @@ messages.each do |msg|
 end
 ```
 
+### Redis Transport
+
+Production-ready Redis pub/sub transport for distributed messaging.
+
+**Features:**
+- Redis pub/sub messaging
+- Automatic channel management using message class names
+- Thread-safe subscriber management
+- Connection resilience with automatic reconnection
+- Configurable connection parameters
+- Background message subscription threads
+
+**Usage:**
+
+```ruby
+# Basic Redis configuration
+transport = SmartMessage::Transport.create(:redis, 
+  url: 'redis://localhost:6379',
+  db: 0
+)
+
+# Production configuration with custom options
+transport = SmartMessage::Transport.create(:redis,
+  url: 'redis://prod-redis:6379',
+  db: 1,
+  auto_subscribe: true,
+  reconnect_attempts: 5,
+  reconnect_delay: 2
+)
+
+# Configure in message class
+class OrderMessage < SmartMessage::Base
+  property :order_id
+  property :customer_id
+  property :amount
+  
+  config do
+    transport SmartMessage::Transport.create(:redis, 
+      url: 'redis://localhost:6379',
+      db: 1
+    )
+    serializer SmartMessage::Serializer::JSON.new
+  end
+  
+  def self.process(message_header, message_payload)
+    order_data = JSON.parse(message_payload)
+    order = new(order_data)
+    puts "Processing order #{order.order_id} for $#{order.amount}"
+    # Your business logic here
+  end
+end
+
+# Subscribe to messages (creates Redis subscription to "OrderMessage" channel)
+OrderMessage.subscribe
+
+# Publish messages (publishes to "OrderMessage" Redis channel)
+order = OrderMessage.new(
+  order_id: "ORD-123",
+  customer_id: "CUST-456", 
+  amount: 99.99
+)
+order.publish
+```
+
+**Options:**
+- `url` (String): Redis connection URL (default: 'redis://localhost:6379')
+- `db` (Integer): Redis database number (default: 0)
+- `auto_subscribe` (Boolean): Automatically start subscriber thread (default: true)
+- `reconnect_attempts` (Integer): Number of reconnection attempts (default: 5)
+- `reconnect_delay` (Integer): Delay between reconnection attempts in seconds (default: 1)
+- `debug` (Boolean): Enable debug output (default: false)
+
+**Channel Naming:**
+
+The Redis transport uses the message class name as the Redis channel name. This provides automatic routing:
+
+```ruby
+class UserMessage < SmartMessage::Base
+  # Messages published to/from Redis channel "UserMessage"
+end
+
+class AdminMessage < SmartMessage::Base  
+  # Messages published to/from Redis channel "AdminMessage"
+end
+
+class OrderProcessing::PaymentMessage < SmartMessage::Base
+  # Messages published to/from Redis channel "OrderProcessing::PaymentMessage"
+end
+```
+
+**Connection Management:**
+
+```ruby
+transport = SmartMessage::Transport.create(:redis, url: 'redis://localhost:6379')
+
+# Check connection status
+puts transport.connected?  # => true/false
+
+# Manual connection management
+transport.connect
+transport.disconnect
+
+# The transport automatically reconnects on connection failures
+```
+
+**Multi-Message Type Support:**
+
+```ruby
+# Different message types can share the same Redis transport
+redis_transport = SmartMessage::Transport.create(:redis, 
+  url: 'redis://localhost:6379',
+  auto_subscribe: true
+)
+
+# Configure multiple message classes to use the same transport
+[OrderMessage, PaymentMessage, ShippingMessage].each do |msg_class|
+  msg_class.config do
+    transport redis_transport
+    serializer SmartMessage::Serializer::JSON.new
+  end
+  
+  # Subscribe to each message type (creates separate Redis subscriptions)
+  msg_class.subscribe
+end
+
+# Publishing to any message type routes to its specific Redis channel
+OrderMessage.new(order_id: "123").publish      # -> "OrderMessage" channel
+PaymentMessage.new(amount: 50.0).publish       # -> "PaymentMessage" channel
+ShippingMessage.new(tracking: "ABC").publish   # -> "ShippingMessage" channel
+```
+
+**Error Handling and Resilience:**
+
+The Redis transport includes built-in error handling:
+
+```ruby
+# Automatic reconnection on connection failures
+transport = SmartMessage::Transport.create(:redis,
+  url: 'redis://localhost:6379',
+  reconnect_attempts: 5,    # Try 5 times to reconnect
+  reconnect_delay: 2        # Wait 2 seconds between attempts
+)
+
+# Connection failures during publishing will trigger automatic retry
+# If all reconnection attempts fail, the original error is raised
+```
+
+**Production Deployment:**
+
+```ruby
+# Production Redis configuration
+class ProductionMessage < SmartMessage::Base
+  config do
+    transport SmartMessage::Transport.create(:redis,
+      url: ENV['REDIS_URL'] || 'redis://localhost:6379',
+      db: ENV['REDIS_DB']&.to_i || 0,
+      auto_subscribe: true,
+      reconnect_attempts: 10,
+      reconnect_delay: 5
+    )
+    serializer SmartMessage::Serializer::JSON.new
+    logger Logger.new(STDOUT)
+  end
+end
+```
+
+**Testing with Redis:**
+
+```ruby
+# Test configuration (using separate Redis database)
+class TestMessage < SmartMessage::Base
+  config do
+    transport SmartMessage::Transport.create(:redis,
+      url: 'redis://localhost:6379',
+      db: 15,  # Use separate database for tests
+      auto_subscribe: true
+    )
+    serializer SmartMessage::Serializer::JSON.new
+  end
+end
+
+# In your test setup
+def setup
+  # Clear test database
+  Redis.new(url: 'redis://localhost:6379', db: 15).flushdb
+end
+```
+
 ## Transport Interface
 
 All transports must implement the `SmartMessage::Transport::Base` interface:
@@ -188,19 +376,24 @@ transport.receive(message_header, message_payload)  # protected method
 Register custom transports for easy creation:
 
 ```ruby
-# Register a transport class
-SmartMessage::Transport.register(:redis, RedisTransport)
+# Register custom transport classes
 SmartMessage::Transport.register(:kafka, KafkaTransport)
+SmartMessage::Transport.register(:webhook, WebhookTransport)
 
-# List all registered transports
+# List all registered transports (includes built-ins)
 puts SmartMessage::Transport.available
-# => [:stdout, :memory, :redis, :kafka]
+# => [:stdout, :memory, :redis, :kafka, :webhook]
 
-# Create instances
+# Create instances of built-in transports
 redis_transport = SmartMessage::Transport.create(:redis, 
   url: "redis://localhost:6379"
 )
 
+memory_transport = SmartMessage::Transport.create(:memory,
+  auto_process: true
+)
+
+# Create instances of custom transports
 kafka_transport = SmartMessage::Transport.create(:kafka,
   servers: ["localhost:9092"]
 )
@@ -311,12 +504,13 @@ SmartMessage::Transport.create(:memory,
   max_messages: 1000
 )
 
-# Hypothetical Redis specific
+# Redis specific
 SmartMessage::Transport.create(:redis,
   url: "redis://localhost:6379",
   db: 1,
-  namespace: "messages",
-  ttl: 3600
+  auto_subscribe: true,
+  reconnect_attempts: 5,
+  reconnect_delay: 2
 )
 ```
 

data/examples/.gitignore

@@ -0,0 +1,2 @@
+/log/
+*.log