smart_message 0.0.13 → 0.0.16

data/lib/smart_message/transport/partitioned_files.rb

@@ -0,0 +1,46 @@
+# lib/smart_message/transport/partitioned_files.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module Transport
+    # Module for fan-out/partitioned file support.
+    module PartitionedFiles
+      def determine_file_path(payload, header)
+        if @options[:filename_selector]&.respond_to?(:call)
+          @options[:filename_selector].call(payload, header)
+        elsif @options[:directory]
+          File.join(@options[:directory], "#{header[:message_class_name].to_s.downcase}.log")
+        else
+          @options[:file_path]
+        end
+      end
+
+      def get_or_open_partition_handle(full_path)
+        @partition_handles ||= {}
+        @partition_mutexes ||= {}
+        
+        unless @partition_handles[full_path]
+          ensure_directory_exists_for(full_path)
+          @partition_handles[full_path] = File.open(full_path, file_mode, encoding: @options[:encoding])
+          @partition_mutexes[full_path] = Mutex.new
+        end
+        
+        @partition_handles[full_path]
+      end
+
+      def ensure_directory_exists_for(path)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) if @options[:create_directories] && !Dir.exist?(dir)
+      end
+
+      def close_partition_handles
+        @partition_handles&.each do |_, handle|
+          handle.close
+        end
+        @partition_handles = {}
+        @partition_mutexes = {}
+      end
+    end
+  end
+end

data/lib/smart_message/transport/stdout_transport.rb

@@ -2,61 +2,75 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require_relative 'file_transport'
+
 module SmartMessage
   module Transport
     # STDOUT transport for testing and development
-    # This transport outputs messages to STDOUT and optionally loops them back
-    class StdoutTransport < Base
-      def default_options
-        {
-          loopback: false,
-          output: $stdout,
-          format: :pretty  # :pretty or :json
+    # This is a publish-only transport that outputs messages to STDOUT
+    # Now inherits from FileTransport but maintains specialized formatting
+    class StdoutTransport < FileTransport
+      def initialize(options = {})
+        # Merge STDOUT-specific defaults with FileTransport defaults
+        stdout_options = {
+          file_path: $stdout,
+          file_mode: 'w',
+          file_type: :regular,
+          format: :pretty,  # :pretty or :json
+          enable_subscriptions: false,  # STDOUT is publish-only
+          auto_flush: true
         }
+        super(stdout_options.merge(options))
       end
 
       # Default to JSON for readability in STDOUT
       def default_serializer
         SmartMessage::Serializer::Json.new
       end
-
+      
+      # Override configuration to handle STDOUT-specific setup
       def configure
-        @output = @options[:output].is_a?(String) ? File.open(@options[:output], 'w') : @options[:output]
+        # If file_path is a string, delegate to parent FileTransport
+        if @options[:file_path].is_a?(String)
+          super
+        else
+          # Use the IO object directly (like $stdout)
+          @file_handle = @options[:file_path]
+          @write_buffer = []
+          @last_flush = Time.now
+          @file_mutex = Mutex.new
+        end
       end
-
-      # Enable/disable loopback mode
-      def loopback=(enabled)
-        @options[:loopback] = enabled
+      
+      # Override write_to_file to handle STDOUT directly
+      def write_to_file(serialized_message)
+        # If using a string file path, delegate to parent
+        if @options[:file_path].is_a?(String)
+          super
+        else
+          # Use IO object directly
+          content = prepare_file_content(serialized_message)
+          @file_handle.write(content)
+          @file_handle.flush if @options[:auto_flush]
+        end
       end
 
-      def loopback?
-        @options[:loopback]
+      # Override the file content preparation to use custom formatting
+      def prepare_file_content(serialized_message)
+        format_message(@current_message_class, serialized_message)
       end
 
-      # Publish message to STDOUT
-      def do_publish(message_class, serialized_message)
-        logger.debug { "[SmartMessage::StdoutTransport] do_publish called" }
-        logger.debug { "[SmartMessage::StdoutTransport] message_class: #{message_class}" }
-        
-        @output.puts format_message(message_class, serialized_message)
-        @output.flush
-
-        # If loopback is enabled, route the message back through the dispatcher
-        if loopback?
-          logger.debug { "[SmartMessage::StdoutTransport] Loopback enabled, calling receive" }
-          receive(message_class, serialized_message)
-        end
-      rescue => e
-        logger.error { "[SmartMessage] Error in stdout transport do_publish: #{e.class.name} - #{e.message}" }
-        raise
+      # Override subscribe methods to log warnings since this is a publish-only transport
+      def subscribe(message_class, process_method, filter_options = {})
+        logger.warn { "[SmartMessage::StdoutTransport] Subscription attempt ignored - STDOUT transport is publish-only (message_class: #{message_class}, process_method: #{process_method})" }
       end
 
-      def connected?
-        !@output.closed?
+      def unsubscribe(message_class, process_method)
+        logger.warn { "[SmartMessage::StdoutTransport] Unsubscribe attempt ignored - STDOUT transport is publish-only (message_class: #{message_class}, process_method: #{process_method})" }
       end
 
-      def disconnect
-        @output.close if @output.respond_to?(:close) && @output != $stdout && @output != $stderr
+      def unsubscribe!(message_class)
+        logger.warn { "[SmartMessage::StdoutTransport] Unsubscribe all attempt ignored - STDOUT transport is publish-only (message_class: #{message_class})" }
       end
 
       private
@@ -69,7 +83,7 @@ module SmartMessage
             message_class: message_class,
             serialized_message: serialized_message,
             timestamp: Time.now.iso8601
-          }.to_json
+          }.to_json + "\n"
         else
           # Pretty format for human reading
           <<~MESSAGE

