Hey, yes library is using a singleton and the logger_name is the key. Once you create the Logger you will get the same logger with get_logger. You do not need to use shared_ptr the logging library owns the logger and the logger itself is thread safe.
Just note that get_logger takes a lock so it’s recommended to store the logger*

the recommended way is

https://github.com/odygrd/quill/tree/master/examples/recommended_usage

you create a wrapper library where you include Backend.h only in the .cpp file. There you handle starting the backend thread. Since the library is header only that will handle compiling all the heavy stuff and you won’t need to include the backend headers anywhere else.

after this it’s pretty much your own choice. You can either have an export static Logger* which you set on main and include everywhere else as in the example, or you can include Frontend.h and call get_logger eg. in the constructor of your classes and store it.

having more than one Logger offers greater control for parts of the application so i would personally create one per different component. This allows to change the log level and have one component on debug log and the other on info for example

I prefer the export static Logger* than storing it in each class as it takes additional space eg when you have a vector<Object> and also it’s less code than doing it for each class

in some cases tho it is worth doing it when additional control is needed, or example you have two instances of a class Foo, one instance that is used by component A and one instance used by component B. In that case i would pass logger_a when component A created Foo and logger_b for component B in Foo construction. That way i can see in the log via the logger name which component is actually using Foo and issuing the log and also will be able to have different log levels per component as mentioned above

once you set it up also please see how to log different types

https://quillcpp.readthedocs.io/en/latest/cheat_sheet.html

hope all of this makes sense! If you have any questions let me know

Thanks for your answer. I'll implement it and check if new questions arise in the process.

I have additional questions: Is changing the log level in runtime possible? how is it evaluated at the log level? As far as I understand there is a log-scale. But I'd like to know more about how this is evaluated. Is there a conditional evaluation (if/switch-case)? How is it optimized for runtime? Thanks in advance.

Changing the log_level is per Logger instance logger->set_log_level(LogLevel) and it is thread safe

It is evaluated with an if statement. If the branch is not taken, then any arguments to the LOG_ won’t be evaluated

if you don’t want the branches you can disable the log level completely in compile time by defining QUILL_COMPILE_ACTIVE_LOG_LEVEL either as compilation flag or before including LogMarcos.h