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