multiple logger to syslog sink

[suri-log]

hi all
i am trying to use spd log to write to syslog .
one question i have is .. is there any difference if i try creating "multiple syslog sinks and use muliple loggers " or "one syslog sink and use muliple loggers ".
i am trying to implement this in asynchronous multi threaded environment. so that i can avoid having multiple reference of sinks

thanks

[tt4g]

syslog_sink_mt is thread-safe.
It is preferable to share one syslog_sink_mt for the same configuration.

[suri-log]

this means the procedure can be initialize the sinks and maintain in global context like
//global static
shr_std_sink= stdout sink ;
shr_sys_sink=syslog sink ;
shr_sysdsink= ststemd sink;

lets`s say if agent1 want only syslog logger :
createsysloglogger1(sshr_sys_sink) --> running in thread1
createsysloglogger2(sshr_sys_sink,) --> running in thread2

lets`s say if agent2 want only stdout logger :
createsysloglogger3(sshr_std_sink) --> running in thread3
createsysloglogger4(sshr_std_sink) --> running in thread4

what if lets`s say if agent3 wants both syslog and stdout logger :

createsysloglogger3( sink.push_back(shr_std_sink), sink.push_back(shr_sys_sink)) --> running in thread3

can i do like the above where shr_std_sink,shr_sys_sink shared to gather for new logger. is this the preferable code which you are suggesting.
or create the new sinks when we need sinks to together

[tt4g]

Yes, sink can be shared. However, managing it as a global variable will cause unintended behavior by the developer in most cases (C++ specification).
See: #2768, #2113

[suri-log]

if managing it as a global variable will cause unintended behavior can you please suggest what is the ideal way to do to share the syslog_sink_mt between multiple threads with multiple loggers asynchronously ?

if above is not going to work , do you suggest to create new logger with new sink

[tt4g]

Define sink with a static variable in the function body.

EDIT: Don't forget. define static variable in .cpp file.

[suri-log]

hi.. i am trying to verify this blow code , in my case mostly i actually need to use syslog sink with multiple loggers , but since i don't had syslog installed i am testing by having stdout sink .
now my question is do we need to have mutex if i am using singleton class with shared sink and if we are trying to log from different threads. or will taken care by spd log itself
#include "SingletonPimplLogger.hp"
#include "spdlog/spdlog.h"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/sinks/basic_file_sink.h"

class SingletonPimplLogger::LoggerImpl
{
public:
static std::shared_ptrspdlog::sinks::sink syslog_sink;
static std::shared_ptrspdlog::sinks::sink stdout_sink;
static std::shared_ptrspdlog::sinks::sink systemd_sink;
std::vectorspdlog::sink_ptr sinks;
stdout_sink = std::make_sharedspdlog::sinks::stdout_color_sink_mt();
syslog_sink = std::make_sharedspdlog::sinks::syslog_sink_mt( logger_ident, LOG_PID , LOG_USER, false );

LoggerImpl() {}

void createLogger(const std::string& loggerName, const std::vector<std::shared_ptr<spdlog::sinks::sink>>& sinks)
{
    sinks.push_back(stdout_sink);
    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%l] %v"); // Set the log pattern
    std::shared_ptr<spdlog::logger> logger = std::make_shared<spdlog::logger>(loggerName, sinks.begin(), sinks.end()); // Create the logger
    loggers_[loggerName] = logger; // Store the logger
    loggers_.back()->set_level(spdlog::level::trace); // Set the log level for the logger
    loggers_.back()->flush_on(spdlog::level::trace); // Set the flush level for the logger
}

void logInfo(const std::string& loggerName, const std::string& message)
{
    auto logger = loggers_.find(loggerName);
    if (logger != loggers_.end())
    {
        logger->second->info(message); // Log an info message
    }
}

void logError(const std::string& loggerName, const std::string& message)
{
    auto logger = loggers_.find(loggerName);
    if (logger != loggers_.end())
    {
        logger->second->error(message); // Log an error message
    }
}

private:
std::unordered_map<std::string, std::shared_ptrspdlog::logger> loggers_;
};

SingletonPimplLogger& SingletonPimplLogger::getInstance()
{
static SingletonPimplLogger instance; // Guaranteed to be destroyed and instantiated on first use
return instance;
}

SingletonPimplLogger::SingletonPimplLogger()
: pimpl_(std::make_unique())
{
}

SingletonPimplLogger::~SingletonPimplLogger() = default;

void SingletonPimplLogger::createLogger(const std::string& loggerName, const std::vector<std::shared_ptrspdlog::sinks::sink>& sinks)
{
pimpl_->createLogger(loggerName, sinks);
}

void SingletonPimplLogger::logInfo(const std::string& loggerName, const std::string& message)
{
pimpl_->logInfo(loggerName, message);
}

void SingletonPimplLogger::logError(const std::string& loggerName, const std::string& message)
{
pimpl_->logError(loggerName, message);
}

=========
#include "SingletonPimplLogger.hpp"

int main()
{
SingletonPimplLogger& logger = SingletonPimplLogger::getInstance();

logger.logInfo("logger1", "This is an information message for logger1.");
logger.logError("logger1", "This is an error message for logger1.");

logger.logInfo("logger2", "This is an information message for logger2.");
logger.logError("logger2", "This is an error message for logger2.");

return 0;

}

[tt4g]

A sink with the _mt prefix in its name can be used in multi-thread application

spdlog's sinks have _mt (multi threaded) or _st (single threaded) suffixes to indicate the thread safety. While single threaded sinks cannot be used from multiple threads simultaneously, they are faster because no locking is employed.

Wiki: https://github.com/gabime/spdlog/wiki/4.-Sinks

And logger is thread-safe.

Wiki: https://github.com/gabime/spdlog/wiki/1.1.-Thread-Safety

---

Your source code is unreadable because of the messed up formatting.
Please format it with GitHub markdown syntax.
See: https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks

```cpp
C++ source here.
```
```

