implement global package-wide logging levels

Author: shikokuchuo

NAMESPACE

@@ -29,6 +29,7 @@ export(dial)
 export(is_nul_byte)
 export(is_resolved)
 export(listen)
+export(logging)
 export(nano)
 export(ncurl)
 export(nng_error)

NEWS.md

@@ -6,12 +6,12 @@
 * `is_resolved()` added as an auxiliary function to query whether an Aio has resolved in a non-blocking fashion.
 * `is_nul_byte()` added as a helper function for request/reply setups.
 * `survey_time()` added as a convenience function for surveyor/respondent patterns.
+* `logging()` function to specify a global package logging level - currently supports 'error' and 'info'.
 * `ncurl()` adds a '...' argument. Support for HTTP methods other than GET.
 
 #### Updates
 
-* Argument 'quietly' added to functions that create or destroy objects. Set to FALSE to enable printing of informational messages for logging purposes.
-* Common format for NNG errors now starts with a timestamp for easier logging.
+* Common format for NNG errors and informational events now starts with a timestamp for easier logging.
 * `listen()` and `dial()` now return (invisible) zero rather than NULL upon success to better align with similar functions.
 * Allows setting the environment variable 'NANONEXT_ARM' prior to package installation
   + Fixes installation issues on certain ARM architectures

R/context.R

@@ -7,9 +7,6 @@
 #'     and listeners, while still benefiting from separate state tracking.
 #'
 #' @param socket a Socket or nano object.
-#' @param quietly [default TRUE] if FALSE, confirmation that the context has been
-#'     successfully opened is printed to the console (stdout), useful for logging
-#'     purposes.
 #'
 #' @return A new Context (object of class 'nanoContext' and 'nano').
 #'
@@ -44,15 +41,12 @@
 #'
 #' @export
 #'
