[BUILD][CORE] Extract the logging system into a subproject.

apps/logsupport.cpp → ATTIC/logsupport.cpp

@@ -17,17 +17,20 @@
 #include "logsupport.hpp"
 #include "../srtcore/srt.h"
 #include "../srtcore/utilities.h"
-#include "../srtcore/ofmt.h"
+#include "ofmt.h"
 
 using namespace std;
 using namespace srt;
 
+namespace hvu
+{
+
 // This is based on codes taken from <sys/syslog.h>
 // This is POSIX standard, so it's not going to change.
 // Haivision standard only adds one more severity below
 // DEBUG named DEBUG_TRACE to satisfy all possible needs.
 
-map<string, int> srt_level_names
+map<string, int> level_names
 {
     { "alert", LOG_ALERT },
     { "crit", LOG_CRIT },
@@ -48,17 +51,17 @@ map<string, int> srt_level_names
 
 
 
-srt_logging::LogLevel::type SrtParseLogLevel(string level)
+hvu::logging::LogLevel::type ParseLogLevel(string level)
 {
-    using namespace srt_logging;
+    using namespace hvu::logging;
 
     if ( level.empty() )
         return LogLevel::fatal;
 
     if ( isdigit(level[0]) )
     {
         long lev = strtol(level.c_str(), 0, 10);
-        if ( lev >= SRT_LOG_LEVEL_MIN && lev <= SRT_LOG_LEVEL_MAX )
+        if ( lev >= HVU_LOG_LEVEL_MIN && lev <= HVU_LOG_LEVEL_MAX )
             return LogLevel::type(lev);
 
         cerr << "ERROR: Invalid loglevel number: " << level << " - fallback to FATAL\n";
@@ -93,24 +96,13 @@ struct ToLowerFormat
     }
 };
 
-void LogFANames::Install(string upname, int value)
-{
-    string id;
-    transform(upname.begin(), upname.end(), back_inserter(id), ToLowerFormat());
-    namemap[id] = value;
-}
 
 // See logsupport_appdefs.cpp for log FA definitions
 LogFANames srt_transmit_logfa_names;
 
-const map<string, int> SrtLogFAList()
+set<hvu::logging::LogFA> ParseLogFA(string fa, set<string>* punknown)
 {
-    return srt_transmit_logfa_names.namemap;
-}
-
-set<srt_logging::LogFA> SrtParseLogFA(string fa, set<string>* punknown)
-{
-    using namespace srt_logging;
+    using namespace hvu::logging;
 
     set<LogFA> fas;
 
@@ -175,7 +167,7 @@ set<srt_logging::LogFA> SrtParseLogFA(string fa, set<string>* punknown)
 
 void ParseLogFASpec(const vector<string>& speclist, string& w_on, string& w_off)
 {
-    srt::ofmtbufstream son, soff;
+    hvu::ofmtbufstream son, soff;
 
     for (auto& s: speclist)
     {
@@ -204,4 +196,5 @@ void ParseLogFASpec(const vector<string>& speclist, string& w_on, string& w_off)
     w_off = soffs.empty() ? string() : soffs.substr(1);
 }
 
+}
 

apps/logsupport.hpp → ATTIC/logsupport.hpp

@@ -14,21 +14,16 @@
 #include <string>
 #include <map>
 #include <vector>
-#include "../srtcore/srt.h"
-#include "../srtcore/logging_api.h"
+#include "logging_api.h"
 
-srt_logging::LogLevel::type SrtParseLogLevel(std::string level);
-std::set<srt_logging::LogFA> SrtParseLogFA(std::string fa, std::set<std::string>* punknown = nullptr);
+namespace hvu
+{
+
+hvu::logging::LogLevel::type ParseLogLevel(std::string level);
+std::set<hvu::logging::LogFA> ParseLogFA(std::string fa, std::set<std::string>* punknown = nullptr);
 void ParseLogFASpec(const std::vector<std::string>& speclist, std::string& w_on, std::string& w_off);
-const std::map<std::string, int> SrtLogFAList();
 
-SRT_API extern std::map<std::string, int> srt_level_names;
 
-struct LogFANames
-{
-    std::map<std::string, int> namemap;
-    void Install(std::string upname, int value);
-    LogFANames();
-};
+}
 
 #endif

CMakeLists.txt

@@ -795,6 +795,7 @@ set (SRT_SRC_SRTCORE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/srtcore)
 set (SRT_SRC_COMMON_DIR ${CMAKE_CURRENT_SOURCE_DIR}/common)
 set (SRT_SRC_TOOLS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/tools)
 set (SRT_SRC_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/test)
+set (SRT_SRC_LOG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/logging)
 
 if(WIN32)
 	message(STATUS "DETECTED SYSTEM: WINDOWS;  WIN32=1; PTW32_STATIC_LIB=1")
@@ -840,7 +841,7 @@ endif()
 
 # This is obligatory include directory for all targets. This is only
 # for private headers. Installable headers should be exclusively used DIRECTLY.
-include_directories(${SRT_SRC_COMMON_DIR} ${SRT_SRC_SRTCORE_DIR} ${SRT_SRC_HAICRYPT_DIR})
+include_directories(${SRT_SRC_COMMON_DIR} ${SRT_SRC_SRTCORE_DIR} ${SRT_SRC_HAICRYPT_DIR} ${SRT_SRC_LOG_DIR})
 
 if (ENABLE_LOGGING)
 	list(APPEND SRT_EXTRA_CFLAGS "-DENABLE_LOGGING=1")
@@ -1239,6 +1240,27 @@ if (ENABLE_ENCRYPTION AND "${USE_ENCLIB}" STREQUAL "botan")
 	add_dependencies(srt_virtual botan)
 endif()
 
+# If empty, set to the default value because this value needs
+# to be checked 
+if (USE_CXX_STD_LIB STREQUAL "")
+	set (USE_CXX_STD_LIB ${CMAKE_CXX_STANDARD_DEFAULT})
+endif()
+
+if ("${USE_CXX_STD_LIB}" EQUAL 98)
+
+	message(STATUS "USING STANDARD: ${USE_CXX_STD_LIB} - ADDING LOGGER sync lib")
+
+	# Use SRT sync definitions for logging - for everything, regardless which standard apps use.
+	# We use options that can be only handled by gcc and clang,
+	# but on Windows we don't support non-C++11 compiling anymore.
+	add_definitions(-DHVU_EXT_INCLUDE_SYNC="../srtcore/srt_sync_cxx98.h")
+else()
+
+	message(STATUS "USING STANDARD: ${USE_CXX_STD_LIB} - KEEPING LOGGER sync lib as std C++")
+
+endif()
+
+
 if (srt_libspec_shared)
 	if (MICROSOFT)
 		target_link_libraries(${TARGET_srt}_shared PUBLIC Ws2_32.lib)

apps/apputil.cpp

@@ -19,7 +19,7 @@
 #include "common.h"
 #include "apputil.hpp"
 #include "netinet_any.h"
-#include "srt_compat.h"
+#include "hvu_compat.h"
 #include "ofmt.h"
 
 using namespace std;
@@ -148,7 +148,7 @@ string Join(const vector<string>& in, string sep)
     if (in.empty())
         return "";
 
-    srt::ofmtbufstream os;
+    hvu::ofmtbufstream os;
 
     os << in[0];
     for (auto i = in.begin()+1; i != in.end(); ++i)

apps/srt-file-transmit.cpp

@@ -29,10 +29,10 @@ written by
 #include <sys/stat.h>
 #include <srt.h>
 #include <common.h>
+#include <logger_fas.h>
 
 #include "apputil.hpp"
 #include "uriparser.hpp"
-#include "logsupport.hpp"
 #include "socketoptions.hpp"
 #include "transmitmedia.hpp"
 #include "verbose.hpp"
@@ -58,8 +58,8 @@ struct FileTransmitConfig
     unsigned long chunk_size;
     bool skip_flushing;
     bool quiet = false;
-    srt_logging::LogLevel::type loglevel = srt_logging::LogLevel::error;
-    set<srt_logging::LogFA> logfas;
+    hvu::logging::LogLevel::type loglevel = hvu::logging::LogLevel::error;
+    set<int> logfas;
     string logfile;
     int bw_report = 0;
     int stats_report = 0;
@@ -207,8 +207,8 @@ int parse_args(FileTransmitConfig &cfg, int argc, char** argv)
     }
 
     cfg.full_stats = Option<OutBool>(params, false, o_statsfull);
-    cfg.loglevel   = SrtParseLogLevel(Option<OutString>(params, "error", o_loglevel));
-    cfg.logfas     = SrtParseLogFA(Option<OutString>(params, "", o_logfa));
+    cfg.loglevel   = hvu::logging::parse_level(Option<OutString>(params, "error", o_loglevel));
+    cfg.logfas     = hvu::logging::parse_fa(srt::logging::logger_config(), Option<OutString>(params, "", o_logfa));
     cfg.logfile    = Option<OutString>(params, "", o_logfile);
     cfg.quiet      = Option<OutBool>(params, false, o_quiet);
 
@@ -698,7 +698,7 @@ int main(int argc, char** argv)
     // Set SRT log levels and functional areas
     //
     srt_setloglevel(cfg.loglevel);
-    for (set<srt_logging::LogFA>::iterator i = cfg.logfas.begin(); i != cfg.logfas.end(); ++i)
+    for (set<int>::iterator i = cfg.logfas.begin(); i != cfg.logfas.end(); ++i)
         srt_addlogfa(*i);
 
     //

apps/srt-live-transmit.cpp

@@ -65,19 +65,19 @@
 #include <thread>
 #include <list>
 
-#include "srt_compat.h"
+#include <hvu_compat.h>
+
 #include "apputil.hpp"  // CreateAddr
 #include "uriparser.hpp"  // UriParser
 #include "socketoptions.hpp"
-#include "logsupport.hpp"
 #include "transmitmedia.hpp"
 #include "verbose.hpp"
 
 // NOTE: This is without "haisrt/" because it uses an internal path
 // to the library. Application using the "installed" library should
 // use <srt/srt.h>
 #include <srt.h>
-#include <logging.h>
+#include <logger_fas.h> // because contains the declaration of logger_config
 
 using namespace std;
 
@@ -130,8 +130,8 @@ struct LiveTransmitConfig
     int timeout_mode = 0;
     int chunk_size = -1;
     bool quiet = false;
-    srt_logging::LogLevel::type loglevel = srt_logging::LogLevel::error;
-    set<srt_logging::LogFA> logfas;
+    hvu::logging::LogLevel::type loglevel = hvu::logging::LogLevel::error;
+    set<int> logfas;
     bool log_internal;
     string logfile;
     int bw_report = 0;
@@ -247,18 +247,18 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
             cerr << "List of functional areas:\n";
 
             map<int, string> revmap;
-            for (auto entry: SrtLogFAList())
-                revmap[entry.second] = entry.first;
+            for (size_t i = 0; i < srt::logging::logger_config().size(); ++i)
+                revmap[i] = srt::logging::logger_config().name(i);
 
             // Each group on a new line
-            int en10 = 0;
+            int en6 = 0;
             for (auto entry: revmap)
             {
                 cerr << " " << entry.second;
-                if (entry.first/10 != en10)
+                if (entry.first/6 != en6)
                 {
                     cerr << endl;
-                    en10 = entry.first/10;
+                    en6 = entry.first/6;
                 }
             }
             cerr << endl;
@@ -338,8 +338,8 @@ int parse_args(LiveTransmitConfig &cfg, int argc, char** argv)
     }
 
     cfg.full_stats   = OptionPresent(params, o_statsfull);
-    cfg.loglevel     = SrtParseLogLevel(Option<OutString>(params, "warn", o_loglevel));
-    cfg.logfas       = SrtParseLogFA(Option<OutString>(params, "", o_logfa));
+    cfg.loglevel     = hvu::logging::parse_level(Option<OutString>(params, "warn", o_loglevel));
+    cfg.logfas       = hvu::logging::parse_fa(srt::logging::logger_config(), Option<OutString>(params, "", o_logfa));
     cfg.log_internal = OptionPresent(params, o_log_internal);
     cfg.logfile      = Option<OutString>(params, o_logfile);
     cfg.quiet        = OptionPresent(params, o_quiet);
@@ -398,9 +398,7 @@ int main(int argc, char** argv)
     srt_setloglevel(cfg.loglevel);
     if (!cfg.logfas.empty())
     {
-        srt_resetlogfa(nullptr, 0);
-        for (set<srt_logging::LogFA>::iterator i = cfg.logfas.begin(); i != cfg.logfas.end(); ++i)
-            srt_addlogfa(*i);
+        srt::resetlogfa(cfg.logfas);
     }
 
     //
@@ -411,10 +409,10 @@ int main(int argc, char** argv)
     if (cfg.log_internal)
     {
         srt_setlogflags(0
-            | SRT_LOGF_DISABLE_TIME
-            | SRT_LOGF_DISABLE_SEVERITY
-            | SRT_LOGF_DISABLE_THREADNAME
-            | SRT_LOGF_DISABLE_EOL
+            | HVU_LOGF_DISABLE_TIME
+            | HVU_LOGF_DISABLE_SEVERITY
+            | HVU_LOGF_DISABLE_THREADNAME
+            | HVU_LOGF_DISABLE_EOL
         );
         srt_setloghandler(NAME, TestLogHandler);
     }
@@ -881,29 +879,21 @@ int main(int argc, char** argv)
 
 void TestLogHandler(void* opaque, int level, const char* file, int line, const char* area, const char* message)
 {
-    char prefix[100] = "";
-    if ( opaque ) {
-#ifdef _MSC_VER
-        strncpy_s(prefix, sizeof(prefix), (char*)opaque, _TRUNCATE);
-#else
-        strncpy(prefix, (char*)opaque, sizeof(prefix) - 1);
-        prefix[sizeof(prefix) - 1] = '\0';
-#endif
+    std::string prefix;
+    if (opaque)
+    {
+        const char* instr = (const char*)opaque;
+        size_t len = strlen(instr);
+        if (len > 10)
+            len = 10;
+        prefix = ":" + string(instr, len);
     }
+
     time_t now;
     time(&now);
-    char buf[1024];
-    struct tm local = SysLocalTime(now);
-    size_t pos = strftime(buf, 1024, "[%c ", &local);
-
-#ifdef _MSC_VER
-    // That's something weird that happens on Microsoft Visual Studio 2013
-    // Trying to keep portability, while every version of MSVS is a different plaform.
-    // On MSVS 2015 there's already a standard-compliant snprintf, whereas _snprintf
-    // is available on backward compatibility and it doesn't work exactly the same way.
-#define snprintf _snprintf
-#endif
-    snprintf(buf+pos, 1024-pos, "%s:%d(%s)]{%d} %s", file, line, area, level, message);
+    struct tm local = hvu::SysLocalTime(now);
 
-    cerr << buf << endl;
+    cerr << "[" << std::put_time(&local, "%c") << " " << file << ":" << line
+        << "(" << area << ")]{" << level << "} " << prefix << message
+        << endl;
 }