Support function-like objects in FormatLogger

Author: omus

src/Sinks/formatlogger.jl

@@ -1,15 +1,15 @@
 
 struct FormatLogger <: AbstractLogger
-    f::Function
+    formatter
     stream::IO
     always_flush::Bool
 end
 
 """
-    FormatLogger(f::Function, io::IO=stderr; always_flush=true)
+    FormatLogger(formatter, io::IO=stderr; always_flush=true)
 
 Logger sink that formats the message and finally writes to `io`.
-The formatting function should be of the form `f(io::IOContext, log_args::NamedTuple)`
+The formatting function should be of the form `formatter(io::IOContext, log_args::NamedTuple)`
 where `log_args` has the following fields:
 `(level, message, _module, group, id, file, line, kwargs)`.
 See [`LoggingExtras.handle_message_args`](@ref) for more information on what field is.
@@ -30,22 +30,22 @@ Main | [Info] This is an informational message.
 Main | [Warn] This is a warning, should take a look.
 ```
 """
-function FormatLogger(f::Function, io::IO=stderr; always_flush=true)
-    return FormatLogger(f, io, always_flush)
+function FormatLogger(formatter, io::IO=stderr; always_flush=true)
+    return FormatLogger(formatter, io, always_flush)
 end
 
 """
-    FormatLogger(f::Function, path::AbstractString; append=false, always_flush=true)
+    FormatLogger(formatter, path::AbstractString; append=false, always_flush=true)
 
 Logger sink that formats the message and writes it to the file at `path`.  This is similar
 to `FileLogger` except that it allows specifying the printing format.
 
 To append to the file (rather than truncating the file first), use `append=true`.
 If `always_flush=true` the stream is flushed after every handled log message.
 """
-function FormatLogger(f::Function, path::AbstractString; append::Bool=false, kw...)
+function FormatLogger(formatter, path::AbstractString; append::Bool=false, kw...)
     io = open(path, append ? "a" : "w")
-    return FormatLogger(f, io; kw...)
+    return FormatLogger(formatter, io; kw...)
 end
 
 function handle_message(logger::FormatLogger, args...; kwargs...)
@@ -54,11 +54,20 @@ function handle_message(logger::FormatLogger, args...; kwargs...)
     # to make sure that everything writes to the logger io in one go.
     iob = IOBuffer()
     ioc = IOContext(iob, logger.stream)
-    logger.f(ioc, log_args)
+    logger.formatter(ioc, log_args)
     write(logger.stream, take!(iob))
     logger.always_flush && flush(logger.stream)
     return nothing
 end
 shouldlog(logger::FormatLogger, arg...) = true
 min_enabled_level(logger::FormatLogger) = BelowMinLevel
 catch_exceptions(logger::FormatLogger) = true # Or false? SimpleLogger doesn't, ConsoleLogger does.
+
+# For backwards compatibility
+function Base.getproperty(logger::FormatLogger, f::Symbol)
+    return if f === :f
+        getfield(logger, :formatter)
+    else
+        getfield(logger, f)
+    end
+end

test/runtests.jl

@@ -197,6 +197,17 @@ end
     end
 end
 
+Base.@kwdef struct BasicLogFormatter
+    include_module::Bool=true
+end
+
+function (formatter::BasicLogFormatter)(io::IO, args::NamedTuple)
+    if formatter.include_module
+        print(io, args._module, " | ")
+    end
+    println(io, "[", args.level, "] ", args.message)
+end
+
 @testset "FormatLogger" begin
     io = IOBuffer()
     logger = FormatLogger(io) do io, args
@@ -242,6 +253,21 @@ end
         l = read(f, String)
         @test startswith(l, "log message")
     end
+
+    # test function-like objects/functor are supported
+    io = IOBuffer()
+    with_logger(FormatLogger(BasicLogFormatter(; include_module=true), io)) do
+        @info "test message"
+    end
+    str = String(take!(io))
+    @test str == "$(@__MODULE__()) | [Info] test message\n"
+
+    io = IOBuffer()
+    with_logger(FormatLogger(BasicLogFormatter(; include_module=false), io)) do
+        @warn "test message"
+    end
+    str = String(take!(io))
+    @test str == "[Warn] test message\n"
 end
 
 @testset "LevelOverrideLogger" begin