opentxs::OTLog Class Reference

#include <OTLog.hpp>

Static Public Member Functions
static EXPORT bool	Init (const OTString &strThreadContext="", const int32_t &nLogLevel=0)
static EXPORT bool	IsInitialized ()
static EXPORT bool	Cleanup ()
static EXPORT const char *	Version ()
static EXPORT const OTString &	GetVersion ()
static EXPORT const char *	PathSeparator ()
static EXPORT const OTString &	GetPathSeparator ()
static EXPORT const OTString &	GetThreadContext ()
static EXPORT const char *	LogFilePath ()
static EXPORT const OTString &	GetLogFilePath ()
static EXPORT int32_t	LogLevel ()
static EXPORT bool	SetLogLevel (const int32_t &nLogLevel)
static EXPORT bool	LogToFile (const OTString &strOutput)
static EXPORT int32_t	GetMemlogSize ()
static EXPORT OTString	GetMemlogAtIndex (int32_t nIndex)
static EXPORT OTString	PeekMemlogFront ()
static EXPORT OTString	PeekMemlogBack ()
static EXPORT bool	PopMemlogFront ()
static EXPORT bool	PopMemlogBack ()
static EXPORT bool	PushMemlogFront (const OTString &strLog)
static EXPORT bool	PushMemlogBack (const OTString &strLog)
static EXPORT bool	SleepSeconds (int64_t lSeconds)
static EXPORT bool	SleepMilliseconds (int64_t lMilliseconds)
static EXPORT void	Output (int32_t nVerbosity, const char *szOutput)
static EXPORT void	vOutput (int32_t nVerbosity, const char *szOutput,...)
static EXPORT void	Error (const char *szError)
static EXPORT void	vError (const char *szError,...)
static EXPORT void	Errno (const char *szLocation=nullptr)
static EXPORT bool	StringFill (OTString &out_strString, const char *szString, int32_t iLength, const char *szAppend=nullptr)
static EXPORT void	SetupSignalHandler ()

Detailed Description

Definition at line 196 of file OTLog.hpp.

Member Function Documentation

bool opentxs::OTLog::Cleanup ( )

static

Definition at line 377 of file OTLog.cpp.

{
    if (nullptr != pLogger) {
        delete pLogger;
        pLogger = nullptr;
        return true;
    }
    return false;
}

void opentxs::OTLog::Errno ( const char *  szLocation = nullptr )

static

defined(_GNU_SOURCE))

Definition at line 859 of file OTLog.cpp.

{
    bool bHaveLogger(false);
    if (nullptr != pLogger)
        if (pLogger->IsInitialized()) bHaveLogger = true;

    // lets check if we are Initialized in this context
    if (bHaveLogger) CheckLogger(OTLog::pLogger);

    const int32_t errnum = errno;
    char buf[128];
    buf[0] = '\0';

    int32_t nstrerr = 0;
    char* szErrString = nullptr;

//#if((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) &&

#if defined(_GNU_SOURCE) && defined(__linux__) && !defined(ANDROID)
    szErrString = strerror_r(errnum, buf, 127);
#elif(_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)
    nstrerr = strerror_r(errnum, buf,
                         127); // (strerror_r is threadsafe version of strerror)
#endif

    const char* szFunc = "OTLog::Errno";
    const char* sz_location = (nullptr == szLocation) ? "" : szLocation;

    if (nullptr == szErrString) szErrString = buf;

    if (0 == nstrerr)
        otErr << szFunc << " " << sz_location << ": errno " << errnum << ": "
              << (szErrString[0] != '\0' ? szErrString : "") << ".\n";
    else
        otErr << szFunc << " " << sz_location << ": errno: " << errnum
              << ". (Unable to retrieve error string for that number.)\n";
}

void opentxs::OTLog::Error ( const char *  szError )

static

Definition at line 831 of file OTLog.cpp.

