smart_message 0.0.12 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e7bd096698c7b656fc3800dcbbd88366dccb0ae36be0a9a1f50240c944a6de3
-  data.tar.gz: 13235c27c12c4f76bdae091b0a432b505f0cfe49cd571fde387358aba98cf7da
+  metadata.gz: b0f06621d7e381b6069aba0fad1c329b941349e95488bdf5d8d39fd66e1d0fd2
+  data.tar.gz: d1ef64216d07f3e6005db87194590984004bf68f923c09bec93aadb889909cb1
 SHA512:
-  metadata.gz: 2b9b74f2203c1c6cd95a981e4f7c89d9fb6e1aad112c99b61420521ce95e89b4f3c378936ba9f435f67ee548b88e2e2ea28d70216856eaf898c028f1058f5d04
-  data.tar.gz: f7a9636706cb07e2b8df17e0e25b13128a2aed8a4ddd3d80ab28fadee3e27fc1ac52fafa9593f9854ffa54fb5920fe93334fb7f361c3394929c1fe4ea9be2adb
+  metadata.gz: f06e42c967e586521659b24e132001a64e51d64541214b06c7d5fa7bf6bfc48782a13bec11ace183ae50ff93b3840a5344ea2c59f3b44f0227fe8162b5452c44
+  data.tar.gz: bd2b874f6574600002a5b1cf845ca37076aef74f53fde34b7bae183af5c8978c5dd7c7fdb4d9f442014d7fb146371655e4f3092216e285fc7b0f5fba65dd254f

data/.gitignore

@@ -13,3 +13,4 @@ site
 .aigcm_msg
 /log/
 /logs/
+*.jsonl

data/CHANGELOG.md

