How to create a thread safe logger with multiple sinks?

[Linhuihang]

I know we should use factory method to create a thread safe logger, just like: spdlog::basic_logger_mt or spdlog::rotating_logger_mt.
But it seems we can only use factory method to create logger with only one sink?
So my question is how to create a thread safe logger with multiple sinks?
Just like: spdlog::logger logger("multi_sink", { consoleSink, rotatingLogger });

[tt4g]

So my question is how to create a thread safe logger with multiple sinks?

The logger with multiple sinks is supported.
See Wiki: https://github.com/gabime/spdlog/wiki/2.-Creating-loggers#creating-loggers-with-multiple-sinks

[Linhuihang]

But this is not the factory method. So the logger created in this way is not thread safe.
( According to https://spdlog.docsforge.com/v1.x/1.1.thread-safety/, we should use the _mt factory functions to create thread safe loggers. )

[tt4g]

Note: This restriction applies to all kind of loggers ("_mt" or "_st").

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

This sentence in the Wiki is strictly incorrect.

The factory method simply calls spdlog::synchronous_factory::create.

spdlog/include/spdlog/sinks/rotating_file_sink.h

Lines 62 to 68 in 81de01c

	template<typename Factory = spdlog::synchronous_factory>
	inline std::shared_ptr<logger> rotating_logger_mt(const std::string &logger_name, const filename_t &filename, size_t max_file_size,
	size_t max_files, bool rotate_on_open = false, const file_event_handlers &event_handlers = {})
	{
	return Factory::template create<sinks::rotating_file_sink_mt>(
	logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
	}

The spdlog::synchronous_factory::create just creates the logger and sink.

spdlog/include/spdlog/details/synchronous_factory.h

Lines 13 to 23 in 81de01c

	struct synchronous_factory
	{
	template<typename Sink, typename... SinkArgs>
	static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
	{
	auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
	auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
	details::registry::instance().initialize_logger(new_logger);
	return new_logger;
	}
	};

In other words, the logger remains at the same thread-safe level whether the factory method is used or not.
The thread-safe guarantee of sink depends on the sink name prefix (_mt and _st).

[Linhuihang]

Thanks for your reply.