data/lib/smart_message/transport/stdout_transport.rb.backup

@@ -0,0 +1,88 @@
+# lib/smart_message/transport/stdout_transport.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+module SmartMessage
+  module Transport
+    # STDOUT transport for testing and development
+    # This is a publish-only transport that outputs messages to STDOUT
+    class StdoutTransport < Base
+      def default_options
+        {
+          output: $stdout,
+          format: :pretty  # :pretty or :json
+        }
+      end
+
+      # Default to JSON for readability in STDOUT
+      def default_serializer
+        SmartMessage::Serializer::Json.new
+      end
+
+      def configure
+        @output = @options[:output].is_a?(String) ? File.open(@options[:output], 'w') : @options[:output]
+      end
+
+
+      # Publish message to STDOUT
+      def do_publish(message_class, serialized_message)
+        logger.debug { "[SmartMessage::StdoutTransport] do_publish called" }
+        logger.debug { "[SmartMessage::StdoutTransport] message_class: #{message_class}" }
+        
+        @output.puts format_message(message_class, serialized_message)
+        @output.flush
+      rescue => e
+        logger.error { "[SmartMessage] Error in stdout transport do_publish: #{e.class.name} - #{e.message}" }
+        raise
+      end
+
+      def connected?
+        !@output.closed?
+      end
+
+      def disconnect
+        @output.close if @output.respond_to?(:close) && @output != $stdout && @output != $stderr
+      end
+
+      # Override subscribe methods to log warnings since this is a publish-only transport
+      def subscribe(message_class, process_method, filter_options = {})
+        logger.warn { "[SmartMessage::StdoutTransport] Subscription attempt ignored - STDOUT transport is publish-only (message_class: #{message_class}, process_method: #{process_method})" }
+      end
+
+      def unsubscribe(message_class, process_method)
+        logger.warn { "[SmartMessage::StdoutTransport] Unsubscribe attempt ignored - STDOUT transport is publish-only (message_class: #{message_class}, process_method: #{process_method})" }
+      end
+
+      def unsubscribe!(message_class)
+        logger.warn { "[SmartMessage::StdoutTransport] Unsubscribe all attempt ignored - STDOUT transport is publish-only (message_class: #{message_class})" }
+      end
+
+      private
+
+      def format_message(message_class, serialized_message)
+        if @options[:format] == :json
+          # Output as JSON for machine parsing
+          {
+            transport: 'stdout',
+            message_class: message_class,
+            serialized_message: serialized_message,
+            timestamp: Time.now.iso8601
+          }.to_json
+        else
+          # Pretty format for human reading
+          <<~MESSAGE
+
+            ===================================================
+            == SmartMessage Published via STDOUT Transport
+            == Message Class: #{message_class}
+            == Serializer: #{@serializer.class.name}
+            == Serialized Message:
+            #{serialized_message}
+            ===================================================
+
+          MESSAGE
+        end
+      end
+    end
+  end
+end

data/lib/smart_message/version.rb

@@ -3,5 +3,5 @@
 # frozen_string_literal: true
 
 module SmartMessage
-  VERSION = '0.0.13'
+  VERSION = '0.0.16'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_message
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.16
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -319,6 +319,7 @@ files:
 - docs/reference/serializers.md
 - docs/reference/transports.md
 - docs/transports/memory-transport.md
