ûjli

 ÿþLinux x86_64 1.10.3 v1.10.3 0b4590a5507d3f3046e5bafc007cacbbfc9b310b  Æ·ýüûú                £   LoggingExtrasvSzÔ—œøæ6l’ó7œ€bû‘6       
      <   /opt/julia/packages/LoggingExtras/VLO3o/src/LoggingExtras.jlÊhºäþ”ÙA        hUÛXMÛ=¸áT{…°ÝVLogging               J   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/common.jlÊhºäþ”ÙA       R   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/activefiltered.jlÊhºäþ”ÙA       Q   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/earlyfiltered.jlÊhºäþ”ÙA       T   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/minlevelfiltered.jlÊhºäþ”ÙA       G   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/tee.jlÊhºäþ”ÙA       O   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/transformer.jlÊhºäþ”ÙA       R   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/overridelogger.jlÊhºäþ”ÙA       A   /opt/julia/packages/LoggingExtras/VLO3o/src/Sinks/formatlogger.jlÊhºäþ”ÙA       ?   /opt/julia/packages/LoggingExtras/VLO3o/src/Sinks/filelogger.jlÊhºäþ”ÙA       F   /opt/julia/packages/LoggingExtras/VLO3o/src/Sinks/datetime_rotation.jlÊhºäþ”ÙA           jà2”	Üû˜EY‘8pÊâ­Dates               8   /opt/julia/packages/LoggingExtras/VLO3o/src/verbosity.jlÊhºäþ”ÙA       9   /opt/julia/packages/LoggingExtras/VLO3o/src/deprecated.jlÊhºäþ”ÙA                                Core                æmÑƒúûüýçÑÆ×J5    Base                æmÑƒúûüý]‹™¸üJ5    Main                æmÑƒúûüýÆôÔÆ×J5    ArgToolsæBÑÅ„­Ÿx»Úï(æmÑƒúûüýêFž	K5 	   Artifactsñ˜mýr-òV3|ÀÝðæmÑƒúûüý¹ùû	K5    Base64½UƒlãD*_½˜—±ä‡æmÑƒúûüý>÷
K5    CRC32c«\yÁ¨.õ‹¼©·žj—æmÑƒúûüýj¾Ì
K5    FileWatchingÜXzsy`{îµÁ¥,z¼¸æmÑƒúûüýh&
K5    LibdluVW5£9ÛË—,ƒûÿµæmÑƒúûüý‚-"
K5    LoggingáT{…°ÝVhUÛXMÛ=¸æmÑƒúûüýr÷U"
K5    Mmap„P~Ñ:¦xg,þO•æmÑƒúûüý›|'
K5    NetworkOptions©CãÂ0YWÊ,‹˜ä¬æmÑƒúûüý‚Ê ,
K5    SHA¯Q<$œ‘ŽêÎ!×<¦ª%ˆæmÑƒúûüý‹–û1
K5    Serialization[)ø*´ˆžk˜1’žé»æmÑƒúûüý¹-¤G
K5    Sockets1VÞ$þbdÌÞ”Ý—†æmÑƒúûüýY‹BY
K5    UnicodeâP>I>¨ÀNõ¨õ¬r¬¹æmÑƒúûüýeszo
K5    LinearAlgebraSømäâ7ŽœÌÌƒî´æmÑƒúûüýuux
K5    OpenBLAS_jll€[(Åšb6Ec³ÅQøF½æmÑƒúûüýDuûx
K5    libblastrampoline_jllLSÛ†…Ž“}lxÓ æmÑƒúûüý¯^ô}
K5    MarkdownZPõ®n7ôÖz`”sœÁ–æmÑƒúûüý/Ed~K5    Printfg^cÚXÞ×¸îÞíQD‡æmÑƒúûüý;hŒ¸K5    Random_É¢„‚?š\ý¡€Y„šæmÑƒúûüýî?ÃK5    Tar¤Oè¦iå¤>±Õ¡÷îó°æmÑƒúûüý!t,úK5    DatesEY‘8pÊâ­jà2”	Üû˜æmÑƒúûüýXûŽK5    FuturebS;3{I¨Ÿ xèVMžæmÑƒúûüýsDî…K5    InteractiveUtils W‘ÒL
~·@¢'Z²èæmÑƒúûüýŠVg‡K5    LibGit2Z[&RPTøv3´EÐšRªŽæmÑƒúûüýè8JµK5    LibGit2_jll
Y¤Xg¯}ãÅÿÒ]$°™ŽæmÑƒúûüý‘D…µK5    MbedTLS_jllAX3ÃÙÿÈ¡_×Ž·æmÑƒúûüý-µµK5    LibSSH2_jlloT«¹Zk)¨ß†­í<“æmÑƒúûüý{dd¶K5    UUIDs[vi§qÏ¤‘õrÜz9šæmÑƒúûüýËÛ)K5    REPLvVñî–Í ?û¿‹u¸³aŠæmÑƒúûüý N/K5    TOMLOI`&úvíáúº3TªæmÑƒúûüýy‡‰VK5    LibCURLÈPç£Â2p²!ýËÛ6-Í€æmÑƒúûüýÐ™[K5    LibCURL_jllYÇ‹G›¬ÞÀ„ÜV¬5þ æmÑƒúûüý §Ê[K5    nghttp2_jll9SˆvÞ…Ž¯*Í*0| æmÑƒúûüýœðë[K5    MozillaCACerts_jll.Vöm`£YÍrÙ!‘æmÑƒúûüýbŽ”\K5 	   DownloadsÔJ
Â$:ôÆax$±ö,…æmÑƒúûüýíâtyK5    PkgêR²ZéÏD·iß¯âr¶æmÑƒúûüý©&ùK5 	   p7zip_jll³SØ33é? ·ÃQ½«ªæmÑƒúûüýPá¾K5     s                                                         Øv    )	¯ýó_@: AÅa	!          0         generic    <   /opt/julia/packages/LoggingExtras/VLO3o/src/LoggingExtras.jl_      module LoggingExtras

