Issue with log from different thread

[cVecchioTheOld]

I'm using this class as a wrapper around spdlog since I'm trying to replace the previous logging library

class FooLog
{
public:
    class LogStream {
    public:
        explicit LogStream(spdlog::level::level_enum level) : m_level(level) {}
        ~LogStream() {
            auto logger = spdlog::get("FooLog");
            if (logger) {
                logger->log(m_level, m_ss.str());
            } else {
                // The logger is not initialized yet. Log to cout as a fallback.
                std::cout << "[UNINITIALIZED LOG] " << m_ss.str() << std::endl;
            }
        }
        template <typename T>
        LogStream& operator<<(const T& msg) {
            m_ss << msg;
            return *this;
        }
    private:
        std::stringstream m_ss;
        spdlog::level::level_enum m_level;
    };

    static LogStream info() {
        return LogStream(spdlog::level::info);
    }
    static LogStream debug() {
        return LogStream(spdlog::level::debug);
    }
    static LogStream error() {
        return LogStream(spdlog::level::err);
    }
    static LogStream warn() {
        return LogStream(spdlog::level::warn);
    }

    static void init(const std::string& name, const std::string &fileName, size_t maxSize, size_t maxFilesNum)
    {
        try
        {
            //console log usefull during debug/development
            auto console_sink = std::make_shared<spdlog::sinks::stdout_sink_mt>();

            //rotating file log
            auto file_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(fileName, maxSize, maxFilesNum);

            spdlog::sinks_init_list sink_list = { file_sink, console_sink };
            auto logger = std::make_shared<spdlog::logger>("FooLog", sink_list.begin(), sink_list.end());

            spdlog::set_default_logger(logger);
            // set a global formatter
            logger->set_pattern("%Y-%m-%d %X,%e %z [%l] %v");
            // flush periodically every 5 seconds (caution: must be _mt logger)
            spdlog::flush_every(std::chrono::seconds(5));
        }
        catch (const spdlog::spdlog_ex& ex)
        {
            std::cout << "Log initialization failed: " << ex.what() << std::endl;
        }
    }

    static void setDebugMode(bool isDebugMode)
    {
        if (isDebugMode) {
            spdlog::set_level(spdlog::level::debug);
        } else {
            spdlog::set_level(spdlog::level::info);
        }
    }
};

After using FooLog::init(...) I use FooLog::info() << "message"; to log inside the code

However not all expected messages are logged inside the file moreover from the console I can see messages with different pattern like

2026-05-05 17:38:40,334 INFO [default] Setting tokens [1f4468d2-71af-40fc-97f8-73585e55f111] X0XbX6XdXdX7X-XcX1X9XdX-XeXbX1X0XfX5,XaX5XdX5X0X8X-XeX7XbX9X-XcXaX0XaXeX8
2026-05-05 17:38:40,334 INFO [default] Performing request [1f4468d2-71af-40fc-97f8-73585e55f111]
2026-05-05 17:38:40,547 INFO [default] Profile fields check completed

Those messages seems to come from threads different from the main thread.
What am I doing wrong?

[tt4g]

Since std::stream has manipulators defined in headers such as <iomanip>, it is impossible to determine whether the change in log message formatting is due to spdlog or std::stream without seeing the actual log output code.
Another possible cause is that if there is code that outputs messages directly to STDOUT, they may be being printed as part of the log messages.

However not all expected messages are logged inside the file

Unless you have called spdlog::shutdown(), spdlog only flushes the log every 5 seconds.
Since files and STDOUT handle I/O buffers differently, calling spdlog::shutdown() might resolve the issue.

[gistrec]

Two separate issues.

Missing file messages - flush timing. spdlog::flush_every(std::chrono::seconds(5)) schedules periodic flushes; if the process exits before the next cycle, buffered entries may not be flushed to disk. Add a shutdown call when the program terminates:

spdlog::shutdown(); // flushes all loggers and stops the background flush thread

For errors you want on disk immediately: logger->flush_on(spdlog::level::err).

[default] in the console - initialization order, not thread-safety. Your custom pattern uses [%l] which prints the log level in lowercase (info, warn). The console lines show INFO [default] - the uppercase level and the logger name "default" match spdlog's built-in default pattern (%L/%n), not yours. This means those lines went through the original spdlog default logger (named "default") that existed before FooLog::init() was called.

spdlog::set_default_logger() replaces the global default atomically, but any code that already ran - or runs on a thread that started before init() - used the old "default" logger. Ensure FooLog::init() is called before spawning any threads that log, and have all call sites use FooLog::info() rather than spdlog::info() directly.

[gistrec]

One more thing: you create a logger named "FooLog", but then retrieve it with spdlog::get("FooLog").

Make sure it is registered:

auto logger = std::make_shared<spdlog::logger>("FooLog", sink_list.begin(), sink_list.end());
spdlog::register_logger(logger);
spdlog::set_default_logger(logger);

Or avoid the registry lookup and keep/use the default logger directly.

Without registration, spdlog::get("FooLog") may return nullptr, so your wrapper may fall back to std::cout, which would also explain why some messages do not appear in the file.

[cVecchioTheOld]

Thank you for the reply, I double checked again and FooLog::init is called at the beginning of main before any thread starts

`
int main(int argc, char **argv)
{
QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
QApplication::setAttribute(Qt::AA_DisableHighDpiScaling);

QApplication app(argc, argv, true);

/** Retrieve branding plugin */
auto brand = retrieveBrand(BRANDING_DIR);

if (brand == nullptr){
    /** Fatal exception: no branding plugin found */
    QMessageBox::critical(nullptr, QCoreApplication::applicationName(),
                          "No branding plugin has been found");
    return EXIT_FAILURE;
}

/** Start log */
FunLog::init(AppConfig::getLogsFolder(brand)+"applog.txt", LOG_FILE_MAX_SIZE, APP_LOG_ROLLOUT_FILES);

`

I tried using both default and getting/setting logger via name but some error messages from lambda functions running in a qt slot are logged to std::out with old default logger in both cases

[tt4g]

If you're outputting logs in a Qt event handler, it's possible that the handler is simply being called before FunLog::init().
Have you debugged the order in which these calls are made?

[cVecchioTheOld]

It turned out that the issue was related to my project structure. There was an internal library which was not correctly updated during build so wiping and recreating workspace fixed the issue. Thank you for the support and suggestions @tt4g @gistrec