Add TransformerLogger

Author: oxinabox

README.md

@@ -190,6 +190,43 @@ julia> with_logger(throttled_logger) do
 This is basically a special case of the early filtered logger,
 that just checks if the level of the message is above the level specified when it was created.
 
+## `TransformerLogger`
+The transformer logger allows for the modification of log messages.
+This modification includes such things as its log level, and content,
+and all the other arguments passed to `handle_message`.
+
+When constructing a `TransformerLogger` you pass in a tranformation function,
+and a logger to be wrapped.
+The  transformation function takes a named tuple containing all the log message fields,
+and should return a new modified named tuple.
+
+A simple example of its use is truncating messages.
+
+```
+julia> using Logging, LoggingExtras
+
+julia> truncating_logger  = TransformerLogger(global_logger()) do log
+           if length(log.message) > 128
+               short_message = log.message[1:min(end, 125)] * "..."
+               return merge(log, (;message=short_message))
+           else
+               return log
+           end
+       end;
+
+julia> with_logger(truncating_logger) do
+           @info "the truncating logger only truncates long messages"
+           @info "Like this one that is this is a long and rambling message, it just keeps going and going and going,  and it seems like it will never end."
+           @info "Not like this one, that is is short"
+       end
+[ Info: the truncating logger only truncates long messages
+[ Info: Like this one that is this is a long and rambling message, it just keeps going and going and going,  and it seems like it wil...
+[ Info: Not like this one, that is is short
+```
+
+It can also be used to do things such as change the log level of messages from a particular module (see the example below).
+
+
 # More Examples
 
 ## Filter out any overly long messages
@@ -220,3 +257,23 @@ end
 global_logger(EarlyFilteredLogger(not_HTTP_message_filter, global_logger()))
 ```
 
+## Raising HTTP debug level errors to be Info level
+
+```
+using LoggingExtras
+using Logging
+using HTTP
+
+transformer_logger(global_logger()) do log
+	if log._module == HTTP && log.level=Logging.Debug
+		# Merge can be used to construct a new NamedTuple
+		# which effectively is the overwriting of fields of a NamedTuple
+		return merge(log, (; level=Logging.Info))
+	else
+		return log
+	end
+end
+
+global_logger(transformer_logger)
+```
+

src/LoggingExtras.jl

@@ -9,7 +9,7 @@ import Base.CoreLogging:
 	handle_message, shouldlog, min_enabled_level, catch_exceptions
 
 export demux_global_logger,
-    DemuxLogger, FileLogger,
+    DemuxLogger, TransformerLogger, FileLogger,
     ActiveFilteredLogger, EarlyFilteredLogger, MinLevelLogger
 
 
@@ -32,7 +32,8 @@ function comp_handle_message_check(logger, args...; kwargs...)
 end
 ###############################
 
-include("demuxlogger.jl")
+include("demux.jl")
+include("transformer.jl")
 include("activefiltered.jl")
 include("earlyfiltered.jl")
 include("minlevelfiltered.jl")

src/activefiltered.jl

@@ -17,7 +17,7 @@ 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 `?LoggingExtra.handle_message_ags` for more information on what each is.
+See `?LoggingExtra.handle_message_args` for more information on what each is.
 """
 struct ActiveFilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
 	filter::F

src/demuxlogger.jl renamed to src/demux.jl

@@ -1,7 +1,7 @@
 using LoggingExtras
 using Test
 using Base.CoreLogging
-using Base.CoreLogging: Debug, Info, Warn
+using Base.CoreLogging: Debug, Info, Warn, Error
 
 using Test: collect_test_logs, TestLogger
 
@@ -84,3 +84,26 @@ end
 end
 
 
+@testset "Transformer" begin
+    testlogger = TestLogger(min_level=Error)
+    transformer_logger = TransformerLogger(testlogger) do log_msg
+        # We are going to transform all warnings into errors
+        if log_msg.level == Warn
+            return merge(log_msg, (; level=Error))
+        else
+            return log_msg
+        end
+    end
+    
+    with_logger(transformer_logger) do
+        @info "info1"
+        @warn "Yo Dawg! It is a warning"
+        @info "info2"
+        @info "Yo Dawg! It's all good"
+        @info "info 3"
+        @error "MISTAKES WERE MADE"
+    end
+    @test length(testlogger.logs) == 2
+end
+
+