All the filtered loggers

Author: oxinabox

README.md

@@ -36,14 +36,18 @@ logger = global_logger()
 # Loggers introduced by this package:
 
 
-This package introduces 3 new loggers.
-The `DemuxLogger`, the `FilteredLogger` and the `FileLogger`.
+This package introduces 5 new loggers.
+The `DemuxLogger`, the `FileLogger`, and 3 types of filtered logger.
 All of them just wrap existing loggers.
-The `DemuxLogger` sends the logs to multiple different loggers.
-The `FilteredLogger` lets you add rules to cause a logger to ignore some inputs.
+ - The `DemuxLogger` sends the logs to multiple different loggers.
+ - The `FileLogger` is a simple logger sink that writes to file.
+ - The 3 filter loggers are used to control if a message is written or not
+     - The `MinLevelLogger` only allowes messages to pass that are above a given level of severity
+     - The `EarlyFilteredLogger` lets you write filter rules based on the `level`, `module`, `group` and `id` of the log message
+     - The `ActiveFilteredLogger` lets you filter based on the full content
 
 
-By combining `DemuxLogger` with `FilteredLogger`s you can arbitrarily route log messages, wherever you want.
+By combining `DemuxLogger` with filter loggers you can arbitrarily route log messages, wherever you want.
 
 The `FileLogger` is just a convience wrapper around the base julia `SimpleLogger`,
 to make it easier to pass in a filename, rather than a stream.
@@ -56,13 +60,13 @@ It takes a list of loggers.
 It also has the keyword argument `include_current_global`,
 to determine if you also want to log to the global logger.
 
-It is up to those loggers to determine if they will accept it.\
+It is up to those loggers to determine if they will accept it.
 Which they do using their methods for `shouldlog` and `min_enabled_level`.
-Or you can do, by wrapping them in a `FilteredLogger` as discussed below.
+Or you can do, by wrapping them in a filtered logger  as discussed below.
 
 The `FileLogger` does logging to file.
 It is really simple.
-It takes a filename; and the minimum level it should log.
+It takes a filename.
 
 ### Demo
 We are going to log info and above to one file,
@@ -72,8 +76,8 @@ and warnings and above to another.
 julia> using Logging; using LoggingExtras;
 
 julia> demux_logger = DemuxLogger(
-		FileLogger("info.log", min_level=Logging.Info),
-		FileLogger("warn.log", min_level=Logging.Warn),
+		MinLevelLogger(FileLogger("info.log"), Logging.Info),
+		MinLevelLogger(FileLogger("warn.log"), Logging.Warn),
 		include_current_global=false
 		);
 

src/LoggingExtras.jl

@@ -9,10 +9,33 @@ import Base.CoreLogging:
 	handle_message, shouldlog, min_enabled_level, catch_exceptions
 
 export demux_global_logger,
-    DemuxLogger, ActiveFilteredLogger, FileLogger
+    DemuxLogger, 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("demuxlogger.jl")
 include("activefiltered.jl")
+include("earlyfiltered.jl")
+include("minlevelfiltered.jl")
 include("filelogger.jl")
 
 end # module

src/activefiltered.jl

@@ -17,7 +17,7 @@ The `filter` should be a function that returns a boolean.
 `true` if the message should be logged and `false` if not.
 As input it will be given a named tuple with the following fields:
 `(level, message, _module, group, id, file, line, kwargs)`
-See `?LoggingExtra.HandleMessageArgs` for more information on what each is.
+See `?LoggingExtra.handle_message_ags` for more information on what each is.
 """
 struct ActiveFilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
 	filter::F
@@ -26,25 +26,25 @@ end
 
 
 function handle_message(logger::ActiveFilteredLogger, args...; kwargs...)
-    log_args = HandleMessageArgs(args...; kwargs...)
-    if logger.filter(log_args)
-		handle_message(logger.logger, args...; kwargs...)
-	end
+    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...)
+	    end
+    end
 end
 
-# As an optimisation, we query if the logger we are sending this to will accept
-# this log. If not then there is no point in us taking it
 function shouldlog(logger::ActiveFilteredLogger, args...)
-    return shouldlog(logger.logger, args...)
+    return comp_shouldlog(logger.logger, args...)
 end
 
 min_enabled_level(logger::ActiveFilteredLogger) = min_enabled_level(logger.logger)
 catch_exceptions(logger::ActiveFilteredLogger) = catch_exceptions(logger.logger)
 
 """