{
    bool bHaveLogger(false);
    if (nullptr != pLogger)
        if (pLogger->IsInitialized()) bHaveLogger = true;

    // lets check if we are Initialized in this context
    if (bHaveLogger) CheckLogger(OTLog::pLogger);

    if ((nullptr == szError)) return;

    // We store the last 1024 logs so programmers can access them via the API.
    if (bHaveLogger) OTLog::PushMemlogFront(szError);

#ifndef ANDROID // if NOT android

    LogToFile(szError);

#else // if Android
    __android_log_write(ANDROID_LOG_ERROR, "OT Error", szError);
#endif
}

const OTString & opentxs::OTLog::GetLogFilePath ( )

static

Definition at line 428 of file OTLog.cpp.

{
    return pLogger->m_strLogFilePath;
}

OTString opentxs::OTLog::GetMemlogAtIndex ( int32_t  nIndex )

static

Definition at line 499 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    uint32_t uIndex = static_cast<uint32_t>(nIndex);

    if ((nIndex < 0) || (uIndex >= OTLog::pLogger->logDeque.size())) {
        otErr << __FUNCTION__ << ": index out of bounds: " << nIndex << "\n";
        return "";
    }

    if (nullptr != OTLog::pLogger->logDeque.at(uIndex))
        ; // check for null
    else
        OT_FAIL;

    const OTString strLogEntry = *OTLog::pLogger->logDeque.at(uIndex);

    if (strLogEntry.Exists())
        return strLogEntry;
    else
        return "";
}

int32_t opentxs::OTLog::GetMemlogSize ( )

static

Definition at line 526 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    return static_cast<int32_t>(OTLog::pLogger->logDeque.size());
}

const OTString & opentxs::OTLog::GetPathSeparator ( )

static

Definition at line 412 of file OTLog.cpp.

{
    return m_strPathSeparator;
}

const OTString & opentxs::OTLog::GetThreadContext ( )

static

Definition at line 419 of file OTLog.cpp.

{
    return pLogger->m_strThreadContext;
}

const OTString & opentxs::OTLog::GetVersion ( )

static

Definition at line 403 of file OTLog.cpp.

{
    return m_strVersion;
}

bool opentxs::OTLog::Init ( const OTString &  strThreadContext = "", const int32_t &  nLogLevel = 0  )

static

Definition at line 300 of file OTLog.cpp.

{
    if (nullptr == pLogger) {
        pLogger = new OTLog();
        pLogger->m_bInitialized = false;
    }

    if (strThreadContext.Compare(GLOBAL_LOGNAME)) return false;

    if (!pLogger->m_bInitialized) {
        pLogger->logDeque = std::deque<OTString*>();
        pLogger->m_strThreadContext = strThreadContext;

        pLogger->m_nLogLevel = nLogLevel;

        if (!strThreadContext.Exists() ||
            strThreadContext.Compare("")) // global
        {
            pLogger->m_strLogFileName = GLOBAL_LOGFILE;
        }
        else // not global
        {

            pLogger->m_strLogFileName.Format(
                "%s%s%s", LOGFILE_PRE, strThreadContext.Get(), LOGFILE_EXT);

            OTSettings config(OTPaths::GlobalConfigFile());

            config.Reset();
            if (!config.Load()) {
                return false;
            };

            bool bIsNew(false);
            if (!config.CheckSet_str("logfile", strThreadContext,
                                     pLogger->m_strLogFileName,
                                     pLogger->m_strLogFileName, bIsNew)) {
                return false;
            }

            if (!config.Save()) {
                return false;
            };
            config.Reset();
        }

#ifdef ANDROID
        if (OTPaths::HomeFolder().Exists())
#endif
            if (!OTPaths::AppendFile(pLogger->m_strLogFilePath,
                                     OTPaths::AppDataFolder(),
                                     pLogger->m_strLogFileName)) {
                return false;
            };

        pLogger->m_bInitialized = true;

        // Set the new log-assert function pointer.
        Assert* pLogAssert = new Assert(OTLog::logAssert);
        std::swap(pLogAssert, Assert::s_pAssert);
        delete pLogAssert;
        pLogAssert = nullptr;

        return true;
    }
    else {
        return false;
    }
}