[suri-log]

one q:
if i pass the same logger name to below and create multiple objects having it in wrapper, will spd library get the same logger instance
of the same or will it create mulitple for each object .

target = std::make_sharedspdlog::logger(logger_name, sink.begin(), sink.end());

and also can you please let me know use of the logger name , and
what is the use if i am creating the multiple loggers with having same sink and same configuration with different logger name

[tt4g]

It creates another instance.

[suri-log]

and also can you please let me know use of the logger name , and
what is the use if i am creating the multiple loggers with having same sink and same configuration with different logger name

[tt4g]

The global registry of spdlog is used to manage loggers.

Wiki: https://github.com/gabime/spdlog/wiki/5.-Logger-registry

[suri-log]

ok .. from the above documentation it looks if we use the registry of spdlog then the logger name is valid per process, and maintaince the loggers based on the name(if we tryto create logger with same name it fill get the existing object ) .
if we dont use registry functions then logger name doesn't have any importance and always create new instance if we try ti create an logger instance
is that correct

[tt4g]

Right.

[suri-log]

wanted to know how efficiently i can use this logger!
my requirement is:
want to use only one global sink/logging configuration
there are inherited classes with element names and i need to log from any of the elements and that need to have element name where its inherited from need to appended to log msg and those objects will be roughly 10k .
i wanted to know using log instance per object is better (any other has tested with that much scale , is it ok to go ahead with this method ) or
having multiple wrapper instances with element name and internally calling that wrapper to single instance of spdLogger is better
to call one logger instance

[tt4g]

If you do not know what objects you want to include in the log messages, but only use one logger, you can use the default logger so that your instance does not have to have a logger as well.

https://github.com/gabime/spdlog/wiki/Default-logger

[suri-log]

ok ,what do you think of creating logger instance per object for 10k will it have any problem /or do you think its overburden to maintain

[tt4g]

It would be nice if there is enough memory, but creating a wrapper object would probably consume less memory than creating a large number of loggers with multiple variables.

[suri-log]

hi ,
i am using gtest to verify unittest and it has option to capture stdout/stderr, but
CaptureStderr,CaptureStdout is not capturing the info when i log the message with different loglevels on stdout/stderr sink, but the logs messsagaes are getting logged on stdout but the capture functions are not working.

can some help/ know how to make that work..

[tt4g]

For questions that differ from the subject, please open a new issue/discussion.
And any questions about gtest's features should be asked in gtest repository.

[tt4g]

google/googletest#4377

[suri-log]

in this case i am trying attach ringbuffer_sink to the existing stdoutlogger and get the messages. but with below code i see ringbuffer is availble and messages are logging to stdout , but ringbuffer sink dont have any messages. can you let me know where this going wrong

void startRingbuff(){
auto ringBufferSink = std::make_sharedspdlog::sinks::ringbuffer_sink_st(10);
logging_target->sinks().push_back(ringBufferSink);
}
getRingbuffMessages(std::vectorstd::string &kmsg,const int &ksize){
std::vectorstd::string last_messages;
auto ringbuffer_sink = std::dynamic_pointer_castspdlog::sinks::ringbuffer_sink_st(logging_target->sinks().back());

    if (ringbuffer_sink) {
                std::cout <<"ring buff sink found" << std::endl;

            std::vector<std::string> messages;
            messages=ringbuffer_sink->last_formatted();
            for (const auto& message : messages) {
                std::cout <<"loop" <<message << std::endl;
            }

}

[suri-log]

@tt4g the above issue seems to be because of the asynchronous logger , if create async logger with below code and try to use the ringbuffer_sink which is not working

is there any restriction or open bug that asynchronous logger can not use ringbuffer_sink

    if (!spdlog::thread_pool()){
        spdlog::init_thread_pool(1024,1 );
    }
    // Set up the default async logger
    target = std::make_shared<spdlog::async_logger>(logger_ident, sink.begin(), sink.end(), spdlog::thread_pool());
    target->set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%t] %v");
    target->set_level(spdlog::level::level_enum::trace);
    // Set the default logger if not set already
    if (!spdlog::default_logger())
    spdlog::set_default_logger(logging_target);
    // Flush logs every 3 seconds
    spdlog::flush_every(std::chrono::seconds(3));

[tt4g]

ringbuffer_sink_st does not support multi-threading, should use ringbuffer_sink_mt.
And as I commented above, if you have a different question than the subject, please start a new issue/discussion.

[tt4g]

#2885