Return from handle_message as to if message was handled or not

src/LoggingExtras.jl

@@ -12,24 +12,7 @@ export TeeLogger, TransformerLogger, FileLogger,
     ActiveFilteredLogger, EarlyFilteredLogger, MinLevelLogger
 
 
-######
-# Utilities for dealing with compositional loggers.
-# Since the logging system itself will not engage its checks
-# Once the first logger has started, any compositional logger needs to check
-# before passing anything on.
-
-# For checking child logger, need to check both `min_enabled_level` and `shouldlog`
-function comp_shouldlog(logger, args...)
-    level = first(args)
-    min_enabled_level(logger) <= level && shouldlog(logger, args...)
-end
-
-# For checking if child logger will take the message you are sending
-function comp_handle_message_check(logger, args...; kwargs...)
-    level, message, _module, group, id, file, line = args
-    return comp_shouldlog(logger, level, _module, group, id)
-end
-###############################
+include("common.jl")
 
 include("tee.jl")
 include("transformer.jl")

src/activefiltered.jl

@@ -29,9 +29,11 @@ function handle_message(logger::ActiveFilteredLogger, args...; kwargs...)
     log_args = handle_message_args(args...; kwargs...)
     if comp_handle_message_check(logger.logger, args...; kwargs...)
         if logger.filter(log_args)
-            handle_message(logger.logger, args...; kwargs...)
+            return handle_message(logger.logger, args...; kwargs...)
         end
     end
+    # otherwise
+    return MessageHandled(false)
 end
 
 function shouldlog(logger::ActiveFilteredLogger, args...)

src/common.jl

@@ -0,0 +1,36 @@
+
+"""
+    MessageHandled(::Bool)
+
+`MessageHandled(false)` should be returned from a `handle_message` on a logger,
+if it did not actually handle the log message.
+For example, if the log message was below the level it should log.
+This is of particular relevance to the [`ActiveFilteredLogger`](@ref), which can't know
+util `handle_message` if a log message will be filtered or not.
+Ideally, `MessageHandled(true)` would be returned from loggers when when they
+successfully handled a message, however this is not strictly required.
+E.g Sinks should always return `MessageHandled(true)`.
+"""
+struct MessageHandled
+    val :: Bool
+end
+
+was_handled(response) = true  # If we don;t get a MessageHandled then assume worked
+was_handled(response::MessageHandled) = response.val
+
+
+# Since the logging system itself will not engage its checks
+# Once the first logger has started, any compositional logger needs to check
+# before passing anything on.
+
+# For checking child logger, need to check both `min_enabled_level` and `shouldlog`
+function comp_shouldlog(logger, args...)
+    level = first(args)
+    min_enabled_level(logger) <= level && shouldlog(logger, args...)
+end
+
+# For checking if child logger will take the message you are sending
+function comp_handle_message_check(logger, args...; kwargs...)
+    level, message, _module, group, id, file, line = args
+    return comp_shouldlog(logger, level, _module, group, id)
+end

src/earlyfiltered.jl

@@ -24,6 +24,8 @@ end
 function handle_message(logger::EarlyFilteredLogger, args...; kwargs...)
     if comp_handle_message_check(logger.logger, args...; kwargs...)
         return handle_message(logger.logger, args...; kwargs...)
+    else
+        return MessageHandled(false)
     end
 end
 

src/filelogger.jl

@@ -12,6 +12,7 @@ end
 function handle_message(filelogger::FileLogger, args...; kwargs...)
     handle_message(filelogger.logger, args...; kwargs...)
     filelogger.always_flush && flush(filelogger.logger.stream)
+    return MessageHandled(true)
 end
 shouldlog(filelogger::FileLogger, arg...) = true
 min_enabled_level(filelogger::FileLogger) = BelowMinLevel

src/minlevelfiltered.jl

@@ -15,6 +15,8 @@ end
 function handle_message(logger::MinLevelLogger, args...; kwargs...)
     if comp_handle_message_check(logger.logger, args...; kwargs...)
         return handle_message(logger.logger, args...; kwargs...)
+    else
+        return MessageHandled(false)
     end
 end
 

src/tee.jl

@@ -19,11 +19,14 @@ function TeeLogger(loggers::Vararg{AbstractLogger})
 end
 
 function handle_message(demux::TeeLogger, args...; kwargs...)
+    handled = false
     for logger in demux.loggers
         if comp_handle_message_check(logger, args...; kwargs...)
-            handle_message(logger, args...; kwargs...)
+            resp = handle_message(logger, args...; kwargs...)
+            handled |= was_handled(resp)
         end
     end
+    return MessageHandled(handled)
 end
 
 function shouldlog(demux::TeeLogger, args...)

src/transformer.jl

@@ -25,7 +25,9 @@ function handle_message(transformer::TransformerLogger, args...; kwargs...)
     kwargs = new_log_args.kwargs
 
     if comp_handle_message_check(transformer.logger, args...; kwargs...)
-        handle_message(transformer.logger, args...; kwargs...)
+        return handle_message(transformer.logger, args...; kwargs...)
+    else
+        return MessageHandled(false)
     end
 end