+- docs/transports/multi-transport.md
 - docs/transports/redis-transport-comparison.md
 - docs/transports/redis-transport.md
 - examples/.gitignore
@@ -355,12 +356,19 @@ files:
 - examples/city_scenario/start_demo.sh
 - examples/city_scenario/stop_demo.sh
 - examples/city_scenario/visitor.rb
+- examples/file/00_run_all_file_demos.rb
+- examples/file/01_basic_file_transport_demo.rb
+- examples/file/02_fifo_transport_demo.rb
+- examples/file/03_file_watching_demo.rb
+- examples/file/04_multi_transport_file_demo.rb
+- examples/file/README.md
+- examples/memory/00_run_all_demos.rb
 - examples/memory/01_message_deduplication_demo.rb
 - examples/memory/02_dead_letter_queue_demo.rb
 - examples/memory/03_point_to_point_orders.rb
 - examples/memory/04_publish_subscribe_events.rb
 - examples/memory/05_many_to_many_chat.rb
-- examples/memory/06_pretty_print_demo.rb
+- examples/memory/06_stdout_publish_only.rb
 - examples/memory/07_proc_handlers_demo.rb
 - examples/memory/08_custom_logger_demo.rb
 - examples/memory/09_error_handling_demo.rb
@@ -370,10 +378,14 @@ files:
 - examples/memory/13_header_block_configuration.rb
 - examples/memory/14_global_configuration_demo.rb
 - examples/memory/15_logger_demo.rb
+- examples/memory/16_pretty_print_demo.rb
 - examples/memory/README.md
+- examples/memory/log/demo_app.log.1
+- examples/memory/log/demo_app.log.2
 - examples/memory/memory_transport_architecture.svg
 - examples/memory/point_to_point_pattern.svg
 - examples/memory/publish_subscribe_pattern.svg
+- examples/multi_transport_example.rb
 - examples/performance_metrics/benchmark_results_ractor_20250818_205603.json
 - examples/performance_metrics/benchmark_results_ractor_20250818_205831.json
 - examples/performance_metrics/benchmark_results_test_20250818_204942.json
@@ -394,13 +406,9 @@ files:
 - examples/redis/redis_transport_architecture.svg
 - examples/redis/smart_home_iot_dataflow.md
 - examples/redis/smart_home_system_architecture.svg
-- ideas/README.md
-- ideas/agents.md
-- ideas/database_transport.md
-- ideas/improvement.md
-- ideas/meshage.md
-- ideas/message_discovery.md
-- ideas/message_schema.md
+- examples/utilities/box_it.rb
+- examples/utilities/doing.rb
+- examples/utilities/temp.md
 - lib/simple_stats.rb
 - lib/smart_message.rb
 - lib/smart_message/.idea/.gitignore
@@ -437,15 +445,21 @@ files:
 - lib/smart_message/serializer/json.rb
 - lib/smart_message/subscription.rb
 - lib/smart_message/transport.rb
+- lib/smart_message/transport/async_publish_queue.rb
 - lib/smart_message/transport/base.rb
+- lib/smart_message/transport/fifo_operations.rb
+- lib/smart_message/transport/file_operations.rb
+- lib/smart_message/transport/file_transport.rb
+- lib/smart_message/transport/file_watching.rb
 - lib/smart_message/transport/memory_transport.rb
+- lib/smart_message/transport/partitioned_files.rb
 - lib/smart_message/transport/redis_transport.rb
 - lib/smart_message/transport/registry.rb
 - lib/smart_message/transport/stdout_transport.rb
+- lib/smart_message/transport/stdout_transport.rb.backup
 - lib/smart_message/utilities.rb
 - lib/smart_message/version.rb
 - lib/smart_message/versioning.rb
-- lib/smart_message/wrapper.rb.bak
 - mkdocs.yml
 - p2p_plan.md
 - p2p_roadmap.md

data/ideas/README.md