using Base.CoreLogging:
    global_logger,
    LogLevel, BelowMinLevel, Debug, Info, Warn, Error, AboveMaxLevel

import Base.CoreLogging:
    AbstractLogger, SimpleLogger,
    handle_message, shouldlog, min_enabled_level, catch_exceptions

export TeeLogger, TransformerLogger, FileLogger,
    ActiveFilteredLogger, EarlyFilteredLogger, MinLevelLogger,
    DatetimeRotatingFileLogger, FormatLogger, LevelOverrideLogger,
    @debugv, @infov, @warnv, @errorv, @logmsgv

######
# Re export Logging.jl from stdlib 
# list is stable between julia 1.0 and 1.6
# https://github.com/JuliaLang/julia/blob/release-1.6/stdlib/Logging/src/Logging.jl#L32-L46
using Logging

export Logging, AbstractLogger, LogLevel, NullLogger,
    @debug, @info, @warn, @error, @logmsg,
    with_logger, current_logger, global_logger, disable_logging,
    SimpleLogger, ConsoleLogger


include("CompositionalLoggers/common.jl")
include("CompositionalLoggers/activefiltered.jl")
include("CompositionalLoggers/earlyfiltered.jl")
include("CompositionalLoggers/minlevelfiltered.jl")
include("CompositionalLoggers/tee.jl")
include("CompositionalLoggers/transformer.jl")
include("CompositionalLoggers/overridelogger.jl")

include("Sinks/formatlogger.jl")
include("Sinks/filelogger.jl")
include("Sinks/datetime_rotation.jl")


include("verbosity.jl")
include("deprecated.jl")

end # module
J   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/common.jl›      # Utilities for dealing with compositional loggers.
# Since the logging system itself will not engage its checks
# Once the first logger has started, any compositional logger needs to check
# before passing anything on.

# For checking child logger, need to check both `min_enabled_level` and `shouldlog`
function comp_shouldlog(logger, level, _module, group, id)
    level = convert(LogLevel, level)
    (min_enabled_level(logger) <= level && shouldlog(logger, level, _module, group, id)) ||
        Base.CoreLogging.env_override_minlevel(group, _module)
        # `env_override_minlevel` is the internal function that makes JULIA_DEBUG environment variable work
end

# For checking if child logger will take the message you are sending
function comp_handle_message_check(logger, args...; kwargs...)
    level, message, _module, group, id, file, line = args
    return comp_shouldlog(logger, level, _module, group, id)
