smart_message 0.0.2 → 0.0.4

data/lib/smart_message/logger/default.rb

@@ -0,0 +1,217 @@
+# lib/smart_message/logger/default.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'logger'
+require 'fileutils'
+require 'stringio'
+
+module SmartMessage
+  module Logger
+    # Default logger implementation for SmartMessage
+    # 
+    # This logger automatically detects and uses the best available logging option:
+    # - Rails.logger if running in a Rails application
+    # - Standard Ruby Logger writing to log/smart_message.log otherwise
+    #
+    # Usage:
+    #   # In your message class
+    #   config do
+    #     logger SmartMessage::Logger::Default.new
+    #   end
+    #
+    #   # Or with custom options
+    #   config do
+    #     logger SmartMessage::Logger::Default.new(
+    #       log_file: 'custom/path.log',    # File path
+    #       level: Logger::DEBUG
+    #     )
+    #   end
+    #
+    #   # To log to STDOUT instead of a file
+    #   config do
+    #     logger SmartMessage::Logger::Default.new(
+    #       log_file: STDOUT,               # STDOUT or STDERR
+    #       level: Logger::INFO
+    #     )
+    #   end
+    class Default < Base
+      attr_reader :logger, :log_file, :level
+      
+      def initialize(log_file: nil, level: nil)
+        @log_file = log_file || default_log_file
+        @level = level || default_log_level
+        
+        @logger = setup_logger
+      end
+      
+      # Message lifecycle logging methods
+      
+      def log_message_created(message)
+        logger.debug { "[SmartMessage] Created: #{message.class.name} - #{message_summary(message)}" }
+      end
+      
+      def log_message_published(message, transport)
+        logger.info { "[SmartMessage] Published: #{message.class.name} via #{transport.class.name.split('::').last}" }
+      end
+      
+      def log_message_received(message_class, payload)
+        logger.info { "[SmartMessage] Received: #{message_class.name} (#{payload.bytesize} bytes)" }
+      end
+      
+      def log_message_processed(message_class, result)
+        logger.info { "[SmartMessage] Processed: #{message_class.name} - #{truncate(result.to_s, 100)}" }
+      end
+      
+      def log_message_subscribe(message_class, handler = nil)
+        handler_desc = handler ? " with handler: #{handler}" : ""
+        logger.info { "[SmartMessage] Subscribed: #{message_class.name}#{handler_desc}" }
+      end
+      
+      def log_message_unsubscribe(message_class)
+        logger.info { "[SmartMessage] Unsubscribed: #{message_class.name}" }
+      end
+      
+      # Error logging
+      
+      def log_error(context, error)
+        logger.error { "[SmartMessage] Error in #{context}: #{error.class.name} - #{error.message}" }
+        logger.debug { "[SmartMessage] Backtrace:\n#{error.backtrace.join("\n")}" } if error.backtrace
+      end
+      
+      def log_warning(message)
+        logger.warn { "[SmartMessage] Warning: #{message}" }
+      end
+      
+      # General purpose logging methods matching Ruby's Logger interface
+      
+      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
+      
+      private
+      
+      def setup_logger
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          # Use Rails logger if available
+          setup_rails_logger
+        else
+          # Use standard Ruby logger
+          setup_ruby_logger
+        end
+      end
+      
+      def setup_rails_logger
+        # Wrap Rails.logger to ensure our messages are properly tagged
+        RailsLoggerWrapper.new(Rails.logger, level: @level)
+      end
+      
+      def setup_ruby_logger
+        # Handle IO objects (STDOUT, STDERR) vs file paths
+        if @log_file.is_a?(IO) || @log_file.is_a?(StringIO)
+          # For STDOUT/STDERR, don't use rotation
+          ruby_logger = ::Logger.new(@log_file)
+        else
+          # For file paths, ensure directory exists and use rotation
+          FileUtils.mkdir_p(File.dirname(@log_file))
+          
+          ruby_logger = ::Logger.new(
+            @log_file,
+            10,           # Keep 10 old log files
+            10_485_760    # Rotate when file reaches 10MB
+          )
+        end
+        
+        ruby_logger.level = @level
+        
+        # Set a clean formatter
+        ruby_logger.formatter = proc do |severity, datetime, progname, msg|
+          timestamp = datetime.strftime('%Y-%m-%d %H:%M:%S.%3N')
+          "[#{timestamp}] #{severity.ljust(5)} -- : #{msg}\n"
+        end
+        
+        ruby_logger
+      end
+      
+      def default_log_file
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.join('log', 'smart_message.log').to_s
+        else
+          'log/smart_message.log'
+        end
+      end
+      
+      def default_log_level
+        if defined?(Rails) && Rails.respond_to?(:env)
+          case Rails.env
+          when 'production'
+            ::Logger::INFO
+          when 'test'
+            ::Logger::ERROR
+          else
+            ::Logger::DEBUG
+          end
+        else
+          # Default to INFO for non-Rails environments
+          ::Logger::INFO
+        end
+      end
+      
+      def message_summary(message)
+        # Create a brief summary of the message for logging
+        if message.respond_to?(:to_h)
+          data = message.to_h
+          # Remove internal header for cleaner logs
+          data.delete(:_sm_header)
+          data.delete('_sm_header')
+          truncate(data.inspect, 200)
+        else
+          truncate(message.inspect, 200)
+        end
+      end
+      
+      def truncate(string, max_length)
+        return string if string.length <= max_length
+        "#{string[0...max_length]}..."
+      end
+      
+      # Internal wrapper for Rails.logger to handle tagged logging
+      class RailsLoggerWrapper
+        def initialize(rails_logger, level: nil)
+          @rails_logger = rails_logger
+          @rails_logger.level = level if level
+        end
+        
+        def method_missing(method, *args, &block)
+          if @rails_logger.respond_to?(:tagged)
+            @rails_logger.tagged('SmartMessage') do
+              @rails_logger.send(method, *args, &block)
+            end
+          else
+            @rails_logger.send(method, *args, &block)
+          end
+        end
+        
+        def respond_to_missing?(method, include_private = false)
+          @rails_logger.respond_to?(method, include_private)
+        end
+      end
+    end
+  end
+end