@@ -7,10 +7,164 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.16] 2025-09-10
+
+### Added
+- **FileTransport Demo Suite**: Comprehensive demonstration programs for FileTransport functionality
+  - **Basic FileTransport Demo** (`examples/file/01_basic_file_transport_demo.rb`): Complete demonstration of core FileTransport features including different output formats (JSON, YAML, raw), append vs overwrite modes, custom serialization, and file rotation examples
+  - **FIFO Transport Demo** (`examples/file/02_fifo_transport_demo.rb`): FIFO (named pipe) demonstrations covering FIFO creation, properties, and concepts with educational content about inter-process communication
+  - **File Watching Demo** (`examples/file/03_file_watching_demo.rb`): File monitoring and change detection examples with polling-based file watching
+  - **Multi-Transport File Demo** (`examples/file/04_multi_transport_file_demo.rb`): Advanced patterns including fan-out to multiple files, conditional routing, multi-transport combinations, archival strategies, and performance monitoring
+  - **Interactive Demo Runner** (`examples/file/00_run_all_file_demos.rb`): Menu-driven demo launcher with comprehensive error handling and user-friendly navigation
+
+### Fixed
+- **Demo Configuration Syntax**: Fixed incorrect `.configure` method usage throughout FileTransport demos
+  - **Issue**: Demos were using non-existent `MessageClass.configure` method causing "undefined method 'configure'" errors
+  - **Solution**: Updated all configuration calls to use `MessageClass.class_eval { transport transport_instance }` pattern consistent with working examples
+  - **Files Updated**: All FileTransport demo files now use correct transport configuration syntax
+- **Message Instantiation Arguments**: Fixed keyword argument errors in message creation
+  - **Issue**: Hash variables being passed to `MessageClass.new(hash_var)` instead of using keyword argument expansion
+  - **Solution**: Updated all message instantiation calls to use `MessageClass.new(**hash_var)` for proper keyword argument passing
+  - **Impact**: Resolves "wrong number of arguments (given 1, expected 0)" errors throughout demo suite
+- **Method Name Consistency**: Updated all demo files to use correct `publish` method instead of deprecated `send`
+  - **Issue**: Some demos were using `.send` method which is not the correct SmartMessage publishing method
+  - **Solution**: Replaced all instances of `.send` with `.publish` across FileTransport demos
+  - **Files Affected**: 02_fifo_transport_demo.rb, 04_multi_transport_file_demo.rb
+- **Missing `from` Property Declarations**: Added required `from` declarations to all message classes
+  - **Issue**: Message classes missing required `from` property causing "The property 'from' From entity ID is required" errors
+  - **Solution**: Added `from 'demo_source'` declarations to all message class definitions including dynamically created classes
+  - **Impact**: Ensures proper message routing and header initialization
+- **FIFO Blocking Issues**: Resolved program hanging when writing to FIFOs without concurrent readers
+  - **Issue**: FIFO operations block indefinitely when no reader process is available
+  - **Solution**: Simplified FIFO examples to demonstrate FIFO concepts and properties without blocking operations, replaced complex multi-process examples with educational demonstrations
+  - **Result**: Demos now complete successfully without hanging while still teaching FIFO fundamentals
+- **Variable Scope Issues**: Fixed transport variable accessibility problems in custom routing logic
+  - **Issue**: Complex custom routing classes couldn't access transport variables from outer scope
+  - **Solution**: Simplified conditional routing examples to use separate message classes for different severity levels instead of dynamic transport switching
+  - **Benefit**: Cleaner, more maintainable code that demonstrates routing concepts without scope complications
+
+### Enhanced
+- **Demo Educational Value**: Improved all FileTransport demos with comprehensive documentation and error handling
+  - **Documentation**: Added detailed comments explaining FileTransport concepts, FIFO characteristics, and usage patterns
+  - **Error Handling**: Enhanced error reporting and graceful degradation in all demo scenarios
+  - **User Experience**: Simplified complex examples to focus on core functionality while maintaining educational value
+  - **Output Clarity**: Improved console output formatting and messaging for better understanding of demo operations
+
+### Documentation
+- **FileTransport Demo README**: Comprehensive documentation for all FileTransport demonstration programs
+  - **Usage Instructions**: Step-by-step guide for running individual demos and the interactive demo runner
+  - **Concept Explanations**: Detailed explanations of FileTransport features, FIFO operations, and advanced patterns
+  - **Troubleshooting**: Common issues and solutions for FileTransport usage
+  - **Example Outputs**: Sample console outputs showing expected demo results
+
+## [0.0.15] 2025-09-10
+
+### Added
+- **Multi-Transport Publishing**: Messages can now be configured to publish to multiple transports simultaneously
+  - **Core Feature**: Configure messages with an array of transports using `transport [transport1, transport2, transport3]` syntax
+  - **Resilient Publishing**: Publishing succeeds if ANY configured transport works; only fails if ALL transports fail
+  - **Error Handling**: Individual transport failures are logged but don't prevent publishing to remaining transports
+  - **Backward Compatibility**: Single transport configuration continues to work unchanged (`transport single_transport`)
+  - **Utility Methods**: Added `transports()`, `single_transport?()`, and `multiple_transports?()` for transport introspection
+  - **Use Cases**: Supports redundancy, integration, migration, and fan-out messaging patterns
+
+### Enhanced
+- **Transport Configuration API**: Extended transport configuration methods to handle both single transports and transport arrays
+  - **Plugins Module**: Updated `transport()` method in `lib/smart_message/plugins.rb` to accept arrays while maintaining backward compatibility
+  - **Internal Storage**: Transport arrays stored internally but `transport()` getter returns first transport for existing code compatibility
+  - **Instance Overrides**: Instance-level transport configuration can override class-level multi-transport settings
+- **Publishing Pipeline**: Enhanced message publishing in `lib/smart_message/messaging.rb` for multi-transport support
+  - **Parallel Publishing**: Iterates through all configured transports and publishes to each
+  - **Comprehensive Logging**: Logs successful and failed transports with detailed error information
+  - **Error Aggregation**: Collects all transport errors and raises `PublishError` only when all transports fail
+  - **Success Tracking**: Continues processing even when individual transports fail
+
+### Added - Error Handling
+- **PublishError**: New error class `SmartMessage::Errors::PublishError` for multi-transport failure scenarios
+  - **Condition**: Only raised when ALL configured transports fail to publish
+  - **Error Detail**: Aggregates error messages from all failed transports for comprehensive debugging
+  - **Added to**: `lib/smart_message/errors.rb`
+
+### Added - Documentation
+- **Comprehensive Guide**: Created `docs/transports/multi-transport.md` with complete multi-transport documentation
+  - **Real-World Examples**: High-availability, development/production dual publishing, monitoring integration, A/B testing
+  - **Best Practices**: Performance considerations, environment-specific configuration, health monitoring
+  - **Troubleshooting**: Common issues, debugging techniques, and solutions
+- **Integration Updates**: Updated main transport documentation and index to reference multi-transport capability
+  - **Transport Layer**: Added multi-transport section to `docs/reference/transports.md`
+  - **Table of Contents**: Added multi-transport link to main documentation index
+
+### Added - Testing
+- **Comprehensive Test Suite**: Created `test/multi_transport_test.rb` with 12 test cases covering all functionality
+  - **Backward Compatibility**: Verified single transport behavior remains unchanged
+  - **Multi-Transport Scenarios**: Tests for successful publishing, partial failures, complete failures
+  - **Configuration Testing**: Class vs instance configuration, transport introspection, method chaining
+  - **Mock Transports**: Added `FailingTransport` and `CountingTransport` for controlled testing
+  - **Integration Tests**: Real transport combinations (Memory + STDOUT)
+
+### Added - Examples
+- **README Integration**: Added multi-transport example to main README.md with practical use case
+  - **Features Section**: Added multi-transport publishing bullet point to feature list
+  - **Transport Implementations**: Complete section with `CriticalOrderMessage` example showing 3 transports
+  - **Key Benefits**: Highlighted redundancy, integration, migration, and resilience benefits
+- **Example File**: Created `examples/multi_transport_example.rb` demonstrating all multi-transport functionality
+  - **Usage Patterns**: Single transport (backward compatibility), multiple transports, instance overrides
+  - **Error Scenarios**: Partial transport failure resilience and complete failure handling
+  - **Utility Demonstrations**: Transport counting, type checking, and configuration inspection
+
+## [0.0.14] 2025-09-10
+
+### Fixed
+- **Configuration Architecture**: Fixed `SmartMessage::Serializer.default` method to properly reflect transport-owned serialization architecture
+  - **Issue**: `SmartMessage::Serializer.default` was trying to access a non-existent `default_serializer` method on global configuration
+  - **Root Cause**: Serialization belongs to transports, not global configuration, but the method was attempting to check global config first
+  - **Solution**: Updated method to return framework default (`SmartMessage::Serializer::Json`) directly without depending on global configuration
+  - **Architecture Clarification**: Each transport owns and configures its own serializer (line 19 in transport/base.rb: `@serializer = options[:serializer] || default_serializer`)
+  - **Demo Fix**: Updated `examples/memory/14_global_configuration_demo.rb` to remove incorrect `config.serializer =` attempts and added architecture comments
+- **Test Method Signatures**: Completed wrapper-to-message architecture transition by fixing remaining method signature issues
+  - **dispatcher_test.rb**: Changed `processer_one` and `processer_two` from instance methods to class methods (`def self.`)
+  - **Message Format**: Updated methods to use flat message structure (`message._sm_header.message_class` and `message.to_json`) instead of old two-tier format (`message_header, encoded_message = message`)
+  - **subscribe_test.rb**: Fixed `business_logic` method to be a class method (`def self.business_logic`) to match subscription call pattern
+  - **Result**: All tests now pass (`176 runs, 578 assertions, 0 failures, 0 errors, 1 skips`) completing the architectural transition
+
+## [0.0.13] 2025-09-10
+
+### Changed
+- **BREAKING: Transport-Level Serialization Architecture**: Major architectural rework moving serializer responsibility from message classes to transport layer
+  - **Core Change**: Serializers now associated with transports instead of message classes, enabling different transports to use different serialization formats
+  - **Message Structure**: Eliminated wrapper objects in favor of flat message structure with `_sm_header` routing metadata
+  - **Serialization Format**: Messages now serialized as single JSON objects containing both header and payload data (e.g., `{"_sm_header": {...}, "content": "value", "property": "data"}`)
+  - **Transport Flexibility**: Each transport can now use its own serializer (JSON, MessagePack, etc.) independently
+  - **Backward Compatibility**: Added `_sm_payload` and `split` methods to maintain compatibility with existing proc handlers
+  - **Performance**: Simplified message processing pipeline with direct message instance passing instead of complex wrapper handling
+
+### Fixed
+- **Message Reconstruction**: Fixed critical bug in `SmartMessage::Base#initialize` where payload properties were not properly extracted from flat serialized structure
+  - **Root Cause**: Initialization logic looked for `props[:_sm_payload]` but flat structure stores properties directly in `props`
+  - **Solution**: Changed to `payload_props = props.except(:_sm_header)` to extract all non-header properties
+  - **Impact**: Proc handlers now receive correct message content, resolving nil property values in `_sm_payload`
+- **Circuit Breaker Test Compatibility**: Updated circuit breaker tests to use new transport method signatures
+  - **Issue**: Tests were calling `transport.publish(header, payload)` with two arguments
+  - **Fix**: Updated to `transport.publish(message_instance)` with single message parameter
+  - **Result**: All circuit breaker tests now pass with new architecture
+- **Deduplication Test Format**: Updated deduplication tests from old wrapper format to new flat structure
+  - **Changed**: `_sm_payload: { content: "value" }` → `content: "value"`
+  - **Maintained**: Full deduplication functionality with handler-scoped DDQ system
+
+### Enhanced
+- **Transport Serialization Control**: Each transport implementation can now specify its preferred serializer
+  - **Memory Transport**: Returns message objects directly without serialization for performance
+  - **STDOUT Transport**: Uses JSON serializer with pretty printing for human readability
+  - **Redis Transport**: Uses MessagePack with JSON fallback for efficient network transmission
+- **Message Processing Pipeline**: Streamlined architecture with direct message instance routing
+  - **Eliminated**: Complex wrapper object creation and management overhead
+  - **Simplified**: Transport `receive` method now directly reconstructs message instances from flat data
+  - **Improved**: Cleaner separation between transport concerns and message processing logic
+
 ### Added
 - **Emergency Services Multi-Program Demo**: Complete emergency dispatch simulation system
   - Added comprehensive emergency services message definitions with validation