endR   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/activefiltered.jl&      """
    ActiveFilteredLogger(filter, logger)

Wraps `logger` in an active filter.
While loggers intrinsictally have in built filtering mechanisms.
Wrapping it in a `ActiveFilterLogger` allows for extract control,
at the cost of a bit of overhead.

The `ActiveFilteredLogger` has full control of what is logged,
as it sees the full message,
this does mean however it determines what to log at runtime,
which is the source of the overhead.
The [`EarlyFilteredLogger`](@ref) has less control,
but decides if to log before the message is computed.

The `filter` should be a function that returns a boolean.
`true` if the message should be logged and `false` if not.
As input it will be given a named tuple with the following fields:
`(level, message, _module, group, id, file, line, kwargs)`
See [`LoggingExtras.handle_message_args`](@ref) for more information on what each is.
"""
struct ActiveFilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
    filter::F
    logger::T
end


function handle_message(logger::ActiveFilteredLogger, args...; kwargs...)
    log_args = handle_message_args(args...; kwargs...)
    if comp_handle_message_check(logger.logger, args...; kwargs...)
        if logger.filter(log_args)
            handle_message(logger.logger, args...; kwargs...)
        end
    end
end

function shouldlog(logger::ActiveFilteredLogger, args...)
    return comp_shouldlog(logger.logger, args...)
end

min_enabled_level(logger::ActiveFilteredLogger) = min_enabled_level(logger.logger)
catch_exceptions(logger::ActiveFilteredLogger) = catch_exceptions(logger.logger)

"""
    handle_message_args

This creates NamedTuple containing all the arguments the logger gives
to `handle_message`
It is the type pased to the active logger filter.
These argument come from the logging macro (@info`, `@warn` etc).

  * `level::LogLevel` Warn, Info, etc,
  * `message::String` the message to be logged
  * `_module::Module` can be used to specify a different originating module from
    the source location of the message.
  * `group::Symbol` can be used to override the message group (this is
    normally derived from the base name of the source file).
  * `id::Symbol` can be used to override the automatically generated unique
    message identifier.  This is useful if you need to very closely associate
    messages generated on different source lines.
  * `file::String` and `line::Int` can be used to override the apparent
    source location of a log message.
  * `kwargs...`: Any  keyword or position arguments passed to the logging macro
"""
function handle_message_args(args...; kwargs...)
    fieldnames = (:level, :message, :_module, :group, :id, :file, :line, :kwargs)
    fieldvals = (args..., kwargs)
    return NamedTuple{fieldnames, typeof(fieldvals)}(fieldvals)
end
Q   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/earlyfiltered.jl	      """
    EarlyFilteredLogger(filter, logger)

Wraps `logger` in an filter that runs before the log message is created.

For contrast see the [`ActiveFilteredLogger`](@ref) which has full control,
but runs after the log message content is computed.
In most circumstances this is fine, but if your log messages are expensive
to create (e.g. they include summary statistics), then the `EarlyFilteredLogger`
is going to be better.

The `filter` should be a function that returns a boolean.
`true` if the message should be logged and `false` if not.
As input it will be given a named tuple with the following fields:
`(level, _module, group, id)`
See [`LoggingExtras.shouldlog_args`](@ref) for more information on what each is.
"""
struct EarlyFilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
    filter::F
    logger::T
end


function handle_message(logger::EarlyFilteredLogger, args...; kwargs...)
    if comp_handle_message_check(logger.logger, args...; kwargs...)
        return handle_message(logger.logger, args...; kwargs...)
    end
end

function shouldlog(logger::EarlyFilteredLogger, args...)
    log_args = shouldlog_args(args...)
    comp_shouldlog(logger.logger, args...) && logger.filter(log_args)
end

min_enabled_level(logger::EarlyFilteredLogger) = min_enabled_level(logger.logger)
catch_exceptions(logger::EarlyFilteredLogger) = catch_exceptions(logger.logger)

