Bypassing pattern formatting for certain logging calls

[sketch34]

I'm porting a legacy logging system to use spdlog. The legacy logger has a WRITE macro that logs with no line annotations, i.e. the pattern should be "%v". I thought about having a separate logger + sink for this case, which can have its pattern set to "%v". But the system requires file logging, and requires that WRITE logging to go to the same file as all other logging. The loggers could share the same file sink, but then the patterns will also be the same.

Other ideas:

• Set the pattern to "%v" on the fly, then reset it to default (efficiency concern, won't work with async unless we also flush).
• Custom sink that supports a different pattern per logging level (not a very elegant solution).

Any better ideas?

[tt4g]

If you don't need to use a logger within the WRITE macro, you can use spdlog::file_event_handlers.
When file sink opens a log file, std::FILE* is passed to the after_open handler, so you just fwrite() to this pointer in the WRITE macro.
Do not access std::FILE* after the before_close() handler is called.

spdlog/include/spdlog/common.h

Lines 328 to 339 in 27cb4c7

	struct file_event_handlers {
	file_event_handlers()
	: before_open(nullptr),
	after_open(nullptr),
	before_close(nullptr),
	after_close(nullptr) {}
	std::function<void(const filename_t &filename)> before_open;
	std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open;
	std::function<void(const filename_t &filename, std::FILE *file_stream)> before_close;
	std::function<void(const filename_t &filename)> after_close;
	};

However, when used in a multi-threaded application, it is necessary to make sure that std::FILE* is not accessed at the same time as file sink.
The easiest way to implement this countermeasure is to proxy access to the file sink with a custom sink such as dist_sink.