data/lib/smart_message/logger.rb

@@ -3,5 +3,13 @@
 # frozen_string_literal: true
 
 module SmartMessage::Logger
-  # TODO: write this
+  # Logger module provides logging capabilities for SmartMessage
+  # The Default logger automatically uses Rails.logger if available,
+  # otherwise falls back to a standard Ruby Logger
 end # module SmartMessage::Logger
+
+# Load the base class first
+require_relative 'logger/base'
+
+# Load the default logger implementation
+require_relative 'logger/default'

data/lib/smart_message/transport/redis_transport.rb

@@ -0,0 +1,190 @@
+# lib/smart_message/transport/redis_transport.rb
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'redis'
+require 'securerandom'
+require 'set'
+
+module SmartMessage
+  module Transport
+    # Redis pub/sub transport for SmartMessage
+    # Uses message class name as the Redis channel name
+    class RedisTransport < Base
+      attr_reader :redis_pub, :redis_sub, :subscriber_thread
+
+      def default_options
+        {
+          url: 'redis://localhost:6379',
+          db: 0,
+          auto_subscribe: true,
+          reconnect_attempts: 5,
+          reconnect_delay: 1
+        }
+      end
+
+      def configure
+        @redis_pub = Redis.new(url: @options[:url], db: @options[:db])
+        @redis_sub = Redis.new(url: @options[:url], db: @options[:db])
+        @subscribed_channels = Set.new
+        @subscriber_thread = nil
+        @running = false
+        @mutex = Mutex.new
+        
+        start_subscriber if @options[:auto_subscribe]
+      end
+
+      # Publish message to Redis channel using message class name
+      def publish(message_header, message_payload)
+        channel = message_header.message_class
+        
+        begin
+          @redis_pub.publish(channel, message_payload)
+        rescue Redis::ConnectionError
+          retry_with_reconnect('publish') { @redis_pub.publish(channel, message_payload) }
+        end
+      end
+
+      # Subscribe to a message class (Redis channel)
+      def subscribe(message_class, process_method)
+        super(message_class, process_method)
+        
+        @mutex.synchronize do
+          @subscribed_channels.add(message_class)
+          restart_subscriber if @running
+        end
+      end
+
+      # Unsubscribe from a specific message class and process method
+      def unsubscribe(message_class, process_method)
+        super(message_class, process_method)
+        
+        @mutex.synchronize do
+          # If no more subscribers for this message class, unsubscribe from channel
+          if @dispatcher.subscribers[message_class].nil? || @dispatcher.subscribers[message_class].empty?
+            @subscribed_channels.delete(message_class)
+            restart_subscriber if @running
+          end
+        end
+      end
+
+      # Unsubscribe from all process methods for a message class
+      def unsubscribe!(message_class)
+        super(message_class)
+        
+        @mutex.synchronize do
+          @subscribed_channels.delete(message_class)
+          restart_subscriber if @running
+        end
+      end
+
+      def connected?
+        begin
+          @redis_pub.ping == 'PONG' && @redis_sub.ping == 'PONG'
+        rescue Redis::ConnectionError
+          false
+        end
+      end
+
+      def connect
+        @redis_pub.ping
+        @redis_sub.ping
+        start_subscriber unless @running
+      end
+
+      def disconnect
+        stop_subscriber
+        @redis_pub.quit if @redis_pub
+        @redis_sub.quit if @redis_sub
+      end
+
+      private
+
+      def start_subscriber
+        return if @running
+        
+        @running = true
+        @subscriber_thread = Thread.new do
+          begin
+            subscribe_to_channels
+          rescue => e
+            # Log error but don't crash the thread
+            puts "Redis subscriber error: #{e.message}" if @options[:debug]
+            retry_subscriber
+          end
+        end
+      end
+
+      def stop_subscriber
+        @running = false
+        
+        if @subscriber_thread
+          @subscriber_thread.kill
+          @subscriber_thread.join(5) # Wait up to 5 seconds
+          @subscriber_thread = nil
+        end
+      end
+
+      def restart_subscriber
+        stop_subscriber
+        start_subscriber if @subscribed_channels.any?
+      end
+
+      def subscribe_to_channels
+        return unless @subscribed_channels.any?
+        
+        begin
+          @redis_sub.subscribe(*@subscribed_channels) do |on|
+            on.message do |channel, message_payload|
+              # Create a header with the channel as message_class
+              message_header = SmartMessage::Header.new(
+                message_class: channel,
+                uuid: SecureRandom.uuid,
+                published_at: Time.now,
+                publisher_pid: 'redis_subscriber'
+              )
+              
+              receive(message_header, message_payload)
+            end
+            
+            on.subscribe do |channel, subscriptions|
+              puts "Subscribed to Redis channel: #{channel} (#{subscriptions} total)" if @options[:debug]
+            end
+            
+            on.unsubscribe do |channel, subscriptions|
+              puts "Unsubscribed from Redis channel: #{channel} (#{subscriptions} total)" if @options[:debug]
+            end
+          end
+        rescue => e
+          # Silently handle connection errors during subscription
+          puts "Redis subscription error: #{e.class.name}" if @options[:debug]
+          retry_subscriber if @running
+        end
+      end
+
+      def retry_subscriber
+        return unless @running
+        
+        sleep(@options[:reconnect_delay])
+        subscribe_to_channels if @running
+      end
+
+      def retry_with_reconnect(operation)
+        attempts = 0
+        begin
+          yield
+        rescue Redis::ConnectionError => e
+          attempts += 1
+          if attempts <= @options[:reconnect_attempts]
+            sleep(@options[:reconnect_delay])
+            # Reconnect
+            @redis_pub = Redis.new(url: @options[:url], db: @options[:db])
+            retry
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smart_message/transport/registry.rb