"""
    shouldlog_args

This returns a NamedTuple containing all the arguments the logger gives
to `shouldlog`
It is passed to the early logger filter.
These argument come from the logging macro (`@info`, `@warn` etc).

  * `level::LogLevel` Warn, Info, etc,
  * `_module::Module` can be used to specify a different originating module from
    the source location of the message.
  * `group::Symbol` can be used to override the message group (this is
    normally derived from the base name of the source file).
  * `id::Symbol` can be used to override the automatically generated unique
    message identifier.  This is useful if you need to very closely associate
    messages generated on different source lines.
"""
function shouldlog_args(fieldvals...)
    fieldnames = (:level, :_module, :group, :id)
    return NamedTuple{fieldnames, typeof(fieldvals)}(fieldvals)
end
T   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/minlevelfiltered.jl!      """
    MinLevelLogger(logger, min_enabled_level)

Wraps `logger` in an filter that runs before the log message is created.
In many ways this is just a specialised [`EarlyFilteredLogger`](@ref)
that only checks the level.
This filter only allowed messages on or above the `min_enabled_level` to pass.
"""
struct MinLevelLogger{T <: AbstractLogger, L} <: AbstractLogger
    logger::T
    min_level::L
end


function handle_message(logger::MinLevelLogger, args...; kwargs...)
    if comp_handle_message_check(logger.logger, args...; kwargs...)
        return handle_message(logger.logger, args...; kwargs...)
    end
end

function shouldlog(logger::MinLevelLogger, args...)
    return comp_shouldlog(logger.logger, args...)
end

function min_enabled_level(logger::MinLevelLogger)
    comp_min_level = min_enabled_level(logger.logger)
    # `max` since if either would not take it then do not enable
    return max(logger.min_level, comp_min_level)
end

catch_exceptions(logger::MinLevelLogger) = catch_exceptions(logger.logger)
G   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/tee.jl      struct TeeLogger{T<:NTuple{<:Any, AbstractLogger}} <: AbstractLogger
    loggers::T
end


"""
    TeeLogger(loggers...)

Send the same log message to all the loggers.

To include the current logger do:
`TeeLogger(current_logger(), loggers...)`
to include the global logger, do:
`TeeLogger(global_logger(), loggers...)`
"""
function TeeLogger(loggers::Vararg{AbstractLogger})
    return TeeLogger(loggers)
end

function handle_message(demux::TeeLogger, args...; kwargs...)
    for logger in demux.loggers
        if comp_handle_message_check(logger, args...; kwargs...)
            handle_message(logger, args...; kwargs...)
        end
    end
end

function shouldlog(demux::TeeLogger, args...)
    any(comp_shouldlog(logger, args...) for logger in demux.loggers)
end

function min_enabled_level(demux::TeeLogger)
    minimum(min_enabled_level(logger) for logger in demux.loggers)
end

function catch_exceptions(demux::TeeLogger)
    any(catch_exceptions(logger) for logger in demux.loggers)
end
O   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/transformer.jlJ      """
    TransformerLogger(f, logger)
Preprocesses log messages, using the function `f`, before passing them to the
`logger` that is wrapped.
This can be used, for example, to truncate a log message.
to conditionally change the log level of logs from a given module
(which depending on the wrappped `logger`, might cause the message to be dropped).

The transforming function `f` is given a named tuple with the fields:
`(level, message, _module, group, id, file, line, kwargs)`
and should return the same.
See [`LoggingExtras.handle_message_args`](@ref) for more information on what each is.
"""
struct TransformerLogger{T<:AbstractLogger, F} <: AbstractLogger
    transform::F
    logger::T
end


function handle_message(transformer::TransformerLogger, args...; kwargs...)
    log_args = handle_message_args(args...; kwargs...)
    new_log_args = transformer.transform(log_args)

    args = Tuple(new_log_args)[1:end-1]
    kwargs = new_log_args.kwargs

    if comp_handle_message_check(transformer.logger, args...; kwargs...)
        handle_message(transformer.logger, args...; kwargs...)
    end
end

shouldlog(transformer::TransformerLogger, args...) = true

min_enabled_level(transformer::TransformerLogger) = BelowMinLevel

