Integrate boost logger

Author: flexferrum

.clang-format

@@ -11,21 +11,23 @@ BraceWrapping:
   BeforeCatch: true
   BeforeElse: true
   AfterStruct: true
+  AfterEnum: true
 AccessModifierOffset: -4
 BinPackParameters: false
 AlwaysBreakAfterReturnType: None
 AlwaysBreakAfterDefinitionReturnType: None
 AllowAllParametersOfDeclarationOnNextLine: false
 ConstructorInitializerIndentWidth: 4
 NamespaceIndentation: None
+FixNamespaceComments: true
 PointerAlignment: Left
 Standard: Cpp11
 UseTab: Never
 AlignAfterOpenBracket: Align
 PenaltyReturnTypeOnItsOwnLine: 0
 IncludeBlocks: Regroup
 IncludeCategories:
-  - Regex:           '^((<|")(shared)\/)'
+  - Regex:           '^((<|")(boost)\/)'
     Priority:        4
   - Regex:           '^((<|")(components)\/)'
     Priority:        3

CMakeLists.txt

@@ -58,6 +58,7 @@ set_property(TARGET ${LIB_TARGET_NAME} PROPERTY PUBLIC_HEADER ${PublicHeaders})
 target_link_libraries(
         ${LIB_TARGET_NAME}
         PUBLIC jinja2cpp::jinja2cpp nlohmann_json::nlohmann_json
+        PRIVATE fmt::fmt
 )
 
 if (FLASK4CPP_ENABLE_SSL)

include/flask4cpp/app_builder.h

@@ -22,12 +22,23 @@ class AppBuilder
     AppBuilder();
     ~AppBuilder();
 
