From be8024d9991b834b3ffc896e9bec141a6e270e0e Mon Sep 17 00:00:00 2001 From: Lyndon White Date: Wed, 6 Nov 2019 11:08:50 +0000 Subject: [PATCH 1/2] Add tracking of if message was handled or not --- src/LoggingExtras.jl | 19 +------------------ src/activefiltered.jl | 4 +++- src/common.jl | 36 ++++++++++++++++++++++++++++++++++++ src/earlyfiltered.jl | 2 ++ src/filelogger.jl | 1 + src/minlevelfiltered.jl | 2 ++ src/tee.jl | 5 ++++- src/transformer.jl | 4 +++- 8 files changed, 52 insertions(+), 21 deletions(-) create mode 100644 src/common.jl diff --git a/src/LoggingExtras.jl b/src/LoggingExtras.jl index 68d8e14..5ec1954 100644 --- a/src/LoggingExtras.jl +++ b/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") diff --git a/src/activefiltered.jl b/src/activefiltered.jl index 7f72e55..5d2fada 100644 --- a/src/activefiltered.jl +++ b/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...) diff --git a/src/common.jl b/src/common.jl new file mode 100644 index 0000000..7e29ff1 --- /dev/null +++ b/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 +til `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 diff --git a/src/earlyfiltered.jl b/src/earlyfiltered.jl index b3a0f05..b5421a2 100644 --- a/src/earlyfiltered.jl +++ b/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 diff --git a/src/filelogger.jl b/src/filelogger.jl index 7b7edcb..a9095ea 100644 --- a/src/filelogger.jl +++ b/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 diff --git a/src/minlevelfiltered.jl b/src/minlevelfiltered.jl index 0819a67..d69e5e8 100644 --- a/src/minlevelfiltered.jl +++ b/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 diff --git a/src/tee.jl b/src/tee.jl index ba46409..ac01037 100644 --- a/src/tee.jl +++ b/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...) diff --git a/src/transformer.jl b/src/transformer.jl index ec426cb..80db006 100644 --- a/src/transformer.jl +++ b/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 From 1c979ae67113ce91c50250e30956d40027e9e909 Mon Sep 17 00:00:00 2001 From: Lyndon White Date: Tue, 12 Nov 2019 09:09:32 +0000 Subject: [PATCH 2/2] Update src/common.jl Co-Authored-By: Chris Foster --- src/common.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/common.jl b/src/common.jl index 7e29ff1..77be583 100644 --- a/src/common.jl +++ b/src/common.jl @@ -6,7 +6,7 @@ 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 -til `handle_message` if a log message will be filtered or not. +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)`.