catch_exceptions(transformer::TransformerLogger) = catch_exceptions(transformer.logger)
R   /opt/julia/packages/LoggingExtras/VLO3o/src/CompositionalLoggers/overridelogger.jlù	      """
    LevelOverrideLogger(level, logger)

A logger that allows overriding the log level of a child level.
Useful in debugging scenarios, where it is desirable to ignore
the log level any other logger may have set.
"""
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...)
    # unlike other CompositionalLoggers: No level check as we are ignoring the 
    # logger.loggers level and just using the overriden leven which has already been checked
    return shouldlog(logger.logger, level, args...)
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)
endA   /opt/julia/packages/LoggingExtras/VLO3o/src/Sinks/formatlogger.jl 	      
struct FormatLogger <: AbstractLogger
    f::Function
    stream::IO
    always_flush::Bool
end

"""
    FormatLogger(f::Function, 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)`
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.

# Examples
```julia-repl
julia> using Logging, LoggingExtras

julia> logger = FormatLogger() do io, args
           println(io, args._module, " | ", "[", args.level, "] ", args.message)
       end;

julia> with_logger(logger) do
           @info "This is an informational message."
           @warn "This is a warning, should take a look."
       end
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)
end

"""
    FormatLogger(f::Function, 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...)
    io = open(path, append ? "a" : "w")
    return FormatLogger(f, io; kw...)
end

function handle_message(logger::FormatLogger, args...; kwargs...)
    log_args = handle_message_args(args...; kwargs...)
    # We help the user by passing an IOBuffer to the formatting function
    # 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)
    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.
?   /opt/julia/packages/LoggingExtras/VLO3o/src/Sinks/filelogger.jlÿ      struct FileLogger <: AbstractLogger
    logger::SimpleLogger
    always_flush::Bool
end

"""
    FileLogger(path::AbstractString; append=false, always_flush=true)

Create a logger sink that write messages to a file specified with `path`.
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.

!!! note
    `FileLogger` uses the same output formatting as `SimpleLogger`. Use a `FormatLogger`
    instead of a `FileLogger` to control the output formatting.

"""
function FileLogger(path; append=false, kwargs...)
    filehandle = open(path, append ? "a" : "w")
    FileLogger(filehandle; kwargs...)
end

"""
    FileLogger(io::IOStream; always_flush=true)

Create a logger sink that write messages to the `io::IOStream`. The stream
is expected to be open and writeable.
If `always_flush=true` the stream is flushed after every handled log message.

!!! note
    `FileLogger` uses the same output formatting as `SimpleLogger`. Use a `FormatLogger`
    instead of a `FileLogger` to control the output formatting.


# Examples
```julia
io = open("path/to/file.log", "a") # append to the file
logger = FileLogger(io)
```
"""
function FileLogger(filehandle::IOStream; always_flush=true)
    FileLogger(SimpleLogger(filehandle, BelowMinLevel), always_flush)
end

function handle_message(filelogger::FileLogger, args...; kwargs...)
    handle_message(filelogger.logger, args...; kwargs...)
    filelogger.always_flush && flush(filelogger.logger.stream)
end
shouldlog(filelogger::FileLogger, arg...) = true
min_enabled_level(filelogger::FileLogger) = BelowMinLevel
catch_exceptions(filelogger::FileLogger) = catch_exceptions(filelogger.logger)
F   /opt/julia/packages/LoggingExtras/VLO3o/src/Sinks/datetime_rotation.jlí      using Dates

@doc raw"""
    DatetimeRotatingFileLogger(dir, file_pattern; always_flush=true, rotation_callback=identity)
    DatetimeRotatingFileLogger(f::Function, dir, file_pattern; always_flush=true, rotation_callback=identity)

Construct a `DatetimeRotatingFileLogger` that rotates its file based on the current date.
The constructor takes a log output directory, `dir`, and a filename pattern. The smallest
time resolution in the format string determines the frequency of log file rotation,
allowing for yearly all the way down to minute-level log rotation.

The pattern can be given as a string or as a `Dates.DateFormat`. Note that if you
wish to have a filename portion that should not be interpreted as a format string, you may
need to escape portions of the filename, as shown in the example below.

It is possible to pass a formatter function as the first argument to control the output.
The formatting function should be of the form `f(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 about what each field represents.

It is also possible to pass `rotation_callback::Function` as a keyword argument. This function
will be called every time a file rotation is happening. The function should accept one
argument which is the absolute path to the just-rotated file. The logger will block until
the callback function returns. Use `@async` if the callback is expensive.

# Examples

```julia
# Logger that logs to a new file every day
logger = DatetimeRotatingFileLogger(log_dir, raw"\a\c\c\e\s\s-yyyy-mm-dd.\l\o\g")

# Logger with a formatter function that rotates the log file hourly
logger = DatetimeRotatingFileLogger(log_dir, raw"yyyy-mm-dd-HH.\l\o\g") do io, args
    println(io, args.level, " | ", args.message)
end

# Example callback function to compress the recently-closed file
compressor(file) = run(`gzip $(file)`)
logger = DatetimeRotatingFileLogger(...; rotation_callback=compressor)
```
"""
mutable struct DatetimeRotatingFileLogger <: AbstractLogger
    logger::Union{SimpleLogger,FormatLogger}
    dir::String
    filename_pattern::DateFormat
    next_reopen_check::DateTime
    always_flush::Bool
    reopen_lock::ReentrantLock
    current_file::Union{String,Nothing}
    rotation_callback::Function
