log.c

Open DMT Client C Source code

        _logSyslogPrint(level, fn, fmt, ap);
        return;
    } 
#endif

    /* 'Level' title */
    const char *lvlName = "?";
    switch (level) {
        case SYSLOG_CRITICAL: lvlName = "CRITICAL";  break; // Critical errors
        case SYSLOG_ERROR:    lvlName = "ERROR";     break; // General errors
        case SYSLOG_WARNING:  lvlName = "WARN";      break; // Warnings
        case SYSLOG_INFO:     lvlName = "info";      break; // Informational
        case SYSLOG_DEBUG:    lvlName = "dbug";      break; // Debug
    }

    /* format the message */
    char msg[MAX_MESSAGE_LENGTH + 2];
    int msgLen = 0;
    if (fn && *fn) {
        // pre-pend function information
        msgLen = sprintf(msg, "%d%s.%s[%s] ", level % 10, syslogName, lvlName, fn);
    }
    // append message
    // (Note: Windows return value for 'VSNPRINTF' is different than Linux)
    int bufSize = MAX_MESSAGE_LENGTH - msgLen;
    int vsnLen = VSNPRINTF(&msg[msgLen], bufSize, fmt, ap);
    if ((vsnLen < 0) || (vsnLen >= bufSize)) {
        // Windows returns '-1' if the written length exceeds 'bufSize'
        // Linux returns the number of bytes that _would_ have been written
        msgLen = MAX_MESSAGE_LENGTH;
    } else {
        // 'vsnLen' bytes written
        msgLen += vsnLen;
    }
    // trailing '\n'
    if (msg[msgLen - 1] != '\n') {
        strcpy(&msg[msgLen++], "\n");
    } else {
        msg[msgLen] = 0;
    }

    /* output message */
    LOG_LOCK {
#if defined(SYSLOG_THREAD)
        if (syslogRunThread) {
            if (!bufferPutData(syslogBuffer,msg,msgLen+1)) { // <-- incl terminator
                // this log message will be discarded
                if (isDebugMode()) { fprintf(CONSOLE_OUTPUT, "Log overflow! [%s]\n", msg); } // ignore returned error code
            }
            LOG_NOTIFY;
        } else 
#endif
        {
            _logMessagePrint(msg, msgLen);
            if ((syslogMsgCount % FLUSH_MODULO) == 0) {
                _logMessageFlush();
            }
        }
        syslogMsgCount++;
    } LOG_UNLOCK

}

// ----------------------------------------------------------------------------

/* return true if current level equals specified level */
utBool logIsLevel(int level)
{
    return (level <= syslogLevel)? utTrue : utFalse;
}

/* return true if syslog is in effect */
utBool logIsSyslog()
{
#if defined(INCLUDE_SYSLOG_SUPPORT)
    return syslogEnabled;
#else
    return utFalse;
#endif
}

/* parse logging level name */
int logParseLevel(const char *level)
{
    if (level && *level) {
        // a prefixing '+'/'-' character means send log messages to 'stderr'
        // ('+' was included to allow for easier command-line parsing)
        int tty = (*level == '+') || (*level == '-')? -1 : 1;
        const char *lvl = (tty < 0)? (level + 1) : level;
        if (isdigit(*lvl)) {
            return tty * (int)strParseInt32(lvl, SYSLOG_ERROR);
        } else
        if (strStartsWithIgnoreCase(lvl,"cri")) {
            return tty * SYSLOG_CRITICAL;
        } else
        if (strStartsWithIgnoreCase(lvl,"err")) {
            return tty * SYSLOG_ERROR;
        } else
        if (strStartsWithIgnoreCase(lvl,"war")) {
            return tty * SYSLOG_WARNING;
        } else
        if (strStartsWithIgnoreCase(lvl,"inf")) {
            return tty * SYSLOG_INFO;
        } else
        if (strStartsWithIgnoreCase(lvl,"deb") || strStartsWithIgnoreCase(lvl,"dbg")) {
            return tty * SYSLOG_DEBUG;
        } else {
            return tty * SYSLOG_ERROR; // the default
        }
    } else {
        return SYSLOG_NONE;
    }
}

/* set logging level */
void logSetLevel(int level)
{
    int lvl = (level >= 0)? level : -level; // absolute value
    if (lvl != syslogLevel) {
        syslogLevel = lvl;
        logPRINTF(LOGSRC,SYSLOG_INFO,"Set log level: %d", syslogLevel);
    } else {
        //logERROR(LOGSRC,"Already at log level: %d", syslogLevel);
    }
}

