Fawkes API
Fawkes Development Version
|
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