I am working with a filter that consists of two parts.

The first part is known and can be written using the expression language. The second part is a user-provided string, so I need to use parse_filter.

Is it possible to combine an expression with the result of parse_filter?

It would be nice if there would be some magic option that will allow to build boost::log with std::filesystem instead of boost::filesystem. This will help with symbol problems in static configuration caused by BOOST_FILESYSTEM_VERSION define.

Hi, I would need to allow my application to provide to the end user with a dynamic control on sinks configured in settings file (typically, change the filtering at runtime). For that, I would need to have to list of the configured sinks, but from my searches results on the web, it looks like there is no such a support.

Would it be possible to add the support for querying and visiting the sinks? If not, what alternative solution would you suggest (if possible, without having to reimplement setup file parser)?

Thanx in advance

Hi,

Following are my environment details: I am using Boost Library version 1.77.0 I am using Windows 10 operating system. I am using Visual Studio 2019. The platform toolset is v142 C++ language standard: ISO C++ 17 (/std:c++17) C Language standard: ISO C 17 (2018) (/std:c17) My project is a DLL project where I am using event logging I am also using the following macro: #define BOOST_ALL_DYN_LINK

I am using custom event logging as described in the following link: https://www.boost.org/doc/libs/1_77_0/libs/log/example/event_log/main.cpp

I have created a custom message configuration file with the following content: ` ; /* -------------------------------------------------------- ; HEADER SECTION ; */ SeverityNames=(Debug=0x0:AUTO_SCORE_SEVERITY_DEBUG Info=0x0:AUTO_SCORE_SEVERITY_INFO Warning=0x2:AUTO_SCORE_SEVERITY_WARNING Error=0x1:AUTO_SCORE_SEVERITY_ERROR )

; /* -------------------------------------------------------- ; MESSAGE DEFINITION SECTION ; */

MessageIdTypedef=WORD

MessageId=0x1 SymbolicName=CATEGORY_DEBUG Language=English Debug Message .

MessageId=0x2 SymbolicName=CATEGORY_INFO Language=English Info Message .

MessageId=0x3 SymbolicName=CATEGORY_WARNING Language=English Warning Message .

MessageId=0x4 SymbolicName=CATEGORY_ERROR Language=English Error Message .

MessageIdTypedef=DWORD

MessageId=0x100 Severity=Debug Facility=Application SymbolicName=DEBUG_MSG Language=English [%1][%2]: %3 .

MessageId=0x101 Severity=Info Facility=Application SymbolicName=INFO_MSG Language=English .

MessageId=0x102 Severity=Warning Facility=Application SymbolicName=WARNING_MSG Language=English [%1][%2]: %3 .

MessageId=0x103 Severity=Error Facility=Application SymbolicName=ERROR_MSG Language=English [%1][%2]: %3 .

`

The logging header file looks like this: ` #pragma once #include #include #include #include <boost/smart_ptr/shared_ptr.hpp> #include <boost/date_time/posix_time/posix_time_types.hpp> #include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time_io.hpp>

#include <boost/log/common.hpp> #include <boost/log/attributes.hpp> #include <boost/log/expressions.hpp> #include <boost/log/sinks/sync_frontend.hpp> #include <boost/log/sinks/event_log_backend.hpp> #include "autoscore_eventlog_provider/autoscore_eventlog_provider.h"

// Check windows #if _WIN32 || _WIN64 #if _WIN64 #define ENVIRONMENT64 #else #define ENVIRONMENT32 #endif #endif

// Check GCC #if GNUC #if x86_64 || ppc64 #define ENVIRONMENT64 #else #define ENVIRONMENT32 #endif #endif

#if !defined(WIN32_LEAN_AND_MEAN) #define WIN32_LEAN_AND_MEAN #endif

#include <windows.h>

namespace autoscore::log { namespace logging = boost::log; namespace attrs = boost::log::attributes; namespace src = boost::log::sources; namespace sinks = boost::log::sinks; namespace expr = boost::log::expressions; namespace keywords = boost::log::keywords;

// Define application-specific severity levels
enum severity_level
{
	debug,
	info,
	warning,
	error
};

//Define AutoScore Logging Config
struct config
{
	severity_level min_logging_level;
	std::string message_file;
	std::string log_name;
	std::string log_source;
	bool enable_win_event_log;
};

void init_logging(config logging_config);

//[ example_sinks_event_log_facilities
BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(event_logger, src::severity_logger_mt< severity_level >)


/// <summary>
/// The function raises an event with a debug message
/// </summary>
/// <param name="message"></param>
/// <param name="session_id"></param>
void log_debug(std::string const& message, std::string const& session_id = "N/A");

/// <summary>
/// The function raises an event with a info message
/// </summary>
/// <param name="message"></param>
/// <param name="session_id"></param>
void log_info(std::string const& message, std::string const& session_id = "N/A");


/// <summary>
/// The function raises an event with a warning message
/// </summary>
/// <param name="message"></param>
/// <param name="session_id"></param>
void log_warning(std::string const& message, std::string const& session_id = "N/A");


/// <summary>
/// The function raises an event with a error message
/// </summary>
/// <param name="message"></param>
/// <param name="session_id"></param>
void log_error(std::string const& message, std::string const& session_id = "N/A");

} `

