Support GELF logging output.

doc/quickstart/02_passive_node.md

@@ -53,7 +53,9 @@ Fields description:
 - *logger*: (optional) logger configuration,
     - *verbosity*: 0 - warning, 1 - info, 2 -debug, 3 and above - trace
     - *format*: log output format - plain or json.
-     - *output*: log output - stderr, syslog (unix only) or journald (linux with systemd only, must be enabled during compilation)
+    - *output*: log output - stderr, gelf (graylog) syslog (unix only) or journald (linux with systemd only, must be enabled during compilation)
+    - *backend*: for gelf output: hostname:port of a graylog server.
+    - *logs_id*: for gelf output: unique id that identify the node as source of the logs.
 - *rest*: (optional) configuration of the rest endpoint.
     - *listen*: listen address
     - *pkcs12*: certificate file (optional)

jormungandr/Cargo.toml

@@ -64,6 +64,7 @@ jormungandr-lib = { path = "../jormungandr-lib" }
 strfmt = "0.1"
 gtmpl = "0.5.6"
 mktemp = "0.4.0"
+slog-gelf = "0.1.0"
 
 [dependencies.actix-web]
 version = "0.7.18"

jormungandr/src/main.rs

@@ -46,6 +46,7 @@ extern crate serde_yaml;
 #[macro_use(b, o, record_static, debug, info, warn, error, crit)]
 extern crate slog;
 extern crate slog_async;
+extern crate slog_gelf;
 #[cfg(feature = "systemd")]
 extern crate slog_journald;
 extern crate slog_json;

jormungandr/src/settings/command_arguments.rs

@@ -77,7 +77,7 @@ pub struct CommandLine {
     #[structopt(long = "log-format", parse(try_from_str))]
     pub log_format: Option<LogFormat>,
 
-    /// Set format of the log emitted. Can be "stderr", "syslog" (unix only) or "journald"
+    /// Set format of the log emitted. Can be "stderr", "gelf", "syslog" (unix only) or "journald"
     /// (linux with systemd only, must be enabled during compilation).
     /// If not configured anywhere, defaults to "stderr".
     #[structopt(long = "log-output", parse(try_from_str))]

jormungandr/src/settings/logging.rs

@@ -1,6 +1,7 @@
 use crate::log::{AsyncableDrain, JsonDrain};
 use slog::{Drain, Logger};
 use slog_async::Async;
+use slog_gelf::Gelf;
 #[cfg(feature = "systemd")]
 use slog_journald::JournaldDrain;
 #[cfg(unix)]
@@ -13,6 +14,8 @@ pub struct LogSettings {
     pub verbosity: slog::Level,
     pub format: LogFormat,
     pub output: LogOutput,
+    pub backend: Option<String>,
+    pub logs_id: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -28,6 +31,7 @@ pub enum LogFormat {
 /// Output of the logger.
 pub enum LogOutput {
     Stderr,
+    Gelf,
     #[cfg(unix)]
     Syslog,
     #[cfg(feature = "systemd")]
@@ -52,6 +56,7 @@ impl FromStr for LogOutput {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match &*s.trim().to_lowercase() {
             "stderr" => Ok(LogOutput::Stderr),
+            "gelf" => Ok(LogOutput::Gelf),
             #[cfg(unix)]
             "syslog" => Ok(LogOutput::Syslog),
             #[cfg(feature = "systemd")]
@@ -63,21 +68,45 @@ impl FromStr for LogOutput {
 
 impl LogSettings {
     pub fn to_logger(&self) -> Result<Logger, Error> {
-        let drain = self.output.to_logger(&self.format)?.fuse();
+        let drain = self
+            .output
+            .to_logger(&self.format, &self.backend, &self.logs_id)?
+            .fuse();
         let drain = slog::LevelFilter::new(drain, self.verbosity).fuse();
         Ok(slog::Logger::root(drain, o!()))
     }
 }
 
 impl LogOutput {
-    fn to_logger(&self, format: &LogFormat) -> Result<Async, Error> {
-        Ok(match self {
-            LogOutput::Stderr => format.decorate_stderr(),
+    fn to_logger(
+        &self,
+        format: &LogFormat,
+        backend: &Option<String>,
+        logs_id: &Option<String>,
+    ) -> Result<Async, Error> {
+        match self {
+            LogOutput::Stderr => Ok(format.decorate_stderr()),
+            LogOutput::Gelf => match backend {
+                Some(graylog_host_port) => {
+                    match logs_id {
+                        Some(graylog_source) => {
+                            let gelf_drain = LogFormat::Plain
+                                .decorate(Gelf::new(graylog_source, graylog_host_port).unwrap());
+                            // We also log to stderr otherwise users see no logs.
+                            // TODO: remove when multiple output is properly supported.
+                            let stderr_drain = format.decorate_stderr();
+                            Ok(slog::Duplicate(gelf_drain, stderr_drain).async())
+                        }
+                        _ => Err(Error::MissingGelfSource),
+                    }
+                }
+                _ => Err(Error::MissingGelfBackend),
+            },
             #[cfg(unix)]
-            LogOutput::Syslog => format.decorate(slog_syslog::unix_3164(Facility::LOG_USER)?),
+            LogOutput::Syslog => Ok(format.decorate(slog_syslog::unix_3164(Facility::LOG_USER)?)),
             #[cfg(feature = "systemd")]
-            LogOutput::Journald => format.decorate(JournaldDrain),
-        })
+            LogOutput::Journald => Ok(format.decorate(JournaldDrain)),
+        }
     }
 }
 
@@ -102,4 +131,6 @@ impl LogFormat {
 
 custom_error! {pub Error
     SyslogAccessFailed { source: io::Error } = "syslog access failed",
+    MissingGelfBackend = "Please specify a backend (host:port of graylog server) for the GELF logger output",
+    MissingGelfSource = "Please specify a logs_id for your logs when using GELF logger output",
 }