factor out common logging initialisation routine

This contains a lowest common denominator of pageserver and safekeeper log
initialisation routines. It uses daemonize flag to decide where to
stream log messages. In case daemonize is true log messages are
forwarded to file. Otherwise streaming to stdout is used. Usage of
stdout for log output is the default in docker side of things, so make
it easier to browse our logs via builtin docker commands.

zenith_utils/src/lib.rs

@@ -28,3 +28,6 @@ pub mod http;
 
 // socket splitting utils
 pub mod sock_split;
+
+// common log initialisation routine
+pub mod logging;

zenith_utils/src/logging.rs

@@ -0,0 +1,47 @@
+use slog::{Drain, Level};
+use std::{
+    fs::{File, OpenOptions},
+    path::Path,
+};
+
+use anyhow::{Context, Result};
+
+pub fn init(
+    log_filename: impl AsRef<Path>,
+    daemonize: bool,
+) -> Result<(slog_scope::GlobalLoggerGuard, File)> {
+    // Don't open the same file for output multiple times;
+    // the different fds could overwrite each other's output.
+    let log_file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&log_filename)
+        .with_context(|| format!("failed to open {:?}", log_filename.as_ref()))?;
+
+    // we are cloning and returning log file in order to allow redirecting daemonized stdout and stderr to it
+    // if we do not use daemonization (e.g. in docker) it is better to log to stdout directly
+    // for example to be in line with docker log command which expects logs comimg from stdout
+    let guard = if daemonize {
+        let decorator = slog_term::PlainSyncDecorator::new(log_file.try_clone()?);
+        let drain = slog_term::FullFormat::new(decorator)
+            .build()
+            .filter_level(Level::Info)
+            .fuse();
+        let logger = slog::Logger::root(drain, slog::o!());
+        slog_scope::set_global_logger(logger)
+    } else {
+        let decorator = slog_term::TermDecorator::new().build();
+        let drain = slog_term::FullFormat::new(decorator)
+            .build()
+            .filter_level(Level::Info)
+            .fuse();
+        let drain = slog_async::Async::new(drain).chan_size(1000).build().fuse();
+        let logger = slog::Logger::root(drain, slog::o!());
+        slog_scope::set_global_logger(logger)
+    };
+
+    // initialise forwarding of std log calls
+    slog_stdlog::init()?;
+
+    Ok((guard, log_file))
+}