The logging implementation file looks like this: ` #include "pch.h" #include "autoscore_log.h"

namespace autoscore::log { void init_win_event_log(config const logging_config) { // Create an event log sink boost::shared_ptr< sinks::event_log_backend > backend( new sinks::event_log_backend(( keywords::message_file = logging_config.message_file, //%APPDATA%\Holberg EEG AS\autoSCORE\Logs\autoscore_eventlog_provider.dll keywords::log_name = logging_config.log_name, //Holberg EEG AS keywords::log_source = logging_config.log_source //autoSCORE )) );

    // Create an event composer. It is initialized with the event identifier mapping.
    sinks::event_log::event_composer composer(
        sinks::event_log::direct_event_id_mapping< int >("EventID"));

    // For each event described in the message file, set up the insertion string formatters
    composer[DEBUG_MSG]
        % expr::attr< std::string >("TimeStamp")
        % expr::attr< std::string >("SessionID")
        % expr::attr< std::string >("Message");

    composer[WARNING_MSG]
        % expr::attr< std::string >("TimeStamp")
        % expr::attr< std::string >("SessionID");
    composer[ERROR_MSG]
        % expr::attr< std::string >("TimeStamp")
        % expr::attr< std::string >("SessionID");

    // Then put the composer to the backend
    backend->set_event_composer(composer);

    auto severity = boost::log::expressions::attr<severity_level>("Severity");

    // We'll have to map our custom levels to the event log event types
    sinks::event_log::custom_event_type_mapping< severity_level > type_mapping("Severity");
    type_mapping[debug] = sinks::event_log::make_event_type(AUTO_SCORE_SEVERITY_DEBUG);
    type_mapping[info] = sinks::event_log::make_event_type(AUTO_SCORE_SEVERITY_INFO);
    type_mapping[warning] = sinks::event_log::make_event_type(AUTO_SCORE_SEVERITY_WARNING);
    type_mapping[error] = sinks::event_log::make_event_type(AUTO_SCORE_SEVERITY_ERROR);

    backend->set_event_type_mapper(type_mapping);

    // Usually event categories can be restored by the event identifier.
    sinks::event_log::custom_event_category_mapping< int > cat_mapping("EventID");
    cat_mapping[DEBUG_MSG] = sinks::event_log::make_event_category(CATEGORY_DEBUG);
    cat_mapping[INFO_MSG] = sinks::event_log::make_event_category(CATEGORY_INFO);
    cat_mapping[WARNING_MSG] = sinks::event_log::make_event_category(CATEGORY_WARNING);
    cat_mapping[ERROR_MSG] = sinks::event_log::make_event_category(CATEGORY_ERROR);

    backend->set_event_category_mapper(cat_mapping);

    // Create the frontend for the sink
    boost::shared_ptr< sinks::synchronous_sink< sinks::event_log_backend > > sink(
        new sinks::synchronous_sink< sinks::event_log_backend >(backend));

    // Set up filter to pass only records that have the necessary attribute
    sink->set_filter(expr::has_attr< int >("EventID"));
    sink->set_filter(severity >= logging_config.min_logging_level);

    logging::core::get()->add_sink(sink);
}

void init_logging(config const logging_config)
{
    if (logging_config.enable_win_event_log)
    {
        init_win_event_log(logging_config);
    }
}

void log_debug(std::string const& message, std::string const& session_id)
{
    auto time_stamp = boost::posix_time::to_simple_string(boost::posix_time::microsec_clock::local_time());
    BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)DEBUG_MSG);
    BOOST_LOG_SCOPED_THREAD_TAG("SessionID", session_id);
    BOOST_LOG_SCOPED_THREAD_TAG("TimeStamp", time_stamp);
    BOOST_LOG_SCOPED_THREAD_TAG("Message", message);
    BOOST_LOG_SEV(event_logger::get(), debug) << "[" << time_stamp << "][" << session_id << "]: " << message;
}

void log_info(std::string const& message, std::string const& session_id)
{
    auto time_stamp = boost::posix_time::to_simple_string(boost::posix_time::microsec_clock::local_time());
    BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)INFO_MSG);
    BOOST_LOG_SCOPED_THREAD_TAG("SessionID", session_id);
    BOOST_LOG_SCOPED_THREAD_TAG("TimeStamp", time_stamp);
    BOOST_LOG_SCOPED_THREAD_TAG("Message", message);
    BOOST_LOG_SEV(event_logger::get(), info) << message;
}

void log_warning(std::string const& message, std::string const& session_id)
{
    auto time_stamp = boost::posix_time::to_simple_string(boost::posix_time::microsec_clock::local_time());
    BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)WARNING_MSG);
    BOOST_LOG_SCOPED_THREAD_TAG("SessionID", session_id);
    BOOST_LOG_SCOPED_THREAD_TAG("TimeStamp", time_stamp);
    BOOST_LOG_SEV(event_logger::get(), warning) << message;
}

void log_error(std::string const& message, std::string const& session_id)
{
    auto time_stamp = boost::posix_time::to_simple_string(boost::posix_time::microsec_clock::local_time());
    BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)ERROR_MSG);
    BOOST_LOG_SCOPED_THREAD_TAG("SessionID", session_id);
    BOOST_LOG_SCOPED_THREAD_TAG("TimeStamp", time_stamp);
    BOOST_LOG_SEV(event_logger::get(), error) << message;
}

}

`

