Make Trunk-Recorder logrotate friendly, via syslogFriendly bool config option. (#1080)

* Added a `syslogFriendly` config option, that by default is `false`. When
set to `true` creates a `trunk-recorder.log` file that can be rotated
with logrotate via logrotate sending a `SIGHUP` signal. Closes #833.

* Added `syslogFriendly` information to `CONFIGURE.md` docs.

Author: Dygear

docs/CONFIGURE.md

@@ -151,6 +151,7 @@ There is a list of available Plugins [here](./Plugins.md).
 | newCallFromUpdate            |          | true                                             | **true** / **false**                                         | Allow for UPDATE trunking messages to start a new Call, in addition to GRANT messages. This may result in more Calls with no transmisions, and use more Recorders. The flipside is that it may catch parts of a Call that would have otherwise been missed. Turn this off if you are running out of Recorders. |
 | softVocoder                  |          | false                                            | **true** / **false**                                         | Use the Software Decode vocoder from OP25 for P25 and DMR. Give it a try if you are hearing weird tones in your audio. Whether it makes your audio sound better or worse is a matter of preference. |
 | recordUUVCalls               |          | true                                             | **true** / **false**                                         | *P25 only* Record Unit to Unit Voice calls.        |
+| syslogFriendly               |          | false                                              | **true** / **false**                                         | Uses static filename `trunk-recorder.log` for use with syslog when `true`. |
 
 
 ## Source Object

trunk-recorder/config.cc

@@ -14,6 +14,9 @@ namespace sinks = boost::log::sinks;
 
 using namespace std;
 
+// Global log sink for SIGHUP rotation support
+boost::shared_ptr<sinks::synchronous_sink<sinks::text_file_backend>> global_log_sink;
+
 void set_logging_level(std::string log_level) {
   boost::log::trivial::severity_level sev_level = boost::log::trivial::info;
 
@@ -67,20 +70,26 @@ void setup_console_log(std::string log_color, std::string time_fmt) {
   console_sink->imbue(loc);
 }
 
-void setup_file_log(std::string log_dir, std::string log_color, std::string time_fmt) {
-  boost::shared_ptr<sinks::synchronous_sink<sinks::text_file_backend>> log_sink = logging::add_file_log(
-      keywords::file_name = log_dir + "/%m-%d-%Y_%H%M_%2N.log",
-      keywords::rotation_size = 100 * 1024 * 1024,
-      keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0),
-      keywords::auto_flush = true);
+void setup_file_log(std::string log_dir, std::string log_color, std::string time_fmt, bool syslog_friendly) {
+  if (syslog_friendly) {
+    global_log_sink = logging::add_file_log(
+        keywords::file_name = log_dir + "/trunk-recorder.log",
+        keywords::auto_flush = true);
+  } else {
+    global_log_sink = logging::add_file_log(
+        keywords::file_name = log_dir + "/%m-%d-%Y_%H%M_%2N.log",
+        keywords::rotation_size = 100 * 1024 * 1024,
+        keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0),
+        keywords::auto_flush = true);
+  }
 
   if ((log_color == "logfile") || (log_color == "all")) {
-    log_sink->set_formatter(logging::expressions::format("[%1%] (%2%)   %3%") %
+    global_log_sink->set_formatter(logging::expressions::format("[%1%] (%2%)   %3%") %
                             logging::expressions::format_date_time<boost::posix_time::ptime>("TimeStamp", time_fmt) %
                             logging::expressions::attr<logging::trivial::severity_level>("Severity") %
                             logging::expressions::smessage);
   } else {
-    log_sink->set_formatter(logging::expressions::format("[%1%] (%2%)   %3%") %
+    global_log_sink->set_formatter(logging::expressions::format("[%1%] (%2%)   %3%") %
                             logging::expressions::format_date_time<boost::posix_time::ptime>("TimeStamp", time_fmt) %
                             logging::expressions::attr<logging::trivial::severity_level>("Severity") %
                             logging::expressions::wrap_formatter(NoColorLoggingFormatter{}));
@@ -134,8 +143,9 @@ bool load_config(string config_file, Config &config, gr::top_block_sptr &tb, std
 
     config.log_file = data.value("logFile", false);
     config.log_dir = data.value("logDir", "logs");
+    config.syslog_friendly = data.value("syslogFriendly", false);
     if (config.log_file) {
-      setup_file_log(config.log_dir, config.log_color, "%Y-%m-%d %H:%M:%S.%f");
+      setup_file_log(config.log_dir, config.log_color, "%Y-%m-%d %H:%M:%S.%f", config.syslog_friendly);
     }
 
     double config_ver = data.value("ver", 0.0);
@@ -153,6 +163,7 @@ bool load_config(string config_file, Config &config, gr::top_block_sptr &tb, std
 
     BOOST_LOG_TRIVIAL(info) << "Log to File: " << config.log_file;
     BOOST_LOG_TRIVIAL(info) << "Log Directory: " << config.log_dir;
+    BOOST_LOG_TRIVIAL(info) << "Syslog Friendly Mode: " << config.syslog_friendly;
 
     std::string defaultTempDir = boost::filesystem::current_path().string();
 

trunk-recorder/global_structs.h

@@ -41,6 +41,7 @@ struct Config {
   double call_timeout;
   bool console_log;
   bool log_file;
+  bool syslog_friendly;
   std::string log_color;
   int control_message_warn_rate;
   int control_retune_limit;

trunk-recorder/monitor_systems.cc

@@ -1,14 +1,25 @@
 #include "monitor_systems.h"
 #include "recorders/p25_recorder.h"
+#include <boost/log/sinks/text_file_backend.hpp>
+#include <boost/log/core.hpp>
+
 using namespace std;
 
+// External reference to global log sink for SIGHUP rotation
+extern boost::shared_ptr<boost::log::sinks::synchronous_sink<boost::log::sinks::text_file_backend>> global_log_sink;
+
 volatile sig_atomic_t exit_flag = 0;
+volatile sig_atomic_t rotate_log_flag = 0;
 int exit_code = EXIT_SUCCESS;
 
 void exit_interupt(int sig) { // can be called asynchronously
   exit_flag = 1;              // set flag
 }
 
+void rotate_log_signal(int sig) { // can be called asynchronously
+  rotate_log_flag = 1;          // set flag
+}
+
 uint64_t time_since_epoch_millisec() {
   using namespace std::chrono;
   return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
@@ -848,6 +859,7 @@ int monitor_messages(Config &config, gr::top_block_sptr &tb, std::vector<Source
   P25Parser *p25_parser;
 
   signal(SIGINT, exit_interupt);
+  signal(SIGHUP, rotate_log_signal);
 
   smartnet_parser = new SmartnetParser(systems.front()); // this has to eventually be generic;
   p25_parser = new P25Parser();
@@ -874,6 +886,19 @@ int monitor_messages(Config &config, gr::top_block_sptr &tb, std::vector<Source
       return exit_code;
     }
 
+    if (rotate_log_flag) { // SIGHUP received for log rotation
+      rotate_log_flag = 0;  // reset flag
+      if (global_log_sink) {
+        BOOST_LOG_TRIVIAL(info) << "Received SIGHUP signal - rotating log file...";
+        // Flush the sink
+        global_log_sink->flush();
+        // Rotate the log file by removing and re-adding the backend
+        boost::log::core::get()->remove_sink(global_log_sink);
+        boost::log::core::get()->add_sink(global_log_sink);
+        BOOST_LOG_TRIVIAL(info) << "Log file rotation complete";
+      }
+    }
+
     process_message_queues(systems);
     process_recorder_message_queues(calls);