Implement a callback function for DatetimeRotatingFileLogger.

Author: fredrikekre

README.md

@@ -316,6 +316,9 @@ julia> filter(f -> endswith(f, ".log"), readdir(pwd()))
 ```
 
 The user implicitly controls when the files will be rolled over based on the `DateFormat` given.
+To post-process the newly rotated file pass `callback::Function` as a keyword argument.
+See the docstring with (`?DatetimeRotatingFileLogger` in the REPL) for more details.
+
 To control the logging output it is possible to pass a formatter function as the first argument
 in the constructor. See `FormatLogger` for the requirements on the formatter function.
 

src/datetime_rotation.jl

@@ -2,8 +2,8 @@ using Dates
 import Base: isless
 
 raw"""
-    DatetimeRotatingFileLogger(dir, file_pattern; always_flush=true)
-    DatetimeRotatingFileLogger(f::Function, dir, file_pattern; always_flush=true)
+    DatetimeRotatingFileLogger(dir, file_pattern; always_flush=true, callback=nothing)
+    DatetimeRotatingFileLogger(f::Function, dir, file_pattern; always_flush=true, callback=nothing)
 
 Construct a `DatetimeRotatingFileLogger` that rotates its file based on the current date.
 The constructor takes a log output directory, `dir`, and a filename pattern.
@@ -18,6 +18,11 @@ where `log_args` has the following fields:
 `(level, message, _module, group, id, file, line, kwargs)`.
 See `?LoggingExtra.handle_message_args` for more information about what each field represents.
 
+It is also possible to pass `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
@@ -28,19 +33,25 @@ logger = DatetimeRotatingFileLogger(log_dir, raw"\a\c\c\e\s\s-yyyy-mm-dd.\l\o\g"
 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
+callback(file) = run(`gzip $(file)`)
 """
 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}
+    callback::Union{Function,Nothing}
 end
 
-function DatetimeRotatingFileLogger(dir, filename_pattern; always_flush=true)
-    DatetimeRotatingFileLogger(nothing, dir, filename_pattern; always_flush=always_flush)
+function DatetimeRotatingFileLogger(dir, filename_pattern; always_flush=true, callback=nothing)
+    DatetimeRotatingFileLogger(nothing, dir, filename_pattern; always_flush=always_flush, callback=callback)
 end
-function DatetimeRotatingFileLogger(f::Union{Function,Nothing}, dir, filename_pattern; always_flush=true)
+function DatetimeRotatingFileLogger(f::Union{Function,Nothing}, dir, filename_pattern; always_flush=true, callback=nothing)
     # 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
@@ -50,15 +61,25 @@ function DatetimeRotatingFileLogger(f::Union{Function,Nothing}, dir, filename_pa
     end
     # abspath in case user constructs the logger with a relative path and later cd's.
     drfl = DatetimeRotatingFileLogger(logger, abspath(dir),
-        DateFormat(filename_pattern), now(), always_flush)
+        DateFormat(filename_pattern), now(), always_flush, ReentrantLock(), nothing, 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)
-    io = open(calc_logpath(drfl.dir, drfl.filename_pattern), "a")
+    if drfl.current_file !== nothing
+        # flush and close the old IOStream
+        flush(drfl.logger.stream)
+        close(drfl.logger.stream)
+        if drfl.callback !== nothing
+            drfl.callback(drfl.current_file)
+        end
+    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
@@ -110,9 +131,10 @@ end
 calc_logpath(dir, filename_pattern) = joinpath(dir, Dates.format(now(), filename_pattern))
 
 function handle_message(drfl::DatetimeRotatingFileLogger, args...; kwargs...)
-    if now() >= drfl.next_reopen_check
-        flush(drfl.logger.stream)
-        reopen!(drfl)
+    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)

test/runtests.jl

@@ -128,8 +128,17 @@ end
         drfl_min = DatetimeRotatingFileLogger(dir, raw"\m\i\n-YYYY-mm-dd-HH-MM.\l\o\g")
         func = (io, args) -> println(io, reverse(args.message))
         drfl_fmt = DatetimeRotatingFileLogger(func, dir, raw"\f\m\t-YYYY-mm-dd-HH-MM-SS.\l\o\g")
+        function compressor(file)
+            open(file) do src; open(file * ".compressed", "w") do sink
+                for line in eachline(src)
+                    write(sink, replace(line, r"Info" => "I"))
+                end
+            end end
+        end
+        drfl_cb = DatetimeRotatingFileLogger(dir, raw"\c\o\m\p-YYYY-mm-dd-HH-MM-SS.\l\o\g";
+                                             callback=compressor)
 
-        sink = TeeLogger(drfl_sec, drfl_min, drfl_fmt)
+        sink = TeeLogger(drfl_sec, drfl_min, drfl_fmt, drfl_cb)
         with_logger(sink) do
             while millisecond(now()) < 100 || millisecond(now()) > 200
                 sleep(0.001)
@@ -142,7 +151,7 @@ end
 
         # Drop anything that's not a .log file or empty
         files = sort(map(f -> joinpath(dir, f), readdir(dir)))
-        files = filter(f -> endswith(f, ".log") && filesize(f) > 0, files)
+        files = filter(f -> (endswith(f, ".log") || endswith(f, ".compressed")) && filesize(f) > 0, files)
         sec_files = filter(f -> startswith(basename(f), "sec-"), files)
         @test length(sec_files) == 2
 
@@ -152,6 +161,13 @@ end
         fmt_files = filter(f -> startswith(basename(f), "fmt-"), files)
         @test length(fmt_files) == 2
 
+        comp_files = filter(f -> startswith(basename(f), "comp-") && endswith(f, ".log"), files)
+        @test length(comp_files) == 2
+
+        compressed_files = filter(f -> endswith(basename(f), ".compressed"), files)
+        # Last file has not been rotated although it exists
+        @test length(compressed_files) == 1
+
         sec1_data = String(read(sec_files[1]))
         @test occursin("first", sec1_data)
         @test occursin("second", sec1_data)
@@ -168,6 +184,14 @@ end
         @test occursin("dnoces", fmt_data)
         fmt_data = String(read(fmt_files[2]))
         @test occursin("driht", fmt_data)
+
+        comp_data = String(read(comp_files[1]))
+        @test occursin("Info:", comp_data)
+        @test !occursin("I:", comp_data)
+
+        compressed_data = String(read(compressed_files[1]))
+        @test !occursin("Info:", compressed_data)
+        @test occursin("I:", compressed_data)
     end
 end