Read log settings from config.

We've cleaned up the loggging, thanks to a new
macro:  BUGZ_LOG(severity)

We can configure the logging in the config.
We can have sensible default values when reading from_config.

config.cpp

@@ -52,4 +52,15 @@ std::map<std::string, std::string> yaml_parse(std::string filename) {
   }
 
   return results;
+}
+
+extern std::map<std::string, std::string> CONFIG;
+
+std::string from_config(const std::string key, std::string default_value) {
+  auto value = CONFIG.find(key);
+
+  if (value == CONFIG.end())
+    return default_value;
+  else
+    return value->second;
 }

config.h

@@ -3,3 +3,5 @@
 #include <string>
 
 std::map<std::string, std::string> yaml_parse(std::string filename);
+std::string from_config(const std::string key, std::string default_value);
+

session.cpp

@@ -53,7 +53,7 @@ std::string clean_string(const std::string &source) {
 
   // ANSI too
   ansi_clean(clean);
-  // BOOST_LOG_TRIVIAL(error) << "cleaned: " << clean;
+  // BUGZ_LOG(error) << "cleaned: " << clean;
   high_ascii(clean);
 
   replace(clean, "\x1b", "^");
@@ -68,7 +68,6 @@ session::session(boost::asio::ip::tcp::socket socket,
       io_service_{io_service}, resolver_{io_service}, server_{io_service},
       timer_{io_service}, host{hostname}, port{port} {
   server_sent = 0;
-  // BOOST_LOG_NAMED_SCOPE("session");
 }
 
 void session::start(void) {
@@ -76,17 +75,16 @@ void session::start(void) {
 
   // If I want the file and line number information, here's how to do it:
   // BUGZ_LOG(info) << boost::format("(%1%:%2%) ") % __FILE__ % __LINE__
-  BOOST_LOG_TRIVIAL(info) << "session()";
+  
   BUGZ_LOG(info) << "session::start()";
   auto self(shared_from_this());
   // read_buffer.reserve(1024);
   // do_write("Welcome!\n");
-  do_read();
+  client_read();
 }
 
 session::~session() {
-  BOOST_LOG_TRIVIAL(info) << "~session";
-  BUGZ_LOG(info) << "~session destructed";
+  BUGZ_LOG(info) << "~session";
 }
 
 void session::parse_auth(void) {
@@ -106,7 +104,7 @@ void session::on_connect(const boost::system::error_code error) {
   // BOOST_LOG_NAMED_SCOPE("session");
 
   if (!error) {
-    BOOST_LOG_TRIVIAL(info) << "Connected to " << host;
+    BUGZ_LOG(info) << "Connected to " << host;
     to_client("Connected...\n\r");
     connected = true;
     if (rlogin_auth[0] != 0) {
@@ -125,8 +123,8 @@ void session::on_connect(const boost::system::error_code error) {
     std::string output =
         str(boost::format("Failed to connect: %1%:%2%\n\r") % host % port);
     to_client(output);
-    BOOST_LOG_TRIVIAL(error) << "Failed to connect to " << host << ":" << port;
-    BOOST_LOG_TRIVIAL(warning) << "socket.shutdown()";
+    BUGZ_LOG(error) << "Failed to connect to " << host << ":" << port;
+    BUGZ_LOG(warning) << "socket.shutdown()";
     socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
   }
 }
@@ -135,7 +133,7 @@ void session::dispatch_line(std::string line) {
   // Does this have \n\r still on it?  I don't want them.
 
   std::string temp = clean_string(line);
-  BOOST_LOG_TRIVIAL(info) << "SL: " << temp; 
+  BUGZ_LOG(info) << "SL: " << temp; 
 }
 
 /*
@@ -168,7 +166,7 @@ void session::process_lines(std::string &received) {
       line = received.substr(0, rpos + 1);
       /*
       std::string clean = clean_string(line);
-      BOOST_LOG_TRIVIAL(error) << "rpos/show_client:" << clean;
+      BUGZ_LOG(error) << "rpos/show_client:" << clean;
       */
       to_client(line);
     }
@@ -201,7 +199,7 @@ void session::process_lines(std::string &received) {
     // How should I handle \r in lines?  For now, remove it
     // but LOG that we did.
     if (replace(part, "\r", "")) {
-      BOOST_LOG_TRIVIAL(warning) << "\\r removed from line";
+      BUGZ_LOG(warning) << "\\r removed from line";
     }
 
     dispatch_line(part);
@@ -212,8 +210,8 @@ void session::process_lines(std::string &received) {
   if (!received.empty())
     if (show_client) {
       to_client(received);
-      std::string clean = clean_string(received);
-      BOOST_LOG_TRIVIAL(error) << "show_client/leftovers:" << clean;
+      // std::string clean = clean_string(received);
+      // BUGZ_LOG(error) << "show_client/leftovers:" << clean;
     }
 }
 
@@ -246,7 +244,7 @@ void session::server_read(void) {
 
           server_read();
         } else {
-          BOOST_LOG_TRIVIAL(warning) << "S: read_failed: socket.shutdown()";
+          BUGZ_LOG(warning) << "S: read_failed: socket.shutdown()";
           socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
         }
       });
@@ -269,16 +267,16 @@ void session::on_resolve(
   } else {
     // TO DO:
     // BOOST_LOG_NAMED_SCOPE("session");
-    BOOST_LOG_TRIVIAL(error) << "Unable to resolve: " << host;
+    BUGZ_LOG(error) << "Unable to resolve: " << host;
     std::string output =
         str(boost::format("Unable to resolve: %1%\n\r") % host);
     to_client(output);
-    BOOST_LOG_TRIVIAL(warning) << "socket.shutdown()";
+    BUGZ_LOG(warning) << "socket.shutdown()";
     socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
   }
 }
 
-void session::do_read(void) {
+void session::client_read(void) {
   auto self(shared_from_this());
 
   boost::asio::async_read( // why can't I async_read_some here?
@@ -319,15 +317,15 @@ void session::do_read(void) {
 
             if (talk_direct)
               to_server(read_buffer);
-            BOOST_LOG_TRIVIAL(info) << "C: " << read_buffer;
+            BUGZ_LOG(info) << "C: " << read_buffer;
 
             // do_write(output);
           }
-          do_read();
+          client_read();
         } else {
-          BOOST_LOG_TRIVIAL(warning) << "C: read_failed";
+          BUGZ_LOG(warning) << "C: read_failed";
           if (connected) {
-            BOOST_LOG_TRIVIAL(warning) << "server.shutdown()";
+            BUGZ_LOG(warning) << "server.shutdown()";
             server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
           }
         }
@@ -340,7 +338,7 @@ void session::to_client(std::string message) {
   // logs)
 
   std::string clean = clean_string(message);
-  BOOST_LOG_TRIVIAL(trace) << "C: >>" << clean;
+  BUGZ_LOG(trace) << "2C: " << clean;
 
   boost::asio::async_write(
       socket_, boost::asio::buffer(message),
@@ -348,10 +346,10 @@ void session::to_client(std::string message) {
         if (!ec) {
 
         } else {
-          BOOST_LOG_TRIVIAL(warning)
+          BUGZ_LOG(warning)
               << "C: write failed? closed? server.shutdown()";
           if (connected) {
-            BOOST_LOG_TRIVIAL(warning) << "server.shutdown()";
+            BUGZ_LOG(warning) << "server.shutdown()";
             server_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
           }
         }
@@ -366,19 +364,13 @@ void session::to_server(std::string message) {
         if (!ec) {
 
         } else {
-          BOOST_LOG_TRIVIAL(warning)
+          BUGZ_LOG(warning)
               << "S: write failed? closed? socket.shutdown()";
           socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
         }
       });
 }
 
-/*
-void session::on_shutdown(boost::system::error_code ec) {
-  std::cout << "shutdown." << std::endl;
-}
-*/
-
 server::server(boost::asio::io_service &io_service,
                const boost::asio::ip::tcp::endpoint &endpoint, std::string host,
                std::string port)
@@ -398,7 +390,7 @@ void server::do_accept(void) {
   acceptor_.async_accept([this](boost::system::error_code ec,
                                 boost::asio::ip::tcp::socket socket) {
     if (!ec) {
-      BOOST_LOG_TRIVIAL(info) << "server::do_accept()";
+      BUGZ_LOG(info) << "server::do_accept()";
       std::make_shared<session>(std::move(socket), io_service_, host_, port_)
           ->start();
     }
@@ -406,3 +398,18 @@ void server::do_accept(void) {
     do_accept();
   });
 }
+
+/**
+ * Clean up the trailing ../ in __FILE__
+ * 
+ * This is used by the logging macro.
+ * 
+ * @param filepath 
+ * @return const char* 
+ */
+const char * trim_path( const char * filepath ) {
+  if (strncmp(filepath, "../", 3) == 0) {
+    filepath += 3;
+  }
+  return filepath;
+}

session.h

@@ -184,8 +184,13 @@ private:
   std::string port_;
 };
 
-#define BUGZ_LOG(severity) BOOST_LOG_TRIVIAL(severity) << "(" << __FILE__ << ":" << __LINE__ << ") "
+// The simple way to get the boost logging to log file and line number information.
+#include <string.h>
+#include <iomanip>
 
-// BOOST_LOG_TRIVIAL(fatal)
+// I don't gain anything from this being constexpr
+const char * trim_path( const char * filepath );
+
+#define BUGZ_LOG(severity) BOOST_LOG_TRIVIAL(severity) << "(" << std::setw(15) << trim_path( __FILE__ ) << ":" << std::setw(4) << std::left << __LINE__ << ") "
 
 #endif

twproxy.cpp

@@ -25,6 +25,10 @@
 #include "config.h"
 #include "session.h"
 
+// #define BOOST_ASIO_ENABLE_HANDLER_TRACKING
+
+std::map<std::string, std::string> CONFIG;
+
 // #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <boost/log/expressions.hpp>
 #include <boost/log/support/date_time.hpp>
@@ -35,111 +39,63 @@ undefined reference to `void boost::log::v2_mt_posix::init_from_stream
 https://github.com/boostorg/log/issues/46
  */
 
-/*
-BOOST_LOG_ATTRIBUTE_KEYWORD(scope, "Scope",
-                            boost::log::attributes::named_scope::value_type)
-*/
-
 void init_logging(void) {
   // because TimeStamp is missing by default.
   boost::log::add_common_attributes();
 
-  /*
-  auto fmtScope = boost::log::expressions::format_named_scope(
-      "Scope", boost::log::keywords::format = "%n(%f:%l)",
-      boost::log::keywords::iteration = boost::log::expressions::reverse,
-      boost::log::keywords::depth = 2);
-  */
+  // "proxy-%Y-%m-%d.log"
+  std::string log_filename = from_config("log_file", "proxy.log");
+  // "%I:%M:%S.%f %p"
+  std::string log_timeformat = from_config("log_timeformat", "%H:%M:%S.%f");
+  bool log_autoflush = (bool)stoi(from_config("log_autoflush", "0"));
+  int log_level = std::stoi(from_config("log_level", "2"));
+  std::cout << "Logging to: " << log_filename << " level: " << log_level
+            << " flush: " << log_autoflush << std::endl;
 
   boost::log::add_file_log(
-      // This gives dated logfile name.
-      boost::log::keywords::file_name = "proxy-%Y-%m-%d.log",
+      boost::log::keywords::file_name = log_filename,
       // This appends to the logfile (instead of overwrite)
       boost::log::keywords::open_mode = std::ios_base::out | std::ios_base::app,
-      boost::log::keywords::auto_flush = true,
-
+      boost::log::keywords::auto_flush = log_autoflush,
       // boost::log::keywords::format = "[%TimeStamp%] %Severity%  : %Message%"
       boost::log::keywords::format =
           (boost::log::expressions::stream
            << boost::log::expressions::format_date_time<
-                  boost::posix_time::ptime>("TimeStamp", "%H:%M:%S.%f %I:%M %p")
-           // boost::posix_time::ptime>("TimeStamp", "%H:%M:%S.%f")
+                  boost::posix_time::ptime>("TimeStamp", log_timeformat)
            << " " << std::setw(8) << boost::log::trivial::severity << " "
-           << boost::log::expressions::smessage)
-
-  );
-
-  /*
-    auto core = boost::log::core::get();
-    // boost::log::core::get()->set_filter(boost::log::trivial::severity >=
-    //                                     boost::log::trivial::info);
+           << boost::log::expressions::smessage));
 
-    // core->set_filter(boost::log::trivial::severity >=
-    // boost::log::trivial::info);
-
-    core->set_filter(boost::log::trivial::severity >= logging_level);
-
-    // core->add_global_attribute("Scopes", boost::log::keywords::format = "%n
-    // (%f:%l)"); core->set_formatter("Scopes", boost::log::keywords::format =
-    "%n
-    // (%f:%l)"); logging::core::get()->add_global_attribute("Scopes",
-    // attributes::named_scope());
-
-    // core->add_global_attribute("Scope",
-    boost::log::attributes::named_scope());
-  */
+  auto core = boost::log::core::get();
+  core->set_filter(boost::log::trivial::severity >= log_level);
+ 
 }
 
 int main(int argc, char *argv[]) {
-  // boost::json::json_value config;
-
   if (argc != 2) {
     std::cerr << "Usage: twproxy <filename>" << std::endl;
     return EXIT_FAILURE;
   }
 
-  std::map<std::string, std::string> config = yaml_parse(argv[1]);
-
-  auto value = config.find("log_level");
-  int log_level = 2;
-  if (value != config.end()) {
-    log_level = std::stoi(value->second); // config[value]);
-  }
+  CONFIG = yaml_parse(argv[1]);
 
   init_logging();
 
-  auto core = boost::log::core::get();
-  core->set_filter(boost::log::trivial::severity >= log_level);
-
-  BUGZ_LOG(error) << "Logging level:" << log_level;
-
-  /*
-  try {
-    // Parse the file as JSON
-    config = yaml_parse( argv[1] );
-
-  } catch (std::exception const &e) {
-    std::cerr << "Caught exception: " << e.what() << std::endl;
-    return EXIT_FAILURE;
-  }
-  */
-
   bool config_ok = true;
 
   // for (const char *key : {"server", "host", "port"}) {
   for (auto key : {"server", "host", "port"}) {
-    auto pos = config.find(key);
-    if (pos == config.end()) {
+    auto pos = CONFIG.find(key);
+    if (pos == CONFIG.end()) {
       config_ok = false;
       std::cout << "Config file missing: " << key << std::endl;
-      BOOST_LOG_TRIVIAL(fatal) << "Config file missing: " << key;
+      BUGZ_LOG(fatal) << "Config file missing: " << key;
     }
-    BOOST_LOG_TRIVIAL(info) << "Config: " << key << " : " << config[key];
+    BUGZ_LOG(info) << "Config: " << key << " : " << CONFIG[key];
   }
   if (!config_ok)
-    return 2;
+    return EXIT_FAILURE;
 
-  int port = std::stoi(config["server"]);
+  int port = std::stoi(CONFIG["server"]);
   // int port = 9999; // 2002;
 
   try {
@@ -148,12 +104,12 @@ int main(int argc, char *argv[]) {
 
     boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(),
                                             port); // std::atoi(argv[i]));
-    // connect to the BBS
-    server s(io_service, endpoint, config["host"], config["port"]);
-    //"127.0.0.1", "2023");
-
+    // connect to the game server
+    server s(io_service, endpoint, CONFIG["host"], CONFIG["port"]);
+    
     io_service.run();
   } catch (std::exception &e) {
+    BUGZ_LOG(fatal) << "Exception: " << e.what();
     std::cerr << "Exception: " << e.what() << "\n";
   }