implement LogCompose

Author: tanmaykm

Project.toml

@@ -0,0 +1,27 @@
+name = "LogCompose"
+uuid = "8416b438-731e-11ea-2421-05f642269042"
+keywords = ["configure", "compose", "logging", "logger"]
+authors = ["tan <[email protected]>"]
+license = "MIT"
+desc = "Compose loggers and logger ensembles declaratively using configuration files"
+version = "0.1.0"
+
+[deps]
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
+Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
+SyslogLogging = "0c4b0c42-68ec-11ea-3bc9-e7fb6e00ea0f"
+LogRoller = "c41e01d8-14e5-11ea-185b-e7eabed7be4b"
+LoggingExtras = "e6f89c97-d47a-5376-807f-9c37f3926c36"
+
+[compat]
+julia = "1"
+SyslogLogging = "0.1"
+LoggingExtras = "0.4"
+LogRoller = "0.2"
+
+[extras]
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["Test"]

src/LogCompose.jl

@@ -0,0 +1,10 @@
+module LogCompose
+
+using Pkg, Logging
+
+export logcompose
+
+include("compose.jl")
+include("connectors.jl")
+
+end # module LogCompose

src/compose.jl

@@ -0,0 +1,56 @@
+using Logging, LogRoller, SyslogLogging, LoggingExtras
+
+name_parts(loggername) = split(loggername, '.')
+
+function configuration(configfile::String; section::String="")
+    config = Pkg.TOML.parsefile(configfile)
+    isempty(section) ? config : get_section(config, [section])
+end
+
+function get_section(config::Dict{String,Any}, path::Vector)
+    isempty(path) && (return config)
+
+    top = get(config, first(path)) do
+        Dict{String,Any}()
+    end
+
+    (length(path) > 1) ? get_section(top, path[2:end]) : top
+end
+
+function flatten(config::Dict{String,Any}, path::Vector)
+    result = Dict{String,Any}()
+    for depth in 1:length(path)
+        merge!(result, get_section(config, path[1:depth]))
+    end
+    result
+end
+
+function get_type(s::String, topmodule::Module=@__MODULE__)
+    try
+        T = topmodule
+        for t in split(s, ".")
+            T = Base.eval(T, Symbol(t))
+        end
+        return T
+    catch ex
+        nextmodule = parentmodule(topmodule)
+        if nextmodule == topmodule
+            error("Could not resolve logger $s. Ensure that the required logging packages are imported!")
+        else
+            return get_type(s, nextmodule)
+        end
+    end
+end
+
+logger(configfile::String, loggername::String; section::String="") = logger(configuration(configfile; section=section), name_parts(loggername))
+logger(config::Dict{String,Any}, loggername::String) = logger(config, name_parts(loggername))
+function logger(config::Dict{String,Any}, loggername::Vector)
+    loggercfg = flatten(config, loggername)
+    loggertypestr = loggercfg["type"]
+    loggertype = get_type(loggertypestr)
+    logcompose(loggertype, config, loggercfg)
+end
+
+logcompose(::Type{T}, config::Dict{String,Any}, logger_config::Dict{String,Any}) where {T} = @error("logcompose not implemented for type $T")
+
+log_min_level(logger_config::Dict{String,Any}, default::String="Info") = getproperty(Logging, Symbol(get(logger_config, "min_level", default)))

src/connectors.jl