bool opentxs::OTLog::IsInitialized ( )

static

Definition at line 371 of file OTLog.cpp.

{
    return nullptr != pLogger && pLogger->m_bInitialized;
}

const char * opentxs::OTLog::LogFilePath ( )

static

Definition at line 424 of file OTLog.cpp.

{
    return OTLog::GetLogFilePath().Get();
}

int32_t opentxs::OTLog::LogLevel ( )

static

Definition at line 434 of file OTLog.cpp.

{
    if (nullptr != pLogger)
        return pLogger->m_nLogLevel;
    else
        return 0;
}

bool opentxs::OTLog::LogToFile ( const OTString &  strOutput )

static

Definition at line 462 of file OTLog.cpp.

{
    // We now do this either way.
    {
        std::cerr << strOutput;
        std::cerr.flush();
    }

    // now log to file, if we can.

    bool bHaveLogger(false);
    if (nullptr != pLogger)
        if (pLogger->IsInitialized()) bHaveLogger = true;

    // lets check if we are Initialized in this context
    if (bHaveLogger) CheckLogger(OTLog::pLogger);

    bool bSuccess = false;

    if (bHaveLogger) {
        // Append to logfile
        if ((strOutput.Exists()) &&
            (OTLog::pLogger->m_strLogFilePath.Exists())) {
            std::ofstream logfile;
            logfile.open(OTLog::LogFilePath(), std::ios::app);

            if (!logfile.fail()) {
                logfile << strOutput;
                logfile.close();
                bSuccess = true;
            }
        }
    }

    return bSuccess;
}

void opentxs::OTLog::Output ( int32_t  nVerbosity, const char *  szOutput  )

static

Definition at line 710 of file OTLog.cpp.

{
    bool bHaveLogger(false);
    if (nullptr != pLogger)
        if (pLogger->IsInitialized()) bHaveLogger = true;

    // lets check if we are Initialized in this context
    if (bHaveLogger) CheckLogger(OTLog::pLogger);

    // If log level is 0, and verbosity of this message is 2, don't bother
    // logging it.
    //    if (nVerbosity > OTLog::__CurrentLogLevel || (nullptr == szOutput))
    if ((nVerbosity > LogLevel()) || (nullptr == szOutput) ||
        (LogLevel() == (-1)))
        return;

    // We store the last 1024 logs so programmers can access them via the API.
    if (bHaveLogger) OTLog::PushMemlogFront(szOutput);

#ifndef ANDROID // if NOT android

    LogToFile(szOutput);

#else // if IS Android
    /*
    typedef enum android_LogPriority {
    ANDROID_LOG_UNKNOWN = 0,
    ANDROID_LOG_DEFAULT,    // only for SetMinPriority()
    ANDROID_LOG_VERBOSE,
    ANDROID_LOG_DEBUG,
    ANDROID_LOG_INFO,
    ANDROID_LOG_WARN,
    ANDROID_LOG_ERROR,
    ANDROID_LOG_FATAL,
    ANDROID_LOG_SILENT,     // only for SetMinPriority(); must be last
    } android_LogPriority;
    */
    switch (nVerbosity) {
    case 0:
    case 1:
        __android_log_write(ANDROID_LOG_INFO, "OT Output", szOutput);
        break;
    case 2:
    case 3:
        __android_log_write(ANDROID_LOG_DEBUG, "OT Debug", szOutput);
        break;
    case 4:
    case 5:
        __android_log_write(ANDROID_LOG_VERBOSE, "OT Verbose", szOutput);
        break;
    default:
        __android_log_write(ANDROID_LOG_UNKNOWN, "OT Unknown", szOutput);
        break;
    }
#endif
}

const char * opentxs::OTLog::PathSeparator ( )

static

Definition at line 408 of file OTLog.cpp.

{
    return OTLog::GetPathSeparator().Get();
}

OTString opentxs::OTLog::PeekMemlogBack ( )

static