@@ -53,6 +53,7 @@ module SmartMessage
         # Register built-in transports
         register(:stdout, SmartMessage::Transport::StdoutTransport)
         register(:memory, SmartMessage::Transport::MemoryTransport)
+        register(:redis, SmartMessage::Transport::RedisTransport)
       end
     end
   end

data/lib/smart_message/transport.rb

@@ -6,6 +6,7 @@ require_relative 'transport/base'
 require_relative 'transport/registry'
 require_relative 'transport/stdout_transport'
 require_relative 'transport/memory_transport'
+require_relative 'transport/redis_transport'
 
 module SmartMessage
   # Transport layer abstraction for SmartMessage

data/lib/smart_message/version.rb

@@ -3,5 +3,5 @@
 # frozen_string_literal: true
 
 module SmartMessage
-  VERSION = "0.0.2"
+  VERSION = '0.0.4'
 end

data/smart_message.gemspec

@@ -39,6 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'hashie'
   spec.add_dependency 'activesupport'
   spec.add_dependency 'concurrent-ruby'
+  spec.add_dependency 'redis'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_message
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -190,14 +204,22 @@ files:
 - docs/examples.md
 - docs/getting-started.md
 - docs/ideas_to_think_about.md
+- docs/logging.md
+- docs/message_processing.md
+- docs/proc_handlers_summary.md
 - docs/properties.md
 - docs/serializers.md
 - docs/transports.md
 - docs/troubleshooting.md
+- examples/.gitignore
 - examples/01_point_to_point_orders.rb
 - examples/02_publish_subscribe_events.rb
 - examples/03_many_to_many_chat.rb
+- examples/04_redis_smart_home_iot.rb
+- examples/05_proc_handlers.rb
+- examples/06_custom_logger_example.rb
 - examples/README.md
+- examples/smart_home_iot_dataflow.md
 - examples/tmux_chat/README.md
 - examples/tmux_chat/bot_agent.rb
 - examples/tmux_chat/human_agent.rb
@@ -214,6 +236,7 @@ files:
 - lib/smart_message/header.rb
 - lib/smart_message/logger.rb
 - lib/smart_message/logger/base.rb
+- lib/smart_message/logger/default.rb
 - lib/smart_message/property_descriptions.rb
 - lib/smart_message/serializer.rb
 - lib/smart_message/serializer/base.rb
@@ -221,6 +244,7 @@ files:
 - lib/smart_message/transport.rb
 - lib/smart_message/transport/base.rb
 - lib/smart_message/transport/memory_transport.rb
+- lib/smart_message/transport/redis_transport.rb
 - lib/smart_message/transport/registry.rb
 - lib/smart_message/transport/stdout_transport.rb
 - lib/smart_message/version.rb