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