code.vuplus.com Git - vuplus_transtreamproxy/blob - src/Logger.cpp

   1 /*
   2  * logger.cpp
   3  *
   4  *  Created on: 2014. 2. 7.
   5  *      Author: kos
   6  */
   7
   8 #include <time.h>
   9 #include <unistd.h>
  10 #include <string.h>
  11 #include <sys/types.h>
  12
  13 #include "Logger.h"
  14
  15 #define USE_COLOR_LOG 1
  16
  17 static char log_data_buffer[MAX_PRINT_LEN] = {0};
  18 #ifdef USE_COLOR_LOG
  19 static const char* LOG_LV_STR[] = {
  20                 "[   NONE]",
  21                 "\e[1;31m[  ERROR]\e[00m",
  22                 "\e[1;33m[WARNING]\e[00m",
  23                 "\e[1;32m[   INFO]\e[00m",
  24                 "\e[1;36m[  DEBUG]\e[00m",
  25                 "[    LOG]"
  26 };
  27 #else
  28 static const char* LOG_LV_STR[] = {
  29                 "[   NONE]",
  30                 "[  ERROR]",
  31                 "[WARNING]",
  32                 "[   INFO]",
  33                 "[  DEBUG]",
  34                 "[    LOG]"
  35 };
  36 #endif
  37 //----------------------------------------------------------------------
  38
  39 char* timestamp(const char* aFormat)
  40 {
  41         time_t t;
  42         time(&t);
  43
  44         struct tm* m = localtime(&t);
  45         static char sz_timestamp[32] = {0};
  46         strftime(sz_timestamp, sizeof(sz_timestamp), aFormat, m);
  47         return sz_timestamp;
  48 }
  49 //----------------------------------------------------------------------
  50
  51 Logger::Logger()
  52         : mLogLevel(0), mLogHandle(0)
  53 {
  54         mPid = getpid();
  55 }
  56 //----------------------------------------------------------------------
  57
  58 Logger::~Logger()
  59 {
  60         if (mLogHandle) {
  61                 fclose(mLogHandle);
  62                 mLogHandle = 0;
  63         }
  64 }
  65 //----------------------------------------------------------------------
  66
  67 void Logger::set_pid()
  68 {
  69         mPid = getpid();
  70 }
  71 //----------------------------------------------------------------------
  72
  73 Logger* Logger::instance()
  74 {
  75         if (mInstHandle == 0) {
  76                 mInstHandle = new Logger();
  77                 atexit(logger_release);
  78         }
  79         return mInstHandle;
  80 }
  81 //----------------------------------------------------------------------
  82
  83 bool Logger::init(const char* aName, int aLogLevel, bool aWithTimestamp, const char* aVersion)
  84 {
  85         mLogLevel = aLogLevel;
  86         if (aName == NULL) {
  87                 mLogHandle = stdout;
  88                 INFO("logger initialized.");
  89                 return true;
  90         }
  91         char path[256] = {0};
  92         if (aWithTimestamp)
  93                 sprintf(path, "%s_%s.log", aName, timestamp("%Y%m%d"));
  94         else sprintf(path, "%s.log", aName);
  95         if (!(mLogHandle = fopen(path, "a+"))) {
  96                 mLogHandle = 0;
  97                 printf("fail to open logger [%s].", path);
  98                 return false;
  99         }
 100         DUMMY("Logger initialized. (Ver %s)", aVersion);
 101         return true;
 102 }
 103 //----------------------------------------------------------------------
 104
 105 void Logger::hexlog(const char *header, const char *buffer, const int length, const char *aFormat, ...)
 106 {
 107         int offset = 0, i = 0, ll = 0;
 108
 109         FILE* output = mLogHandle;
 110
 111         memset(log_data_buffer, 0, MAX_PRINT_LEN);
 112
 113         va_list args;
 114         va_start(args, aFormat);
 115         ll = vsnprintf(log_data_buffer, MAX_PRINT_LEN-1, aFormat, args);
 116         va_end(args);
 117
 118         if (ll > MAX_PRINT_LEN - 1) {
 119                 ll = MAX_PRINT_LEN - 1;
 120         }
 121         fprintf(output, "%s\n", log_data_buffer);
 122
 123         fprintf(output, "HEX DUMP : [%s]-[%d]\n", header, length);
 124         fprintf(output, "-----------------------------------------------------------------------------\n");
 125         while (offset < length) {
 126                 char *tmp = (char*) (buffer + offset);
 127                 int  tmp_len  = (offset + 16 < length) ? 16 : (length - offset);
 128
 129                 fprintf(output, "%08X:  ", offset);
 130                 for (i = 0; i < tmp_len; i++) {
 131                         if (i == 8) fprintf(output, " ");
 132                         fprintf(output, "%02X ", (unsigned char) tmp[i]);
 133                 }
 134
 135                 for (i = 0; i <= (16 - tmp_len) * 3; i++)
 136                         fprintf(output, " ");
 137                 if (tmp_len < 9) fprintf(output, " ");
 138
 139                 for (i = 0; i < tmp_len; i++)
 140                         fprintf(output, "%c", (tmp[i] >= 0x20 && tmp[i] <= 0x7E) ? tmp[i] : '.');
 141                 offset += 16; fprintf(output, "\n");
 142         }
 143         if (offset == 0) fprintf(output, "%08X:  ", offset);
 144         fprintf(output, "-----------------------------------------------------------------------------\n");
 145         fflush(output);
 146 }
 147 //----------------------------------------------------------------------
 148
 149 void Logger::log(const char* aFormat, ...)
 150 {
 151         memset(log_data_buffer, 0, MAX_PRINT_LEN);
 152
 153         va_list args;
 154         va_start(args, aFormat);
 155         vsnprintf(log_data_buffer, MAX_PRINT_LEN-1, aFormat, args);
 156         va_end(args);
 157
 158         fprintf(mLogHandle, "%s\n", log_data_buffer);
 159         fflush(mLogHandle);
 160 }
 161 //----------------------------------------------------------------------
 162
 163 void Logger::log(int aLogLevel, const char* aFormat, ...)
 164 {
 165 #ifndef _DISABLE_LOGGER
 166         if (aLogLevel > mLogLevel || mLogHandle == 0) {
 167                 //printf("mLogHandle : %p, mLogLevel : %d, aLogLevel : %d\n", mLogHandle, mLogLevel, aLogLevel);
 168                 return;
 169         }
 170
 171         memset(log_data_buffer, 0, MAX_PRINT_LEN);
 172         va_list args;
 173         va_start(args, aFormat);
 174         vsnprintf(log_data_buffer, MAX_PRINT_LEN-1, aFormat, args);
 175         va_end(args);
 176
 177         fprintf(mLogHandle, "[%s]%s[%d] %s\n", timestamp(DEFAULT_TIMESTAMP_FORMAT), LOG_LV_STR[aLogLevel], mPid, log_data_buffer);
 178         fflush(mLogHandle);
 179 #endif
 180 }
 181 //----------------------------------------------------------------------
 182
 183 Logger* Logger::mInstHandle = 0;
 184 //----------------------------------------------------------------------