-  - Emergency Dispatch Center (911) routing calls to appropriate departments 
+  - Emergency Dispatch Center (911) routing calls to appropriate departments
   - Fire Department, Police Department, and Health Department service implementations
   - AI-powered visitor generating realistic emergency scenarios with retry logic
   - Health monitoring system across all city services with status reporting

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    smart_message (0.0.12)
+    smart_message (0.0.16)
       activesupport
       async
       async-redis
@@ -30,7 +30,7 @@ GEM
       tzinfo (~> 2.0, >= 2.0.5)
       uri (>= 0.13.1)
     amazing_print (1.8.1)
-    async (2.29.0)
+    async (2.31.0)
       console (~> 1.29)
       fiber-annotation
       io-event (~> 1.11)
@@ -69,12 +69,12 @@ GEM
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
     io-endpoint (0.15.2)
-    io-event (1.13.0)
+    io-event (1.14.0)
     io-stream (0.10.0)
     json (2.13.2)
     logger (1.7.0)
     lumberjack (1.4.1)
-    metrics (0.14.0)
+    metrics (0.15.0)
     minitest (5.25.5)
     minitest-power_assert (0.3.1)
       minitest
@@ -85,7 +85,7 @@ GEM
     rake (13.3.0)
     redis (5.4.1)
       redis-client (>= 0.22.0)