@@ -1,41 +0,0 @@
-# SmartMessage Ideas and Design Discussions
-
-This directory contains design discussions and architectural ideas for extending the SmartMessage framework. Each document explores a different aspect of potential enhancements to the system.
-
-## database_transport.md
-
-Explores implementing a database-backed transport layer for SmartMessage, enabling persistent message queuing and reliable delivery without requiring external message brokers like RabbitMQ or Kafka. This approach would store messages directly in a PostgreSQL or MySQL database, providing built-in persistence, transactional guarantees, and the ability to query message history.
-
-The design includes database schema definitions, message lifecycle management (pending, processing, completed, failed states), retry mechanisms with exponential backoff, and dead letter queue functionality. This transport would be particularly useful for applications that already have a database but don't want the operational complexity of managing a separate message broker, or for scenarios requiring long-term message retention and complex querying capabilities.
-
-## improvement.md
-
-Contains a comprehensive list of potential improvements and enhancements to the SmartMessage framework, covering areas from core functionality to developer experience. The ideas range from technical enhancements like performance optimizations and new transport implementations to architectural improvements such as better plugin systems and schema management.
-
-Key improvement areas include adding support for additional transports (Redis, AWS SQS, Google Pub/Sub), implementing message compression and encryption, enhancing the validation framework, improving error handling and retry logic, and adding comprehensive metrics and monitoring capabilities. The document also explores developer experience improvements like better debugging tools, enhanced documentation, and a potential web UI for message inspection.
-
-## message_discovery.md
-
-Focuses on the service discovery and dynamic class creation capabilities that would allow SmartMessage-based services to automatically discover and use message types from other services without manual integration. This system would enable services to query a central registry to find available message schemas and dynamically create the corresponding Ruby classes at runtime.
-
-The discovery mechanism includes APIs for browsing available message types by service, environment, or tags, dynamic class generation from stored schemas without requiring Ruby source files, and automatic synchronization when schemas are updated. This enables true microservice architectures where services can integrate with new message types without code changes or deployments, supporting patterns like partner integrations, multi-tenant systems, and runtime service composition.
-
-## message_schema.md
-
-Describes a comprehensive schema registry system that transforms SmartMessage from a messaging framework into a schema management platform. The core innovation is bidirectional conversion between SmartMessage Ruby classes and JSON Schema, enabling message definitions to be stored as data rather than code.
-
-The system includes automatic schema registration when classes are defined, version tracking and evolution management, and most importantly, the ability to serialize a Ruby class definition to JSON Schema and reconstruct it later using `to_json_schema` and `from_json_schema` methods. This enables powerful capabilities like storing schemas in databases, sharing schemas across different programming languages (with examples for Rust, Python, TypeScript, Go, and Java), runtime schema updates without deployment, and schema governance with approval workflows. The JSON Schema approach provides cross-language interoperability while maintaining safety (no code execution) and human readability, fundamentally changing how distributed systems manage message contracts.
-
-## meshage.md
-
-Explores implementing a true mesh network transport for SmartMessage that enables completely decentralized messaging with location-agnostic publishing. Unlike direct peer-to-peer systems, mesh networks allow publishers to send messages to service names without knowing which physical nodes host those services - the mesh automatically routes messages through intermediate nodes until they reach their destination or expire.
-
-The design emphasizes the key mesh network principles of complete decentralization, multi-hop message routing, and self-terminating messages with TTL. Services register themselves with the mesh, and the network maintains a distributed service directory that enables automatic route discovery. Messages can travel through multiple intermediate nodes (A → C → F → K) to reach their destination, with the mesh providing fault tolerance through alternate routing paths. The document incorporates insights from existing P2P libraries (journeta, p2p2) for proven patterns in NAT traversal, connection management, and network coordination. Multi-layer deduplication ensures message storms are prevented at subscriber, node, and network levels, while network control messages handle presence, health monitoring, and graceful shutdown protocols.
-
-## agents.md
-
-Comprehensive exploration of AI agents using SmartMessage for intelligent communication patterns. The document examines how AI agents represent the next evolution in distributed systems - intelligent entities that can make contextual decisions, adapt to scenarios, and communicate using natural language understanding combined with structured messaging.
-
-The analysis covers three complementary architecture patterns: Agent99 for request/response service coordination, SmartMessage AI for context-aware dynamic messaging, and hybrid approaches that combine both. Key innovations include contextual message selection where AI chooses appropriate message types based on scenarios, intelligent property generation using LLM understanding of validation constraints, and self-healing validation with automatic retry logic.
-
-The document includes a crucial analysis of Model Context Protocol (MCP) integration, demonstrating how MCP's resource sharing capabilities complement rather than compete with SmartMessage+Agent99. The integration creates a three-layer intelligence stack: Context Layer (MCP) for rich data access, Intelligence Layer (AI + SmartMessage) for smart decision making, and Coordination Layer (Agent99) for multi-agent orchestration. Real-world applications span smart city management, autonomous supply chains, and healthcare coordination systems, showing how these technologies enable truly intelligent distributed systems that understand context, communicate naturally, and coordinate seamlessly.