Fawkes API  Fawkes Development Version
syslog.cpp
00001 
00002 /***************************************************************************
00003  *  syslog.cpp - Fawkes syslog logger
00004  *
00005  *  Created: Thu Aug 18 17:15:30 2011
00006  *  Copyright  2006-2011  Tim Niemueller [www.niemueller.de]
00007  *
00008  ****************************************************************************/
00009 
00010 /*  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version. A runtime exception applies to
00014  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00015  *
00016  *  This program is distributed in the hope that it will be useful,
00017  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *  GNU Library General Public License for more details.
00020  *
00021  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00022  */
00023 
00024 #include <core/threading/mutex.h>
00025 #include <logging/syslog.h>
00026 
00027 #include <syslog.h>
00028 #include <cstdlib>
00029 #include <sys/time.h>
00030 #include <ctime>
00031 #include <cstdio>
00032 #include <cstring>
00033 
00034 namespace fawkes {
00035 
00036 /** @class SyslogLogger <logging/syslog.h>
00037  * Interface for logging to syslog.
00038  * The SyslogLogger will pipe all output to the syslog.
00039  * @author Tim Niemueller
00040  */
00041 
00042 /** Constructor.
00043  * @param log_level minimum level to log
00044  */
00045 SyslogLogger::SyslogLogger(LogLevel log_level)
00046   : Logger(log_level)
00047 {
00048   now_s = (struct ::tm *)malloc(sizeof(struct ::tm));
00049   mutex = new Mutex();
00050   __ident = NULL;
00051   openlog("Fawkes", LOG_CONS | LOG_NDELAY, LOG_USER);
00052 }
00053 
00054 
00055 /** Constructor with ident.
00056  * @param ident ident string passed to openlog.
00057  * @param log_level minimum level to log
00058  */
00059 SyslogLogger::SyslogLogger(const char *ident, LogLevel log_level)
00060   : Logger(log_level)
00061 {
00062   now_s = (struct ::tm *)malloc(sizeof(struct ::tm));
00063   mutex = new Mutex();
00064   if (ident == NULL) {
00065     __ident = NULL;
00066     openlog("Fawkes", LOG_CONS | LOG_NDELAY, LOG_USER);
00067   } else {
00068     __ident = strdup(ident);
00069     openlog(__ident, LOG_CONS | LOG_NDELAY, LOG_USER);
00070   }
00071 }
00072 
00073 
00074 /** Destructor. */
00075 SyslogLogger::~SyslogLogger()
00076 {
00077   free(now_s);
00078   delete mutex;
00079   closelog();
00080   if (__ident)  free(__ident);
00081   __ident = NULL;
00082 }
00083 
00084 
00085 void
00086 SyslogLogger::vlog_debug(const char *component, const char *format, va_list va)
00087 {
00088   if (log_level <= LL_DEBUG ) {
00089     mutex->lock();
00090     char *message;
00091     if (vasprintf(&message, format, va) != -1) {
00092       syslog(LOG_DEBUG, "%s: %s", component, message);
00093       free(message);
00094     } else {
00095       vsyslog(LOG_DEBUG, format, va);
00096     }
00097     mutex->unlock();
00098   }
00099 }
00100 
00101 
00102 void
00103 SyslogLogger::vlog_info(const char *component, const char *format, va_list va)
00104 {
00105   if (log_level <= LL_INFO ) {
00106     mutex->lock();
00107     char *message;
00108     if (vasprintf(&message, format, va) != -1) {
00109       syslog(LOG_INFO, "%s: %s", component, message);
00110       free(message);
00111     } else {
00112       vsyslog(LOG_INFO, format, va);
00113     }
00114     mutex->unlock();
00115   }
00116 }
00117 
00118 
00119 void
00120 SyslogLogger::vlog_warn(const char *component, const char *format, va_list va)
00121 {
00122   if ( log_level <= LL_WARN ) {
00123     mutex->lock();
00124     char *message;
00125     if (vasprintf(&message, format, va) != -1) {
00126       syslog(LOG_WARNING, "%s: %s", component, message);
00127       free(message);
00128     } else {
00129       vsyslog(LOG_WARNING, format, va);
00130     }
00131     mutex->unlock();
00132   }
00133 }
00134 
00135 
00136 void
00137 SyslogLogger::vlog_error(const char *component, const char *format, va_list va)
00138 {
00139   if ( log_level <= LL_ERROR ) {
00140     mutex->lock();
00141     char *message;
00142     if (vasprintf(&message, format, va) != -1) {
00143       syslog(LOG_ERR, "%s: %s", component, message);
00144       free(message);
00145     } else {
00146       vsyslog(LOG_ERR, format, va);
00147     }
00148     mutex->unlock();
00149   }
00150 }
00151 
00152 
00153 void
00154 SyslogLogger::log_debug(const char *component, const char *format, ...)
00155 {
00156   va_list arg;
00157   va_start(arg, format);
00158   vlog_debug(component, format, arg);
00159   va_end(arg);
00160 }
00161 
00162 
00163 void
00164 SyslogLogger::log_info(const char *component, const char *format, ...)
00165 {
00166   va_list arg;
00167   va_start(arg, format);
00168   vlog_info(component, format, arg);
00169   va_end(arg);
00170 }
00171 
00172 
00173 void
00174 SyslogLogger::log_warn(const char *component, const char *format, ...)
00175 {
00176   va_list arg;
00177   va_start(arg, format);
00178   vlog_warn(component, format, arg);
00179   va_end(arg);
00180 }
00181 
00182 
00183 void
00184 SyslogLogger::log_error(const char *component, const char *format, ...)
00185 {
00186   va_list arg;
00187   va_start(arg, format);
00188   vlog_error(component, format, arg);
00189   va_end(arg);
00190 }
00191 
00192 
00193 void
00194 SyslogLogger::log_debug(const char *component, Exception &e)
00195 {
00196   if (log_level <= LL_DEBUG ) {
00197     mutex->lock();
00198     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00199       syslog(LOG_DEBUG, "%s: [EXC] %s", component, *i);
00200     }
00201     mutex->unlock();
00202   }
00203 }
00204 
00205 
00206 void
00207 SyslogLogger::log_info(const char *component, Exception &e)
00208 {
00209   if (log_level <= LL_INFO ) {
00210     mutex->lock();
00211     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00212       syslog(LOG_INFO, "%s: [EXC] %s", component, *i);
00213     }
00214     mutex->unlock();
00215   }
00216 }
00217 
00218 
00219 void
00220 SyslogLogger::log_warn(const char *component, Exception &e)
00221 {
00222   if (log_level <= LL_WARN ) {
00223     mutex->lock();
00224     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00225       syslog(LOG_WARNING, "%s: [EXC] %s", component, *i);
00226     }
00227     mutex->unlock();
00228   }
00229 }
00230 
00231 
00232 void
00233 SyslogLogger::log_error(const char *component, Exception &e)
00234 {
00235   if (log_level <= LL_DEBUG ) {
00236     mutex->lock();
00237     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00238       syslog(LOG_ERR, "%s: [EXC] %s", component, *i);
00239     }
00240     mutex->unlock();
00241   }
00242 }
00243 
00244 
00245 void
00246 SyslogLogger::tlog_debug(struct timeval *t, const char *component, const char *format, ...)
00247 {
00248   va_list arg;
00249   va_start(arg, format);
00250   vtlog_debug(t, component, format, arg);
00251   va_end(arg);
00252 }
00253 
00254 
00255 void
00256 SyslogLogger::tlog_info(struct timeval *t, const char *component, const char *format, ...)
00257 {
00258   va_list arg;
00259   va_start(arg, format);
00260   vtlog_info(t, component, format, arg);
00261   va_end(arg);
00262 }
00263 
00264 
00265 void
00266 SyslogLogger::tlog_warn(struct timeval *t, const char *component, const char *format, ...)
00267 {
00268   va_list arg;
00269   va_start(arg, format);
00270   vtlog_warn(t, component, format, arg);
00271   va_end(arg);
00272 }
00273 
00274 
00275 void
00276 SyslogLogger::tlog_error(struct timeval *t, const char *component, const char *format, ...)
00277 {
00278   va_list arg;
00279   va_start(arg, format);
00280   vtlog_error(t, component, format, arg);
00281   va_end(arg);
00282 }
00283 
00284 
00285 void
00286 SyslogLogger::tlog_debug(struct timeval *t, const char *component, Exception &e)
00287 {
00288   if (log_level <= LL_DEBUG ) {
00289     mutex->lock();
00290     localtime_r(&t->tv_sec, now_s);
00291     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00292       syslog(LOG_DEBUG, "%s @ %02d:%02d:%02d.%06ld: [EXC] %s", component,
00293              now_s->tm_hour, now_s->tm_min, now_s->tm_sec, (long)t->tv_usec, *i);
00294     }
00295     mutex->unlock();
00296   }
00297 }
00298 
00299 
00300 void
00301 SyslogLogger::tlog_info(struct timeval *t, const char *component, Exception &e)
00302 {
00303   if (log_level <= LL_INFO ) {
00304     mutex->lock();
00305     localtime_r(&t->tv_sec, now_s);
00306     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00307       syslog(LOG_INFO, "%s @ %02d:%02d:%02d.%06ld: [EXC] %s", component,
00308              now_s->tm_hour, now_s->tm_min, now_s->tm_sec, (long)t->tv_usec, *i);
00309     }
00310     mutex->unlock();
00311   }
00312 }
00313 
00314 
00315 void
00316 SyslogLogger::tlog_warn(struct timeval *t, const char *component, Exception &e)
00317 {
00318   if (log_level <= LL_WARN ) {
00319     mutex->lock();
00320     localtime_r(&t->tv_sec, now_s);
00321     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00322       syslog(LOG_WARNING, "%s @ %02d:%02d:%02d.%06ld: [EXC] %s", component,
00323              now_s->tm_hour, now_s->tm_min, now_s->tm_sec, (long)t->tv_usec, *i);
00324     }
00325     mutex->unlock();
00326   }
00327 }
00328 
00329 
00330 void
00331 SyslogLogger::tlog_error(struct timeval *t, const char *component, Exception &e)
00332 {
00333   if (log_level <= LL_DEBUG ) {
00334     mutex->lock();
00335     localtime_r(&t->tv_sec, now_s);
00336     for (Exception::iterator i = e.begin(); i != e.end(); ++i) {
00337       syslog(LOG_ERR, "%s @ %02d:%02d:%02d.%06ld: [EXC] %s", component,
00338              now_s->tm_hour, now_s->tm_min, now_s->tm_sec, (long)t->tv_usec, *i);
00339     }
00340     mutex->unlock();
00341   }
00342 }
00343 
00344 
00345 
00346 
00347 void
00348 SyslogLogger::vtlog_debug(struct timeval *t, const char *component,
00349                           const char *format, va_list va)
00350 {
00351   if (log_level <= LL_DEBUG ) {
00352     mutex->lock();
00353     localtime_r(&t->tv_sec, now_s);
00354     char *message;
00355     if (vasprintf(&message, format, va) != -1) {
00356       syslog(LOG_DEBUG, "%s @ %02d:%02d:%02d.%06ld: %s", component,
00357              now_s->tm_hour, now_s->tm_min, now_s->tm_sec,
00358              (long)t->tv_usec, message);
00359       free(message);
00360     } else {
00361       vsyslog(LOG_DEBUG, format, va);
00362     }
00363     mutex->unlock();
00364   }
00365 }
00366 
00367 
00368 void
00369 SyslogLogger::vtlog_info(struct timeval *t, const char *component, const char *format, va_list va)
00370 {
00371   if (log_level <= LL_INFO ) {
00372     mutex->lock();
00373     localtime_r(&t->tv_sec, now_s);
00374     char *message;
00375     if (vasprintf(&message, format, va) != -1) {
00376       syslog(LOG_INFO, "%s @ %02d:%02d:%02d.%06ld: %s", component,
00377              now_s->tm_hour, now_s->tm_min, now_s->tm_sec,
00378              (long)t->tv_usec, message);
00379       free(message);
00380     } else {
00381       vsyslog(LOG_INFO, format, va);
00382     }
00383     mutex->unlock();
00384   }
00385 }
00386 
00387 
00388 void
00389 SyslogLogger::vtlog_warn(struct timeval *t, const char *component, const char *format, va_list va)
00390 {
00391   if ( log_level <= LL_WARN ) {
00392     mutex->lock();
00393     localtime_r(&t->tv_sec, now_s);
00394     char *message;
00395     if (vasprintf(&message, format, va) != -1) {
00396       syslog(LOG_WARNING, "%s @ %02d:%02d:%02d.%06ld: %s", component,
00397              now_s->tm_hour, now_s->tm_min, now_s->tm_sec,
00398              (long)t->tv_usec, message);
00399       free(message);
00400     } else {
00401       vsyslog(LOG_WARNING, format, va);
00402     }
00403     mutex->unlock();
00404   }
00405 }
00406 
00407 
00408 void
00409 SyslogLogger::vtlog_error(struct timeval *t, const char *component, const char *format, va_list va)
00410 {
00411   if ( log_level <= LL_ERROR ) {
00412     mutex->lock();
00413     localtime_r(&t->tv_sec, now_s);
00414     char *message;
00415     if (vasprintf(&message, format, va) != -1) {
00416       syslog(LOG_ERR, "%s @ %02d:%02d:%02d.%06ld: %s", component,
00417              now_s->tm_hour, now_s->tm_min, now_s->tm_sec,
00418              (long)t->tv_usec, message);
00419       free(message);
00420     } else {
00421       vsyslog(LOG_ERR, format, va);
00422     }
00423     mutex->unlock();
00424   }
00425 }
00426 
00427 
00428 } // end namespace fawkes