-    redis-client (0.25.2)
+    redis-client (0.25.3)
       connection_pool
     securerandom (0.4.1)
     shoulda (4.0.0)
@@ -95,7 +95,7 @@ GEM
     shoulda-matchers (4.5.1)
       activesupport (>= 4.2.0)
     state_machines (0.100.1)
-    traces (0.18.1)
+    traces (0.18.2)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     uri (1.0.3)

data/README.md

@@ -23,6 +23,7 @@ Think of SmartMessage as ActiveRecord for messaging - just as ActiveRecord frees
 ## Features
 
 - **Transport Abstraction**: Plugin architecture supporting multiple message transports (Redis, RabbitMQ, Kafka, etc.)
+- **Multi-Transport Publishing**: Send messages to multiple transports simultaneously for redundancy, integration, and migration scenarios
 - **🌟 Redis Queue Transport**: Advanced transport with RabbitMQ-style routing patterns, persistent FIFO queues, load balancing, and 10x faster performance than traditional message brokers. Built on Ruby's Async framework for fiber-based concurrency supporting thousands of concurrent subscriptions - [see full documentation](docs/transports/redis-queue.md)
 - **Serialization Flexibility**: Pluggable serialization formats (JSON, MessagePack, etc.)
 - **Entity-to-Entity Addressing**: Built-in FROM/TO/REPLY_TO addressing for point-to-point and broadcast messaging patterns
@@ -36,7 +37,7 @@ Think of SmartMessage as ActiveRecord for messaging - just as ActiveRecord frees
 - **Advanced Logging System**: Comprehensive logging with colorized console output, JSON structured logging, and file rolling
 - **Built-in Statistics**: Message processing metrics and monitoring
 - **Message Deduplication**: Handler-scoped deduplication queues (DDQ) with memory or Redis storage for preventing duplicate message processing
