Is there any way to control how named_args are populated with the key value pairs?

[persona94]

First of, love the library, lets me do so much customization. I'm having to support dual logging based on run time config - either a JSON format or a proprietary format. I want to discuss a question for the proprietary format. The pattern itself is unimportant, I'm trying to see if there's a library feature I haven't read about that might help me better with extra key-value pairs.

I have a macro that does

MY_LOG_DEBUG(fmt_str, ...) \
 { \
   std::string msg = fmt::format(fmt::runtime(fmt_str), std::forward<Args>(args)...); \
   QUILL_LOG_ERROR(logger, "{message}", msg, ##__VA_ARGS__); \
 }

I have a custom console sink

class MyConsoleSink final : public quill::ConsoleSink
{
public:
void write_log(quill::MacroMetadata const* log_metadata, uint64_t log_timestamp,
        std::string_view thread_id, std::string_view thread_name,
        std::string const& process_id, std::string_view logger_name, quill::LogLevel log_level, std::string_view log_level_description,
        std::string_view log_level_short_code,
        std::vector<std::pair<std::string, std::string>> const* named_args,
        [[maybe_unused]] std::string_view log_message, std::string_view) override;
};

MyConsoleSink::write_log(quill::MacroMetadata const* log_metadata, uint64_t log_timestamp,
        std::string_view thread_id, std::string_view thread_name,
        std::string const& process_id, std::string_view logger_name, quill::LogLevel log_level, std::string_view log_level_description,
        std::string_view log_level_short_code,
        std::vector<std::pair<std::string, std::string>> const* named_args,
        [[maybe_unused]] std::string_view log_message, std::string_view)
{
    // Bunch of code that reads metadata, timestamp and other params

    if (named_args)
    {
        for (auto const& [key, value] : *named_args)
        {
            std::cout << "key: " << key << " value: " << value << std::endl;
        }
  }
}

So when I call my macro

MY_LOG_DEBUG("Hello {}", "world", "{another key}", "value");

The print from write_log will read

key: message value: Hello World
key: _1 value: {another key}
key: _2 value: value

Getting the key of message and value Hello world is great and what I need. And I can push every value whose key begins with _ into another vector and then turn them into key-value pairs at position i and i+1. All this works, but is there any way to just get the extra args as key-value pairs directly? So the named_args loop would print

key: message value: Hello World
key: another key value: value

[odygrd]

Hey,

All named arguments are stored in the same vector, so what you're asking isn't directly possible. You'll need to manually process them in your user-defined Sink, as you've already noticed.

Here's how it works:

QUILL_LOG_ERROR(logger, "{message}", msg, ##__VA_ARGS__);

In the example above, the named argument {message} maps to the value msg.

Any subsequent arguments—since they don't have a {...} placeholder—are assigned keys based on their index.

So you'll see entries like _1: value, _2: value, and so on.

If you want to separate them, you'll have to filter and handle them yourself in your custom sink implementation.

Also, consider why you need the extra tags. If it's just for tagging purposes—such as marking certain logs as errors—you might want to look into log tagging in Quill.

Note that log tagging uses compile-time static tags, which differs from your current approach that looks more like runtime tagging.

There is an example here

#801

Hope this helps!