The following vignette presents benchmarks for log4r against all general-purpose logging packages available on CRAN:
Each logging package features slightly different capabilities, but these benchmarks are focused on the two situations common to using all of them:
The first of these is likely the most common kind of logging done by end users, although some may chose to log to files, over HTTP, or to the system log (among others). Yet a benchmark of these other scenarios would largely show the relative expense of these operations, instead of the overhead of the logic performed by the logging packages themselves.
The second measures the performance impact of leaving logging messages in running code, even if they are below the current threshold of visibility. This is another measure of overhead for each logging package.
cat()
As a reference point, we can measure how long it takes R itself to write a simple message to the console:
<- function() {
cat_debug cat() # Print nothing.
}
<- function() cat(
cat_info "INFO [", format(Sys.time(), "%Y-%m-%d %H:%M:%S", usetz = FALSE),
"] Info message.", sep = ""
)
The following is a typical log4r setup:
<- log4r::logger(threshold = "INFO")
log4r_logger
<- function() {
log4r_info ::info(log4r_logger, "Info message.")
log4r
}
<- function() {
log4r_debug ::debug(log4r_logger, "Debug message.")
log4r }
The following is a typical futile.logger setup:
requireNamespace("futile.logger")
#> Loading required namespace: futile.logger
::flog.logger()
futile.logger
<- function() {
fl_info ::flog.info("Info message.")
futile.logger
}
<- function() {
fl_debug ::flog.debug("Debug message.")
futile.logger }
The following is what I believe to be a typical logging setup:
requireNamespace("logging")
#> Loading required namespace: logging
::basicConfig()
logging
<- function() {
logging_info ::loginfo("Info message.")
logging
}
<- function() {
logging_debug ::logdebug("Debug message.")
logging }
The following is what I believe to be a typical logger setup:
requireNamespace("logger")
#> Loading required namespace: logger
# Match the behaviour of other logging packages and write to the console.
::log_appender(logger::appender_stdout)
logger
<- function() {
logger_info ::log_info("Info message.")
logger
}
<- function() {
logger_debug ::log_debug("Debug message.")
logger }
The following is what I believe to be a typical lgr setup:
requireNamespace("lgr")
#> Loading required namespace: lgr
<- lgr::get_logger("perf-test")
lgr_logger $set_appenders(list(cons = lgr::AppenderConsole$new()))
lgr_logger$set_propagate(FALSE)
lgr_logger
<- function() {
lgr_info $info("Info message.")
lgr_logger
}
<- function() {
lgr_debug $debug("Debug message.")
lgr_logger }
The following is what I believe to be a typical loggit setup. Since we only want to log to the console, set the output file to /dev/null
. In addition, loggit does not have a notion of thresholds, so there is no “do nothing” operation to test.
requireNamespace("loggit")
#> Loading required namespace: loggit
if (.Platform$OS.type == "unix") {
::set_logfile("/dev/null")
loggitelse {
} ::set_logfile("nul")
loggit
}
<- function() {
loggit_info ::loggit("INFO", "Info message.")
loggit }
The rlog package currently has no configuration options other than the threshold, which is controlled via an environment variable and defaults to hiding debug-level messages:
requireNamespace("rlog")
#> Loading required namespace: rlog
<- function() {
rlog_info ::log_info("Info message.")
rlog
}
<- function() {
rlog_debug ::log_debug("Debug message.")
rlog }
Debug messages should print nothing.
log4r_debug()
cat_debug()
logging_debug()
fl_debug()
logger_debug()
lgr_debug()
rlog_debug()
Info messages should print to the console. Small differences in output format are to be expected.
log4r_info()
#> INFO [2021-10-28 01:56:44] Info message.
cat_info()
#> INFO [2021-10-28 01:56:44] Info message.
logging_info()
#> 2021-10-28 01:56:44 INFO::Info message.
fl_info()
#> INFO [2021-10-28 01:56:44] Info message.
logger_info()
#> INFO [2021-10-28 01:56:44] Info message.
lgr_info()
#> INFO [01:56:44.566] Info message.
loggit_info()
#> {"timestamp": "2021-10-28T01:56:44+0000", "log_lvl": "INFO", "log_msg": "Info message."}
rlog_info()
#> 2021-10-28 01:56:44 [INFO] Info message.
The following benchmarks all loggers defined above:
<- microbenchmark::microbenchmark(
info_bench cat = cat_info(),
log4r = log4r_info(),
futile.logger = fl_info(),
logging = logging_info(),
logger = logger_info(),
lgr = lgr_info(),
loggit = loggit_info(),
rlog = rlog_info(),
times = 500,
control = list(warmups = 50)
)
<- microbenchmark::microbenchmark(
debug_bench cat = cat_debug(),
log4r = log4r_debug(),
futile.logger = fl_debug(),
logging = logging_debug(),
logger = logger_debug(),
lgr = lgr_debug(),
rlog = rlog_debug(),
times = 500,
control = list(warmups = 50)
)
print(info_bench, order = "median")
#> Unit: microseconds
#> expr min lq mean median uq max neval
#> cat 26.5 38.20 47.6586 41.40 52.15 1476.4 500
#> log4r 27.2 50.70 59.5264 57.95 65.55 1029.4 500
#> rlog 68.1 95.85 113.4314 106.55 117.75 2795.0 500
#> logger 230.3 282.10 301.2706 293.70 308.05 3229.2 500
#> futile.logger 317.4 365.85 393.2444 377.70 392.45 3300.0 500
#> logging 341.2 376.85 412.8234 391.70 407.40 7856.9 500
#> lgr 580.6 620.45 747.4960 636.50 654.00 31746.7 500
#> loggit 756.7 789.50 842.4718 807.05 830.10 3721.9 500
print(debug_bench, order = "median")
#> Unit: microseconds
#> expr min lq mean median uq max neval
#> cat 1.6 2.80 5.7712 4.35 5.40 801.9 500
#> log4r 8.5 10.70 21.7778 13.25 16.70 3042.3 500
#> rlog 11.9 15.10 27.2926 20.50 23.10 2920.0 500
#> lgr 14.4 18.10 31.8206 24.90 29.90 3015.6 500
#> logger 23.2 28.50 37.8986 38.05 43.15 856.7 500
#> logging 22.3 29.65 40.8678 43.00 48.75 851.2 500
#> futile.logger 230.2 249.95 266.5912 264.10 275.15 1191.0 500