-- **Development Tools**: STDOUT and in-memory transports for testing
+- **Development Tools**: STDOUT transport for publish-only scenarios and in-memory transport for testing with local processing
 - **Production Ready**: Redis transport with automatic reconnection and error handling
 - **Dead Letter Queue**: File-based DLQ with JSON Lines format for failed message capture and replay
 - **Circuit Breaker Integration**: Production-grade reliability with BreakerMachines for automatic fallback and recovery
@@ -131,8 +132,8 @@ class OrderMessage < SmartMessage::Base
 
   # Configure transport and serializer at class level
   config do
-    # Option 1: Simple STDOUT for development
-    transport SmartMessage::Transport.create(:stdout, loopback: true)
+    # Option 1: Memory transport for local development with message processing
+    transport SmartMessage::Transport::MemoryTransport.new
 
     # Option 2: Redis Queue for production (10x faster than RabbitMQ!)
     # transport SmartMessage::Transport.create(:redis_queue,
@@ -196,24 +197,19 @@ OrderMessage.subscribe
 OrderMessage.subscribe("PaymentService.process_order")
 
 # 3. Block handler (NEW!)
-OrderMessage.subscribe do |wrapper|
-  header, payload = wrapper.split
-  order_data = JSON.parse(payload)
-  puts "Quick processing: Order #{order_data['order_id']}"
+OrderMessage.subscribe do |message|
+  puts "Quick processing: Order #{message.order_id}"
 end
 
 # 4. Proc handler (NEW!)
-order_processor = proc do |wrapper|
-  header, payload = wrapper.split
-  order_data = JSON.parse(payload)
-  EmailService.send_confirmation(order_data['customer_id'])
+order_processor = proc do |message|
+  EmailService.send_confirmation(message.customer_id)
 end
 OrderMessage.subscribe(order_processor)
 
 # 5. Lambda handler (NEW!)
-audit_handler = lambda do |wrapper|
-  header, payload = wrapper.split
-  AuditLog.record("Order processed at #{header.published_at}")
+audit_handler = lambda do |message|
+  AuditLog.record("Order processed at #{message._sm_header.published_at}")
 end
 OrderMessage.subscribe(audit_handler)
 ```
@@ -542,8 +538,8 @@ The foundation class that all messages inherit from. Built on `Hashie::Dash` wit
 #### Transport Layer
 Pluggable message delivery system with built-in implementations:
 
-- **StdoutTransport**: Development and testing transport
-- **MemoryTransport**: In-memory queuing for testing
+- **StdoutTransport**: Publish-only transport for debugging and external integration
+- **MemoryTransport**: In-memory queuing for testing with local message processing
 - **RedisTransport**: Redis pub/sub transport for production messaging
 - **Custom Transports**: Implement `SmartMessage::Transport::Base`
 
@@ -586,6 +582,38 @@ This enables gateway patterns where messages can be received from one transport/
 
 ## Transport Implementations
 
+### Multi-Transport Messages
+
+SmartMessage supports publishing to multiple transports simultaneously for redundancy, integration, and migration scenarios:
+
+```ruby
+class CriticalOrderMessage < SmartMessage::Base
+  property :order_id, required: true
+  property :amount, required: true
+  
+  # Configure multiple transports - message goes to ALL of them
+  transport [
+    SmartMessage::Transport.create(:redis_queue, url: 'redis://primary:6379'),
+    SmartMessage::Transport.create(:redis, url: 'redis://backup:6379'),
+    SmartMessage::Transport::StdoutTransport.new(format: :json)
+  ]
+end
+
+# Publishes to Redis Queue, Redis Pub/Sub, and STDOUT simultaneously
+message = CriticalOrderMessage.new(order_id: "ORD-123", amount: 99.99)
+message.publish  # ✅ Succeeds if ANY transport works
+
+# Check transport configuration
+puts message.multiple_transports?  # => true
+puts message.transports.length     # => 3
+```
+
+**Key Benefits:**
+- **Redundancy**: Messages reach multiple destinations for reliability
+- **Integration**: Simultaneously log to STDOUT, send to Redis, and webhook external systems  
+- **Migration**: Gradually transition between transport systems
+- **Resilient**: Publishing succeeds as long as ANY transport works
+
 ### Redis Queue Transport (Featured) 🌟
 
 The Redis Queue Transport provides enterprise-grade message routing with exceptional performance:
@@ -637,17 +665,35 @@ OrderMessage.new(
 
 📚 **Full Documentation:** [Redis Queue Transport Guide](docs/transports/redis-queue.md) | [Getting Started](docs/guides/redis-queue-getting-started.md) | [Examples](examples/redis_queue/)
 
-### STDOUT Transport (Development)
+### STDOUT Transport (Publish-Only)
+
+The STDOUT transport is designed for publish-only scenarios - perfect for debugging, logging, or integration with external systems.
 
 ```ruby