end

function DatetimeRotatingFileLogger(dir, filename_pattern; always_flush=true, rotation_callback=identity)
    DatetimeRotatingFileLogger(nothing, dir, filename_pattern; always_flush=always_flush, rotation_callback=rotation_callback)
end
function DatetimeRotatingFileLogger(f::Union{Function,Nothing}, dir, filename_pattern; always_flush=true, rotation_callback=identity)
    # Construct the backing logger with a temp IOBuffer that will be replaced
    # by the correct filestream in the call to reopen! below
    logger = if f === nothing
        SimpleLogger(IOBuffer(), BelowMinLevel)
    else # f isa Function
        FormatLogger(f, IOBuffer(); always_flush=false) # no need to flush twice
    end
    filename_pattern isa DateFormat || (filename_pattern = DateFormat(filename_pattern))
    # abspath in case user constructs the logger with a relative path and later cd's.
    drfl = DatetimeRotatingFileLogger(logger, abspath(dir),
        filename_pattern, now(), always_flush, ReentrantLock(), nothing, rotation_callback)
    reopen!(drfl)
    return drfl
end

similar_logger(::SimpleLogger, io) = SimpleLogger(io, BelowMinLevel)
similar_logger(l::FormatLogger, io) = FormatLogger(l.f, io, l.always_flush)
function reopen!(drfl::DatetimeRotatingFileLogger)
    if drfl.current_file !== nothing
        # close the old IOStream and pass the file to the callback
        close(drfl.logger.stream)
        drfl.rotation_callback(drfl.current_file)
    end
    new_file = calc_logpath(drfl.dir, drfl.filename_pattern)
    drfl.current_file = new_file
    io = open(new_file, "a")
    drfl.logger = similar_logger(drfl.logger, io)
    drfl.next_reopen_check = next_datetime_transition(drfl.filename_pattern)
    return nothing
end

"""
    next_datetime_transition(fmt::DateFormat)

Given a DateFormat that is being applied to our filename, what is the next
time at which our filepath will need to change?
"""
function next_datetime_transition(fmt::DateFormat)
    extract_token(x::Dates.DatePart{T}) where {T} = T
    token_timescales = Dict(
        # Milliseconds is the smallest timescale
        's' => Millisecond(1),
        # Seconds
        'S' => Second(1),
        # Minutes
        'M' => Minute(1),
        # Hours
        'I' => Hour(1),
        'H' => Hour(1),
        # Days
        'd' => Day(1),
        'e' => Day(1),
        'E' => Day(1),
        # Month
        'm' => Month(1),
        'u' => Month(1),
        'U' => Month(1),
        # Year
        'y' => Year(1),
        'Y' => Year(1),
    )

    # Dates for some reason explicitly does not define equality between the smaller
    # timescales (Second, Minute, Day, etc..) and the larger, non-constant timescales
    # (Month, Year).  We do so explicitly here, without committing type piracy:
    custom_isless(x, y) = isless(x, y)
    custom_isless(x::Union{Millisecond,Second,Minute,Hour,Day}, y::Union{Month, Year}) = true
    custom_isless(x::Union{Month, Year}, y::Union{Millisecond,Second,Minute,Hour,Day}) = false

    tokens = filter(t -> isa(t, Dates.DatePart), collect(fmt.tokens))
    minimum_timescale = first(sort(map(t -> token_timescales[extract_token(t)], tokens), lt=custom_isless))
    if custom_isless(minimum_timescale, Minute(1))
        throw(ArgumentError("rotating the logger with sub-minute resolution not supported"))
    end
    return ceil(now(), minimum_timescale)
