From 4d25cb9624e57e788c2c72e161a1b6711f66488d Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Tue, 6 Aug 2024 15:39:50 -0500 Subject: [PATCH 01/10] WIP: simplify `log_level()` Previously created a function then immediately called it. Now it just inlines the results of that function, which leads to a bunch of simplification. Waiting for #170 since otherwise `catch_base_log()` ends up setting `appender()` to something other than a function. After this can probably deprecate `logger()` since I don't think there's much use for it outside the package anyway. --- .covrignore | 2 +- R/formatters.R | 3 ++ R/helpers.R | 13 ++++--- R/logger.R | 64 +++++++++++++++++--------------- tests/testthat/test-formatters.R | 3 -- 5 files changed, 46 insertions(+), 39 deletions(-) diff --git a/.covrignore b/.covrignore index 4917d164..855dd6b3 100644 --- a/.covrignore +++ b/.covrignore @@ -1 +1 @@ -R/zzz.R \ No newline at end of file +R/zzz.R diff --git a/R/formatters.R b/R/formatters.R index 5ba7ade1..b9f8c8b6 100644 --- a/R/formatters.R +++ b/R/formatters.R @@ -186,6 +186,9 @@ skip_formatter <- function(message, ...) { structure(message, skip_formatter = TRUE) } +is_skip_formatter <- function(x) { + isTRUE(attr(x, 'skip_formatter', exact = TRUE)) +} #' Mimic the default formatter used in the \pkg{logging} package #' diff --git a/R/helpers.R b/R/helpers.R index d7cde06c..18da285d 100644 --- a/R/helpers.R +++ b/R/helpers.R @@ -104,12 +104,13 @@ log_separator <- function(level = INFO, base_info_chars <- nchar(catch_base_log(level, namespace, .topcall = .topcall, .topenv = .topenv)) log_level( - paste(rep(separator, max(0, width - base_info_chars)), collapse = ''), - level = level, - namespace = namespace, - .logcall = .logcall, - .topcall = .topcall, - .topenv = .topenv) + paste(rep(separator, max(0, width - base_info_chars)), collapse = ''), + level = level, + namespace = namespace, + .logcall = .logcall, + .topcall = .topcall, + .topenv = .topenv + ) } diff --git a/R/logger.R b/R/logger.R index 0cac3c42..0e1aaf1e 100644 --- a/R/logger.R +++ b/R/logger.R @@ -28,6 +28,7 @@ logger <- function(threshold, formatter, layout, appender) { threshold <- validate_log_level(threshold) force(layout) force(appender) + stop("Here") function(level, ..., namespace = NA_character_, .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { @@ -266,46 +267,51 @@ log_namespaces <- function() { #' log_info(glue::glue('ok {1:3} + {1:3} = {2*(1:3)}')) #' } #' @return Invisible `list` of `logger` objects. See [logger()] for more details on the format/ -log_level <- function(level, ..., namespace = NA_character_, - .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { +log_level <- function(level, + ..., + namespace = NA_character_, + .logcall = sys.call(), + .topcall = sys.call(-1), + .topenv = parent.frame()) { + level <- validate_log_level(level) ## guess namespace if (is.na(namespace)) { topenv <- top_env_name(.topenv) namespace <- ifelse(topenv == 'R_GlobalEnv', 'global', topenv) } + .topcall <- .topcall %||% NA - definitions <- get_logger_definitions(namespace, .topenv = .topenv) - level <- validate_log_level(level) - - ## super early return (even before evaluating passed parameters) - if (length(definitions) == 1 && level > definitions[[1]]$threshold) { - return(invisible(NULL)) - } - - log_arg <- list(...) - log_arg$level <- level - log_arg$.logcall <- .logcall - log_arg$.topcall <- if(!is.null(.topcall)) { - .topcall - } else { - ## cannot pass NULL - NA - } - log_arg$.topenv <- .topenv - log_arg$namespace <- namespace - - invisible(lapply(definitions, function(definition) { - - if (level > definition$threshold) { - return(NULL) + loggers <- get_logger_definitions(namespace, .topenv = .topenv) + for (logger in loggers) { + if (level > logger$threshold) { + return(invisible()) } - log_fun <- do.call(logger, definition) - structure(do.call(log_fun, log_arg), class = 'logger') + if (...length() == 1 && is_skip_formatter(..1)) { + # optionally skip fomrmatting + message <- ..1 + } else { + message <- logger$formatter( + ..., + .logcall = .logcall, + .topcall = .topcall, + .topenv = .topenv + ) + } - })) + record <- logger$layout( + level, + message, + namespace = namespace, + .logcall = .logcall, + .topcall = .topcall, + .topenv = .topenv + ) + logger$appender(record) + } + invisible() } diff --git a/tests/testthat/test-formatters.R b/tests/testthat/test-formatters.R index cc95126a..9c8250d7 100644 --- a/tests/testthat/test-formatters.R +++ b/tests/testthat/test-formatters.R @@ -19,9 +19,6 @@ test_that('glue works', { expect_equal(formatter_glue("Hi {everything}"), "Hi 42") expect_equal(formatter_glue("Hi {1:2}"), paste("Hi", 1:2)) - expect_output(do.call(logger, namespaces$global[[1]])(INFO, 42), '42') - expect_output(do.call(logger, namespaces$global[[1]])(INFO, "Hi {everything}"), '42') - expect_output(log_info("Hi {everything}"), '42') expect_output(log_warn("Hi {everything}"), '42') expect_output(g(), '42') From ab10db67245b7b92cd32dd4dd4f6e955063eedb9 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Tue, 6 Aug 2024 15:40:53 -0500 Subject: [PATCH 02/10] Revert incidental changes --- R/helpers.R | 25 ++++++++++++------------- R/logger.R | 1 - 2 files changed, 12 insertions(+), 14 deletions(-) diff --git a/R/helpers.R b/R/helpers.R index 18da285d..3ce76ea3 100644 --- a/R/helpers.R +++ b/R/helpers.R @@ -1,7 +1,7 @@ #' Evaluate an expression and log results #' @param expr R expression to be evaluated while logging the expression itself along with the result -#' @param level [log_levels()] -#' @param multiline setting to `FALSE` will print both the expression (enforced to be on one line by removing line-breaks if any) and its result on a single line separated by `=>`, while setting to `TRUE` will log the expression and the result in separate sections reserving line-breaks and rendering the printed results +#' @param level \code{\link{log_levels}} +#' @param multiline setting to \code{FALSE} will print both the expression (enforced to be on one line by removing line-breaks if any) and its result on a single line separated by \code{=>}, while setting to \code{TRUE} will log the expression and the result in separate sections reserving line-breaks and rendering the printed results #' @examples \dontrun{ #' log_eval(pi * 2, level = INFO) #' @@ -90,7 +90,7 @@ log_eval <- function(expr, level = TRACE, multiline = FALSE) { #' log_separator(ERROR, separator = '!', width = 100) #' log_layout(layout_blank) #' log_separator(ERROR, separator = '!', width = 80) -#' @seealso [log_with_separator()] +#' @seealso \code{\link{log_with_separator}} log_separator <- function(level = INFO, namespace = NA_character_, separator = '=', @@ -104,13 +104,12 @@ log_separator <- function(level = INFO, base_info_chars <- nchar(catch_base_log(level, namespace, .topcall = .topcall, .topenv = .topenv)) log_level( - paste(rep(separator, max(0, width - base_info_chars)), collapse = ''), - level = level, - namespace = namespace, - .logcall = .logcall, - .topcall = .topcall, - .topenv = .topenv - ) + paste(rep(separator, max(0, width - base_info_chars)), collapse = ''), + level = level, + namespace = namespace, + .logcall = .logcall, + .topcall = .topcall, + .topenv = .topenv) } @@ -135,7 +134,7 @@ log_separator <- function(level = INFO, #' logger <- layout_glue_generator(format = '{node}/{pid}/{namespace}/{fn} {time} {level}: {msg}') #' log_layout(logger) #' log_with_separator('Boo!', level = FATAL, width = 120) -#' @seealso [log_separator()] +#' @seealso \code{\link{log_separator}} log_with_separator <- function(..., level = INFO, namespace = NA_character_, separator = '=', width = 80) { base_info_chars <- nchar(catch_base_log(level, namespace, .topcall = sys.call(-1))) @@ -174,8 +173,8 @@ log_with_separator <- function(..., level = INFO, namespace = NA_character_, sep #' Tic-toc logging -#' @param ... passed to `log_level` -#' @param level see [log_levels()] +#' @param ... passed to \code{log_level} +#' @param level see \code{\link{log_levels}} #' @param namespace x #' @export #' @examples \dontrun{ diff --git a/R/logger.R b/R/logger.R index 0e1aaf1e..a25e0ea0 100644 --- a/R/logger.R +++ b/R/logger.R @@ -28,7 +28,6 @@ logger <- function(threshold, formatter, layout, appender) { threshold <- validate_log_level(threshold) force(layout) force(appender) - stop("Here") function(level, ..., namespace = NA_character_, .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { From 4abe9d3e5ef9090c76ebc5add37926cabdec90fe Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Tue, 6 Aug 2024 15:42:02 -0500 Subject: [PATCH 03/10] Actually revert --- .covrignore | 2 +- R/helpers.R | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.covrignore b/.covrignore index 855dd6b3..4917d164 100644 --- a/.covrignore +++ b/.covrignore @@ -1 +1 @@ -R/zzz.R +R/zzz.R \ No newline at end of file diff --git a/R/helpers.R b/R/helpers.R index 3ce76ea3..d7cde06c 100644 --- a/R/helpers.R +++ b/R/helpers.R @@ -1,7 +1,7 @@ #' Evaluate an expression and log results #' @param expr R expression to be evaluated while logging the expression itself along with the result -#' @param level \code{\link{log_levels}} -#' @param multiline setting to \code{FALSE} will print both the expression (enforced to be on one line by removing line-breaks if any) and its result on a single line separated by \code{=>}, while setting to \code{TRUE} will log the expression and the result in separate sections reserving line-breaks and rendering the printed results +#' @param level [log_levels()] +#' @param multiline setting to `FALSE` will print both the expression (enforced to be on one line by removing line-breaks if any) and its result on a single line separated by `=>`, while setting to `TRUE` will log the expression and the result in separate sections reserving line-breaks and rendering the printed results #' @examples \dontrun{ #' log_eval(pi * 2, level = INFO) #' @@ -90,7 +90,7 @@ log_eval <- function(expr, level = TRACE, multiline = FALSE) { #' log_separator(ERROR, separator = '!', width = 100) #' log_layout(layout_blank) #' log_separator(ERROR, separator = '!', width = 80) -#' @seealso \code{\link{log_with_separator}} +#' @seealso [log_with_separator()] log_separator <- function(level = INFO, namespace = NA_character_, separator = '=', @@ -134,7 +134,7 @@ log_separator <- function(level = INFO, #' logger <- layout_glue_generator(format = '{node}/{pid}/{namespace}/{fn} {time} {level}: {msg}') #' log_layout(logger) #' log_with_separator('Boo!', level = FATAL, width = 120) -#' @seealso \code{\link{log_separator}} +#' @seealso [log_separator()] log_with_separator <- function(..., level = INFO, namespace = NA_character_, separator = '=', width = 80) { base_info_chars <- nchar(catch_base_log(level, namespace, .topcall = sys.call(-1))) @@ -173,8 +173,8 @@ log_with_separator <- function(..., level = INFO, namespace = NA_character_, sep #' Tic-toc logging -#' @param ... passed to \code{log_level} -#' @param level see \code{\link{log_levels}} +#' @param ... passed to `log_level` +#' @param level see [log_levels()] #' @param namespace x #' @export #' @examples \dontrun{ From 0a268fe496aec1fbacbe0eca35094239c9d07479 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 7 Aug 2024 07:51:19 -0500 Subject: [PATCH 04/10] Remove unnecessary substitute() from formatter_logging() and clarify intent with comments --- R/formatters.R | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/R/formatters.R b/R/formatters.R index ce4a3643..1444e3dd 100644 --- a/R/formatters.R +++ b/R/formatters.R @@ -204,15 +204,17 @@ is_skip_formatter <- function(x) { #' @seealso This is a [log_formatter()], for alternatives, see [formatter_paste()], [formatter_glue()], [formatter_glue_safe()], [formatter_glue_or_sprintf()], [formatter_json()], [formatter_pander()] and [skip_formatter()] for marking a string not to apply the formatter on it. formatter_logging <- structure(function(..., .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { - params <- list(...) - .logcall <- substitute(.logcall) - - if (is.character(params[[1]])) { - return(do.call(sprintf, params, envir = .topenv)) + # If the first argument is a string, then use sprintf + if (is.character(..1)) { + return(sprintf(...)) } - sapply(1:length(params), function(i) { - paste(deparse(as.list(.logcall)[-1][[i]]), params[[i]], sep = ': ') + # Otherwise show unevaluated inputs next to result + params <- list(...) + args <- as.list(.logcall)[-1] + + sapply(seq_along(params), function(i) { + paste(deparse(args[[i]]), params[[i]], sep = ': ') }) }, generator = quote(formatter_logging())) From b6e027405ddd3dddcf6437f5e947affc1a849d87 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 7 Aug 2024 07:52:55 -0500 Subject: [PATCH 05/10] Eliminate now unneeded tests --- tests/testthat/test-return.R | 14 -------------- 1 file changed, 14 deletions(-) delete mode 100644 tests/testthat/test-return.R diff --git a/tests/testthat/test-return.R b/tests/testthat/test-return.R deleted file mode 100644 index b596c17a..00000000 --- a/tests/testthat/test-return.R +++ /dev/null @@ -1,14 +0,0 @@ -glue_or_sprintf_result <- c( - "Hi foo, did you know that 2*4=8?", - "Hi bar, did you know that 2*4=8?") - -test_that("return value is formatted string", { - local_test_logger(appender = appender_file(withr::local_tempfile())) - - log_formatter(formatter_glue) - expect_equal(log_info('pi is {round(pi, 2)}')[[1]]$message, 'pi is 3.14') - expect_match(log_info('pi is {round(pi, 2)}')[[1]]$record, 'INFO [[0-9: -]*] pi is 3.14') - log_formatter(formatter_paste, index = 2) - expect_equal(log_info('pi is {round(pi, 2)}')[[1]]$message, 'pi is 3.14') - expect_equal(log_info('pi is {round(pi, 2)}')[[2]]$message, 'pi is {round(pi, 2)}') -}) From ee25504fc42dec12b7f96b3c983ac2e2183eb6b4 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 7 Aug 2024 09:14:23 -0500 Subject: [PATCH 06/10] Fix think-o --- R/logger.R | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/R/logger.R b/R/logger.R index 2bf41f33..c6567736 100644 --- a/R/logger.R +++ b/R/logger.R @@ -279,7 +279,7 @@ log_level <- function(level, loggers <- get_logger_definitions(namespace, .topenv = .topenv) for (logger in loggers) { if (level > logger$threshold) { - return(invisible()) + next } if (...length() == 1 && is_skip_formatter(..1)) { From dae124d64c587977f67de5257f316c4b3e602616 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 7 Aug 2024 16:31:47 -0500 Subject: [PATCH 07/10] Re-style --- R/formatters.R | 24 ++++++++--------- R/logger.R | 71 ++++++++++++++++++++++++-------------------------- 2 files changed, 45 insertions(+), 50 deletions(-) diff --git a/R/formatters.R b/R/formatters.R index 772b5993..ad2acfda 100644 --- a/R/formatters.R +++ b/R/formatters.R @@ -236,7 +236,7 @@ skip_formatter <- function(message, ...) { } is_skip_formatter <- function(x) { - isTRUE(attr(x, 'skip_formatter', exact = TRUE)) + isTRUE(attr(x, "skip_formatter", exact = TRUE)) } #' Mimic the default formatter used in the \pkg{logging} package @@ -271,20 +271,18 @@ is_skip_formatter <- function(x) { #' @export #' @seealso This is a [log_formatter()], for alternatives, see [formatter_paste()], [formatter_glue()], [formatter_glue_safe()], [formatter_glue_or_sprintf()], [formatter_json()], [formatter_pander()] and [skip_formatter()] for marking a string not to apply the formatter on it. formatter_logging <- structure(function(..., .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { + # If the first argument is a string, then use sprintf + if (is.character(..1)) { + return(sprintf(...)) + } - # If the first argument is a string, then use sprintf - if (is.character(..1)) { - return(sprintf(...)) - } - - # Otherwise show unevaluated inputs next to result - params <- list(...) - args <- as.list(.logcall)[-1] - - sapply(seq_along(params), function(i) { - paste(deparse(args[[i]]), params[[i]], sep = ': ') - }) + # Otherwise show unevaluated inputs next to result + params <- list(...) + args <- as.list(.logcall)[-1] + sapply(seq_along(params), function(i) { + paste(deparse(args[[i]]), params[[i]], sep = ": ") + }) }, generator = quote(formatter_logging())) diff --git a/R/logger.R b/R/logger.R index c0ad32fa..fde4a40b 100644 --- a/R/logger.R +++ b/R/logger.R @@ -109,7 +109,6 @@ fallback_namespace <- function(namespace) { #' If `value` is not `NULL`, will return the previously set value. #' @noRd log_config_setter <- function(name, value, namespace = "global", index = 1) { - if (length(namespace) > 1) { for (ns in namespace) { log_config_setter(name, value, ns, index) @@ -141,7 +140,6 @@ log_config_setter <- function(name, value, namespace = "global", index = 1) { configs[[min(index, length(config) + 1)]] <- config assign(namespace, configs, envir = namespaces) invisible(old) - } @@ -325,45 +323,44 @@ log_level <- function(level, .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { + level <- validate_log_level(level) + ## guess namespace + if (is.na(namespace)) { + topenv <- top_env_name(.topenv) + namespace <- ifelse(topenv == "R_GlobalEnv", "global", topenv) + } + .topcall <- .topcall %||% NA - level <- validate_log_level(level) - ## guess namespace - if (is.na(namespace)) { - topenv <- top_env_name(.topenv) - namespace <- ifelse(topenv == 'R_GlobalEnv', 'global', topenv) + loggers <- get_logger_definitions(namespace, .topenv = .topenv) + for (logger in loggers) { + if (level > logger$threshold) { + next } - .topcall <- .topcall %||% NA - - loggers <- get_logger_definitions(namespace, .topenv = .topenv) - for (logger in loggers) { - if (level > logger$threshold) { - next - } - - if (...length() == 1 && is_skip_formatter(..1)) { - # optionally skip fomrmatting - message <- ..1 - } else { - message <- logger$formatter( - ..., - .logcall = .logcall, - .topcall = .topcall, - .topenv = .topenv - ) - } - - record <- logger$layout( - level, - message, - namespace = namespace, - .logcall = .logcall, - .topcall = .topcall, - .topenv = .topenv - ) - logger$appender(record) + + if (...length() == 1 && is_skip_formatter(..1)) { + # optionally skip fomrmatting + message <- ..1 + } else { + message <- logger$formatter( + ..., + .logcall = .logcall, + .topcall = .topcall, + .topenv = .topenv + ) } - invisible() + record <- logger$layout( + level, + message, + namespace = namespace, + .logcall = .logcall, + .topcall = .topcall, + .topenv = .topenv + ) + logger$appender(record) + } + + invisible() } From d4d6583a89724a655830dc107e9b1a2020101966 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 7 Aug 2024 16:32:36 -0500 Subject: [PATCH 08/10] Re-document --- man/formatter_logging.Rd | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/man/formatter_logging.Rd b/man/formatter_logging.Rd index 712996ed..c207b5d7 100644 --- a/man/formatter_logging.Rd +++ b/man/formatter_logging.Rd @@ -12,8 +12,7 @@ formatter_logging( ) } \arguments{ -\item{...}{string and further params passed to \code{sprintf} or R -expressions to be evaluated} +\item{...}{string and further params passed to \code{sprintf} or R expressions to be evaluated} \item{.logcall}{the logging call being evaluated (useful in formatters and layouts when you want to have access to the raw, @@ -28,6 +27,8 @@ where the formatter function will be evaluated and that is used to look up the \code{namespace} as well via \code{logger:::top_env_name}} } \value{ +character vector + character vector } \description{ @@ -54,4 +55,6 @@ This is a \code{\link[=log_formatter]{log_formatter()}}, for alternatives, see \code{\link[=formatter_glue_safe]{formatter_glue_safe()}}, \code{\link[=formatter_glue_or_sprintf]{formatter_glue_or_sprintf()}}, \code{\link[=formatter_json]{formatter_json()}}, \code{\link[=formatter_pander]{formatter_pander()}} and \code{\link[=skip_formatter]{skip_formatter()}} for marking a string not to apply the formatter on it. + +This is a \code{\link[=log_formatter]{log_formatter()}}, for alternatives, see \code{\link[=formatter_paste]{formatter_paste()}}, \code{\link[=formatter_glue]{formatter_glue()}}, \code{\link[=formatter_glue_safe]{formatter_glue_safe()}}, \code{\link[=formatter_glue_or_sprintf]{formatter_glue_or_sprintf()}}, \code{\link[=formatter_json]{formatter_json()}}, \code{\link[=formatter_pander]{formatter_pander()}} and \code{\link[=skip_formatter]{skip_formatter()}} for marking a string not to apply the formatter on it. } From cf79fc13735cf7b40b94b80a1e486f681fc7e4c5 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Wed, 7 Aug 2024 16:41:44 -0500 Subject: [PATCH 09/10] Add missing %||% --- R/utils.R | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/R/utils.R b/R/utils.R index 8f6944ef..8c1cb805 100644 --- a/R/utils.R +++ b/R/utils.R @@ -101,3 +101,7 @@ catch_base_log <- function(level, namespace, .topcall = sys.call(-1), .topenv = in_pkgdown <- function() { identical(Sys.getenv("IN_PKGDOWN"), "true") } + +`%||%` <- function(x, y) { + if (is.null(x)) y else x +} From 4e8d0857a314b87b7ed5a430ed00423555f4a093 Mon Sep 17 00:00:00 2001 From: Hadley Wickham Date: Thu, 8 Aug 2024 06:57:31 -0500 Subject: [PATCH 10/10] Fix merge mistake --- R/formatters.R | 5 ----- man/formatter_logging.Rd | 7 ++----- 2 files changed, 2 insertions(+), 10 deletions(-) diff --git a/R/formatters.R b/R/formatters.R index ad2acfda..d9cf1de2 100644 --- a/R/formatters.R +++ b/R/formatters.R @@ -265,11 +265,6 @@ is_skip_formatter <- function(x) { #' log_info("vector %s", 1:3) #' log_info(12, 1 + 1, 2 * 2) #' } -#' @param ... string and further params passed to `sprintf` or R expressions to be evaluated -#' @inheritParams log_level -#' @return character vector -#' @export -#' @seealso This is a [log_formatter()], for alternatives, see [formatter_paste()], [formatter_glue()], [formatter_glue_safe()], [formatter_glue_or_sprintf()], [formatter_json()], [formatter_pander()] and [skip_formatter()] for marking a string not to apply the formatter on it. formatter_logging <- structure(function(..., .logcall = sys.call(), .topcall = sys.call(-1), .topenv = parent.frame()) { # If the first argument is a string, then use sprintf if (is.character(..1)) { diff --git a/man/formatter_logging.Rd b/man/formatter_logging.Rd index c207b5d7..712996ed 100644 --- a/man/formatter_logging.Rd +++ b/man/formatter_logging.Rd @@ -12,7 +12,8 @@ formatter_logging( ) } \arguments{ -\item{...}{string and further params passed to \code{sprintf} or R expressions to be evaluated} +\item{...}{string and further params passed to \code{sprintf} or R +expressions to be evaluated} \item{.logcall}{the logging call being evaluated (useful in formatters and layouts when you want to have access to the raw, @@ -27,8 +28,6 @@ where the formatter function will be evaluated and that is used to look up the \code{namespace} as well via \code{logger:::top_env_name}} } \value{ -character vector - character vector } \description{ @@ -55,6 +54,4 @@ This is a \code{\link[=log_formatter]{log_formatter()}}, for alternatives, see \code{\link[=formatter_glue_safe]{formatter_glue_safe()}}, \code{\link[=formatter_glue_or_sprintf]{formatter_glue_or_sprintf()}}, \code{\link[=formatter_json]{formatter_json()}}, \code{\link[=formatter_pander]{formatter_pander()}} and \code{\link[=skip_formatter]{skip_formatter()}} for marking a string not to apply the formatter on it. - -This is a \code{\link[=log_formatter]{log_formatter()}}, for alternatives, see \code{\link[=formatter_paste]{formatter_paste()}}, \code{\link[=formatter_glue]{formatter_glue()}}, \code{\link[=formatter_glue_safe]{formatter_glue_safe()}}, \code{\link[=formatter_glue_or_sprintf]{formatter_glue_or_sprintf()}}, \code{\link[=formatter_json]{formatter_json()}}, \code{\link[=formatter_pander]{formatter_pander()}} and \code{\link[=skip_formatter]{skip_formatter()}} for marking a string not to apply the formatter on it. }