-# Basic STDOUT output
-transport = SmartMessage::Transport.create(:stdout)
+# Basic STDOUT output (publish-only)
+transport = SmartMessage::Transport::StdoutTransport.new
+
+# Pretty-printed format for human reading (default)
+transport = SmartMessage::Transport::StdoutTransport.new(format: :pretty)
 
-# With loopback for testing subscriptions
-transport = SmartMessage::Transport.create(:stdout, loopback: true)
+# JSON format for machine processing
+transport = SmartMessage::Transport::StdoutTransport.new(format: :json)
 
-# Output to file
-transport = SmartMessage::Transport.create(:stdout, output: "messages.log")
+# Output to file instead of STDOUT
+transport = SmartMessage::Transport::StdoutTransport.new(output: "messages.log")
+```
+
+**Key Features:**
+- **Publish-only**: No message processing or loopback
+- **Subscription attempts are ignored** with warning logs
+- **Two formats**: `:pretty` for debugging, `:json` for integration
+- **Perfect for**: debugging, logging, piping to external tools
+- **Use cases**: `./app | jq`, `./app | fluentd`, development monitoring
+
+**For local message processing, use MemoryTransport instead:**
+```ruby
+# Use Memory transport if you need local message processing
+transport = SmartMessage::Transport::MemoryTransport.new
 ```
 
 ### Memory Transport (Testing)
@@ -952,8 +998,8 @@ You can also set descriptions within configuration blocks:
 class ConfiguredMessage < SmartMessage::Base
   config do
     description "Set within config block"
-    transport SmartMessage::Transport.create(:stdout)
-    serializer SmartMessage::Serializer::JSON.new
+    transport SmartMessage::Transport::MemoryTransport.new
+    serializer SmartMessage::Serializer::Json.new
   end
 end
 ```

data/docs/core-concepts/architecture.md

@@ -9,10 +9,10 @@ SmartMessage is designed around the principle that **messages should be independ
 ### Core Principles
 
 1. **Separation of Concerns**: Message content, transport, and serialization are independent
-2. **Plugin Architecture**: Pluggable transports and serializers
+2. **Plugin Architecture**: Pluggable transports
 3. **Dual Configuration**: Both class-level and instance-level configuration
 4. **Thread Safety**: Concurrent message processing with thread pools
-5. **Gateway Support**: Messages can flow between different transports/serializers
+5. **Gateway Support**: Messages can flow between different transports
 
 ## Architecture Overview
 
@@ -26,7 +26,7 @@ The foundation class that all messages inherit from, built on `Hashie::Dash`.
 
 **Key Responsibilities:**
 - Property management and validation
-- Plugin configuration (transport, serializer, logger)
+- Plugin configuration (transport, logger)
 - Message lifecycle management
 - Header generation and management
 
@@ -40,7 +40,6 @@ class MyMessage < SmartMessage::Base
   
   config do
     transport MyTransport.new
-    serializer MySerializer.new
   end
 end
 ```
@@ -163,7 +162,6 @@ puts header.from          # "payment-service"
 puts header.to            # "order-service"
 puts header.reply_to      # "payment-service" (defaults to from)
 puts header.version       # 1
-puts header.serializer    # "SmartMessage::Serializer::JSON"
 ```
 
 ## Message Lifecycle
@@ -176,7 +174,6 @@ class OrderMessage < SmartMessage::Base
   
   config do
     transport SmartMessage::Transport.create(:memory)
-    serializer SmartMessage::Serializer::Json.new
   end
 end
 ```
@@ -201,7 +198,7 @@ order = OrderMessage.new(order_id: "123", amount: 99.99)
 order.from("order-service").to("payment-service")
 order.publish
 # 1. Creates header with UUID, timestamp, addressing
-# 2. Encodes message via serializer  
+# 2. Encodes message via transport's serializer  
 # 3. Sends via transport
 # 4. Circuit breaker monitors for failures
 ```