Definition at line 554 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    if (OTLog::pLogger->logDeque.size() <= 0) return nullptr;

    if (nullptr != OTLog::pLogger->logDeque.back())
        ; // check for null
    else
        OT_FAIL;

    const OTString strLogEntry = *OTLog::pLogger->logDeque.back();

    if (strLogEntry.Exists())
        return strLogEntry;
    else
        return "";
}

OTString opentxs::OTLog::PeekMemlogFront ( )

static

Definition at line 534 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    if (OTLog::pLogger->logDeque.size() <= 0) return nullptr;

    if (nullptr != OTLog::pLogger->logDeque.front())
        ; // check for null
    else
        OT_FAIL;

    const OTString strLogEntry = *OTLog::pLogger->logDeque.front();

    if (strLogEntry.Exists())
        return strLogEntry;
    else
        return "";
}

bool opentxs::OTLog::PopMemlogBack ( )

static

Definition at line 592 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    if (OTLog::pLogger->logDeque.size() <= 0) return false;

    OTString* strLogBack = OTLog::pLogger->logDeque.back();
    if (nullptr != strLogBack) delete strLogBack;
    strLogBack = nullptr;

    OTLog::pLogger->logDeque.pop_back();

    return true;
}

bool opentxs::OTLog::PopMemlogFront ( )

static

Definition at line 575 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    if (OTLog::pLogger->logDeque.size() <= 0) return false;

    OTString* strLogFront = OTLog::pLogger->logDeque.front();
    if (nullptr != strLogFront) delete strLogFront;
    strLogFront = nullptr;

    OTLog::pLogger->logDeque.pop_front();

    return true;
}

bool opentxs::OTLog::PushMemlogBack ( const OTString &  strLog )

static

Definition at line 627 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    OT_ASSERT(strLog.Exists());

    OTLog::pLogger->logDeque.push_back(new OTString(strLog));

    return true;
}

bool opentxs::OTLog::PushMemlogFront ( const OTString &  strLog )

static

Definition at line 609 of file OTLog.cpp.

{
    // lets check if we are Initialized in this context
    CheckLogger(OTLog::pLogger);

    OT_ASSERT(strLog.Exists());

    OTLog::pLogger->logDeque.push_front(new OTString(strLog));

    if (OTLog::pLogger->logDeque.size() > LOG_DEQUE_SIZE) {
        OTLog::PopMemlogBack(); // We start removing from the back when it
                                // reaches this size.
    }

    return true;
}

bool opentxs::OTLog::SetLogLevel ( const int32_t &  nLogLevel )

static

Definition at line 443 of file OTLog.cpp.

{
    if (nullptr == pLogger) {
        OT_FAIL;
    }
    else {
        pLogger->m_nLogLevel = nLogLevel;
        return true;
    }
}

void opentxs::OTLog::SetupSignalHandler ( )

static

Definition at line 1315 of file OTLog.cpp.

{
    static int32_t nCount = 0;

    if (0 == nCount) {
        ++nCount;

        OT_HANDLE_SIGNAL(SIGINT)  // Ctrl-C. (So we can shutdown gracefully, I
                                  // suppose, on Ctrl-C.)
        OT_HANDLE_SIGNAL(SIGSEGV) // Segmentation fault.
                                  //      OT_HANDLE_SIGNAL(SIGABRT) // Abort.
        OT_HANDLE_SIGNAL(SIGBUS)  // Bus error
        //      OT_HANDLE_SIGNAL(SIGHUP)  // I believe this is for sending a
        // "restart" signal to your process, that sort of thing.
        OT_HANDLE_SIGNAL(SIGTERM) // Used by kill pid (NOT kill -9 pid). Used
                                  // for "killing softly."
        OT_HANDLE_SIGNAL(SIGILL)  // Illegal instruction.
        OT_HANDLE_SIGNAL(SIGTTIN) // SIGTTIN may be sent to a background process
                                  // that attempts to read from its controlling
                                  // terminal.
        OT_HANDLE_SIGNAL(SIGTTOU) // SIGTTOU may be sent to a background process
                                  // that attempts to write to its controlling
                                  // terminal.
        //      OT_HANDLE_SIGNAL(SIGPIPE) // Unix supports the principle of
        // piping. When a pipe is broken, the process writing to it is sent the
        // SIGPIPE.
        //      OT_HANDLE_SIGNAL(SIGKILL) // kill -9. "The receiving process
        // cannot perform any clean-up upon receiving this signal."
        OT_HANDLE_SIGNAL(SIGFPE)  // Floating point exception.
        OT_HANDLE_SIGNAL(SIGXFSZ) // SIGXFSZ is the signal sent to a process
                                  // when it grows a file larger than the
                                  // maximum allowed size.
        //      OT_HANDLE_SIGNAL(SIGQUIT) // SIGQUIT is the signal sent to a
        // process by its controlling terminal when the user requests that the
        // process perform a core dump.
        OT_HANDLE_SIGNAL(SIGSYS) // sent when a process supplies an incorrect
                                 // argument to a system call.
        //      OT_HANDLE_SIGNAL(SIGTRAP) // used by debuggers
    }
}