@@ -0,0 +1,69 @@
+module Connectors
+
+using ..LogCompose
+import ..LogCompose: logcompose, log_min_level
+
+using Logging, LogRoller, SyslogLogging, LoggingExtras, Sockets
+
+#--------------------------------------------------------------------
+# The connectors for individual logger implementations should ideally
+# be in their own packages.
+#--------------------------------------------------------------------
+
+function logcompose(::Type{Logging.SimpleLogger}, config::Dict{String,Any}, logger_config::Dict{String,Any})
+    level = log_min_level(logger_config, "Info")
+
+    streamname = strip(get(logger_config, "stream", "stdout"))
+    @assert !isempty(streamname)
+
+    stream = streamname == "stdout" ? stdout :
+             streamname == "stderr" ? stderr :
+             open(streamname, "w+")
+
+    Logging.SimpleLogger(stream, level)
+end
+
+const sysloglck = ReentrantLock()
+function logcompose(::Type{SyslogLogging.SyslogLogger}, config::Dict{String,Any}, logger_config::Dict{String,Any})
+    ident = logger_config["identity"]
+    level = log_min_level(logger_config, "Info")
+
+    kwargs = Dict{Symbol,Any}()
+
+    kwargs[:facility] = Symbol(get(logger_config, "facility", "user"))
+
+    if get(logger_config, "lock", false)
+        kwargs[:lck] = sysloglck
+    end
+
+    server_type = get(logger_config, "server_type", "local")
+    if (server_type == "tcp") || (server_type == "udp")
+        kwargs[:tcp] = (server_type == "tcp")
+        if haskey(logger_config, "server_host")
+            kwargs[:host] = Sockets.IPv4(logger_config["server_host"])
+        end
+        if haskey(logger_config, "server_port")
+            kwargs[:port] = parse(Int, logger_config["server_port"])
+        end
+    end
+    SyslogLogging.SyslogLogger(ident, level; kwargs...)
+end
+
+function logcompose(::Type{LogRoller.RollingLogger}, config::Dict{String,Any}, logger_config::Dict{String,Any})
+    filename = String(strip(logger_config["filename"]))
+    @assert !isempty(filename)
+
+    level = log_min_level(logger_config, "Info")
+    sizelimit = parse(Int, get(logger_config, "sizelimit", "10240000"))
+    nfiles = parse(Int, get(logger_config, "nfiles", "5"))
+    timestamp_identifier = Symbol(get(logger_config, "timestamp_identifier", "time"))
+
+    LogRoller.RollingLogger(filename, sizelimit, nfiles, level; timestamp_identifier=timestamp_identifier)
+end
+
+function logcompose(::Type{LoggingExtras.TeeLogger}, config::Dict{String,Any}, logger_config::Dict{String,Any})
+    destinations = [LogCompose.logger(config, dest) for dest in logger_config["destinations"]]
+    LoggingExtras.TeeLogger(destinations...)
+end
+
+end # module Connectors

test/runtests.jl

@@ -0,0 +1,44 @@
+using LogCompose, Test, Logging, LogRoller, SyslogLogging, LoggingExtras
+
+function test()
+    config = joinpath(@__DIR__, "testapp.toml")
+    default_logfile = "/tmp/default.log"
+    rotated_logfile = "/tmp/testapp.log"
+    rm(rotated_logfile; force=true)
+    rm(default_logfile; force=true)
+
+    let logger = LogCompose.logger(config, "default"; section="loggers")
+        with_logger(logger) do
+            @info("testdefault")
+        end
+        @test isfile(default_logfile)
+    end
+
+    let logger = LogCompose.logger(config, "file.testapp"; section="loggers")
+        with_logger(logger) do
+            @info("testroller")
+        end
+        @test isfile(rotated_logfile)
+    end
+
+    let logger = LogCompose.logger(config, "syslog.testapp"; section="loggers")
+        with_logger(logger) do
+            @info("testsyslog")
+        end
+    end
+
+    let logger = LogCompose.logger(config, "testapp"; section="loggers")
+        with_logger(logger) do
+            @info("testtee")
+        end
+    end
+
+    log_file_contents = readlines(default_logfile)
+    @test findfirst("testdefault", log_file_contents[1]) !== nothing
+
+    log_file_contents = readlines(rotated_logfile)
+    @test findfirst("testroller", log_file_contents[1]) !== nothing
+    @test findfirst("testtee", log_file_contents[3]) !== nothing
+end
+
+test()

test/testapp.toml

@@ -0,0 +1,41 @@
+[loggers.default]
+type = "Logging.SimpleLogger"
+# min_level = "Debug"                   # Debug, Info (default) or Error
+stream = "/tmp/default.log"             # stdout (default), stderr or a filepath
+
+[loggers.file]
+type = "LogRoller.RollingLogger"
+# sizelimit = 10240000
+# nfiles = 5
+# min_level = "Debug"                   # Debug, Info (default) or Error
+# timestamp_identifier = "time"
+
+[loggers.syslog]
+type = "SyslogLogging.SyslogLogger"
+# min_level = "Info"                      # default is Info
+# facility = "user"                       # one of the facility types listed in Syslogs.jl (default is user)
+# server_type = "tcp"                     # tcp or udp or local (default)
+# server_host = 
+# server_port =
+# lock = false                            # whether to lock the syslog facility while logging
+
+# [loggers.stackdriver]
+# type = "StackDriver.StackdriverLogger"
+# min_level = "Info"                      # default is Info
+# project_name =
+# log_name =
+# key_file_path =
+# access_token =
+
+[loggers.file.testapp]
+filename = "/tmp/testapp.log"
+
+[loggers.syslog.testapp]
+identity = "testapp"
+
+[loggers.stackdriver.testapp]
+log_name = "testapp"
+
+[loggers.testapp]
+type = "LoggingExtras.TeeLogger"
+destinations = ["file.testapp", "syslog.testapp"]