@@ -210,7 +207,7 @@ order.publish
 ```ruby
 # Transport receives serialized message
 transport.receive(message_class, serialized_message)
-# 1. Decodes message using class's configured serializer
+# 1. Decodes message using transport's serializer
 # 2. Routes decoded message to dispatcher
 # 3. Dispatcher checks DDQ for duplicates per handler
 # 4. Applies message filters (from/to/broadcast)
@@ -271,7 +268,6 @@ SmartMessage supports configuration at both class and instance levels:
 class PaymentMessage < SmartMessage::Base
   config do
     transport ProductionTransport.new
-    serializer SecureSerializer.new
   end
 end
 
@@ -459,7 +455,6 @@ Configuration uses method-based DSL:
 ```ruby
 config do
   transport MyTransport.new(option1: value1)
-  serializer MySerializer.new(option2: value2)
   logger MyLogger.new(level: :debug)
 end
 ```

data/docs/getting-started/examples.md

@@ -20,7 +20,6 @@ class NotificationMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:stdout, loopback: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -87,7 +86,6 @@ class UserRegisteredEvent < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -152,7 +150,6 @@ class WelcomeEmailMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:stdout)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -171,7 +168,6 @@ class AnalyticsMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:stdout)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -209,7 +205,6 @@ class OrderCreatedMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -252,7 +247,6 @@ class InventoryReservationMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -289,7 +283,6 @@ class PaymentProcessingMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -362,7 +355,6 @@ class LogMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:stdout, output: "application.log")
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -412,7 +404,6 @@ class MetricMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -496,7 +487,6 @@ class MessageGateway < SmartMessage::Base
   # Receive from one transport
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -621,7 +611,6 @@ class ResilientMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -689,7 +678,6 @@ class DeadLetterMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:stdout, output: "dead_letter_queue.log")
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)

data/docs/getting-started/quick-start.md

@@ -92,7 +92,6 @@ class WelcomeMessage < SmartMessage::Base
   # Configure the transport (where messages go)
   config do
     transport SmartMessage::Transport.create(:stdout, loopback: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   # Define how to process received messages
@@ -213,12 +212,10 @@ transport SmartMessage::Transport.create(:memory, auto_process: true)
 ```
 
 ### Serializers
-Serializers handle message encoding/decoding:
-
-```ruby
-# JSON serialization (built-in)
-serializer SmartMessage::Serializer::Json.new
-```
+Transports handle their own serialization automatically:
+- **MemoryTransport**: No serialization (objects passed directly)
+- **StdoutTransport**: JSON serialization for readability
+- **RedisTransport**: MessagePack (with JSON fallback) for efficiency
 
 ### Message Handlers
 
@@ -321,7 +318,6 @@ class NotificationMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:memory, auto_process: true)
-    serializer SmartMessage::Serializer::Json.new
   end
 
   def self.process(decoded_message)
@@ -364,7 +360,6 @@ class EventMessage < SmartMessage::Base
 
   config do
     transport SmartMessage::Transport.create(:stdout, output: 'events.log')
-    serializer SmartMessage::Serializer::Json.new
   end
 end
 

data/docs/index.md

@@ -31,13 +31,15 @@ Think of SmartMessage as ActiveRecord for messaging - just as ActiveRecord frees
 
 ### Transports
 - [Transport Layer](reference/transports.md)
-- [Redis Queue Transport](transports/redis-queue-transport.md) ⭐ **Featured**
+- [Multi-Transport Publishing](transports/multi-transport.md)
+- [Redis Transport](transports/redis-transport.md)
 - [Redis Transport Comparison](transports/redis-transport-comparison.md)
+- [Memory Transport](transports/memory-transport.md)
 
 ### Guides
-- [Redis Queue Getting Started](guides/redis-queue-getting-started.md)
-- [Advanced Routing Patterns](guides/redis-queue-patterns.md)
-- [Production Deployment](guides/redis-queue-production.md)
+- [Examples & Use Cases](getting-started/examples.md)
+- [Architecture Overview](core-concepts/architecture.md)
+- [Transport Configuration](reference/transports.md)
 
 ### Reference
 - [Serializers](reference/serializers.md)