bool opentxs::OTLog::SleepMilliseconds ( int64_t  lMilliseconds )

static

Definition at line 651 of file OTLog.cpp.

{
#ifdef _WIN32
    Sleep(static_cast<DWORD>(lMilliseconds));
#else
    usleep(lMilliseconds * 1000);
#endif
    return true;
}

bool opentxs::OTLog::SleepSeconds ( int64_t  lSeconds )

static

Definition at line 640 of file OTLog.cpp.

{
#ifdef _WIN32
    Sleep(static_cast<DWORD>(1000 * lSeconds));
#else
    sleep(lSeconds);
#endif
    return true;
}

bool opentxs::OTLog::StringFill ( OTString &  out_strString, const char *  szString, int32_t  iLength, const char *  szAppend = nullptr  )

static

Definition at line 900 of file OTLog.cpp.

{
    std::string strString(szString);

    if (nullptr != szAppend) strString.append(szAppend);

    for (; (static_cast<int32_t>(strString.length()) < iLength);
         strString.append(" "))
        ;

    out_strString.Set(strString.c_str());

    return true;
}

void opentxs::OTLog::vError ( const char *  szError,   ...  )

static

Definition at line 800 of file OTLog.cpp.

{
    bool bHaveLogger(false);
    if (nullptr != pLogger)
        if (pLogger->IsInitialized()) bHaveLogger = true;

    // lets check if we are Initialized in this context
    if (bHaveLogger) CheckLogger(OTLog::pLogger);

    if ((nullptr == szError)) return;

    va_list args;
    va_start(args, szError);

    std::string strOutput;

    const bool bFormatted = OTString::vformat(szError, &args, strOutput);

    va_end(args);

    if (bFormatted)
        OTLog::Error(strOutput.c_str());
    else
        OT_FAIL;
}

const char * opentxs::OTLog::Version ( )

static

Definition at line 399 of file OTLog.cpp.

{
    return OTLog::GetVersion().Get();
}

void opentxs::OTLog::vOutput ( int32_t  nVerbosity, const char *  szOutput,   ...  )

static

Definition at line 768 of file OTLog.cpp.

{
    bool bHaveLogger(false);
    if (nullptr != pLogger)
        if (pLogger->IsInitialized()) bHaveLogger = true;

    // lets check if we are Initialized in this context
    if (bHaveLogger) CheckLogger(OTLog::pLogger);

    // If log level is 0, and verbosity of this message is 2, don't bother
    // logging it.
    if (((0 != LogLevel()) && (nVerbosity > LogLevel())) ||
        (nullptr == szOutput))
        return;

    va_list args;
    va_start(args, szOutput);

    std::string strOutput;

    const bool bFormatted = OTString::vformat(szOutput, &args, strOutput);

    va_end(args);

    if (bFormatted)
        OTLog::Output(nVerbosity, strOutput.c_str());
    else
        OT_FAIL;
    return;
}

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/core/OTLog.hpp
• /usr/local/src/opentxs/src/core/OTLog.cpp