Added support for broadcast_to

Author: ndbroadbent

lib/log_struct/semantic_logger/concerns/log_methods.rb

@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module SemanticLogger
+    module Concerns
+      module LogMethods
+        extend T::Sig
+        extend T::Helpers
+        requires_ancestor { LogStruct::SemanticLogger::Logger }
+
+        # Override log methods to handle LogStruct types and broadcast
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def debug(message = nil, payload = nil, &block)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:debug)
+            message.is_a?(String) ? logger.debug(message) : (logger.debug(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def info(message = nil, payload = nil, &block)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:info)
+            message.is_a?(String) ? logger.info(message) : (logger.info(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def warn(message = nil, payload = nil, &block)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:warn)
+            message.is_a?(String) ? logger.warn(message) : (logger.warn(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def error(message = nil, payload = nil, &block)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:error)
+            message.is_a?(String) ? logger.error(message) : (logger.error(&block) if block)
+          end
+          result
+        end
+
+        sig { params(message: T.untyped, payload: T.untyped, block: T.nilable(T.proc.returns(String))).returns(T::Boolean) }
+        def fatal(message = nil, payload = nil, &block)
+          result = if message.is_a?(LogStruct::Log::Interfaces::CommonFields) || message.is_a?(T::Struct) || message.is_a?(Hash)
+            super(nil, payload: message, &block)
+          else
+            super
+          end
+          broadcasts.each do |logger|
+            next unless logger.respond_to?(:fatal)
+            message.is_a?(String) ? logger.fatal(message) : (logger.fatal(&block) if block)
+          end
+          result
+        end
+      end
+    end
+  end
+end

lib/log_struct/semantic_logger/logger.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "semantic_logger"
+require_relative "concerns/log_methods"
 
 module LogStruct
   module SemanticLogger
@@ -69,25 +70,31 @@ class Logger < ::SemanticLogger::Logger
       def initialize(name = "Application", level: nil, filter: nil)
         # SemanticLogger::Logger expects positional arguments, not named arguments
         super(name, level, filter)
+        # T.untyped because users can pass any logger: ::Logger, ActiveSupport::Logger,
+        # custom loggers (FakeLogger in tests), or third-party loggers
+        @broadcasts = T.let([], T::Array[T.untyped])
       end
 
-      # Override log methods to handle LogStruct types
-      %i[debug info warn error fatal].each do |level|
-        define_method(level) do |message = nil, payload = nil, &block|
-          # If message is a LogStruct type, use it as payload
-          if message.is_a?(LogStruct::Log::Interfaces::CommonFields) ||
-              message.is_a?(T::Struct) ||
-              message.is_a?(Hash)
-            payload = message
-            message = nil
-            super(message, payload: payload, &block)
-          else
-            # For plain string messages, pass them through normally
-            super(message, payload, &block)
-          end
-        end
+      # ActiveSupport::BroadcastLogger compatibility
+      # These methods allow Rails.logger to broadcast to multiple loggers
+      sig { returns(T::Array[T.untyped]) }
+      attr_reader :broadcasts
+
+      # T.untyped for logger param because we accept any logger-like object:
+      # ::Logger, ActiveSupport::Logger, test doubles, etc.
+      sig { params(logger: T.untyped).returns(T.untyped) }
+      def broadcast_to(logger)
+        @broadcasts << logger
+        logger
+      end
+
+      sig { params(logger: T.untyped).void }
+      def stop_broadcasting_to(logger)
+        @broadcasts.delete(logger)
       end
 
+      include Concerns::LogMethods
+
       # Support for tagged logging
       sig { params(tags: T.untyped, block: T.proc.returns(T.untyped)).returns(T.untyped) }
       def tagged(*tags, &block)
@@ -124,6 +131,14 @@ def push_tags(*tags)
       def pop_tags(count = 1)
         ::SemanticLogger.pop_tags(count)
       end
+
+      # Support for << operator (used by RailsLogSplitter)
+      sig { params(msg: String).returns(T.self_type) }
+      def <<(msg)
+        info(msg)
+        @broadcasts.each { |logger| logger << msg if logger.respond_to?(:<<) }
+        self
+      end
     end
   end
 end

test/log_struct/semantic_logger_test.rb

@@ -120,6 +120,98 @@ class SemanticLoggerTest < ActiveSupport::TestCase
       assert_respond_to @logger, :push_tags
       assert_respond_to @logger, :pop_tags
       assert_respond_to @logger, :clear_tags!
+      # ActiveSupport::BroadcastLogger compatibility
+      assert_respond_to @logger, :broadcast_to
+      assert_respond_to @logger, :stop_broadcasting_to
+      assert_respond_to @logger, :broadcasts
+      assert_respond_to @logger, :<<
+    end
+
+    test "supports broadcast_to for multiple loggers" do
+      # Create a secondary logger to broadcast to
+      secondary_io = StringIO.new
+      secondary_logger = Logger.new(secondary_io)
+
+      # Add secondary logger to broadcasts
+      @logger.broadcast_to(secondary_logger)
+
+      # Log a message
+      @logger.info("Test broadcast message")
+      ::SemanticLogger.flush
+
+      # Check main logger output
+      main_output = @io.string
+
+      assert_includes main_output, "Test broadcast message"
+
+      # Check secondary logger output
+      secondary_output = secondary_io.string
+
+      assert_includes secondary_output, "Test broadcast message"
+    end
+
+    test "stop_broadcasting_to removes logger from broadcasts" do
+      secondary_io = StringIO.new
+      secondary_logger = Logger.new(secondary_io)
+
+      @logger.broadcast_to(secondary_logger)
+      @logger.stop_broadcasting_to(secondary_logger)
+
+      @logger.info("After removal")
+      ::SemanticLogger.flush
+
+      # Main logger should have output
+      assert_includes @io.string, "After removal"
+
+      # Secondary logger should NOT have output
+      assert_empty secondary_io.string
+    end
+
+    test "broadcasts array returns all broadcast loggers" do
+      logger1 = Logger.new(StringIO.new)
+      logger2 = Logger.new(StringIO.new)
+
+      @logger.broadcast_to(logger1)
+      @logger.broadcast_to(logger2)
+
+      assert_equal 2, @logger.broadcasts.length
+      assert_includes @logger.broadcasts, logger1
+      assert_includes @logger.broadcasts, logger2
+    end
+
+    test "supports << operator for appending messages" do
+      secondary_io = StringIO.new
+      secondary_logger = Logger.new(secondary_io)
+
+      @logger.broadcast_to(secondary_logger)
+      @logger << "Appended message"
+      ::SemanticLogger.flush
+
+      # Check main logger output
+      assert_includes @io.string, "Appended message"
+
+      # Check secondary logger output
+      assert_includes secondary_io.string, "Appended message"
+    end
+
+    test "broadcast works with different log levels" do
+      secondary_io = StringIO.new
+      secondary_logger = Logger.new(secondary_io)
+
+      @logger.broadcast_to(secondary_logger)
+
+      @logger.debug("Debug message")
+      @logger.info("Info message")
+      @logger.warn("Warn message")
+      @logger.error("Error message")
+      ::SemanticLogger.flush
+
+      secondary_output = secondary_io.string
+
+      assert_includes secondary_output, "Debug message"
+      assert_includes secondary_output, "Info message"
+      assert_includes secondary_output, "Warn message"
+      assert_includes secondary_output, "Error message"
     end
 
     test "handles errors gracefully" do