-    HandleMessageArgs
+    handle_message_args
 
-This is an alias for a NamedTuple containing all the arguments the logger gives
+This creates NamedTuple containing all the arguments the logger gives
 to `handle_message`
 It is the type pased to the active logger filter.
 These argument come from the logging macro (@info`, `@warn` etc).
@@ -62,7 +62,7 @@ These argument come from the logging macro (@info`, `@warn` etc).
     source location of a log message.
   * `kwargs...`: Any  keyword or position arguments passed to the logging macro
 """
-function HandleMessageArgs(args...; kwargs...)
+function handle_message_args(args...; kwargs...)
     fieldnames = (:level, :message, :_module, :group, :id, :file, :line, :kwargs)
     fieldvals = (args..., kwargs)
     return NamedTuple{fieldnames, typeof(fieldvals)}(fieldvals)

src/demuxlogger.jl

@@ -21,17 +21,16 @@ function DemuxLogger(loggers::Vararg{AbstractLogger}; include_current_global=tru
 	DemuxLogger(loggers)
 end
 
-function handle_message(demux::DemuxLogger, level, message, _module, group, id, file, line; kwargs...)
+function handle_message(demux::DemuxLogger, args...; kwargs...)
 	for logger in demux.loggers
-        if min_enabled_level(logger)<= level &&  shouldlog(logger,  level, _module, group, id)
-            # we bypassed those checks above, so we got to check them for each
-			handle_message(logger, level, message, _module, group, id, file, line; kwargs...)
+        if comp_handle_message_check(logger, args...; kwargs...)
+			handle_message(logger, args...; kwargs...)
 		end
 	end
 end
 
-function shouldlog(demux::DemuxLogger, level, _module, group, id)
-	any(shouldlog(logger, level, _module, group, id) for logger in demux.loggers)
+function shouldlog(demux::DemuxLogger, args...)
+	any(comp_shouldlog(logger, args...) for logger in demux.loggers)
 end
 
 function min_enabled_level(demux::DemuxLogger)

src/filelogger.jl

@@ -1,7 +1,3 @@
-# TODO: Maybe this should just be a function
-# It is a super thing wrapper around a SimpleLogger
-
-
 struct FileLogger <: AbstractLogger
 	logger::SimpleLogger
     always_flush::Bool

test/runtests.jl

@@ -52,3 +52,35 @@ end
     end
     @test length(testlogger.logs) == 2
 end
+
+@testset "Early Filter" begin
+    testlogger = TestLogger()
+    filtered_logger = EarlyFilteredLogger(testlogger) do logargs
+        logargs.level == Info  # Only exactly Info, nothing more nothing less
+    end
+    
+    with_logger(filtered_logger) do
+        @info "info1"
+        @warn "Yo Dawg! It is a warning"
+        @info "info2"
+        @info "Yo Dawg! It's all good"
+    end
+    @test length(testlogger.logs) == 3
+end
+
+@testset "MinLevel Filter" begin
+    testlogger = TestLogger()
+    filtered_logger = MinLevelLogger(testlogger, Warn)
+    
+    with_logger(filtered_logger) do
+        @info "info1"
+        @warn "Yo Dawg! It is a warning"
+        @info "info2"
+        @info "Yo Dawg! It's all good"
+        @info "info 3"
+        @error "MISTAKES WERE MADE"
+    end
+    @test length(testlogger.logs) == 2
+end
+
+