qxLib
logger.inl
Go to the documentation of this file.
1 /**
2 
3  @file logger.inl
4  @author Khrapov
5  @date 17.06.2019
6  @copyright (c) Nick Khrapov, 2021. All right reserved.
7 
8 **/
9 
10 namespace qx
11 {
12 
13 namespace details
14 {
15 
16 template<sbo_poly_assignable_c<base_logger_stream> stream_t>
17 static constexpr auto k_LoggerStreamFilter = [](const logger::logger_sbo& stream)
18 {
19  return stream->is<stream_t>();
20 };
21 
22 } // namespace details
23 
24 inline logger::logger() noexcept
25 {
26  logger::reset();
27  add_stream(fwrite_logger_stream());
28 }
29 
30 inline logger::~logger() noexcept
31 {
32  logger::flush();
33 }
34 
35 template<sbo_poly_assignable_c<base_logger_stream> stream_t>
36 inline void logger::add_stream(stream_t stream) noexcept
37 {
38  std::unique_lock _(m_StreamsMutex);
39  m_Streams.emplace_back(std::move(stream));
40 }
41 
42 template<sbo_poly_assignable_c<base_logger_stream> stream_t>
43 inline stream_t* logger::get_stream() noexcept
44 {
45  auto it = std::ranges::find_if(m_Streams, details::k_LoggerStreamFilter<stream_t>);
46  return it != m_Streams.end() ? static_cast<stream_t*>(&it->get()) : nullptr;
47 }
48 
49 template<sbo_poly_assignable_c<base_logger_stream> stream_t>
50 inline auto logger::get_streams() noexcept
51 {
52  return m_Streams | std::views::filter(details::k_LoggerStreamFilter<stream_t>)
53  | std::views::transform(
54  [](logger_sbo& stream)
55  {
56  return static_cast<stream_t*>(&stream.get());
57  });
58 }
59 
60 inline std::shared_mutex& logger::get_streams_mutex() noexcept
61 {
62  return m_StreamsMutex;
63 }
64 
65 template<sbo_poly_assignable_c<base_logger_stream> stream_t>
66 inline size_t logger::remove_streams() noexcept
67 {
68  std::unique_lock _(m_StreamsMutex);
69  return std::erase_if(m_Streams, details::k_LoggerStreamFilter<stream_t>);
70 }
71 
72 inline void logger::register_category(const category& category, category_data data) noexcept
73 {
74  register_category(string(category.get_name()), std::move(data));
75 }
76 
77 inline void logger::register_category(string sCategoryName, category_data data) noexcept
78 {
79  std::unique_lock _(m_RegisteredCategoriesMutex);
80  m_RegisteredCategories.try_emplace(std::move(sCategoryName), std::move(data));
81 }
82 
84  const category& category,
85  category_data::format_user_message_func FormatUserMessage) noexcept
86 {
87  set_category_formatter(category.get_name(), std::move(FormatUserMessage));
88 }
89 
91  string_view svCategoryName,
92  category_data::format_user_message_func FormatUserMessage) noexcept
93 {
94  std::unique_lock _(m_RegisteredCategoriesMutex);
95  if (auto it = m_RegisteredCategories.find(svCategoryName); it != m_RegisteredCategories.end())
96  {
97  it->second.FormatUserMessage = std::move(FormatUserMessage);
98  }
99 }
100 
101 inline compile_pattern_result logger::set_default_pattern(string sPattern) noexcept
102 {
103  const compile_pattern_result eResult = compile_pattern(sPattern);
104 
105  if (eResult == compile_pattern_result::ok)
106  m_sDefaultPattern = std::move(sPattern);
107 
108  return eResult;
109 }
110 
111 inline void logger::log_macro(
112  const category& category,
113  verbosity eVerbosity,
114  std::thread::id threadId,
115  std::chrono::system_clock::time_point messageTime,
116  string_view svFile,
117  string_view svFunction,
118  int nLine,
119  flags<message_necessity_type> eMessageNecessity,
120  logger_string_pool::item message)
121 {
122  {
123  std::shared_lock _(m_RegisteredCategoriesMutex);
124  if (auto itRegisteredCategory = m_RegisteredCategories.find(category.get_name());
125  itRegisteredCategory != m_RegisteredCategories.end())
126  {
127  const category_data& data = itRegisteredCategory->second;
128  if (data.FormatUserMessage)
129  {
130  message = data.FormatUserMessage(std::move(message), m_StringsPool);
131  }
132  }
133  }
134 
135  if (eMessageNecessity != message_necessity_type::not_required)
136  {
137  // assume most streams will not have their own pattern and pre-format with the default pattern
138  logger_string_pool::item finalLogMessage = m_StringsPool.acquire();
140  finalLogMessage.sValue,
141  m_sDefaultPattern,
142  category,
143  eVerbosity,
144  threadId,
145  messageTime,
146  svFile,
147  svFunction,
148  nLine,
149  message.sValue);
150 
151  {
152  std::shared_lock _(m_StreamsMutex);
153  for (auto& stream : m_Streams)
154  {
155  if (eMessageNecessity != message_necessity_type::one_of_streams_requires
156  || stream->log_unconditionally_required(
157  category,
158  eVerbosity,
159  threadId,
160  messageTime,
161  svFile,
162  svFunction,
163  nLine))
164  {
165  std::optional<logger_string_pool::item> optStreamLogMessage;
166  if (const std::optional<string_view> optPattern = stream->get_pattern())
167  {
168  optStreamLogMessage = m_StringsPool.acquire();
170  optStreamLogMessage->sValue,
171  *optPattern,
172  category,
173  eVerbosity,
174  threadId,
175  messageTime,
176  svFile,
177  svFunction,
178  nLine,
179  message.sValue);
180  }
181 
182  stream->log(
183  category,
184  eVerbosity,
185  threadId,
186  messageTime,
187  svFile,
188  svFunction,
189  nLine,
190  optStreamLogMessage ? optStreamLogMessage->sValue : finalLogMessage.sValue);
191 
192  if (optStreamLogMessage)
193  m_StringsPool.release(std::move(*optStreamLogMessage));
194  }
195  }
196  }
197 
198  m_StringsPool.release(std::move(finalLogMessage));
199  }
200 
201  m_StringsPool.release(std::move(message));
202 }
203 
204 inline void logger::flush()
205 {
206  std::shared_lock _(m_StreamsMutex);
207  for (auto& stream : m_Streams)
208  stream->flush();
209 }
210 
211 inline void logger::reset() noexcept
212 {
213  flush();
214 
215  {
216  std::unique_lock _(m_StreamsMutex);
217  m_Streams.clear();
218  }
219 
220  {
221  std::unique_lock _(m_RegisteredCategoriesMutex);
222  m_RegisteredCategories.clear();
223  }
224 
225  /*
226  Default pattern for the logger. Some examples:
227 
228  > [08.01.2026_23:51:41] Time? Is it really that time again?
229  > [08.01.2026_23:51:41][CatCore] Time? Is it really that time again?
230  >[W][08.01.2026_23:51:41] Time? Is it really that time again?
231  >[W][08.01.2026_23:51:41][CatCore] Time? Is it really that time again?
232  */
233  set_default_pattern(QXT("{verbosity:l}[{time:%d.%m.%Y_%H:%M:%S}]{category:l} {message}\n"));
234 }
235 
237  const category& category,
238  verbosity eVerbosity,
239  std::thread::id threadId,
240  std::chrono::system_clock::time_point messageTime,
241  string_view svFile,
242  string_view svFunction,
243  int nLine) const noexcept
244 {
245  flags<message_necessity_type> eMessageNecessity;
246  {
247  std::shared_lock _(m_StreamsMutex);
248  const bool bSomeStreamRequires = std::ranges::any_of(
249  m_Streams,
250  [&category, eVerbosity, threadId, messageTime, svFile, svFunction, nLine](const auto& stream)
251  {
252  return stream->log_unconditionally_required(
253  category,
254  eVerbosity,
255  threadId,
256  messageTime,
257  svFile,
258  svFunction,
259  nLine);
260  });
261  if (bSomeStreamRequires)
262  eMessageNecessity |= message_necessity_type::one_of_streams_requires;
263  }
264 
265  {
266  std::shared_lock _(m_RegisteredCategoriesMutex);
267  if (auto itRegisteredCategory = m_RegisteredCategories.find(category.get_name());
268  itRegisteredCategory != m_RegisteredCategories.end())
269  {
270  const category_data& data = itRegisteredCategory->second;
271  if (eVerbosity >= data.eRuntimeVerbosity)
272  eMessageNecessity |= message_necessity_type::category_verbosity;
273  }
274  }
275 
276  if (eVerbosity >= verbosity::log)
277  eMessageNecessity |= message_necessity_type::default_verbosity;
278 
279  return eMessageNecessity;
280 }
281 
282 inline logger::logger_string_pool* logger::_get_string_pool() noexcept
283 {
284  return &m_StringsPool;
285 }
286 
287 } // namespace qx
A category is a class that identifies a particular piece of code. This code can be located in differe...
Definition: category.h:62
constexpr string_view get_name() const noexcept
Get category name.
Definition: category.inl:26
Wrapper for enumerations to be used as a list of flags.
Definition: flags.h:64
void set_category_formatter(const category &category, category_data::format_user_message_func FormatUserMessage) noexcept
Set category formatter.
Definition: logger.inl:83
size_t remove_streams() noexcept
Remove all the streams of the given type.
Definition: logger.inl:66
auto get_streams() noexcept
Get all the streams of the given type.
Definition: logger.inl:50
flags< message_necessity_type > get_message_necessity_type(const category &category, verbosity eVerbosity, std::thread::id threadId, std::chrono::system_clock::time_point messageTime, string_view svFile, string_view svFunction, int nLine) const noexcept
Check if this message will go somewhere.
Definition: logger.inl:236
void add_stream(stream_t stream) noexcept
Add an output stream to the logger.
Definition: logger.inl:36
void register_category(const category &category, category_data data) noexcept
Add custom rules for category.
Definition: logger.inl:72
std::shared_mutex & get_streams_mutex() noexcept
Get streams mutex.
Definition: logger.inl:60
stream_t * get_stream() noexcept
Get the first occurrence of a stream of the given type.
Definition: logger.inl:43
virtual void reset() noexcept
Reset logger and clear all streams.
Definition: logger.inl:211
virtual void log_macro(const category &category, verbosity eVerbosity, std::thread::id threadId, std::chrono::system_clock::time_point messageTime, string_view svFile, string_view svFunction, int nLine, flags< message_necessity_type > eMessageNecessity, logger_string_pool::item message)
Main log function: log to all streams. For macro and internal usage.
Definition: logger.inl:111
virtual void flush()
Flush all streams.
Definition: logger.inl:204
compile_pattern_result set_default_pattern(string sPattern) noexcept
Compile and set the default pattern for log messages.
Definition: logger.inl:101
Fixed-size atomic string pool.
Definition: string_pool.h:35
item acquire()
Acquire a string from the pool.
Definition: string_pool.inl:33
void release(item item)
Return a string back to the pool.
Definition: string_pool.inl:58
Small Buffer Object for polymorphic classes.
void format_log_specifiers(string &sStorage, string_view svPattern, const category &category, verbosity eVerbosity, std::thread::id threadId, std::chrono::system_clock::time_point messageTime, string_view svFile, string_view svFunction, int nLine, string_view svMessage)
Format sStorage using qx::logger_specifiers.
compile_pattern_result compile_pattern(basic_string< char_t, traits_t > &sPattern) noexcept
Compile an fmt pattern with named arguments into replacement fields.