-    enum class BuildErrors {
+    enum class BuildErrors
+    {
         NotInitialized,
         ConfigurationError,
         NoSSLSupport,
     };
 
+    enum class LogLevel
+    {
+        Trace,
+        Debug,
+        Info,
+        Warning,
+        Error,
+        Fatal
+    };
+
     AppBuilder& ConfigureDefault();
     AppBuilder& ListenOn(const nonstd::string_view& name, const nonstd::string_view& address, uint16_t port);
     AppBuilder& ListenOnSsl(const nonstd::string_view& name,
@@ -36,6 +47,8 @@ class AppBuilder
                             const nonstd::string_view& certPath,
                             const nonstd::string_view& keyPath);
 
+    AppBuilder& SetLogLevel(LogLevel level);
+
     nonstd::expected<App, BuildErrors> CreateApp();
 
 private:

src/app_builder.cpp

@@ -3,8 +3,13 @@
 //
 
 #include "app_settings.h"
+#include "log.h"
 
 #include <flask4cpp/app_builder.h>
+#include <fmt/format.h>
+
+#include <boost/log/utility/setup/console.hpp>
+#include <boost/log/utility/setup/filter_parser.hpp>
 
 namespace flask4cpp
 {
@@ -59,18 +64,84 @@ AppBuilder& AppBuilder::ListenOnSsl(const nonstd::string_view& name,
     return *this;
 }
 
+AppBuilder& AppBuilder::SetLogLevel(AppBuilder::LogLevel level)
+{
+    EnsureSettingsCreated();
+    auto& logSetts = m_settings->logSettings;
+    using namespace boost::log;
+
+    switch (level)
+    {
+        case LogLevel::Trace:
+            logSetts.severity = trivial::trace;
+            break;
+        case LogLevel::Debug:
+            logSetts.severity = trivial::debug;
+            break;
+        case LogLevel::Info:
+            logSetts.severity = trivial::info;
+            break;
+        case LogLevel::Warning:
+            logSetts.severity = trivial::warning;
+            break;
+        case LogLevel::Error:
+            logSetts.severity = trivial::error;
+            break;
+        case LogLevel::Fatal:
+            logSetts.severity = trivial::fatal;
+            break;
+    }
+    return *this;
+}
+
+namespace
+{
+auto InitializeLogger(const LogSettings& setts)
+{
+    auto log = std::make_unique<AppSettings::LoggerType>();
+    if (!setts.enableConsole)
+    {
+        auto console = boost::log::add_console_log();
+        console->set_filter(boost::log::expressions::attr<int>("Severity") >= 10);
+    }
+
+    return log;
+}
+
+struct EndpointAddressBuilder
+{
+    std::string operator()(const ListenerParams& l) const { return fmt::format("http://{}:{}", l.address, l.port); }
+    std::string operator()(const SSLListenerParams& l) const { return fmt::format("https://{}:{}", l.address, l.port); }
+};
+} // namespace
+
 nonstd::expected<App, AppBuilder::BuildErrors> AppBuilder::CreateApp()
 {
     if (!m_settings)
         return nonstd::make_unexpected(BuildErrors::NotInitialized);
 
+    m_settings->logger = std::move(InitializeLogger(m_settings->logSettings));
+
+    auto log = [this] { return m_settings->logger.get(); };
+    LOG_DEBUG() << "Start verifying configuration";
+    for (auto& l : m_settings->listeners)
+    {
+        auto endpoint = nonstd::visit(EndpointAddressBuilder(), l);
+        LOG_DEBUG() << "Found endpoint: " << endpoint;
+    }
     return App(m_settings.release());
 }
 
 void AppBuilder::EnsureSettingsCreated()
 {
     if (!m_settings)
+    {
         m_settings = std::make_unique<AppSettings>();
+#ifndef NDEBUG
+        m_settings->logSettings.severity = boost::log::trivial::debug;
+        m_settings->logSettings.enableConsole = true;
+#endif
+    }
 }
 
 } // namespace flask4cpp

src/app_settings.h

@@ -7,6 +7,15 @@
 
 #include <nonstd/variant.hpp>
 
+#if defined(BOOST_LOG_NO_THREADS)
+#undef BOOST_LOG_NO_THREADS
+#endif
+
+#include <boost/log/common.hpp>
+#include <boost/log/trivial.hpp>
+// #include <boost/log/sources/severity_logger.hpp>
+#include <boost/log/sources/logger.hpp>
+
 #include <string>
 #include <vector>
 
@@ -31,9 +40,19 @@ struct SSLListenerParams
 
 using ListenerInfo = nonstd::variant<ListenerParams, SSLListenerParams>;
 
+struct LogSettings
+{
+    boost::log::trivial::severity_level severity = boost::log::trivial::info;
+    bool enableConsole = false;
+};
+
 struct AppSettings
 {
+    using LoggerType = boost::log::sources::severity_logger_mt<boost::log::trivial::severity_level>;
+
     std::vector<ListenerInfo> listeners;
+    LogSettings logSettings;
+    std::unique_ptr<LoggerType> logger;
 };
 
 } // namespace flask4cpp

src/log.h

@@ -0,0 +1,23 @@
+//
+// Created by flexf on 13.03.2020.
+//
+
+#ifndef FLASK4CPP_LOG_H
+#define FLASK4CPP_LOG_H
+
+#include <boost/log/sources/severity_feature.hpp>
+#include <boost/log/trivial.hpp>
+
+namespace flask4cpp
+{
+#define TO_LOG(L, LV) BOOST_LOG_SEV((L), boost::log::trivial::LV)
+
+#define LOG_TRACE() TO_LOG(log(), trace)
+#define LOG_DEBUG() TO_LOG((*log()), debug)
+#define LOG_INFO() TO_LOG(log(), info)
+#define LOG_WARNING() TO_LOG(log(), warning)
+#define LOG_ERROR() TO_LOG(log(), error)
+#define LOG_FATAL() TO_LOG(log(), fatal)
+} // namespace flask4cpp
+
+#endif // FLASK4CPP_LOG_H