/*
* Write the requested prefixes into the log message.
*/
static void log_write_prefixes(Logger *logger,
const char *file, int line, const char *func)
{
struct tm tm = { 0 };
struct timeval tv = { 0 };
LOG_Prefix *pfx;
tv.tv_sec = -1;
for (pfx = listHead(&logger->prefixes); pfx; pfx = listNext(pfx)) {
switch(pfx->type) {
case LOG_PT_DATE:
if (tv.tv_sec == -1) log_get_time(&tm, &tv);
bufAddF(&logger->scratch, "%04d-%02d-%02d ",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
break;
case LOG_PT_TIME:
if (tv.tv_sec == -1) log_get_time(&tm, &tv);
bufAddF(&logger->scratch, "%02d:%02d:", tm.tm_hour, tm.tm_min);
if (pfx->u.precision == 0) {
bufAddF(&logger->scratch, "%02d ", tm.tm_sec);
}
else {
double seconds =
(double) tm.tm_sec + (double) tv.tv_usec / 1000000.0;
bufAddF(&logger->scratch, "%0*.*f ",
3 + pfx->u.precision, pfx->u.precision, seconds);
}
break;
case LOG_PT_FILE:
bufAddF(&logger->scratch, "%s ", file);
break;
case LOG_PT_LINE:
bufAddF(&logger->scratch, "%d ", line);
break;
case LOG_PT_FUNC:
bufAddF(&logger->scratch, "%s ", func);
break;
case LOG_PT_STR:
bufAddF(&logger->scratch, "%s ", pfx->u.string);
break;
}
}
}
static ssize_t _log_fwrite(struct iovec *vec, int n)
{
int i, ret;
unsigned long long tmp_size = get_file_size_by_fp(_log_fp);
if (UNLIKELY(tmp_size > _log_file_size)) {
if (CHECK_LOG_PREFIX(_log_prefix, LOG_VERBOSE_BIT)) {
fprintf(stderr, "%s size= %llu reach max %llu, splited\n",
_log_name, tmp_size, _log_file_size);
}
if (EOF == _log_fclose()) {
fprintf(stderr, "_log_fclose errno:%d", errno);
}
log_get_time(_log_name_time, sizeof(_log_name_time), 1);
snprintf(_log_name, sizeof(_log_name), "%s%s_%s",
_log_path, _log_name_prefix, _log_name_time);
_log_fopen(_log_name);
if (CHECK_LOG_PREFIX(_log_prefix, LOG_VERBOSE_BIT)) {
fprintf(stderr, "splited file %s\n", _log_name);
}
}
for (i = 0; i < n; i++) {
ret = fprintf(_log_fp, "%s", (char *)vec[i].iov_base);
if (ret != (int)vec[i].iov_len) {
fprintf(stderr, "fprintf failed: %s\n", strerror(errno));
return -1;
}
if (EOF == fflush(_log_fp)) {
fprintf(stderr, "fflush failed: %s\n", strerror(errno));
return -1;
}
}
return 0;
}
static int log_init_file(const char *ident)
{
log_filename_parse(ident);
memset(_log_name, 0, sizeof(_log_name));
if (ident == NULL) {
log_get_time(_log_name, sizeof(_log_name), 1);
} else {
strncpy(_log_name, ident, sizeof(_log_name));
}
_log_fp = NULL;
_log_fd = 0;
_log_handle->open(_log_name);
return 0;
}
static ssize_t _log_write(struct iovec *vec, int n)
{
unsigned long long tmp_size = get_file_size(_log_name);
if (UNLIKELY(tmp_size > _log_file_size)) {
fprintf(stderr, "%s size= %llu reach max %llu, splited\n",
_log_name, tmp_size, _log_file_size);
if (-1 == _log_close()) {
fprintf(stderr, "_log_close errno:%d", errno);
}
log_get_time(_log_name_time, sizeof(_log_name_time), 1);
snprintf(_log_name, sizeof(_log_name), "%s%s_%s",
_log_path, _log_name_prefix, _log_name_time);
_log_open(_log_name);
fprintf(stderr, "splited file %s\n", _log_name);
}
return writev(_log_fd, vec, n);
}
static ssize_t _log_write(struct iovec *vec, int n)
{
char log_rename[FILENAME_LEN] = {0};
unsigned long long tmp_size = get_file_size(_log_name);
if (UNLIKELY(tmp_size > _log_file_size)) {
fprintf(stderr, "%s size= %llu reach max %llu, splited\n",
_log_name, tmp_size, _log_file_size);
if (-1 == _log_close()) {
fprintf(stderr, "_log_close errno:%d", errno);
}
log_get_time(_log_name_time, sizeof(_log_name_time), 1);
snprintf(log_rename, sizeof(log_rename), "%s%s_%s",
_log_path, _log_name_prefix, _log_name_time);
if (-1 == rename(_log_name, log_rename)) {
fprintf(stderr, "log file splited %s error: %d:%s\n",
log_rename, errno , strerror(errno));
}
_log_open(_log_name);
fprintf(stderr, "splited file %s\n", log_rename);
}
return writev(_log_fd, vec, n);
}
/*
*time: level: process[pid]: [tid] tag: message
* [verbose ]
*/
static int _log_print(int lvl, const char *tag,
const char *file, int line,
const char *func, const char *msg)
{
int ret = 0, i = 0;
struct iovec vec[LOG_IOVEC_MAX];
char s_time[LOG_TIME_SIZE];
char s_lvl[LOG_LEVEL_SIZE];
char s_tag[LOG_TAG_SIZE];
char s_pname[LOG_PNAME_SIZE];
char s_pid[LOG_PNAME_SIZE];
char s_tid[LOG_PNAME_SIZE];
char s_file[LOG_TEXT_SIZE];
char s_msg[LOG_BUF_SIZE];
pthread_mutex_lock(&_log_mutex);
log_get_time(s_time, sizeof(s_time), 0);
if (_log_fp == stderr || _log_fd == STDERR_FILENO) {
switch(lvl) {
case LOG_EMERG:
case LOG_ALERT:
case LOG_CRIT:
case LOG_ERR:
snprintf(s_lvl, sizeof(s_lvl),
B_RED("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), RED("%s"), msg);
break;
case LOG_WARNING:
snprintf(s_lvl, sizeof(s_lvl),
B_YELLOW("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), YELLOW("%s"), msg);
break;
case LOG_INFO:
snprintf(s_lvl, sizeof(s_lvl),
B_GREEN("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), GREEN("%s"), msg);
break;
case LOG_DEBUG:
snprintf(s_lvl, sizeof(s_lvl),
B_WHITE("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), WHITE("%s"), msg);
break;
default:
snprintf(s_lvl, sizeof(s_lvl),
"[%7s]", _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), "%s", msg);
break;
}
} else {
snprintf(s_lvl, sizeof(s_lvl),
"[%7s]", _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), "%s", msg);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_PIDTID_BIT)) {
snprintf(s_pname, sizeof(s_pname), "[%s ", _proc_name);
snprintf(s_pid, sizeof(s_pid), "pid:%d ", getpid());
snprintf(s_tid, sizeof(s_tid), "tid:%d]", _gettid());
snprintf(s_tag, sizeof(s_tag), "[%s]", tag);
snprintf(s_file, sizeof(s_file), "[%s:%d: %s] ", file, line, func);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT)) {
snprintf(s_file, sizeof(s_file), "[%s:%d: %s] ", file, line, func);
}
i = -1;
if (CHECK_LOG_PREFIX(_log_prefix, LOG_TIMESTAMP_BIT)) {
vec[++i].iov_base = (void *)s_time;
vec[i].iov_len = strlen(s_time);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_PIDTID_BIT)) {
vec[++i].iov_base = (void *)s_pname;
vec[i].iov_len = strlen(s_pname);
vec[++i].iov_base = (void *)s_pid;
vec[i].iov_len = strlen(s_pid);
vec[++i].iov_base = (void *)s_tid;
vec[i].iov_len = strlen(s_tid);
}
vec[++i].iov_base = (void *)s_lvl;
vec[i].iov_len = strlen(s_lvl);
if (CHECK_LOG_PREFIX(_log_prefix, LOG_TAG_BIT)) {
vec[++i].iov_base = (void *)s_tag;
vec[i].iov_len = strlen(s_tag);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT)) {
vec[++i].iov_base = (void *)s_file;
vec[i].iov_len = strlen(s_file);
}
vec[++i].iov_base = (void *)s_msg;
vec[i].iov_len = strlen(s_msg);
if (UNLIKELY(!_log_syslog)) {
ret = _log_handle->write(vec, i+1);
}
pthread_mutex_unlock(&_log_mutex);
return ret;
}
