RecursiveJSON format?

[ericphanson]

If the user logs something JSON-able, it might be nice to recurse into that. E.g.

julia> global_logger(FormatLogger(LoggingFormats.JSON(), stderr))
FormatLogger(LoggingFormats.JSON(), Base.TTY(RawFD(15) open, 0 bytes waiting), true)

julia> @info "Hi" my_json = Dict("hi1" => Dict("hi2" => "bye"))
{"level":"info","msg":"Hi","module":"Main","file":"REPL[86]","line":1,"group":"REPL[86]","id":"Main_b58745e1","kwargs":{"my_json":"Dict(\"hi1\" => Dict(\"hi2\" => \"bye\"))"}}

could emit

julia> @info "Hi" my_json = Dict("hi1" => Dict("hi2" => "bye"))
{"level":"info","msg":"Hi","module":"Main","file":"REPL[90]","line":1,"group":"REPL[90]","id":"Main_b58745e3","kwargs":"my_json":{"hi1":{"hi2":"bye"}}}

It's less safe though, since

julia> struct A end

julia> @info "Hi" my_json = Dict("hi1" => Dict("hi2" => A()))
ERROR: ArgumentError: A doesn't have a defined `StructTypes.StructType`

which is probably why you didn't do this, but maybe it could be useful as a separate RecursiveJSON format?

(might also be a bit less painful with something like JuliaData/StructTypes.jl#61)

[ericphanson]

With

module MyLoggingFormats
using StructTypes, JSON3, Logging, LoggingFormats

lvlstr(lvl::Logging.LogLevel) = lvl >= Logging.Error ? "error" :
                                lvl >= Logging.Warn  ? "warn"  :
                                lvl >= Logging.Info  ? "info"  :
                                                       "debug"

struct RecursiveJSONLogMessage
    level::String
    msg::String
    _module::Union{String,Nothing}
    file::Union{String,Nothing}
    line::Union{Int,Nothing}
    group::Union{String,Nothing}
    id::Union{String,Nothing}
    kwargs::Dict{String,Any}
end
function RecursiveJSONLogMessage(args)
    RecursiveJSONLogMessage(
        lvlstr(args.level),
        args.message isa AbstractString ? args.message : string(args.message),
        args._module === nothing ? nothing : string(args._module),
        args.file,
        args.line,
        args.group === nothing ? nothing : string(args.group),
        args.id === nothing ? nothing : string(args.id),
        Dict{String,Any}(string(k) => v for (k, v) in args.kwargs)
    )
end
StructTypes.StructType(::Type{RecursiveJSONLogMessage}) = StructTypes.OrderedStruct()
StructTypes.names(::Type{RecursiveJSONLogMessage}) = ((:_module, :module), )

struct RecursiveJSON <: Function
end

function (::RecursiveJSON)(io, args)
    logmsg = RecursiveJSONLogMessage(args)
    try
        JSON3.write(io, logmsg)
    catch e
        fallback_msg = LoggingFormats.JSONLogMessage(args)
        fallback_msg.kwargs["RecursiveJSONLogMessageError"] = sprint(Base.showerror, e)
        JSON3.write(io, fallback_msg)
    end
    println(io)
    return nothing
end
end

I get

julia> global_logger(FormatLogger(MyLoggingFormats.RecursiveJSON(), stderr));

julia> @info "Hi" my_json = Dict("hi1" => Dict("hi2" => A()))
{"level":"info","msg":"Hi","module":"Main","file":"REPL[17]","line":1,"group":"REPL[17]","id":"Main_b9f02421","kwargs":{"RecursiveJSONLogMessageError":"ArgumentError: A doesn't have a defined `StructTypes.StructType`","my_json":"Dict(\"hi1\" => Dict(\"hi2\" => A()))"}}

julia> @info "Hi" my_json = Dict("hi1" => Dict("hi2" => "bye"))
{"level":"info","msg":"Hi","module":"Main","file":"REPL[18]","line":1,"group":"REPL[18]","id":"Main_b58745e0","kwargs":{"my_json":{"hi1":{"hi2":"bye"}}}}

which seems OK. Seems a bit weird to stick the error into the kwargs, but I feel like that's the bit of the schema where ad-hoc things can go.

(The thing I want to do is log timers, ref KristofferC/TimerOutputs.jl#136 (comment))