I have created the header file and definitions DLL based on the *.mc file and created the registry keys by running the DLL consumer application as administrator.

I am able to see the events in the event viewer but without any content. I am attaching screen shots of how it looks like.

I am not sure what is my mistake. Can some one help m e?

When I run the following code https://paste.debian.net/1190133/ the second time, the wrong 00008.log file is deleted.

After run 1: (I copied the folder ...)

$ ls -ort logs-first-run/
-rw-r--r-- 1 mak 16363 20. Mär 11:33 file_00001.log
-rw-r--r-- 1 mak 16359 20. Mär 11:33 file_00002.log
-rw-r--r-- 1 mak 16359 20. Mär 11:33 file_00003.log
-rw-r--r-- 1 mak 16335 20. Mär 11:33 file_00004.log
-rw-r--r-- 1 mak 16356 20. Mär 11:33 file_00005.log
-rw-r--r-- 1 mak 16356 20. Mär 11:33 file_00006.log
-rw-r--r-- 1 mak 16356 20. Mär 11:33 file_00007.log
-rw-r--r-- 1 mak 16356 20. Mär 11:33 file_00008.log

After run 2:

$ ls -ort logs/
-rw-r--r-- 1 mak 16356 20. Mär 11:33 file_00007.log
-rw-r--r-- 1 mak 16344 20. Mär 11:34 file_00010.log
-rw-r--r-- 1 mak 16375 20. Mär 11:34 file_00011.log
-rw-r--r-- 1 mak 16359 20. Mär 11:34 file_00012.log
-rw-r--r-- 1 mak 16359 20. Mär 11:34 file_00013.log
-rw-r--r-- 1 mak 16335 20. Mär 11:34 file_00014.log
-rw-r--r-- 1 mak 16356 20. Mär 11:34 file_00015.log
-rw-r--r-- 1 mak 16356 20. Mär 11:34 file_00016.log
-rw-r--r-- 1 mak 16356 20. Mär 11:34 file_00017.log
-rw-r--r-- 1 mak 16356 20. Mär 11:34 file_00018.log

I am using Boost 1.74.0 from Debian bullseye.

The library builds with -fno-strict-aliasing on GCC: https://github.com/boostorg/log/blob/8a880720be5a990fdd0f864244bfff1a39a69d83/build/Jamfile.v2#L202 The comment says that it is because of other Boost libraries but does not name them or link bug reports, making it hard to justify the flag. It should be a good thing to re-raise the issue on the libraries that still had not fixed it, as strict aliasing is a severe violation.