=bring it all together

Author: oxinabox

README.md

@@ -3,3 +3,115 @@
 [![Build Status](https://travis-ci.org/oxinabox/LoggingExtras.jl.svg?branch=master)](https://travis-ci.org/oxinabox/LoggingExtras.jl)
 
 [![codecov.io](http://codecov.io/github/oxinabox/LoggingExtras.jl/coverage.svg?branch=master)](http://codecov.io/github/oxinabox/LoggingExtras.jl?branch=master)
+
+
+
+## Usage
+Load the package with `using LoggingExtras`.
+You likely also want to load the `Logging` standard lib.
+Loggers can be constructed and used like normal.
+
+
+### Basics of working with loggers
+For full details, see the [Julia documentation on Logging](https://docs.julialang.org/en/v1/stdlib/Logging/index.html)
+
+To use a `logger` in a given scope do
+```
+with_logger(logger) do
+	#things
+end
+```
+
+To make a logger the global logger, use
+```
+global_logger(logger)
+```
+
+to get the current global logger, use
+```
+logger = global_logger()
+```
+
+# Loggers introduced by this package:
+
+## `DemuxLogger` and `FileLogger`
+
+The `DemuxLogger` sends the log messages to multiple places.
+It takes a list of loggers.
+It also has the keyword argument `include_current_global`,
+to determine if you also want to log to the global logger.
+
+It is up to those loggers to determine if they will accept it.\
+Which they do using their methods for `shouldlog` and `min_enabled_level`.
+Or you can do, by wrapping them in a `FilteredLogger` as discussed below.
+
+The `FileLogger` does logging to file.
+It is really simple.
+It takes a filename; and the minimum level it should log.
+
+### Demo
+We are going to log info and above to one file,
+and warnings and above to another.
+
+```
+julia> using Logging; using LoggingExtras;
+
+julia> demux_logger = DemuxLogger(
+		FileLogger("info.log", min_level=Logging.Info),
+		FileLogger("warn.log", min_level=Logging.Warn),
+		include_current_global=false
+		);
+
+
+julia> with_logger(demux_logger) do
+		@warn("It is bad")
+		@info("normal stuff")
+		@error("THE WORSE THING")
+		@debug("it is chill")
+	end
+
+shell>  cat warn.log
+┌ Warning: It is bad
+└ @ Main REPL[34]:2
+┌ Error: THE WORSE THING
+└ @ Main REPL[34]:4
+
+shell>  cat info.log
+┌ Warning: It is bad
+└ @ Main REPL[34]:2
+┌ Info: normal stuff
+└ @ Main REPL[34]:3
+┌ Error: THE WORSE THING
+└ @ Main REPL[34]:4
+```
+
+## `FilteredLogger`
+
+The `FilteredLogger` exists to give more control over which messages should be logged.
+It warps any logger, and before sending messages to the logger to log,
+checks them against a filter function.
+The filter function takes the full set of parameters of the message.
+(See it's docstring with `?FilteredLogger` for more details.)
+
+### Demo
+We want to filter to only log strings staring with `"Yo Dawg!"`.
+
+```
+julia> function yodawg_filter(level, message, _module, group, id, file, line; kwargs...)
+		startswith(msg, "Yo Dawg!")
+end
+ yodawg_filter (generic function with 1 method)                                                                                     
+
+julia> filtered_logger = FilteredLogger(yodawg_filter, global_logger());
+
+julia> with_logger(filtered_logger) do
+		@info "Boring message"
+		@warn "Yo Dawg! it is bad"
+		@info "Another boring message"
+		@info "Yo Dawg! it is all good"
+	end
+┌ Warning: Yo Dawg! it is bad
+└ @ Main REPL[28]:3
+[ Info: Yo Dawg! it is all good
+```
+

src/LoggingExtras.jl

@@ -9,7 +9,7 @@ import Base.CoreLogging:
 	handle_message, shouldlog, min_enabled_level, catch_exceptions
 
 export demux_global_logger,
-    DemuxLogger, FilterLogger, FileLogger
+    DemuxLogger, FilteredLogger, FileLogger
 
 include("demuxlogger.jl")
 include("filteredlogger.jl")

src/demuxlogger.jl

@@ -23,7 +23,8 @@ end
 
 function handle_message(demux::DemuxLogger, level, message, _module, group, id, file, line; kwargs...)
 	for logger in demux.loggers
-		if shouldlog(logger,  level, _module, group, id)
+        if min_enabled_level(logger)<= level &&  shouldlog(logger,  level, _module, group, id)
+            # we bypassed those checks above, so we got to check them for each
 			handle_message(logger, level, message, _module, group, id, file, line; kwargs...)
 		end
 	end

src/filelogger.jl

@@ -7,9 +7,9 @@ struct FileLogger <: AbstractLogger
     always_flush::Bool
 end
 
-function FileLogger(path, level=Info; append=false, always_flush=true)
+function FileLogger(path::AbstractString; min_level=Info, append=false, always_flush=true)
     filehandle = open(path, append ? "a" : "w")
-    FileLogger(SimpleLogger(filehandle, level), always_flush)
+    FileLogger(SimpleLogger(filehandle, min_level), always_flush)
 end
 
 

src/filteredlogger.jl

@@ -10,7 +10,7 @@ at the cost of a bit of overhead.
 The `filter` should be a function that returns a boolean.
 `true` if the message should be logged and `false` if not.
 It should take as inputs:
-`level, message, _module, group, id, file, line; kwargs...)`
+`(level, message, _module, group, id, file, line; kwargs...)`
 
 These argument come from the logging macro (@info`, `@warn` etc).
   
@@ -27,14 +27,14 @@ These argument come from the logging macro (@info`, `@warn` etc).
     source location of a log message.
   * `kwargs...` any keyword or positional arguments to the logging macro.
 """
-struct FilteredLogger{T,F} <: AbstractLogger where T<: AbstractLogger
+struct FilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
 	filter::F
-	logger::SimpleLogger
+	logger::T
 end
 
 
 function handle_message(filteredlogger::FilteredLogger, level, message, _module, group, id, file, line; kwargs...)
-	if filteredlogger.filter(filteredlogger.logger, level, message, _module, group, id, file, line; kwargs...)
+	if filteredlogger.filter(level, message, _module, group, id, file, line; kwargs...)
 		handle_message(filteredlogger.logger, level, message, _module, group, id, file, line; kwargs...)
 	end
 end

test/demo.jl

@@ -0,0 +1,30 @@
+
+using Logging; using LoggingExtras
+
+yodawg_filter(lvl, msg, args...; kwargs...) = startswith(msg, "Yo Dawg!")
+filtered_logger = FilteredLogger(yodawg_filter, global_logger())
+with_logger(filtered_logger) do
+    @info "Boring message"
+    @warn "Yo Dawg! it is bad"
+    @info "Another boring message"
+    @info "Yo Dawg! it is all good"
+end
+
+
+
+
+demux_logger = DemuxLogger(
+    FileLogger("info.log", min_level=Logging.Info),
+    FileLogger("warn.log", min_level=Logging.Warn),
+    include_current_global=false
+    )
+with_logger(demux_logger) do
+    @warn("It is bad")
+    @info("normal stuff")
+    @error("THE WORSE THING")
+    @debug("it is chill")
+end
+
+; cat warn.log
+; cat info.log
+

test/runtests.jl

@@ -1,5 +1,57 @@
 using LoggingExtras
 using Test
+using Base.CoreLogging
+using Base.CoreLogging: Debug, Info, Warn
 
-# write your own tests here
-@test 1 == 2
+using Test: collect_test_logs, TestLogger
+
+
+
+
+@testset "Demux" begin
+    testlogger_info = TestLogger(min_level=Info)
+    testlogger_warn = TestLogger(min_level=Warn)
+
+    with_logger(DemuxLogger(testlogger_warn, testlogger_info)) do
+        @info "info1"
+        @warn "warn1"
+        @info "info2"
+    end
+    @test length(testlogger_info.logs) == 3
+    @test length(testlogger_warn.logs) == 1
+
+end
+
+
+
+@testset "Filter" begin
+    testlogger = TestLogger()
+    yodawg_filter(lvl, msg, args...; kwargs...) = startswith(msg, "Yo Dawg!")
+
+    filtered_logger = FilteredLogger(yodawg_filter, testlogger)
+    
+    with_logger(filtered_logger) do
+        @info "info1"
+        @warn "Yo Dawg! It is a warning"
+        @info "info2"
+        @info "Yo Dawg! It's all good"
+    end
+    @test length(testlogger.logs) == 2
+
+end
+
+
+@testset "File" begin
+    mktempdir() do dir
+        filepath = joinpath(dir, "log")
+        with_logger(FileLogger(filepath)) do
+            @info "first"
+            @warn "second"
+            @info "third"
+        end
+        logtext = String(read(filepath))
+        @test occursin("first", logtext)
+        @test occursin("second", logtext)
+        @test occursin("third", logtext)
+    end
+end