smart_message 0.0.13 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b75aa70a9ab79b0fd9ac311d7e5634491789e5813161630ff7e04f17d61373
-  data.tar.gz: 8196665b3a660cfaad1c30753697f020c4a54b50c25d23be6f6c3c6ad9149e38
+  metadata.gz: b0f06621d7e381b6069aba0fad1c329b941349e95488bdf5d8d39fd66e1d0fd2
+  data.tar.gz: d1ef64216d07f3e6005db87194590984004bf68f923c09bec93aadb889909cb1
 SHA512:
-  metadata.gz: 876f94f732eb022c568a200747438ab6a0938602735f89601fc7c9e48f34bf21791c75608b2d877475d9190a9629974a63448f5ceb6eeb24bf073b0cc1e4ee19
-  data.tar.gz: 310150522f4d6561c40e7322072a75778867b643b5eb6b79364b750a39689e27cbfd7c7022ae0f0c8a44ae9a850549c02e94005930d4b878ba75cb1eb1192a58
+  metadata.gz: f06e42c967e586521659b24e132001a64e51d64541214b06c7d5fa7bf6bfc48782a13bec11ace183ae50ff93b3840a5344ea2c59f3b44f0227fe8162b5452c44
+  data.tar.gz: bd2b874f6574600002a5b1cf845ca37076aef74f53fde34b7bae183af5c8978c5dd7c7fdb4d9f442014d7fb146371655e4f3092216e285fc7b0f5fba65dd254f

data/.gitignore

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

data/CHANGELOG.md

@@ -7,6 +7,126 @@ 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    smart_message (0.0.13)
+    smart_message (0.0.16)
       activesupport
       async
       async-redis
@@ -74,7 +74,7 @@ GEM
     json (2.13.2)
     logger (1.7.0)
     lumberjack (1.4.1)
-    metrics (0.14.1)
+    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)

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/index.md

@@ -31,8 +31,10 @@ Think of SmartMessage as ActiveRecord for messaging - just as ActiveRecord frees
 
 ### Transports
 - [Transport Layer](reference/transports.md)
+- [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
 - [Examples & Use Cases](getting-started/examples.md)

data/docs/reference/transports.md

@@ -5,34 +5,57 @@ The transport layer is responsible for moving messages between systems. SmartMes
 ## Overview
 
 Transports handle:
-- **Publishing**: Sending messages to a destination
+- **Publishing**: Sending messages to a destination (single or multiple transports)
 - **Subscribing**: Registering interest in message types
 - **Routing**: Directing incoming messages to the dispatcher
 - **Connection Management**: Handling connections to external systems
 
+## Multi-Transport Publishing
+
+SmartMessage supports publishing to **multiple transports simultaneously** for redundancy, integration, and migration scenarios. Configure an array of transports to send messages to multiple destinations with a single `publish()` call.
+
+```ruby
+class CriticalMessage < SmartMessage::Base
+  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
+
+message = CriticalMessage.new(data: "important")
+message.publish  # ✅ Publishes to all three transports
+```
+
+**📚 See [Multi-Transport Documentation](../transports/multi-transport.md) for comprehensive examples and best practices.**
+
 ## Built-in Transports
 
 ### STDOUT Transport
 
-Perfect for development, debugging, and logging scenarios.
+**Publish-only transport** perfect for debugging, logging, and integration with external systems.
 
 **Features:**
-- Outputs messages to console or file
-- Optional loopback for testing subscriptions
-- Human-readable message formatting
+- **Publish-only**: No message processing or loopback capability
+- Outputs messages to console or file in pretty-print or JSON formats
+- Subscription attempts are ignored with warning logs
+- Perfect for piping to external tools and log aggregators
 - No external dependencies
 
 **Usage:**
 
 ```ruby
-# Basic STDOUT output
-transport = SmartMessage::Transport.create(:stdout)
+# Basic STDOUT output (publish-only)
+transport = SmartMessage::Transport::StdoutTransport.new
 
-# With loopback enabled (messages get processed locally)
-transport = SmartMessage::Transport.create(:stdout, loopback: true)
+# Pretty-printed format for human reading (default)
+transport = SmartMessage::Transport::StdoutTransport.new(format: :pretty)
+
+# JSON format for machine processing
+transport = SmartMessage::Transport::StdoutTransport.new(format: :json)
 
 # Output to file instead of console
-transport = SmartMessage::Transport.create(:stdout, output: "messages.log")
+transport = SmartMessage::Transport::StdoutTransport.new(output: "messages.log")
 
 # Configure in message class
 class LogMessage < SmartMessage::Base
@@ -40,17 +63,19 @@ class LogMessage < SmartMessage::Base
   property :message
   
   config do
-    transport SmartMessage::Transport.create(:stdout, 
-      output: "app.log",
-      loopback: false
+    transport SmartMessage::Transport::StdoutTransport.new(
+      format: :json,
+      output: "app.log"
     )
   end
 end
 ```
 
 **Options:**
-- `loopback` (Boolean): Whether to process published messages locally (default: false)
-- `output` (String|IO): Output destination - filename string or IO object (default: $stdout)
+- `format` (Symbol): Output format - `:pretty` for debugging, `:json` for integration (default: `:pretty`)
+- `output` (String|IO): Output destination - filename string or IO object (default: `$stdout`)
+
+**Important:** For local message processing during development, use **MemoryTransport** instead.
 
 **Example Output:**
 ```
@@ -421,11 +446,11 @@ end
 order = OrderMessage.new(order_id: "123", amount: 99.99)
 
 order.config do
-  # This instance will use STDOUT instead of memory
-  transport SmartMessage::Transport.create(:stdout, loopback: true)
+  # This instance will use STDOUT instead of memory (publish-only)
+  transport SmartMessage::Transport::StdoutTransport.new(format: :json)
 end
 
-order.publish  # Uses STDOUT transport
+order.publish  # Uses STDOUT transport (publish-only)
 ```
 
 ### Runtime Transport Switching
@@ -490,9 +515,9 @@ transport = SmartMessage::Transport.create(:custom,
 Each transport may have specific options:
 
 ```ruby
-# STDOUT specific
-SmartMessage::Transport.create(:stdout,
-  loopback: true,
+# STDOUT specific (publish-only)
+SmartMessage::Transport::StdoutTransport.new(
+  format: :json,
   output: "/var/log/messages.log"
 )
 

data/docs/transports/memory-transport.md

@@ -348,7 +348,8 @@ The `examples/memory/` directory contains comprehensive, runnable examples demon
 - **[12_regex_filtering_microservices.rb](https://github.com/MadBomber/smart_message/blob/main/examples/memory/12_regex_filtering_microservices.rb)** - Advanced regex filtering for microservices
 
 ### Visual Demonstrations
-- **[06_pretty_print_demo.rb](https://github.com/MadBomber/smart_message/blob/main/examples/memory/06_pretty_print_demo.rb)** - Message inspection and pretty-printing capabilities
+- **[06_stdout_publish_only.rb](https://github.com/MadBomber/smart_message/blob/main/examples/memory/06_stdout_publish_only.rb)** - STDOUT transport publish-only demonstration with logging and metrics examples
+- **[16_pretty_print_demo.rb](https://github.com/MadBomber/smart_message/blob/main/examples/memory/16_pretty_print_demo.rb)** - Message inspection and pretty-printing capabilities
 
 ### Running Examples