Propagate Log Level Override (#67)

Author: oxinabox

src/CompositionalLoggers/overridelogger.jl

@@ -22,3 +22,39 @@ end
 
 min_enabled_level(logger::LevelOverrideLogger) = logger.level
 catch_exceptions(logger::LevelOverrideLogger) = catch_exceptions(logger.logger)
+
+#################################################################################
+# Propagating the constructor down to places it is needed
+
+# fallback case, not a logger we know about, assume it is a sink
+propagate_level_override(level, sink) = LevelOverrideLogger(level, sink)
+
+
+for L in (ActiveFilteredLogger, EarlyFilteredLogger,  TransformerLogger)
+    @eval function propagate_level_override(level, logger::$L)
+        # these loggers don't level filter on their own, just based on what they wrap
+        # so just need to propagate on to what they wrapped
+        return $L(getfield(logger, 1), propagate_level_override(level, logger.logger))
+    end
+end
+
+function propagate_level_override(level, logger::MinLevelLogger)
+    # override overpowers any MinLevelLogger so can drop that, and just propagate on to sink
+    #TODO: CHECK ME is this right for both MinLevelLoggers that are higher and also that are lower?
+    return propagate_level_override(level, logger.logger)
+end
+
+function propagate_level_override(level, logger::LevelOverrideLogger)
+    # overriding the override: just use the new one, and propagate
+    return LevelOverrideLogger(level, propagate_level_override(level, logger.logger))
+end
+
+function propagate_level_override(level, logger::TeeLogger)
+    # We are going to propage through each of them, this is not unarguably the universal
+    # the right choice, but it is consistent. For more control should construct directly
+    new_backings = map(logger.loggers) do backing
+        propagate_level_override(level, backing)
+    end
+    # The TeeLogger itself had no level control so doesn't need a wrapper
+    return TeeLogger(new_backings)
+end

src/LoggingExtras.jl

@@ -29,9 +29,9 @@ include("CompositionalLoggers/common.jl")
 include("CompositionalLoggers/activefiltered.jl")
 include("CompositionalLoggers/earlyfiltered.jl")
 include("CompositionalLoggers/minlevelfiltered.jl")
-include("CompositionalLoggers/overridelogger.jl")
 include("CompositionalLoggers/tee.jl")
 include("CompositionalLoggers/transformer.jl")
+include("CompositionalLoggers/overridelogger.jl")
 
 include("Sinks/formatlogger.jl")
 include("Sinks/filelogger.jl")

src/verbosity.jl

@@ -84,11 +84,21 @@ log level before being passed on to be logged.
 For convenience, a `verbosity` keyword argument can be passed which also
 filters the "verbose logging" messages; see [`@debugv`](@ref), [`@infov`](@ref),
 [`@warnv`](@ref), [`@errorv`](@ref), and [`@logmsgv`](@ref).
+
+!!! note
+
+    If you are not using any of the LoggingExtras compositional loggers then the level 
+    override just applies to the current logger. If on the other hand you are using 
+    compositional loggers then the override is applied throughout the current logging tree.
+    This is generally what you want, but do be aware that in the case of the 
+    [`TeeLogger`](@ref) all branches of the T are overriden.
+    For more control directly construct the logger you want by making use of
+    [`LevelOverrideLogger`](@ref) and then use `with_logger` to make it active.
 """
 function withlevel(f, level::Union{Int, LogLevel}=Info; verbosity::Integer=0)
     with_logger(EarlyFilteredLogger(
         args -> !(args.group isa Verbosity) || verbosity >= args.group.verbosity,
-        LevelOverrideLogger(level, current_logger()))
+        propagate_level_override(level, current_logger()))
     ) do
         f()
     end

test/runtests.jl

@@ -289,7 +289,7 @@ end
             end
         end
     end
-    @test_broken length(logger.logs) == 1
+    @test length(logger.logs) == 1
 end
 
 @testset "Deprecations" begin