Alternative approach to debug logging utilities.

Alternative to what's proposed in #63. In particular, the pieces
proposed here include:
  * More general "verbosity" argument separate and supporing any log level
  * Convenience macros for passing verbosity (i.e. `@debugv 1 "hey"` => `@debug "hey" verbosity=1`)
  * A `LevelOverrideLogger` for overriding the level of any nested logger
  * A convenience `LoggingExtras.with` function for *very* easily passing a temporary
    log level and/or verbosity while a function is run.

My thoughts have evolved here for supporting package developers wishing to have an easy way to
support multiple levels of debug verbosity logging. The approach I'm converging on is:
  * Package devs support accepting a `verbose::Int=0` keyword arg to high-level user-facing
    API functions; *very early on*, this keyword arg is "handled" by checking the level and
    wrapping the remaining function body in a `LoggingExtras.with` call to enable verbose
    debug logging. An important key here is that as a package dev, I *don't* have to thread
    the `verbose` keyword through a potentially messy nested call graph of a function. I can
    just wrap the invocation in `LoggingExtras.with` and then sprinkle `@debugv N` calls
    at any nested depth I'd like.
  * For users, this also provides an extremely easy/intuitive interface for enabling verbose
    debug logging. I don't have to fiddle with configuring a logger or messing w/ global state,
    I just pass `verbose=1` or `verbose=3` and any verbose logs will be written out.

If this approach sounds reasonable, I can clean up this PR w/ docs/examples/tests.

Author: quinnj

src/LoggingExtras.jl

@@ -10,7 +10,8 @@ import Base.CoreLogging:
 
 export TeeLogger, TransformerLogger, FileLogger,
     ActiveFilteredLogger, EarlyFilteredLogger, MinLevelLogger,
-    DatetimeRotatingFileLogger, FormatLogger
+    DatetimeRotatingFileLogger, FormatLogger,
+    @debugv, @infov, @warnv, @errorv, @logmsgv
 
 ######
 # Re export Logging.jl from stdlib 
@@ -50,6 +51,9 @@ include("minlevelfiltered.jl")
 include("filelogger.jl")
 include("formatlogger.jl")
 include("datetime_rotation.jl")
+include("overridelogger.jl")
+include("verbosity.jl")
+include("util.jl")
 include("deprecated.jl")
 
 end # module

src/overridelogger.jl

@@ -0,0 +1,15 @@
+struct LevelOverrideLogger{T <: AbstractLogger} <: AbstractLogger
+    level::LogLevel
+    logger::T
+end
+
+
+handle_message(logger::LevelOverrideLogger, args...; kwargs...) =
+    handle_message(logger.logger, args...; kwargs...)
+
+function shouldlog(logger::LevelOverrideLogger, level, args...)
+    level >= logger.level && shouldlog(logger.logger, level, args...)
+end
+
+min_enabled_level(logger::LevelOverrideLogger) = logger.level
+catch_exceptions(logger::LevelOverrideLogger) = catch_exceptions(logger.logger)

src/util.jl

@@ -0,0 +1,22 @@
+function with(f; level::Union{Int, LogLevel}=Info, verbosity::Int=0)
+    with_logger(genlogger(level, verbosity)) do
+        f()
+    end
+end
+
+genlogger(l, v) = ActiveFilteredLogger(
+    LogVerbosityCheck(v),
+    TransformerLogger(
+        args -> merge(args, (kwargs=Base.structdiff(values(args.kwargs), (verbosity=0,)),)),
+        LevelOverrideLogger(l, current_logger())
+    )
+)
+
+struct LogVerbosityCheck
+    verbosity::Int
+end
+
+function (f::LogVerbosityCheck)(logargs)
+    kw = values(logargs.kwargs)
+    return !haskey(kw, :verbosity) || f.verbosity >= kw.verbosity
+end

src/verbosity.jl

@@ -0,0 +1,24 @@
+"""Calls @debug with the passed verbosity level"""
+macro debugv(verbosity::Int64, msg, exs...)
+    return esc(:($Base.@debug $msg verbosity=$verbosity $(exs...)))
+end
+
+"""Calls @info with the passed verbosity level"""
+macro infov(verbosity::Int64, msg, exs...)
+    return esc(:($Base.@info $msg verbosity=$verbosity $(exs...)))
+end
+
+"""Calls @warn with the passed verbosity level"""
+macro warnv(verbosity::Int64, msg, exs...)
+    return esc(:($Base.@warn $msg verbosity=$verbosity $(exs...)))
+end
+
+"""Calls @error with the passed verbosity level"""
+macro errorv(verbosity::Int64, msg, exs...)
+    return esc(:($Base.@error $msg verbosity=$verbosity $(exs...)))
+end
+
+"""Calls @error with the passed verbosity level"""
+macro logmsgv(verbosity::Int64, level, msg, exs...)
+    return esc(:($Base.@logmsgv $level $msg verbosity=$verbosity $(exs...)))
+end