end

calc_logpath(dir, filename_pattern) = joinpath(dir, Dates.format(now(), filename_pattern))

function handle_message(drfl::DatetimeRotatingFileLogger, args...; kwargs...)
    lock(drfl.reopen_lock) do
        if now() >= drfl.next_reopen_check
            reopen!(drfl)
        end
    end
    handle_message(drfl.logger, args...; kwargs...)
    drfl.always_flush && flush(drfl.logger.stream)
end

shouldlog(drfl::DatetimeRotatingFileLogger, arg...) = true
min_enabled_level(drfl::DatetimeRotatingFileLogger) = BelowMinLevel
catch_exceptions(drfl::DatetimeRotatingFileLogger) = catch_exceptions(drfl.logger)
8   /opt/julia/packages/LoggingExtras/VLO3o/src/verbosity.jl      function restore_callsite_source_position!(expr, src)
    @assert expr.head == :escape
    @assert expr.args[1].head == :macrocall
    @assert expr.args[1].args[2] isa LineNumberNode
    # used to fix the logging source file + line
    # since we're lowering our verbose logging macros to the
    # Logging.jl macros; otherwise, they would always report this (verbosity.jl)
    # file as the logging callsite
    expr.args[1].args[2] = src
    return expr
end

vlogmacrodocs = """
    @debugv N msg args...
    @infov N msg args...
    @warnv N msg args...
    @errorv N msg args...

"Verbose" logging macros. Drop in replacements of standard logging macros, but an
additional verbosity level `N` is passed to indicate differing verbosity levels
for a given log level. The verbosity argument is passed as the `group` argument
to the core logging logic as a `LoggingExtras.Verbosity` object.

Note these "verbose" logging messages will only be filtered if a filter logger is used.
A `LoggingExtras.EarlyFilteredLogger`can be used to filter on the `group.verbosity` argument.
For convenience, the
[`LoggingExtras.withlevel(f, level; verbosity)`](@ref) function is provided to temporarily
wrap the current logger with a log level and verbosity to filter while `f` is executed.
"""

struct Verbosity
    verbosity::Int
end

"$vlogmacrodocs"
macro debugv(verbosity::Int, msg, exs...)
    return restore_callsite_source_position!(
        esc(:($Base.@debug $msg _group=$(Verbosity(verbosity)) $(exs...))),
        __source__,
    )
end

"$vlogmacrodocs"
macro infov(verbosity::Int, msg, exs...)
    return restore_callsite_source_position!(
        esc(:($Base.@info $msg _group=$(Verbosity(verbosity)) $(exs...))),
        __source__,
    )
end

"$vlogmacrodocs"
macro warnv(verbosity::Int, msg, exs...)
    return restore_callsite_source_position!(
        esc(:($Base.@warn $msg _group=$(Verbosity(verbosity)) $(exs...))),
        __source__,
    )
end

"$vlogmacrodocs"
macro errorv(verbosity::Int, msg, exs...)
    return restore_callsite_source_position!(
        esc(:($Base.@error $msg _group=$(Verbosity(verbosity)) $(exs...))),
        __source__,
    )
end

"$vlogmacrodocs"
macro logmsgv(verbosity::Int, level, msg, exs...)
    return restore_callsite_source_position!(
        esc(:($Base.@logmsg $level $msg _group=$(Verbosity(verbosity)) $(exs...))),
        __source__,
    )
end

"""
    LoggingExtras.withlevel(f, level; verbosity::Integer=0)

Convenience function like `Logging.with_logger` to temporarily wrap
the current logger with a level filter while `f` is executed.
That is, the current logger will still be used for actual logging, but
log messages will first be checked that they meet the `level`
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,
        propagate_level_override(level, current_logger()))
    ) do
        f()
    end
end
9   /opt/julia/packages/LoggingExtras/VLO3o/src/deprecated.jl&       # There are currently no deprecations.    ×’öíú