Fawkes API  Fawkes Development Version
mongodb_log_logger_thread.cpp
1 
2 /***************************************************************************
3  * mongodb_logger_thread.cpp - MongoDB logger thread
4  *
5  * Created: Tue Dec 07 22:59:47 2010
6  * Copyright 2006-2017 Tim Niemueller [www.niemueller.de]
7  ****************************************************************************/
8 
9 /* This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Library General Public License for more details.
18  *
19  * Read the full text in the LICENSE.GPL file in the doc directory.
20  */
21 
22 #include "mongodb_log_logger_thread.h"
23 
24 #include <core/threading/mutex.h>
25 #include <core/threading/mutex_locker.h>
26 
27 // from MongoDB
28 #include <mongo/client/dbclient.h>
29 
30 using namespace mongo;
31 using namespace fawkes;
32 
33 /** @class MongoLogLoggerThread "mongodb_log_logger_thread.h"
34  * Thread that provides a logger writing to MongoDB.
35  * This thread provides a logger, which writes log information to a
36  * MongoDB collection.
37  * @author Tim Niemueller
38  */
39 
40 /** Constructor. */
42 : Thread("MongoLogLoggerThread", Thread::OPMODE_WAITFORWAKEUP),
43  LoggerAspect(this),
44  MongoDBAspect("default")
45 {
46  mutex_ = new Mutex();
47 }
48 
49 /** Destructor. */
51 {
52  delete mutex_;
53 }
54 
55 void
57 {
58  collection_ = "fawkes.msglog";
59  try {
60  collection_ = config->get_string("/plugins/mongodb/logger_collection");
61  } catch (Exception &e) {
62  }
63 }
64 
65 void
67 {
68 }
69 
70 void
72 {
73 }
74 
75 void
76 MongoLogLoggerThread::insert_message(LogLevel ll,
77  const char *component,
78  const char *format,
79  va_list va)
80 {
81  if (log_level <= ll) {
82  MutexLocker lock(mutex_);
83  struct timeval now;
84  gettimeofday(&now, NULL);
85  Date_t nowd = now.tv_sec * 1000 + now.tv_usec / 1000;
86 
87  char *msg;
88  if (vasprintf(&msg, format, va) == -1) {
89  // Cannot do anything useful, drop log message
90  return;
91  }
92 
93  BSONObjBuilder b;
94  switch (ll) {
95  case LL_DEBUG: b.append("level", "DEBUG"); break;
96  case LL_INFO: b.append("level", "INFO"); break;
97  case LL_WARN: b.append("level", "WARN"); break;
98  case LL_ERROR: b.append("level", "ERROR"); break;
99  default: b.append("level", "UNKN"); break;
100  }
101  b.append("component", component);
102  b.appendDate("time", nowd);
103  b.append("message", msg);
104 
105  free(msg);
106 
107  try {
108  mongodb_client->insert(collection_, b.obj());
109  } catch (mongo::DBException &e) {
110  } // ignored
111  }
112 }
113 
114 void
115 MongoLogLoggerThread::insert_message(LogLevel ll, const char *component, Exception &e)
116 {
117  if (log_level <= ll) {
118  MutexLocker lock(mutex_);
119  struct timeval now;
120  gettimeofday(&now, NULL);
121  Date_t nowd = now.tv_sec * 1000 + now.tv_usec / 1000;
122 
123  for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
124  BSONObjBuilder b;
125  switch (ll) {
126  case LL_DEBUG: b.append("level", "DEBUG"); break;
127  case LL_INFO: b.append("level", "INFO"); break;
128  case LL_WARN: b.append("level", "WARN"); break;
129  case LL_ERROR: b.append("level", "ERROR"); break;
130  default: b.append("level", "UNKN"); break;
131  }
132  b.append("component", component);
133  b.appendDate("time", nowd);
134  b.append("message", std::string("[EXCEPTION] ") + *i);
135  try {
136  mongodb_client->insert(collection_, b.obj());
137  } catch (mongo::DBException &e) {
138  } // ignored
139  }
140  }
141 }
142 
143 void
144 MongoLogLoggerThread::vlog_debug(const char *component, const char *format, va_list va)
145 {
146  insert_message(LL_DEBUG, component, format, va);
147 }
148 
149 void
150 MongoLogLoggerThread::vlog_info(const char *component, const char *format, va_list va)
151 {
152  insert_message(LL_INFO, component, format, va);
153 }
154 
155 void
156 MongoLogLoggerThread::vlog_warn(const char *component, const char *format, va_list va)
157 {
158  insert_message(LL_WARN, component, format, va);
159 }
160 
161 void
162 MongoLogLoggerThread::vlog_error(const char *component, const char *format, va_list va)
163 {
164  insert_message(LL_ERROR, component, format, va);
165 }
166 
167 void
168 MongoLogLoggerThread::log_debug(const char *component, const char *format, ...)
169 {
170  va_list arg;
171  va_start(arg, format);
172  insert_message(LL_DEBUG, component, format, arg);
173  va_end(arg);
174 }
175 
176 void
177 MongoLogLoggerThread::log_info(const char *component, const char *format, ...)
178 {
179  va_list arg;
180  va_start(arg, format);
181  insert_message(LL_INFO, component, format, arg);
182  va_end(arg);
183 }
184 
185 void
186 MongoLogLoggerThread::log_warn(const char *component, const char *format, ...)
187 {
188  va_list arg;
189  va_start(arg, format);
190  insert_message(LL_WARN, component, format, arg);
191  va_end(arg);
192 }
193 
194 void
195 MongoLogLoggerThread::log_error(const char *component, const char *format, ...)
196 {
197  va_list arg;
198  va_start(arg, format);
199  insert_message(LL_ERROR, component, format, arg);
200  va_end(arg);
201 }
202 
203 void
204 MongoLogLoggerThread::log_debug(const char *component, Exception &e)
205 {
206  insert_message(LL_DEBUG, component, e);
207 }
208 
209 void
210 MongoLogLoggerThread::log_info(const char *component, Exception &e)
211 {
212  insert_message(LL_INFO, component, e);
213 }
214 
215 void
216 MongoLogLoggerThread::log_warn(const char *component, Exception &e)
217 {
218  insert_message(LL_WARN, component, e);
219 }
220 
221 void
222 MongoLogLoggerThread::log_error(const char *component, Exception &e)
223 {
224  insert_message(LL_ERROR, component, e);
225 }
226 
227 void
228 MongoLogLoggerThread::tlog_insert_message(LogLevel ll,
229  struct timeval *t,
230  const char * component,
231  const char * format,
232  va_list va)
233 {
234  if (log_level <= ll) {
235  MutexLocker lock(mutex_);
236  char * msg;
237  if (vasprintf(&msg, format, va) == -1) {
238  return;
239  }
240 
241  Date_t nowd = t->tv_sec * 1000 + t->tv_usec / 1000;
242 
243  BSONObjBuilder b;
244  switch (ll) {
245  case LL_DEBUG: b.append("level", "DEBUG"); break;
246  case LL_INFO: b.append("level", "INFO"); break;
247  case LL_WARN: b.append("level", "WARN"); break;
248  case LL_ERROR: b.append("level", "ERROR"); break;
249  default: b.append("level", "UNKN"); break;
250  }
251  b.append("component", component);
252  b.appendDate("time", nowd);
253  b.append("message", msg);
254  try {
255  mongodb_client->insert(collection_, b.obj());
256  } catch (mongo::DBException &e) {
257  } // ignored
258 
259  free(msg);
260 
261  mutex_->unlock();
262  }
263 }
264 
265 void
266 MongoLogLoggerThread::tlog_insert_message(LogLevel ll,
267  struct timeval *t,
268  const char * component,
269  Exception & e)
270 {
271  if (log_level <= ll) {
272  MutexLocker lock(mutex_);
273  Date_t nowd = t->tv_sec * 1000 + t->tv_usec / 1000;
274  for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
275  BSONObjBuilder b;
276  switch (ll) {
277  case LL_DEBUG: b.append("level", "DEBUG"); break;
278  case LL_INFO: b.append("level", "INFO"); break;
279  case LL_WARN: b.append("level", "WARN"); break;
280  case LL_ERROR: b.append("level", "ERROR"); break;
281  default: b.append("level", "UNKN"); break;
282  }
283  b.append("component", component);
284  b.appendDate("time", nowd);
285  b.append("message", std::string("[EXCEPTION] ") + *i);
286  try {
287  mongodb_client->insert(collection_, b.obj());
288  } catch (mongo::DBException &e) {
289  } // ignored
290  }
291  }
292 }
293 
294 void
295 MongoLogLoggerThread::tlog_debug(struct timeval *t, const char *component, const char *format, ...)
296 {
297  va_list arg;
298  va_start(arg, format);
299  tlog_insert_message(LL_DEBUG, t, component, format, arg);
300  va_end(arg);
301 }
302 
303 void
304 MongoLogLoggerThread::tlog_info(struct timeval *t, const char *component, const char *format, ...)
305 {
306  va_list arg;
307  va_start(arg, format);
308  tlog_insert_message(LL_INFO, t, component, format, arg);
309  va_end(arg);
310 }
311 
312 void
313 MongoLogLoggerThread::tlog_warn(struct timeval *t, const char *component, const char *format, ...)
314 {
315  va_list arg;
316  va_start(arg, format);
317  tlog_insert_message(LL_WARN, t, component, format, arg);
318  va_end(arg);
319 }
320 
321 void
322 MongoLogLoggerThread::tlog_error(struct timeval *t, const char *component, const char *format, ...)
323 {
324  va_list arg;
325  va_start(arg, format);
326  tlog_insert_message(LL_ERROR, t, component, format, arg);
327  va_end(arg);
328 }
329 
330 void
331 MongoLogLoggerThread::tlog_debug(struct timeval *t, const char *component, Exception &e)
332 {
333  tlog_insert_message(LL_DEBUG, t, component, e);
334 }
335 
336 void
337 MongoLogLoggerThread::tlog_info(struct timeval *t, const char *component, Exception &e)
338 {
339  tlog_insert_message(LL_INFO, t, component, e);
340 }
341 
342 void
343 MongoLogLoggerThread::tlog_warn(struct timeval *t, const char *component, Exception &e)
344 {
345  tlog_insert_message(LL_WARN, t, component, e);
346 }
347 
348 void
349 MongoLogLoggerThread::tlog_error(struct timeval *t, const char *component, Exception &e)
350 {
351  tlog_insert_message(LL_ERROR, t, component, e);
352 }
353 
354 void
356  const char * component,
357  const char * format,
358  va_list va)
359 {
360  tlog_insert_message(LL_DEBUG, t, component, format, va);
361 }
362 
363 void
365  const char * component,
366  const char * format,
367  va_list va)
368 {
369  tlog_insert_message(LL_INFO, t, component, format, va);
370 }
371 
372 void
374  const char * component,
375  const char * format,
376  va_list va)
377 {
378  tlog_insert_message(LL_WARN, t, component, format, va);
379 }
380 
381 void
383  const char * component,
384  const char * format,
385  va_list va)
386 {
387  tlog_insert_message(LL_ERROR, t, component, format, va);
388 }
virtual void vtlog_error(struct timeval *t, const char *component, const char *format, va_list va)
Log error message for specific time.
Thread aspect that allows to provide a logger to Fawkes.
Definition: logger.h:33
LogLevel log_level
Minimum log level.
Definition: logger.h:126
virtual void tlog_warn(struct timeval *t, const char *component, const char *format,...)
Log warning message for specific time.
informational output about normal procedures
Definition: logger.h:53
virtual void finalize()
Finalize the thread.
virtual void vlog_info(const char *component, const char *format, va_list va)
Log informational message.
Fawkes library namespace.
void unlock()
Unlock the mutex.
Definition: mutex.cpp:131
Mutex locking helper.
Definition: mutex_locker.h:33
mongo::DBClientBase * mongodb_client
MongoDB client to use to interact with the database.
Definition: mongodb.h:55
warning, should be investigated but software still functions, an example is that something was reques...
Definition: logger.h:54
Thread class encapsulation of pthreads.
Definition: thread.h:45
Message iterator for exceptions.
Definition: exception.h:72
virtual void log_debug(const char *component, const char *format,...)
Log debug message.
virtual void log_error(const char *component, const char *format,...)
Log error message.
error, may be recoverable (software still running) or not (software has to terminate).
Definition: logger.h:57
virtual void tlog_error(struct timeval *t, const char *component, const char *format,...)
Log error message for specific time.
iterator end()
Get end iterator for messages.
Definition: exception.cpp:692
virtual void vtlog_info(struct timeval *t, const char *component, const char *format, va_list va)
Log informational message for specific time.
Base class for exceptions in Fawkes.
Definition: exception.h:35
virtual ~MongoLogLoggerThread()
Destructor.
Thread aspect to access MongoDB.
Definition: mongodb.h:39
virtual void log_warn(const char *component, const char *format,...)
Log warning message.
virtual void log_info(const char *component, const char *format,...)
Log informational message.
virtual void loop()
Code to execute in the thread.
iterator begin()
Get iterator for messages.
Definition: exception.cpp:676
debug output, relevant only when tracking down problems
Definition: logger.h:52
virtual void vtlog_debug(struct timeval *t, const char *component, const char *format, va_list va)
Log debug message for specific time.
virtual void vlog_error(const char *component, const char *format, va_list va)
Log error message.
virtual void vtlog_warn(struct timeval *t, const char *component, const char *format, va_list va)
Log warning message for specific time.
virtual void init()
Initialize the thread.
virtual void vlog_warn(const char *component, const char *format, va_list va)
Log warning message.
Mutex mutual exclusion lock.
Definition: mutex.h:32
virtual void tlog_info(struct timeval *t, const char *component, const char *format,...)
Log informational message for specific time.
Configuration * config
This is the Configuration member used to access the configuration.
Definition: configurable.h:41
virtual void vlog_debug(const char *component, const char *format, va_list va)
Log debug message.
virtual void tlog_debug(struct timeval *t, const char *component, const char *format,...)
Log debug message for specific time.
virtual std::string get_string(const char *path)=0
Get value from configuration which is of type string.