void logEnableSyslog(utBool enable)
{
#if defined(INCLUDE_SYSLOG_SUPPORT)
    syslogEnabled = enable;
#endif
}

// ----------------------------------------------------------------------------

/* log messages */
void logPrintf_(const char *ftn, int line, int level, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    _logPrint(utTrue, level, ftn, line, fmt, ap);
    va_end(ap);
}

/* log debug messages */
void logDebug_(const char *ftn, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    _logPrint(utFalse, SYSLOG_DEBUG, ftn, line, fmt, ap);
    va_end(ap);
}

/* log info messages */
void logInfo_(const char *ftn, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    _logPrint(utFalse, SYSLOG_INFO, ftn, line, fmt, ap);
    va_end(ap);
}

/* log warning messages */
void logWarning_(const char *ftn, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    _logPrint(utFalse, SYSLOG_WARNING, ftn, line, fmt, ap);
    va_end(ap);
}

/* log error messages */
void logError_(const char *ftn, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    _logPrint(utFalse, SYSLOG_ERROR, ftn, line, fmt, ap);
    va_end(ap);
}

/* log critical messages */
void logCritical_(const char *ftn, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    _logPrint(utFalse, SYSLOG_CRITICAL, ftn, line, fmt, ap);
    va_end(ap);
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

#if defined(SYSLOG_THREAD)

/* thread main */
static void _syslogThreadRunnable(void *arg)
{
    char data[MAX_MESSAGE_LENGTH + 2];
    int maxDataLen = sizeof(data);
    while (syslogRunThread) {
        
        /* wait for data */
        int len = 0;
        while (syslogRunThread && (len <= 0)) {
            LOG_LOCK {
                // get a single string
                len = bufferGetString(syslogBuffer, data, maxDataLen);
            } LOG_UNLOCK
            if (len <= 0L) {
                // queue is empty, flush output now (outside of the lock!)
                _logMessageFlush();
                // wait until we have something in the queue
                LOG_LOCK {
                    if (bufferGetLength(syslogBuffer) <= 0L) {
                        // still nothing in the queue
                        // wait a few seconds, or until we get notified
                        LOG_WAIT(5000L);
                    }
                } LOG_UNLOCK
            }
        }
        if (!syslogRunThread) {
            break;
        }

        /* print string */
        //fprintf(CONSOLE_OUTPUT, "{Thread} ");  // ignore returned error code
        _logMessagePrint(data, len);

    }
    // once this thread stops, it isn't starting again
    logERROR(LOGSRC,"Stopping thread");
    threadExit();
}

/* call-back to stop thread */
static void _syslogStopThread(void *arg)
{
    syslogRunThread = utFalse;
#if defined(SYSLOG_THREAD)
    LOG_LOCK { LOG_NOTIFY; } LOG_UNLOCK
#endif
}

/* start serial communication thread */
static utBool _syslogStartThread()
{
    
    /* thread already running? */
    if (syslogRunThread) {
        return utTrue;
    }
    
    /* init */
    threadConditionInit(&syslogCond);
    syslogBuffer = bufferCreate(LOG_BUFFER_SIZE);

    /* create thread */
    syslogRunThread = utTrue;
    if (threadCreate(&syslogThread,&_syslogThreadRunnable,0,"Syslog") == 0) {
        // thread started successfully
        threadAddThreadStopFtn(&_syslogStopThread,0);
        return utTrue;
    } else {
        syslogRunThread = utFalse;
        return utFalse;
    }
    
}

#endif // defined(SYSLOG_THREAD)

/* start serial communication thread */
utBool logStartThread()
{
#if defined(SYSLOG_THREAD)
    return _syslogStartThread();
#else
    return utFalse;
#endif
}

// ----------------------------------------------------------------------------

/* logging initialization */
void logInitialize(const char *id)
{
    
    /* init syslog */
    if (!syslogInit) {
        syslogInit = utTrue;

        /* save name */
        strncpy(syslogName, ((id && *id)? id : "unknown"), sizeof(syslogName) - 1);
        syslogName[sizeof(syslogName) - 1] = 0;

        /* init log mutex */
        threadMutexInit(&syslogMutex);

        /* init syslog */
#if defined(INCLUDE_SYSLOG_SUPPORT)
        int syslogOptions = LOG_NDELAY;
        if (!id || !*id) { syslogOptions |= LOG_PID; }
        openlog(syslogName, syslogOptions, LOG_DAEMON);
#endif

    }
    
}

// ----------------------------------------------------------------------------