-context <- function(socket, quietly = TRUE) {
+context <- function(socket) {
 
   if (is.environment(socket)) socket <- .subset2(socket, "socket")
   res <- .Call(rnng_ctx_open, socket)
   if (is.integer(res)) {
     message(Sys.time(), " [ ", res, " ] ", nng_error(res))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
-    cat(format.POSIXct(Sys.time()), "[ ctxt open ] id:",
-        attr(res, "id"), "| sock:", attr(res, "socket"), "\n")
   }
   res
 

R/listdial.R

@@ -11,8 +11,6 @@
 #' @param autostart [default TRUE] whether to start the dialer. Set to FALSE if
 #'     you wish to set configuration options on the dialer as it is not
 #'     generally possible to change these once started.
-#' @param quietly [default TRUE] if FALSE, confirmation of a successful start is
-#'     printed to the console (stdout), useful for logging purposes.
 #'
 #' @return Zero (invisibly) on success. A new Dialer (object of class 'nanoDialer'
 #'     and 'nano') is created and bound to the Socket.
@@ -72,8 +70,7 @@
 #'
 dial <- function(socket,
                  url = "inproc://nanonext",
-                 autostart = TRUE,
-                 quietly = TRUE) {
+                 autostart = TRUE) {
 
   is.character(url) || stop("'url' should be a character string")
   if (is.environment(socket)) {
@@ -84,7 +81,7 @@ dial <- function(socket,
         message(Sys.time(), " [ ", res, " ] ", nng_error(res))
         return(invisible(res))
       }
-      if (!missing(quietly) && !isTRUE(quietly)) {
+      if (logging()) {
         cat(format.POSIXct(Sys.time()), "[ dial start ] sock:",
             attr(res, "socket"), "| url:", url, "\n")
       }
@@ -113,7 +110,7 @@ dial <- function(socket,
         message(Sys.time(), " [ ", res, " ] ", nng_error(res))
         return(invisible(res))
       }
-      if (!missing(quietly) && !isTRUE(quietly)) {
+      if (logging()) {
         cat(format.POSIXct(Sys.time()), "[ dial start ] sock:",
             attr(res, "socket"), "| url:", url, "\n")
       }
@@ -135,7 +132,7 @@ dial <- function(socket,
 #'
 #' Creates a new Listener and binds it to a Socket.
 #'
-#' @inheritParams dial
+#' @param socket a Socket or nano object.
 #' @param url [default 'inproc://nanonext'] a URL to dial or listen at, specifying
 #'     the transport and address as a character string e.g. 'inproc://anyvalue'
 #'     or 'tcp://127.0.0.1:5555' (see \link{transports}).
@@ -202,8 +199,7 @@ dial <- function(socket,
 #'
 listen <- function(socket,
                    url = "inproc://nanonext",
-                   autostart = TRUE,
-                   quietly = TRUE) {
+                   autostart = TRUE) {
 
   is.character(url) || stop("'url' should be a character string")
   if (is.environment(socket)) {
@@ -214,7 +210,7 @@ listen <- function(socket,
         message(Sys.time(), " [ ", res, " ] ", nng_error(res))
         return(invisible(res))
       }
-      if (!missing(quietly) && !isTRUE(quietly)) {
+      if (logging()) {
         cat(format.POSIXct(Sys.time()), "[ list start ] sock:",
             attr(res, "socket"), "| url:", url, "\n")
       }
@@ -243,7 +239,7 @@ listen <- function(socket,
         message(Sys.time(), " [ ", res, " ] ", nng_error(res))
         return(invisible(res))
       }
-      if (!missing(quietly) && !isTRUE(quietly)) {
+      if (logging()) {
         cat(format.POSIXct(Sys.time()), "[ list start ] sock:",
             attr(res, "socket"), "| url:", url, "\n")
       }

R/methods.R

@@ -11,7 +11,6 @@
 #'     failures somewhat more difficult.  If FALSE, failure, such as if the
 #'     connection is refused, will be returned immediately, and no further
 #'     action will be taken.
-#' @inheritParams nano
 #' @param ... not used.
 #'
 #' @return Zero (invisibly) on success.
@@ -25,12 +24,12 @@ NULL
 #' @method start nanoListener
 #' @export
 #'
-start.nanoListener <- function(x, quietly = TRUE, ...) {
+start.nanoListener <- function(x, ...) {
 
   xc <- .Call(rnng_listener_start, x)
   if (xc) {
     message(Sys.time(), " [ ", xc, " ] ", nng_error(xc))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
+  } else if (logging()) {
     cat(format.POSIXct(Sys.time()), "[ list start ] sock:",
         attr(x, "socket"), "| url:", attr(x, "url"), "\n")
   }
@@ -42,12 +41,12 @@ start.nanoListener <- function(x, quietly = TRUE, ...) {
 #' @method start nanoDialer
 #' @export
 #'
-start.nanoDialer <- function(x, async = TRUE, quietly = TRUE, ...) {
+start.nanoDialer <- function(x, async = TRUE, ...) {
 
   xc <- .Call(rnng_dialer_start, x, async)
   if (xc) {
     message(Sys.time(), " [ ", xc, " ] ", nng_error(xc))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
+  } else if (logging()) {
     cat(format.POSIXct(Sys.time()), "[ dial start ] sock:",
         attr(x, "socket"), "| url:", attr(x, "url"), "\n")
   }
@@ -60,9 +59,6 @@ start.nanoDialer <- function(x, async = TRUE, quietly = TRUE, ...) {
 #' Close Connection on a Socket, Context, Dialer or Listener.
 #'
 #' @param con a Socket, Context, Dialer or Listener.
-#' @param quietly [default TRUE] if FALSE, confirmation that the object has been
-#'     successfully closed is printed to the console (stdout), useful for logging
-#'     purposes.
 #' @param ... not used.
 #'
 #' @return Zero (invisibly) on success.
@@ -91,12 +87,12 @@ NULL
 #' @method close nanoSocket
 #' @export
 #'
-close.nanoSocket <- function(con, quietly = TRUE, ...) {
+close.nanoSocket <- function(con, ...) {
 
   xc <- .Call(rnng_close, con)
   if (xc) {
     message(Sys.time(), " [ ", xc, " ] ", nng_error(xc))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
+  } else if (logging()) {
     cat(format.POSIXct(Sys.time()), "[ sock close ] id:",
         attr(con, "id"), "| protocol:", attr(con, "protocol"), "\n")
   }
@@ -108,12 +104,12 @@ close.nanoSocket <- function(con, quietly = TRUE, ...) {
 #' @method close nanoContext
 #' @export
 #'
-close.nanoContext <- function(con, quietly = TRUE, ...) {
+close.nanoContext <- function(con, ...) {
 
   xc <- .Call(rnng_ctx_close, con)
   if (xc) {
     message(Sys.time(), " [ ", xc, " ] ", nng_error(xc))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
+  } else if (logging()) {
     cat(format.POSIXct(Sys.time()), "[ ctxt close ] id:",
         attr(con, "id"), "| sock:", attr(con, "socket"), "\n")
   }
@@ -125,12 +121,12 @@ close.nanoContext <- function(con, quietly = TRUE, ...) {
 #' @method close nanoDialer
 #' @export
 #'
-close.nanoDialer <- function(con, quietly = TRUE, ...) {
+close.nanoDialer <- function(con, ...) {
 
   xc <- .Call(rnng_dialer_close, con)
   if (xc) {
     message(Sys.time(), " [ ", xc, " ] ", nng_error(xc))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
+  } else if (logging()) {
     cat(format.POSIXct(Sys.time()), "[ dial start ] sock:",
         attr(con, "socket"), "| url:", attr(con, "url"), "\n")
   }
@@ -143,12 +139,12 @@ close.nanoDialer <- function(con, quietly = TRUE, ...) {
 #' @method close nanoListener
 #' @export
 #'
-close.nanoListener <- function(con, quietly = TRUE, ...) {
+close.nanoListener <- function(con, ...) {
 
   xc <- .Call(rnng_listener_close, con)
   if (xc) {
     message(Sys.time(), " [ ", xc, " ] ", nng_error(xc))
-  } else if (!missing(quietly) && !isTRUE(quietly)) {
+  } else if (logging()) {
     cat(format.POSIXct(Sys.time()), "[ list close ] sock:",
         attr(con, "socket"), "| url:", attr(con, "url"), "\n")
   }

R/nano.R

@@ -6,9 +6,6 @@
 #'     Dialer/Listener.
 #'
 #' @inheritParams socket
-#' @param quietly [default TRUE] if FALSE, confirmation of successful socket
-#'     creation and dialer or listener start is printed to the console (stdout),
-#'     useful for logging purposes.
 #'
 #' @return An nano object of class 'nanoObject'.
 #'
@@ -58,48 +55,43 @@ nano <- function(protocol = c("pair", "bus", "push", "pull", "req", "rep",
                               "pub", "sub", "surveyor", "respondent"),
                  dial = NULL,
                  listen = NULL,
-                 autostart = TRUE,
-                 quietly = TRUE) {
+                 autostart = TRUE) {
 
   protocol <- match.arg(protocol)
 
   nano <- `class<-`(new.env(), "nanoObject")
-  socket <- socket(protocol, quietly = quietly)
+  socket <- socket(protocol)
   makeActiveBinding("socket", function(x) socket, nano)
 
   if (!missing(dial)) {
-    dial(nano, url = dial, autostart = autostart, quietly = quietly)
+    dial(nano, url = dial, autostart = autostart)
     if(!isTRUE(autostart)) {
-      nano[["dialer_start"]] <- function(async = TRUE, quietly = TRUE) {
+      nano[["dialer_start"]] <- function(async = TRUE) {
         rm("dialer_start", envir = nano)
-        start(.subset2(nano, "dialer")[[1L]], async = async, quietly = quietly)
+        start(.subset2(nano, "dialer")[[1L]], async = async)
       }
     }
   }
 
   if (!missing(listen)) {
-    listen(nano, url = listen, autostart = autostart, quietly = quietly)
+    listen(nano, url = listen, autostart = autostart)
     if(!isTRUE(autostart)) {
-      nano[["listener_start"]] <- function(quietly = TRUE) {
+      nano[["listener_start"]] <- function() {
         rm("listener_start", envir = nano)
-        start(.subset2(nano, "listener")[[1L]], quietly = quietly)
+        start(.subset2(nano, "listener")[[1L]])
       }
     }
   }
 
-  nano[["close"]] <- function(quietly = TRUE) close(socket, quietly = quietly)
+  nano[["close"]] <- function() close(socket)
   nano[["dial"]] <- function(url = "inproc://nanonext",
-                             autostart = TRUE,
-                             quietly = TRUE) dial(nano,
-                                                  url = url,
-                                                  autostart = autostart,
-                                                  quietly = quietly)
+                             autostart = TRUE) dial(nano,
+                                                    url = url,
+                                                    autostart = autostart)
   nano[["listen"]] <- function(url = "inproc://nanonext",
-                               autostart = TRUE,
-                               quietly = TRUE) listen(nano,
-                                                      url = url,
-                                                      autostart = autostart,
-                                                      quietly = quietly)
+                               autostart = TRUE) listen(nano,
+                                                        url = url,
+                                                        autostart = autostart)
   nano[["recv"]] <- function(mode = c("serial", "character", "complex", "double",
                                       "integer", "logical", "numeric", "raw"),
                              block = FALSE,
@@ -137,20 +129,13 @@ nano <- function(protocol = c("pair", "bus", "push", "pull", "req", "rep",
                                                     value = value)
 
   if (protocol == "sub") {
-    nano[["subscribe"]] <- function(topic = NULL,
-                                    quietly = TRUE) subscribe(socket,
-                                                              topic = topic,
-                                                              quietly = quietly)
-    nano[["unsubscribe"]] <- function(topic = NULL,
-                                      quietly = TRUE) unsubscribe(socket,
-                                                                  topic = topic,
-                                                                  quietly = quietly)
+    nano[["subscribe"]] <- function(topic = NULL) subscribe(socket,
+                                                            topic = topic)
+    nano[["unsubscribe"]] <- function(topic = NULL) unsubscribe(socket,
+                                                                topic = topic)
   }
   if (protocol == "surveyor") {
-    nano[["survey_time"]] <- function(time,
-                                      quietly = TRUE) survey_time(socket,
-                                                                  time = time,
-                                                                  quietly = quietly)
+    nano[["survey_time"]] <- function(time) survey_time(socket, time = time)
   }
 
   nano

R/nanonext-package.R

@@ -122,3 +122,9 @@
 #'
 NULL
 
+.onLoad <- function(libname, pkgname) {
+  logging <- logging()
+  logging <<- logging
+  invisible()
+}
+