ncbidiag.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: ncbidiag.cpp 102765 2024-07-09 13:08:37Z grichenk $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Denis Vakatov et al.
 *
 * File Description:
 *   NCBI C++ diagnostic API
 *
 */
 
 
#include <ncbi_pch.hpp>
#include <common/ncbi_source_ver.h>
#include <common/ncbi_package_ver.h>
#include <common/ncbi_sanitizers.h>
#include <corelib/ncbiexpt.hpp>
#include <corelib/version.hpp>
#include <corelib/ncbi_process.hpp>
#include <corelib/ncbifile.hpp>
#include <corelib/syslog.hpp>
#include <corelib/error_codes.hpp>
#include <corelib/request_ctx.hpp>
#include <corelib/request_control.hpp>
#include <corelib/ncbi_strings.h>
#include <corelib/impl/ncbi_param_impl.hpp>
#include <corelib/ncbiapp_api.hpp>
#include "ncbidiag_p.hpp"
#include "ncbisys.hpp"
#include <fcntl.h>
#include <stdlib.h>
#include <stack>
#include <atomic>
#include <thread>
#include <unordered_set>
#include <sstream>
 
#if defined(NCBI_OS_UNIX)
#  include <unistd.h>
#  include <sys/utsname.h>
#endif
 
#if defined(NCBI_OS_MSWIN)
#  include <io.h>
#elif defined (NCBI_OS_DARWIN)
#  include <crt_externs.h>
#  define environ (*_NSGetEnviron())
#else
extern char** environ;
#endif
 
 
#define NCBI_USE_ERRCODE_X   Corelib_Diag
 
 
BEGIN_NCBI_SCOPE
 
static bool s_DiagUseRWLock = true;
DEFINE_STATIC_MUTEX(s_DiagMutex);
DEFINE_STATIC_MUTEX(s_DiagPostMutex);
static CSafeStatic<CRWLock> s_DiagRWLock(CSafeStaticLifeSpan(CSafeStaticLifeSpan::eLifeSpan_Long, 1));
static CSafeStatic<CAtomicCounter_WithAutoInit> s_ReopenEntered;
 
DEFINE_STATIC_MUTEX(s_ApproveMutex);
 
 
void g_Diag_Use_RWLock(bool enable)
{
    if (s_DiagUseRWLock == enable) return; // already switched
    // Try to detect at least some dangerous situations.
    // This does not guarantee safety since some thread may
    // be waiting for lock while we switch to the new method.
    if ( enable ) {
        bool diag_unlocked = s_DiagMutex.TryLock();
        // Mutex is locked - fail
        _ASSERT(diag_unlocked);
        if (!diag_unlocked) {
            _TROUBLE;
            NCBI_THROW(CCoreException, eCore,
                       "Cannot switch diagnostic to RW-lock - mutex is locked.");
        }
        s_DiagMutex.Unlock();
    }
    else {
        // Switch from RW-lock to mutex
        bool diag_unlocked = s_DiagRWLock->TryWriteLock();
        // RW-lock is locked - fail
        _ASSERT(diag_unlocked);
        if (!diag_unlocked) {
            _TROUBLE;
            NCBI_THROW(CCoreException, eCore,
                       "Cannot switch diagnostic to mutex - RW-lock is locked.");
        }
        s_DiagRWLock->Unlock();
    }
    s_DiagUseRWLock = enable;
}
 
 
class CDiagLock
{
public:
    enum ELockType {
        eRead,   // read lock
        eWrite,  // write lock (modifying flags etc.)
        ePost    // lock used by diag handlers to lock stream in Post()
    };
 
    CDiagLock(ELockType locktype)
        : m_UsedRWLock(false), m_LockType(locktype)
    {
        if (s_DiagUseRWLock) {
            if (m_LockType == eRead) {
                m_UsedRWLock = true;
                s_DiagRWLock->ReadLock();
                return;
            }
            if (m_LockType == eWrite) {
                m_UsedRWLock = true;
                s_DiagRWLock->WriteLock();
                return;
            }
            // For ePost use normal mutex below.
        }
        if (m_LockType == ePost) {
            s_DiagPostMutex.Lock();
        }
        else {
            s_DiagMutex.Lock();
        }
    }
 
    ~CDiagLock(void)
    {
        if (m_UsedRWLock) {
            s_DiagRWLock->Unlock();
        }
        else {
            if (m_LockType == ePost) {
                s_DiagPostMutex.Unlock();
            }
            else {
                s_DiagMutex.Unlock();
            }
        }
    }
 
private:
    bool      m_UsedRWLock;
    ELockType m_LockType;
};
 
 
static const char* kLogName_None     = "NONE";
static const char* kLogName_Unknown  = "UNKNOWN";
static const char* kLogName_Stdout   = "STDOUT";
static const char* kLogName_Stderr   = "STDERR";
static const char* kLogName_Stream   = "STREAM";
static const char* kLogName_Memory   = "MEMORY";
static const char* kLogName_Tee      = "STDERR-TEE";
 
 
class CDiagFileHandleHolder : public CObject
{
public:
    CDiagFileHandleHolder(const string& fname, CDiagHandler::TReopenFlags flags);
    virtual ~CDiagFileHandleHolder(void);
 
    int GetHandle(void) { return m_Handle; }
 
private:
    int m_Handle;
};
 
 
// Special diag handler for duplicating error log messages on stderr.
class CTeeDiagHandler : public CDiagHandler
{
public:
    CTeeDiagHandler(CDiagHandler* orig, bool own_orig);
    virtual void Post(const SDiagMessage& mess);
 
    virtual void PostToConsole(const SDiagMessage& mess)
    {
        // Console manipulator ignores severity, so we have to always print
        // the message to console and set NoTee flag to avoid duplicates.
        CDiagHandler::PostToConsole(mess);
        const_cast<SDiagMessage&>(mess).m_NoTee = true;
    }
 
    virtual string GetLogName(void)
    {
        return m_OrigHandler.get() ?
            m_OrigHandler->GetLogName() : kLogName_Tee;
    }
    virtual void Reopen(TReopenFlags flags)
    {
        if ( m_OrigHandler.get() ) {
            m_OrigHandler->Reopen(flags);
        }
    }
 
    CDiagHandler* GetOriginalHandler(void) const
    {
        return m_OrigHandler.get();
    }
 
private:
    EDiagSev              m_MinSev;
    AutoPtr<CDiagHandler> m_OrigHandler;
};
 
 
#if defined(NCBI_POSIX_THREADS) && defined(HAVE_PTHREAD_ATFORK)
 
#include <unistd.h> // for pthread_atfork()
 
extern "C" {
    static void s_NcbiDiagPreFork(void)
    {
        s_DiagMutex.Lock();
    }
    static void s_NcbiDiagPostFork(void)
    {
        s_DiagMutex.Unlock();
    }
}
 
#endif
 
 
///////////////////////////////////////////////////////
//  Output format parameters
 
// Use old output format if the flag is set
NCBI_PARAM_DECL(bool, Diag, Old_Post_Format);
NCBI_PARAM_DEF_EX(bool, Diag, Old_Post_Format, true, eParam_NoThread,
                  DIAG_OLD_POST_FORMAT);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, Old_Post_Format)> s_OldPostFormat(
    CSafeStaticLifeSpan(CSafeStaticLifeSpan::eLifeSpan_Long, 2));
 
// Auto-print context properties on set/change.
NCBI_PARAM_DECL(bool, Diag, AutoWrite_Context);
NCBI_PARAM_DEF_EX(bool, Diag, AutoWrite_Context, false, eParam_NoThread,
                  DIAG_AUTOWRITE_CONTEXT);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, AutoWrite_Context)> s_AutoWrite_Context;
 
// Print system TID rather than CThread::GetSelf()
NCBI_PARAM_DECL(bool, Diag, Print_System_TID);
NCBI_PARAM_DEF_EX(bool, Diag, Print_System_TID, false, eParam_NoThread,
                  DIAG_PRINT_SYSTEM_TID);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, Print_System_TID)> s_PrintSystemTID;
 
// Use assert() instead of abort() when printing fatal errors
// to show the assertion dialog and allow to choose the action
// (stop/debug/continue).
NCBI_PARAM_DECL(bool, Diag, Assert_On_Abort);
NCBI_PARAM_DEF_EX(bool, Diag, Assert_On_Abort, false, eParam_NoThread,
                  DIAG_ASSERT_ON_ABORT);
 
// Limit log file size, rotate log when it reaches the limit.
NCBI_PARAM_DECL(long, Diag, Log_Size_Limit);
NCBI_PARAM_DEF_EX(long, Diag, Log_Size_Limit, 0, eParam_NoThread,
                  DIAG_LOG_SIZE_LIMIT);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, Log_Size_Limit)> s_LogSizeLimit;
 
// Limit max line length, zero = no limit (default).
NCBI_PARAM_DECL(size_t, Diag, Max_Line_Length);
NCBI_PARAM_DEF_EX(size_t, Diag, Max_Line_Length, 0, eParam_NoThread,
    DIAG_MAX_LINE_LENGTH);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, Max_Line_Length)> s_MaxLineLength;
 
 
///////////////////////////////////////////////////////
//  Output rate control parameters
 
class CLogRateLimit
{
public:
    typedef unsigned int TValue;
    CLogRateLimit(void) : m_Value(kMax_UInt) {}
    CLogRateLimit(TValue val) : m_Value(val) {}
 
    operator TValue(void) const
    {
        return m_Value;
    }
 
    void Set(TValue val)
    {
        m_Value = val;
    }
 
private:
    TValue m_Value;
};
 
 
CNcbiIstream& operator>>(CNcbiIstream& in, CLogRateLimit& lim)
{
    lim.Set(kMax_UInt);
    string s;
    getline(in, s);
    if ( !NStr::EqualNocase(s, "off") ) {
        lim.Set(NStr::StringToNumeric<CLogRateLimit::TValue>(s));
    }
    return in;
}
 
 
// Need CSafeStatic_Proxy<> instance for CLogRateLimit to allow static
// initialization of default values with unsigned int.
NCBI_PARAM_STATIC_PROXY(CLogRateLimit, CLogRateLimit::TValue);
 
 
// AppLog limit per period
NCBI_PARAM_DECL(CLogRateLimit, Diag, AppLog_Rate_Limit);
NCBI_PARAM_DEF_EX(CLogRateLimit, Diag, AppLog_Rate_Limit, 50000,
                  eParam_NoThread, DIAG_APPLOG_RATE_LIMIT);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, AppLog_Rate_Limit)> s_AppLogRateLimit;
 
// AppLog period, sec
NCBI_PARAM_DECL(unsigned int, Diag, AppLog_Rate_Period);
NCBI_PARAM_DEF_EX(unsigned int, Diag, AppLog_Rate_Period, 10, eParam_NoThread,
                  DIAG_APPLOG_RATE_PERIOD);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, AppLog_Rate_Period)> s_AppLogRatePeriod;
 
// ErrLog limit per period
NCBI_PARAM_DECL(CLogRateLimit, Diag, ErrLog_Rate_Limit);
NCBI_PARAM_DEF_EX(CLogRateLimit, Diag, ErrLog_Rate_Limit, 5000,
                  eParam_NoThread, DIAG_ERRLOG_RATE_LIMIT);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, ErrLog_Rate_Limit)> s_ErrLogRateLimit;
 
// ErrLog period, sec
NCBI_PARAM_DECL(unsigned int, Diag, ErrLog_Rate_Period);
NCBI_PARAM_DEF_EX(unsigned int, Diag, ErrLog_Rate_Period, 1, eParam_NoThread,
                  DIAG_ERRLOG_RATE_PERIOD);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, ErrLog_Rate_Period)> s_ErrLogRatePeriod;
 
// TraceLog limit per period
NCBI_PARAM_DECL(CLogRateLimit, Diag, TraceLog_Rate_Limit);
NCBI_PARAM_DEF_EX(CLogRateLimit, Diag, TraceLog_Rate_Limit, 5000,
                  eParam_NoThread, DIAG_TRACELOG_RATE_LIMIT);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, TraceLog_Rate_Limit)> s_TraceLogRateLimit;
 
// TraceLog period, sec
NCBI_PARAM_DECL(unsigned int, Diag, TraceLog_Rate_Period);
NCBI_PARAM_DEF_EX(unsigned int, Diag, TraceLog_Rate_Period, 1, eParam_NoThread,
                  DIAG_TRACELOG_RATE_PERIOD);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, TraceLog_Rate_Period)> s_TraceLogRatePeriod;
 
// Duplicate messages to STDERR
NCBI_PARAM_DECL(bool, Diag, Tee_To_Stderr);
NCBI_PARAM_DEF_EX(bool, Diag, Tee_To_Stderr, false, eParam_NoThread,
                  DIAG_TEE_TO_STDERR);
typedef NCBI_PARAM_TYPE(Diag, Tee_To_Stderr) TTeeToStderr;
 
// Minimum severity of the messages duplicated to STDERR
NCBI_PARAM_ENUM_DECL(EDiagSev, Diag, Tee_Min_Severity);
NCBI_PARAM_ENUM_ARRAY(EDiagSev, Diag, Tee_Min_Severity)
{
    {"Info", eDiag_Info},
    {"Warning", eDiag_Warning},
    {"Error", eDiag_Error},
    {"Critical", eDiag_Critical},
    {"Fatal", eDiag_Fatal},
    {"Trace", eDiag_Trace}
};
 
const EDiagSev kTeeMinSeverityDef =
#if defined(NDEBUG)
    eDiag_Error;
#else
    eDiag_Warning;
#endif
 
NCBI_PARAM_ENUM_DEF_EX(EDiagSev, Diag, Tee_Min_Severity,
                       kTeeMinSeverityDef,
                       eParam_NoThread, DIAG_TEE_MIN_SEVERITY);
 
 
NCBI_PARAM_DECL(size_t, Diag, Collect_Limit);
NCBI_PARAM_DEF_EX(size_t, Diag, Collect_Limit, 1000, eParam_NoThread,
                  DIAG_COLLECT_LIMIT);
 
 
NCBI_PARAM_DECL(bool, Log, Truncate);
NCBI_PARAM_DEF_EX(bool, Log, Truncate, false, eParam_NoThread, LOG_TRUNCATE);
 
 
NCBI_PARAM_DECL(bool, Log, NoCreate);
NCBI_PARAM_DEF_EX(bool, Log, NoCreate, false, eParam_NoThread, LOG_NOCREATE);
 
 
// Logging of environment variables: space separated list of names which
// should be logged after app start and after each request start.
NCBI_PARAM_DECL(string, Log, LogEnvironment);
NCBI_PARAM_DEF_EX(string, Log, LogEnvironment, "",
                  eParam_NoThread,
                  DIAG_LOG_ENVIRONMENT);
 
 
// Logging of registry values: space separated list of 'section:name' strings.
NCBI_PARAM_DECL(string, Log, LogRegistry);
NCBI_PARAM_DEF_EX(string, Log, LogRegistry, "",
                  eParam_NoThread,
                  DIAG_LOG_REGISTRY);
 
 
// Turn off all applog messages (start/stop, request start/stop, extra).
NCBI_PARAM_DECL(bool, Diag, Disable_AppLog_Messages);
NCBI_PARAM_DEF_EX(bool, Diag, Disable_AppLog_Messages, false, eParam_NoThread,
    DIAG_DISABLE_APPLOG_MESSAGES);
static CSafeStatic<NCBI_PARAM_TYPE(Diag, Disable_AppLog_Messages)> s_DisableAppLog;
 
 
static bool s_FinishedSetupDiag = false;
 
 
///////////////////////////////////////////////////////
//  CDiagContextThreadData::
 
 
/// Thread local context data stored in TLS
class CDiagContextThreadData
{
public:
    CDiagContextThreadData(void);
    ~CDiagContextThreadData(void);
 
    /// Get current request context.
    CRequestContext& GetRequestContext(void);
    /// Set request context. If NULL, switches the current thread
    /// to its default request context.
    void SetRequestContext(CRequestContext* ctx);
 
    typedef SDiagMessage::TCount TCount;
 
    /// Request id
    NCBI_DEPRECATED TCount GetRequestId(void);
    NCBI_DEPRECATED void SetRequestId(TCount id);
    NCBI_DEPRECATED void IncRequestId(void);
 
    /// Get request timer, create if not exist yet
    NCBI_DEPRECATED CStopWatch* GetOrCreateStopWatch(void) { return NULL; }
    /// Get request timer or null
    NCBI_DEPRECATED CStopWatch* GetStopWatch(void) { return NULL; }
    /// Delete request timer
    NCBI_DEPRECATED void ResetStopWatch(void) {}
 
    /// Diag buffer
    CDiagBuffer& GetDiagBuffer(void) { return *m_DiagBuffer; }
 
    /// Get diag context data for the current thread
    static CDiagContextThreadData& GetThreadData(void);
 
    /// Thread ID
    typedef Uint8 TTID;
 
    /// Get cached thread ID
    TTID GetTID(void) const { return m_TID; }
 
    /// Get thread post number
    TCount GetThreadPostNumber(EPostNumberIncrement inc);
 
    void AddCollectGuard(CDiagCollectGuard* guard);
    void RemoveCollectGuard(CDiagCollectGuard* guard);
    CDiagCollectGuard* GetCollectGuard(void);
 
    void CollectDiagMessage(const SDiagMessage& mess);
 
private:
    CDiagContextThreadData(const CDiagContextThreadData&);
    CDiagContextThreadData& operator=(const CDiagContextThreadData&);
 
    // Guards override the global post level and define severity
    // for collecting messages.
    typedef list<CDiagCollectGuard*> TCollectGuards;
 
    // Collected diag messages
    typedef list<SDiagMessage>       TDiagCollection;
 
    unique_ptr<CDiagBuffer> m_DiagBuffer;       // Thread's diag buffer
    TTID                  m_TID;              // Cached thread ID
    TCount                m_ThreadPostNumber; // Number of posted messages
    TCollectGuards        m_CollectGuards;
    TDiagCollection       m_DiagCollection;
    size_t                m_DiagCollectionSize; // cached size of m_DiagCollection
    CRef<CRequestContext> m_RequestCtx;        // Request context
    CRef<CRequestContext> m_DefaultRequestCtx; // Default request context
};
 
 
CDiagCollectGuard::CDiagCollectGuard(void)
{
    // the severities will be adjusted by x_Init()
    x_Init(eDiag_Critical, eDiag_Fatal, eDiscard);
}
 
 
CDiagCollectGuard::CDiagCollectGuard(EDiagSev print_severity)
{
    // the severities will be adjusted by x_Init()
    x_Init(eDiag_Critical, print_severity, eDiscard);
}
 
 
CDiagCollectGuard::CDiagCollectGuard(EDiagSev print_severity,
                                     EDiagSev collect_severity,
                                     EAction  action)
{
    // the severities will be adjusted by x_Init()
    x_Init(print_severity, collect_severity, action);
}
 
 
void CDiagCollectGuard::x_Init(EDiagSev print_severity,
                               EDiagSev collect_severity,
                               EAction  action)
{
    // Get current print severity
    EDiagSev psev, csev;
    CDiagContextThreadData& thr_data =
        CDiagContextThreadData::GetThreadData();
    if ( thr_data.GetCollectGuard() ) {
        psev = thr_data.GetCollectGuard()->GetPrintSeverity();
        csev = thr_data.GetCollectGuard()->GetCollectSeverity();
    }
    else {
        psev = CDiagBuffer::sm_PostSeverity;
        csev = psev;
    }
    psev = CompareDiagPostLevel(psev, print_severity) > 0
        ? psev : print_severity;
    csev = CompareDiagPostLevel(csev, collect_severity) < 0
        ? csev : collect_severity;
 
    m_StartingPoint
        = CDiagContext::GetThreadPostNumber(ePostNumber_NoIncrement);
    m_PrintSev = psev;
    m_CollectSev = csev;
    m_SeverityCap = csev;
    m_Action = action;
    thr_data.AddCollectGuard(this);
}
 
 
CDiagCollectGuard::~CDiagCollectGuard(void)
{
    Release();
}
 
 
void CDiagCollectGuard::Release(void)
{
    CDiagContextThreadData& thr_data = CDiagContextThreadData::GetThreadData();
    thr_data.RemoveCollectGuard(this);
}
 
 
void CDiagCollectGuard::Release(EAction action)
{
    SetAction(action);
    Release();
}
 
 
void CDiagCollectGuard::SetPrintSeverity(EDiagSev sev)
{
    if ( CompareDiagPostLevel(m_PrintSev, sev) < 0 ) {
        m_PrintSev = sev;
    }
}
 
 
void CDiagCollectGuard::SetCollectSeverity(EDiagSev sev)
{
    if ( CompareDiagPostLevel(m_CollectSev, sev) < 0 ) {
        m_CollectSev = sev;
    }
}
 
 
///////////////////////////////////////////////////////
//  Static variables for Trace and Post filters
 
static CSafeStatic<CDiagFilter> s_TraceFilter;
static CSafeStatic<CDiagFilter> s_PostFilter;
 
 
// Analogue to strstr.
// Returns a pointer to the last occurrence of a search string in a string
const char* 
str_rev_str(const char* begin_str, const char* end_str, const char* str_search)
{
    if (begin_str == NULL)
        return NULL;
    if (end_str == NULL)
        return NULL;
    if (str_search == NULL)
        return NULL;
 
    const char* search_char = str_search + strlen(str_search);
    const char* cur_char = end_str;
 
    do {
        --search_char;
        do {
            --cur_char;
        } while(*cur_char != *search_char && cur_char != begin_str);
        if (*cur_char != *search_char)
            return NULL; 
    }
    while (search_char != str_search);
    
    return cur_char;
}
 
 
 
/////////////////////////////////////////////////////////////////////////////
/// CDiagCompileInfo::
 
CDiagCompileInfo::CDiagCompileInfo(void)
    : m_File(""),
      m_Module(""),
      m_Line(0),
      m_CurrFunctName(0),
      m_Parsed(false),
      m_ClassSet(false)
{
}
 
CDiagCompileInfo::CDiagCompileInfo(const char* file, 
                                   int         line, 
                                   const char* curr_funct, 
                                   const char* module)
    : m_File(file),
      m_Module(""),
      m_Line(line),
      m_CurrFunctName(curr_funct),
      m_Parsed(false),
      m_ClassSet(false)
{
    if (!file) {
        m_File = "";
        return;
    }
    if (!module)
        return;
    if ( 0 != strcmp(module, "NCBI_MODULE") && x_NeedModule() ) {
        m_Module = module;
    }
}
 
 
CDiagCompileInfo::CDiagCompileInfo(const string& file,
                                   int           line,
                                   const string& curr_funct,
                                   const string& module)
    : m_File(""),
      m_Module(""),
      m_Line(line),
      m_CurrFunctName(""),
      m_Parsed(false),
      m_ClassSet(false)
{
    SetFile(file);
    if ( m_File  &&  !module.empty()  &&  x_NeedModule() ) {
        SetModule(module);
    }
    SetFunction(curr_funct);
}
 
 
bool CDiagCompileInfo::x_NeedModule(void) const
{
    // Check for a file extension without creating of temporary string objects
    const char* cur_extension = strrchr(m_File, '.');
    if (cur_extension == NULL)
        return false; 
 
    if (*(cur_extension + 1) != '\0') {
        ++cur_extension;
    } else {
        return false;
    }
 
    return strcmp(cur_extension, "cpp") == 0 ||
        strcmp(cur_extension, "C") == 0 ||
        strcmp(cur_extension, "c") == 0 ||
        strcmp(cur_extension, "cxx") == 0;
}
 
 
CDiagCompileInfo::~CDiagCompileInfo(void)
{
}
 
 
void CDiagCompileInfo::SetFile(const string& file)
{
    m_StrFile = file;
    m_File = m_StrFile.c_str();
}
 
 
void CDiagCompileInfo::SetModule(const string& module)
{
    m_StrModule = module;
    m_Module = m_StrModule.c_str();
}
 
 
void CDiagCompileInfo::SetLine(int line)
{
    m_Line = line;
}
 
 
void CDiagCompileInfo::SetFunction(const string& func)
{
    m_Parsed = false;
    m_StrCurrFunctName = func;
    if (m_StrCurrFunctName.find(')') == NPOS) {
        m_StrCurrFunctName += "()";
    }
    m_CurrFunctName = m_StrCurrFunctName.c_str();
    m_FunctName.clear();
    if ( !m_ClassSet ) {
        m_ClassName.clear();
    }
}
 
 
void CDiagCompileInfo::SetClass(const string& cls)
{
    m_ClassName = cls;
    m_ClassSet = true;
}
 
 
// Skip matching l/r separators, return the last char before them
// or null if the separators are unbalanced.
const char* find_match(char        lsep,
                       char        rsep,
                       const char* start,
                       const char* stop)
{
    if (*(stop - 1) != rsep) return stop;
    int balance = 1;
    const char* pos = stop - 2;
    for (; pos > start; pos--) {
        if (*pos == rsep) {
            balance++;
        }
        else if (*pos == lsep) {
            if (--balance == 0) break;
        }
    }
    return (pos <= start) ? NULL : pos;
}
 
 
void
CDiagCompileInfo::ParseCurrFunctName(void) const
{
    m_Parsed = true;
    if (!m_CurrFunctName  ||  !(*m_CurrFunctName)) {
        return;
    }
    // Parse curr_funct
 
    // Skip function arguments
    size_t len = strlen(m_CurrFunctName);
    const char* end_str = find_match('(', ')',
                                     m_CurrFunctName,
                                     m_CurrFunctName + len);
    if (end_str == m_CurrFunctName + len) {
        // Missing '('
        return;
    }
    if ( end_str ) {
        // Skip template arguments
        end_str = find_match('<', '>', m_CurrFunctName, end_str);
    }
    if ( !end_str ) {
        return;
    }
    // Get a function/method name
    const char* start_str = NULL;
 
    // Get a function start position.
    const char* start_str_tmp =
        str_rev_str(m_CurrFunctName, end_str, "::");
    bool has_class = start_str_tmp != NULL;
    if (start_str_tmp != NULL) {
        start_str = start_str_tmp + 2;
    } else {
        start_str_tmp = str_rev_str(m_CurrFunctName, end_str, " ");
        if (start_str_tmp != NULL) {
            start_str = start_str_tmp + 1;
        } 
    }
 
    const char* cur_funct_name =
        (start_str == NULL ? m_CurrFunctName : start_str);
    while (cur_funct_name  &&  *cur_funct_name  &&
        (*cur_funct_name == '*'  ||  *cur_funct_name == '&')) {
        ++cur_funct_name;
    }
    size_t cur_funct_name_len = end_str - cur_funct_name;
    m_FunctName = string(cur_funct_name, cur_funct_name_len);
 
    // Get a class name
    if (has_class  &&  !m_ClassSet) {
        end_str = find_match('<', '>', m_CurrFunctName, start_str - 2);
        start_str = str_rev_str(m_CurrFunctName, end_str, " ");
        const char* cur_class_name =
            (start_str == NULL ? m_CurrFunctName : start_str + 1);
        while (cur_class_name  &&  *cur_class_name  &&
            (*cur_class_name == '*'  ||  *cur_class_name == '&')) {
            ++cur_class_name;
        }
        size_t cur_class_name_len = end_str - cur_class_name;
        m_ClassName = string(cur_class_name, cur_class_name_len);
    }
}
 
 
 
///////////////////////////////////////////////////////
//  CDiagRecycler::
 
class CDiagRecycler {
public:
    CDiagRecycler(void)
    {
#if defined(NCBI_POSIX_THREADS) && defined(HAVE_PTHREAD_ATFORK)
        pthread_atfork(s_NcbiDiagPreFork,   // before
                       s_NcbiDiagPostFork,  // after in parent
                       s_NcbiDiagPostFork); // after in child
#endif
    }
    ~CDiagRecycler(void)
    {
        SetDiagHandler(0, false);
        SetDiagErrCodeInfo(0, false);
    }
};
 
static CSafeStatic<CDiagRecycler> s_DiagRecycler;
 
 
// Helper function to check if applog severity lock is set and
// return the proper printable severity.
 
EDiagSev AdjustApplogPrintableSeverity(EDiagSev sev)
{
    if ( !CDiagContext::IsApplogSeverityLocked() ) return sev;
    return CompareDiagPostLevel(sev, eDiag_Warning) < 0
        ? sev : eDiag_Warning;
}
 
 
inline Uint8 s_GetThreadId(void)
{
    if (s_PrintSystemTID->Get()) {
        return (Uint8)GetCurrentThreadSystemID(); // GCC 3.4.6 gives warning - ignore it.
    } else {
        return CThread::GetSelf();
    }
}
 
 
enum EThreadDataState {
    eUninitialized = 0,
    eInitializing,
    eInitialized,
    eDeinitialized,
    eReinitializing
};
 
static thread_local EThreadDataState s_ThreadDataState(eUninitialized);
#define USE_TLS_DATA_CACHE
#ifdef USE_TLS_DATA_CACHE
static thread_local CDiagContextThreadData* s_ThreadDataCache;
#endif
 
 
bool CDiagContext::IsMainThreadDataInitialized(void)
{
    return CThread::IsMain() && s_ThreadDataState == eInitialized;
}
 
 
CDiagContextThreadData::CDiagContextThreadData(void)
    : m_DiagBuffer(new CDiagBuffer),
      m_TID(s_GetThreadId()),
      m_ThreadPostNumber(0),
      m_DiagCollectionSize(0)
{
    // Default context should auto-reset on request start.
    m_RequestCtx = m_DefaultRequestCtx = new CRequestContext(CRequestContext::fResetOnStart);
    m_RequestCtx->SetAutoIncRequestIDOnPost(CRequestContext::GetDefaultAutoIncRequestIDOnPost());
}
 
 
CDiagContextThreadData::~CDiagContextThreadData(void)
{
#ifdef USE_TLS_DATA_CACHE
    if ( s_ThreadDataCache == this ) {
        s_ThreadDataCache = 0;
    }
#endif
}
 
 
void CDiagContext::sx_ThreadDataTlsCleanup(CDiagContextThreadData* value,
                                           void* /*cleanup_data*/)
{
    if ( CThread::IsMain() ) {
        // Copy properties from the main thread's TLS to the global properties.
        CDiagLock lock(CDiagLock::eWrite);
        // Print stop message.
        if (!CDiagContext::IsSetOldPostFormat()  &&  s_FinishedSetupDiag) {
            GetDiagContext().PrintStop();
        }
    }
    s_ThreadDataState = eDeinitialized; // re-enable protection
    delete value;
}
 
 
CDiagContextThreadData& CDiagContextThreadData::GetThreadData(void)
{
    // If any of this method's direct or indirect callees attempted to
    // report a (typically fatal) error, the result would ordinarily
    // be infinite recursion resulting in an undignified crash.  The
    // business with s_ThreadDataState allows the program to exit
    // (relatively) gracefully in such cases.
    //
    // In principle, such an event could happen at any stage; in
    // practice, however, the first call involves a superset of most
    // following calls' actions, at least until deep program
    // finalization.  Moreover, attempting to catch bad calls
    // mid-execution would both add overhead and open up uncatchable
    // opportunities for inappropriate recursion.
 
 #ifdef USE_TLS_DATA_CACHE
    if ( CDiagContextThreadData* data = s_ThreadDataCache ) {
        return *data;
    }
#endif
 
 
    if (s_ThreadDataState != eInitialized) {
        // Avoid false positives, while also taking care not to call
        // anything that might itself produce diagnostics.
        EThreadDataState thread_data_state = s_ThreadDataState; // for Clang10
        switch (thread_data_state) {
        case eInitialized:
            break;
 
        case eUninitialized:
            s_ThreadDataState = eInitializing;
            break;
 
        case eInitializing:
            cerr << "FATAL ERROR: inappropriate recursion initializing NCBI"
                    " diagnostic framework." << endl;
            Abort();
            break;
 
        case eDeinitialized:
            s_ThreadDataState = eReinitializing;
            break;
 
        case eReinitializing:
            cerr << "FATAL ERROR: NCBI diagnostic framework no longer"
                    " initialized." << endl;
            Abort();
            break;
        }
    }
 
    static CStaticTls<CDiagContextThreadData>
        s_ThreadData(nullptr, CSafeStaticLifeSpan(CSafeStaticLifeSpan::eLifeSpan_Long, 1));
 
    // Deliberate leak for 'data'-- for both cases: 
    // GetValue() and new CDiagContextThreadData.
    NCBI_LSAN_DISABLE_GUARD;
    
    CDiagContextThreadData* data = s_ThreadData.GetValue();
    if ( !data ) {
        // Cleanup data set to null for any thread except the main one.
        // This value is used as a flag to copy threads' properties to global
        // upon TLS cleanup.
        data = new CDiagContextThreadData;
        s_ThreadData.SetValue(data, CDiagContext::sx_ThreadDataTlsCleanup,
            !CThread::IsMain() ? 0 : (void*)(1),
            CTlsBase::eDoCleanup);
        s_ThreadDataState = eInitialized;
    }
 
#ifdef USE_TLS_DATA_CACHE
    s_ThreadDataCache = data;
#endif
    return *data;
}
 
 
CRequestContext& CDiagContextThreadData::GetRequestContext(void)
{
    _ASSERT(m_RequestCtx);
    return *m_RequestCtx;
}
 
 
static const Uint8 kOwnerTID_None = Uint8(-1);
 
void CDiagContextThreadData::SetRequestContext(CRequestContext* ctx)
{
    if (m_RequestCtx) {
        // If pointers are the same (e.g. consecutive calls with the same ctx)
        if (ctx == m_RequestCtx.GetPointer()) {
            return;
        }
 
        // Reset TID in the context.
        m_RequestCtx->m_OwnerTID = kOwnerTID_None;
    }
 
    if (!ctx) {
        m_RequestCtx = m_DefaultRequestCtx;
        return;
    }
 
    m_RequestCtx = ctx;
    if (!m_RequestCtx->GetReadOnly()) {
        if (m_RequestCtx->m_OwnerTID == kOwnerTID_None) {
            // Save current TID in the context.
            m_RequestCtx->m_OwnerTID = m_TID;
        }
        else if (m_RequestCtx->m_OwnerTID != m_TID) {
            ERR_POST_X_ONCE(29,
                "Using the same CRequestContext in multiple threads is unsafe!"
                << CStackTrace());
            _TROUBLE;
        }
    }
    else {
        // Read-only contexts should not remember owner thread.
        m_RequestCtx->m_OwnerTID = kOwnerTID_None;
    }
}
 
 
CDiagContextThreadData::TCount
CDiagContextThreadData::GetThreadPostNumber(EPostNumberIncrement inc)
{
    return inc == ePostNumber_Increment ?
        ++m_ThreadPostNumber : m_ThreadPostNumber;
}
 
 
void CDiagContextThreadData::AddCollectGuard(CDiagCollectGuard* guard)
{
    m_CollectGuards.push_front(guard);
}
 
 
void CDiagContextThreadData::RemoveCollectGuard(CDiagCollectGuard* guard)
{
    TCollectGuards::iterator itg = find(
        m_CollectGuards.begin(), m_CollectGuards.end(), guard);
    if (itg == m_CollectGuards.end()) {
        return; // The guard has been already released
    }
    m_CollectGuards.erase(itg);
    auto action = guard->GetAction();
    unique_ptr<CDiagLock> lock;
    if (action == CDiagCollectGuard::ePrintCapped) {
        lock.reset(new CDiagLock(CDiagLock::eRead));
        EDiagSev cap = guard->GetSeverityCap();
        auto start = guard->GetStartingPoint();
        NON_CONST_ITERATE(TDiagCollection, itc, m_DiagCollection) {
            if (itc->m_ThrPost >= start
                &&  CompareDiagPostLevel(itc->m_Severity, cap) > 0) {
                itc->m_Severity = cap;
            }
        }
        action = CDiagCollectGuard::ePrint;
    }
    if ( !m_CollectGuards.empty() ) {
        return;
        // Previously printing was done for each guard, discarding - only for
        // the last guard.
    }
    // If this is the last guard, perform its action
    if (lock.get() == nullptr) {
        lock.reset(new CDiagLock(CDiagLock::eRead));
    }
    if (action == CDiagCollectGuard::ePrint) {
        CDiagHandler* handler = GetDiagHandler();
        if ( handler ) {
            ITERATE(TDiagCollection, itc, m_DiagCollection) {
                if ((itc->m_Flags & eDPF_IsConsole) != 0) {
                    // Print all messages to console
                    handler->PostToConsole(*itc);
                }
                // Make sure only messages with the severity above allowed
                // are printed to normal log.
                EDiagSev post_sev = AdjustApplogPrintableSeverity(
                    guard->GetCollectSeverity());
                bool allow_trace = post_sev == eDiag_Trace;
                if (itc->m_Severity == eDiag_Trace  &&  !allow_trace) {
                    continue; // trace is disabled
                }
                if (itc->m_Severity < post_sev) {
                    continue;
                }
                handler->Post(*itc);
            }
            size_t discarded = m_DiagCollectionSize - m_DiagCollection.size();
            if (discarded > 0) {
                ERR_POST_X(18, Warning << "Discarded " << discarded <<
                    " messages due to collection limit. Set "
                    "DIAG_COLLECT_LIMIT to increase the limit.");
            }
        }
    }
    m_DiagCollection.clear();
    m_DiagCollectionSize = 0;
}
 
 
CDiagCollectGuard* CDiagContextThreadData::GetCollectGuard(void)
{
    return m_CollectGuards.empty() ? NULL : m_CollectGuards.front();
}
 
 
void CDiagContextThreadData::CollectDiagMessage(const SDiagMessage& mess)
{
    static CSafeStatic<NCBI_PARAM_TYPE(Diag, Collect_Limit)> s_DiagCollectLimit;
    if (m_DiagCollectionSize >= s_DiagCollectLimit->Get()) {
        m_DiagCollection.erase(m_DiagCollection.begin());
    }
    m_DiagCollection.push_back(mess);
    m_DiagCollectionSize++;
}
 
 
CDiagContextThreadData::TCount
CDiagContextThreadData::GetRequestId(void)
{
    return GetRequestContext().GetRequestID();
}
 
 
void CDiagContextThreadData::SetRequestId(TCount id)
{
    GetRequestContext().SetRequestID(id);
}
 
 
void CDiagContextThreadData::IncRequestId(void)
{
    GetRequestContext().SetRequestID();
}
 
 
extern Uint8 GetDiagRequestId(void)
{
    return GetDiagContext().GetRequestContext().GetRequestID();
}
 
 
extern void SetDiagRequestId(Uint8 id)
{
    GetDiagContext().GetRequestContext().SetRequestID(id);
}
 
 
///////////////////////////////////////////////////////
//  CDiagContext::
 
 
// AppState formatting/parsing
static const char* s_AppStateStr[] = {
    "NS", "PB", "P", "PE", "RB", "R", "RE"
};
 
static const char* s_LegacyAppStateStr[] = {
    "AB", "A", "AE"
};
 
const char* s_AppStateToStr(EDiagAppState state)
{
    return s_AppStateStr[state];
}
 
EDiagAppState s_StrToAppState(const string& state)
{
    for (int st = (int)eDiagAppState_AppBegin;
        st <= eDiagAppState_RequestEnd; st++) {
        if (state == s_AppStateStr[st]) {
            return (EDiagAppState)st;
        }
    }
    // Backward compatibility - allow to use 'A' instead of 'P'
    for (int st = (int)eDiagAppState_AppBegin;
        st <= eDiagAppState_AppEnd; st++) {
        if (state == s_LegacyAppStateStr[st - 1]) {
            return (EDiagAppState)st;
        }
    }
 
    // Throw to notify caller about invalid app state.
    NCBI_THROW(CException, eUnknown, "Invalid EDiagAppState value");
    /*NOTREACHED*/
    return eDiagAppState_NotSet;
}
 
 
NCBI_PARAM_DECL(bool, Diag, UTC_Timestamp);
NCBI_PARAM_DEF_EX(bool, Diag, UTC_Timestamp, false,
                  eParam_NoThread, DIAG_UTC_TIMESTAMP);
 
 
static CTime s_GetFastTime(void)
{
    static CSafeStatic<NCBI_PARAM_TYPE(Diag, UTC_Timestamp)> s_UtcTimestamp;
    return (s_UtcTimestamp->Get() && !CDiagContext::IsApplogSeverityLocked()) ?
        CTime(CTime::eCurrent, CTime::eGmt) : GetFastLocalTime();
}
 
 
struct SDiagMessageData
{
    SDiagMessageData(void);
    ~SDiagMessageData(void) {}
 
    string m_Message;
    string m_File;
    string m_Module;
    string m_Class;
    string m_Function;
    string m_Prefix;
    string m_ErrText;
 
    CDiagContext::TUID m_UID;
    CTime              m_Time;
 
    // If the following properties are not set, take them from DiagContext.
    string m_Host;
    string m_Client;
    string m_Session;
    string m_AppName;
    EDiagAppState m_AppState;
};
 
 
SDiagMessageData::SDiagMessageData(void)
    : m_UID(0),
      m_Time(s_GetFastTime()),
      m_AppState(eDiagAppState_NotSet)
{
}
 
 
CDiagContext* CDiagContext::sm_Instance = NULL;
bool CDiagContext::sm_ApplogSeverityLocked = false;
 
 
CDiagContext::CDiagContext(void)
    : m_UID(0),
      m_Host(new CEncodedString),
      m_Username(new CEncodedString),
      m_AppName(new CEncodedString),
      m_AppNameSet(false),
      m_LoggedHitId(false),
      m_ExitCode(0),
      m_ExitCodeSet(false),
      m_ExitSig(0),
      m_AppState(eDiagAppState_AppBegin),
      m_StopWatch(new CStopWatch(CStopWatch::eStart)),
      m_MaxMessages(100), // limit number of collected messages to 100
      m_AppLogRC(new CRequestRateControl(
          GetLogRate_Limit(eLogRate_App),
          CTimeSpan((long)GetLogRate_Period(eLogRate_App)),
          CTimeSpan((long)0),
          CRequestRateControl::eErrCode,
          CRequestRateControl::eDiscrete)),
      m_ErrLogRC(new CRequestRateControl(
          GetLogRate_Limit(eLogRate_Err),
          CTimeSpan((long)GetLogRate_Period(eLogRate_Err)),
          CTimeSpan((long)0),
          CRequestRateControl::eErrCode,
          CRequestRateControl::eDiscrete)),
      m_TraceLogRC(new CRequestRateControl(
          GetLogRate_Limit(eLogRate_Trace),
          CTimeSpan((long)GetLogRate_Period(eLogRate_Trace)),
          CTimeSpan((long)0),
          CRequestRateControl::eErrCode,
          CRequestRateControl::eDiscrete)),
      m_AppLogSuspended(false),
      m_ErrLogSuspended(false),
      m_TraceLogSuspended(false)
{
    sm_Instance = this;
}
 
 
CDiagContext::~CDiagContext(void)
{
    sm_Instance = NULL;
}
 
 
void CDiagContext::ResetLogRates(void)
{
    CMutexGuard lock(s_ApproveMutex);
    m_AppLogRC->Reset(GetLogRate_Limit(eLogRate_App),
        CTimeSpan((long)GetLogRate_Period(eLogRate_App)),
        CTimeSpan((long)0),
        CRequestRateControl::eErrCode,
        CRequestRateControl::eDiscrete);
    m_ErrLogRC->Reset(GetLogRate_Limit(eLogRate_Err),
        CTimeSpan((long)GetLogRate_Period(eLogRate_Err)),
        CTimeSpan((long)0),
        CRequestRateControl::eErrCode,
        CRequestRateControl::eDiscrete);
    m_TraceLogRC->Reset(GetLogRate_Limit(eLogRate_Trace),
        CTimeSpan((long)GetLogRate_Period(eLogRate_Trace)),
        CTimeSpan((long)0),
        CRequestRateControl::eErrCode,
        CRequestRateControl::eDiscrete);
    m_AppLogSuspended = false;
    m_ErrLogSuspended = false;
    m_TraceLogSuspended = false;
}
 
 
unsigned int CDiagContext::GetLogRate_Limit(ELogRate_Type type) const
{
    switch ( type ) {
    case eLogRate_App:
        return s_AppLogRateLimit->Get();
    case eLogRate_Err:
        return s_ErrLogRateLimit->Get();
    case eLogRate_Trace:
    default:
        return s_TraceLogRateLimit->Get();
    }
}
 
void CDiagContext::SetLogRate_Limit(ELogRate_Type type, unsigned int limit)
{
    CMutexGuard lock(s_ApproveMutex);
    switch ( type ) {
    case eLogRate_App:
        s_AppLogRateLimit->Set(limit);
        if ( m_AppLogRC.get() ) {
            m_AppLogRC->Reset(limit,
                CTimeSpan((long)GetLogRate_Period(type)),
                CTimeSpan((long)0),
                CRequestRateControl::eErrCode,
                CRequestRateControl::eDiscrete);
        }
        m_AppLogSuspended = false;
        break;
    case eLogRate_Err:
        s_ErrLogRateLimit->Set(limit);
        if ( m_ErrLogRC.get() ) {
            m_ErrLogRC->Reset(limit,
                CTimeSpan((long)GetLogRate_Period(type)),
                CTimeSpan((long)0),
                CRequestRateControl::eErrCode,
                CRequestRateControl::eDiscrete);
        }
        m_ErrLogSuspended = false;
        break;
    case eLogRate_Trace:
    default:
        s_TraceLogRateLimit->Set(limit);
        if ( m_TraceLogRC.get() ) {
            m_TraceLogRC->Reset(limit,
                CTimeSpan((long)GetLogRate_Period(type)),
                CTimeSpan((long)0),
                CRequestRateControl::eErrCode,
                CRequestRateControl::eDiscrete);
        }
        m_TraceLogSuspended = false;
        break;
    }
}
 
unsigned int CDiagContext::GetLogRate_Period(ELogRate_Type type) const
{
    switch ( type ) {
    case eLogRate_App:
        return s_AppLogRatePeriod->Get();
    case eLogRate_Err:
        return s_ErrLogRatePeriod->Get();
    case eLogRate_Trace:
    default:
        return s_TraceLogRatePeriod->Get();
    }
}
 
void CDiagContext::SetLogRate_Period(ELogRate_Type type, unsigned int period)
{
    CMutexGuard lock(s_ApproveMutex);
    switch ( type ) {
    case eLogRate_App:
        s_AppLogRatePeriod->Set(period);
        if ( m_AppLogRC.get() ) {
            m_AppLogRC->Reset(GetLogRate_Limit(type),
                CTimeSpan((long)period),
                CTimeSpan((long)0),
                CRequestRateControl::eErrCode,
                CRequestRateControl::eDiscrete);
        }
        m_AppLogSuspended = false;
        break;
    case eLogRate_Err:
        s_ErrLogRatePeriod->Set(period);
        if ( m_ErrLogRC.get() ) {
            m_ErrLogRC->Reset(GetLogRate_Limit(type),
                CTimeSpan((long)period),
                CTimeSpan((long)0),
                CRequestRateControl::eErrCode,
                CRequestRateControl::eDiscrete);
        }
        m_ErrLogSuspended = false;
        break;
    case eLogRate_Trace:
    default:
        s_TraceLogRatePeriod->Set(period);
        if ( m_TraceLogRC.get() ) {
            m_TraceLogRC->Reset(GetLogRate_Limit(type),
                CTimeSpan((long)period),
                CTimeSpan((long)0),
                CRequestRateControl::eErrCode,
                CRequestRateControl::eDiscrete);
        }
        m_TraceLogSuspended = false;
        break;
    }
}
 
 
bool CDiagContext::ApproveMessage(SDiagMessage& msg,
                                  bool*         show_warning)
{
    bool approved = true;
    if ( IsSetDiagPostFlag(eDPF_AppLog, msg.m_Flags) ) {
        if ( m_AppLogRC->IsEnabled() ) {
            CMutexGuard lock(s_ApproveMutex);
            approved = m_AppLogRC->Approve();
        }
        if ( approved ) {
            m_AppLogSuspended = false;
        }
        else {
            *show_warning = !m_AppLogSuspended.exchange(true);
        }
    }
    else {
        switch ( msg.m_Severity ) {
        case eDiag_Info:
        case eDiag_Trace:
            if ( m_TraceLogRC->IsEnabled() ) {
                CMutexGuard lock(s_ApproveMutex);
                approved = m_TraceLogRC->Approve();
            }
            if ( approved ) {
                m_TraceLogSuspended = false;
            }
            else {
                *show_warning = !m_TraceLogSuspended.exchange(true);
            }
            break;
        default:
            if ( m_ErrLogRC->IsEnabled() ) {
                CMutexGuard lock(s_ApproveMutex);
                approved = m_ErrLogRC->Approve();
            }
            if ( approved ) {
                m_ErrLogSuspended = false;
            }
            else {
                *show_warning = !m_ErrLogSuspended.exchange(true);
            }
        }
    }
    return approved;
}
 
 
CDiagContext::TPID CDiagContext::sm_PID = 0;
 
CDiagContext::TPID CDiagContext::GetPID(void)
{
    if ( !sm_PID ) {
        sm_PID = CCurrentProcess::GetPid();
    }
    return sm_PID;
}
 
 
bool CDiagContext::UpdatePID(void)
{
    TPID old_pid = sm_PID;
    TPID new_pid = CCurrentProcess::GetPid();
    if (sm_PID == new_pid) {
        return false;
    }
    sm_PID = new_pid;
    CDiagContext& ctx = GetDiagContext();
    TUID old_uid = ctx.GetUID();
    // Update GUID to match the new PID
    ctx.x_CreateUID();
    ctx.Extra().
        Print("action", "fork").
        Print("parent_guid", ctx.GetStringUID(old_uid)).
        Print("parent_pid", NStr::NumericToString(old_pid));
    return true;
}
 
 
bool CDiagContext::UpdatePID_AsyncSafe(void)
{
    TPID new_pid = CCurrentProcess::GetPid();
    if (sm_PID == new_pid) {
        return false;
    }
    sm_PID = new_pid;
    // Update GUID to match the new PID.
    // GetDiagContext() call is not async safe in common, but should be safe
    // after Diag API initialization, it's just doing a pointer type cast.
    GetDiagContext().x_CreateUID_AsyncSafe();
    return true;
}
 
 
void CDiagContext::UpdateOnFork(TOnForkFlags flags)
{
    if (flags & fOnFork_AsyncSafe) {
        UpdatePID_AsyncSafe();
        return;
    }
    // not async safe:
 
    // Do not perform any actions in the parent process
    if ( !UpdatePID() ) return;
 
    if (flags & fOnFork_ResetTimer) {
        GetDiagContext().m_StopWatch->Restart();
    }
    if (flags & fOnFork_PrintStart) {
        GetDiagContext().PrintStart(kEmptyStr);
    }
}
 
 
const CDiagContext::TUID kUID_InitBase =  212;
const CDiagContext::TUID kUID_Mult     = 1265;
 
CDiagContext::TUID s_CreateUID(CDiagContext::TUID base)
{
    // This method expected to be async-signal-safe
    // https://man7.org/linux/man-pages/man7/signal-safety.7.html
    // All non-async-safe code should go to x_CreateUID().
 
    typedef CDiagContext::TPID TPID;
    typedef CDiagContext::TUID TUID;
    
    TPID pid = CDiagContext::GetPID();
    time_t t = time(0);
 
    base &= 0xFFFF;
 
    // The low 4 bits are reserved for GUID generator version number.
    // As of October 2017 the following versions are used:
    //   0 - very old C++ Toolkit
    //   1 - contemporary C++ Toolkit
    //   2 - ?
    //   3 - "C" client (CLOG API); "Python" module 'python-applog'
    //   4 - ?
    //   5 - Java
    //   6 - Scala
    //  13 - Perl (NcbiApplog.pm)
 
    return (TUID(base) << 48) |
           ((TUID(pid) & 0xFFFF) << 32) |
           ((TUID(t) & 0xFFFFFFF) << 4) |
           1; // version #1 - fixed type conversion bug
}
 
void CDiagContext::x_CreateUID(void) const
{
    TUID base = kUID_InitBase;
    const string& host = GetHost();
    for (auto c : host) {
        base = base * kUID_Mult + c;
    }
    m_UID = s_CreateUID(base);
}
 
void CDiagContext::x_CreateUID_AsyncSafe(void) const
{
    // This method expected to be async-signal-safe
    // https://man7.org/linux/man-pages/man7/signal-safety.7.html
    // Implemented for Unix only, on other platforms works the same
    // as a regular x_CreateUID().
    
#if defined(NCBI_OS_UNIX)
    TUID base = kUID_InitBase;
    struct utsname buf;
    if (uname(&buf) >= 0) {
        const char* s = buf.nodename;
        while (*s) {
            base = base * kUID_Mult + *s;
            s++;
        }
    }
    else {
        // Rough workaround in case of uname() error
        base = base * kUID_Mult + (TUID)GetPID();
    }
    m_UID = s_CreateUID(base);
#else 
    x_CreateUID();
#endif
}
 
 
DEFINE_STATIC_MUTEX(s_CreateGUIDMutex);
 
CDiagContext::TUID CDiagContext::GetUID(void) const
{
    if ( !m_UID ) {
        CMutexGuard guard(s_CreateGUIDMutex);
        if ( !m_UID ) {
            x_CreateUID();
        }
    }
    return m_UID;
}
 
 
void CDiagContext::GetStringUID(TUID uid, char* buf, size_t buflen) const
{
    _ASSERT(buflen > 16);
    int hi = int((uid >> 32) & 0xFFFFFFFF);
    int lo = int(uid & 0xFFFFFFFF);
    snprintf(buf, buflen, "%08X%08X", hi, lo);
}
 
 
void CDiagContext::GetStringUID(TUID uid, char* buf) const
{
    GetStringUID(uid, buf, 17);
}
 
 
string CDiagContext::GetStringUID(TUID uid) const
{
    char buf[17];
    if (uid == 0) {
        uid = GetUID();
    }
    GetStringUID(uid, buf, 17);
    return string(buf);
}
 
 
CDiagContext::TUID CDiagContext::UpdateUID(TUID uid) const
{
    if (uid == 0) {
        uid = GetUID();
    }
    time_t t = time(0);
    // Clear old timestamp
    uid &= ~((TUID)0xFFFFFFF << 4);
    // Add current timestamp
    return uid | ((TUID(t) & 0xFFFFFFF) << 4);
}
 
 
string CDiagContext::GetNextHitID(void) const
{
    return x_GetNextHitID(false);
}
 
 
string CDiagContext::x_GetNextHitID(bool is_default) const
{
    static CAtomicCounter s_HitIdCounter;
 
    Uint8 hi = GetUID();
    Uint4 b3 = Uint4((hi >> 32) & 0xFFFFFFFF);
    Uint4 b2 = Uint4(hi & 0xFFFFFFFF);
 
    CDiagContextThreadData& thr_data = CDiagContextThreadData::GetThreadData();
    Uint8 tid = (thr_data.GetTID() & 0xFFFFFF) << 40;
    Uint8 rid;
    if ( !is_default ) {
        rid = ((Uint8)thr_data.GetRequestContext().GetRequestID() & 0xFFFFFF) << 16;
    }
    else {
        rid = ((Uint8)0xFFFFFF) << 16;
    }
    Uint8 us = (Uint8)(s_HitIdCounter.Add(1) & 0xFFFF);
    Uint8 lo = tid | rid | us;
    Uint4 b1 = Uint4((lo >> 32) & 0xFFFFFFFF);
    Uint4 b0 = Uint4(lo & 0xFFFFFFFF);
    char buf[33];
    snprintf(buf, 33, "%08X%08X%08X%08X", b3, b2, b1, b0);
    return string(buf);
}
 
 
string CDiagContext::GetDefaultHitID(void) const
{
    return x_GetDefaultHitID(eHitID_Create).GetHitId();
}
 
 
const string& CDiagContext::GetUsername(void) const
{
    return m_Username->GetOriginalString();
}
 
 
void CDiagContext::SetUsername(const string& username)
{
    m_Username->SetString(username);
}
 
 
const string& CDiagContext::GetHost(void) const
{
    // Check context properties
    if ( !m_Host->IsEmpty() ) {
        return m_Host->GetOriginalString();
    }
    if ( !m_HostIP.empty() ) {
        return m_HostIP;
    }
 
    // All platforms - check NCBI_HOST first.
    const TXChar* ncbi_host = NcbiSys_getenv(_TX("NCBI_HOST"));
    if (ncbi_host  &&  *ncbi_host) {
        m_Host->SetString(_T_STDSTRING(ncbi_host));
        return m_Host->GetOriginalString();
    }
 
#if defined(NCBI_OS_UNIX)
    // UNIX - use uname()
    {{
        struct utsname buf;
        if (uname(&buf) >= 0) {
            m_Host->SetString(buf.nodename);
            return m_Host->GetOriginalString();
        }
    }}
#endif
 
#if defined(NCBI_OS_MSWIN)
    // MSWIN - use COMPUTERNAME
    const TXChar* compname = NcbiSys_getenv(_TX("COMPUTERNAME"));
    if ( compname  &&  *compname ) {
        m_Host->SetString(_T_STDSTRING(compname));
        return m_Host->GetOriginalString();
    }
#endif
 
    // Server env. - use SERVER_ADDR
    const TXChar* servaddr = NcbiSys_getenv(_TX("SERVER_ADDR"));
    if ( servaddr  &&  *servaddr ) {
        m_Host->SetString(_T_STDSTRING(servaddr));
    }
    return m_Host->GetOriginalString();
}
 
 
const string& CDiagContext::GetEncodedHost(void) const
{
    if ( !m_Host->IsEmpty() ) {
        return m_Host->GetEncodedString();
    }
    if ( !m_HostIP.empty() ) {
        return m_HostIP;
    }
    // Initialize m_Host, this does not change m_HostIP
    GetHost();
    return m_Host->GetEncodedString();
}
 
 
const string& CDiagContext::GetHostname(void) const
{
    return m_Host->GetOriginalString();
}
 
 
const string& CDiagContext::GetEncodedHostname(void) const
{
    return m_Host->GetEncodedString();
}
 
 
void CDiagContext::SetHostname(const string& hostname)
{
    m_Host->SetString(hostname);
}
 
 
void CDiagContext::SetHostIP(const string& ip)
{
    if ( !NStr::IsIPAddress(ip) ) {
        m_HostIP.clear();
        ERR_POST("Bad host IP value: " << ip);
        return;
    }
    m_HostIP = ip;
}
 
 
DEFINE_STATIC_MUTEX(s_AppNameMutex);
 
const string& CDiagContext::GetAppName(void) const
{
    if ( !m_AppNameSet ) {
        CMutexGuard guard(s_AppNameMutex);
        if ( !m_AppNameSet ) {
            m_AppName->SetString(CNcbiApplication::GetAppName());
            // Cache appname if CNcbiApplication instance exists only,
            // the Diag API can be used before instance initialization and appname
            //  could be set to a binary name, and changes later (CXX-5076).
            if (CNcbiApplication::Instance()  &&  !m_AppName->IsEmpty()) {
                m_AppNameSet = true;
            }
        }
    }
    return m_AppName->GetOriginalString();
}
 
 
const string& CDiagContext::GetEncodedAppName(void) const
{
    if ( !m_AppNameSet ) {
        GetAppName(); // Initialize app name
    }
    return m_AppName->GetEncodedString();
}
 
 
void CDiagContext::SetAppName(const string& app_name)
{
    if ( m_AppNameSet ) {
        // AppName can be set only once
        ERR_POST("Application name cannot be changed.");
        return;
    }
    CMutexGuard guard(s_AppNameMutex);
    m_AppName->SetString(app_name);
    m_AppNameSet = true;
    if ( m_AppName->IsEncoded() ) {
        ERR_POST("Illegal characters in application name: '" << app_name <<
            "', using URL-encode.");
    }
}
 
 
CRequestContext& CDiagContext::GetRequestContext(void)
{
    return CDiagContextThreadData::GetThreadData().GetRequestContext();
}
 
 
void CDiagContext::SetRequestContext(CRequestContext* ctx)
{
    CDiagContextThreadData::GetThreadData().SetRequestContext(ctx);
}
 
 
void CDiagContext::SetAutoWrite(bool value)
{
    s_AutoWrite_Context->Set(value);
}
 
 
inline bool IsGlobalProperty(const string& name)
{
    return
        name == CDiagContext::kProperty_UserName  ||
        name == CDiagContext::kProperty_HostName  ||
        name == CDiagContext::kProperty_HostIP    ||
        name == CDiagContext::kProperty_AppName   ||
        name == CDiagContext::kProperty_ExitSig   ||
        name == CDiagContext::kProperty_ExitCode;
}
 
 
void CDiagContext::SetProperty(const string& name,
                               const string& value,
                               EPropertyMode mode)
{
    // Global properties
    if (name == kProperty_UserName) {
        SetUsername(value);
        return;
    }
    if (name == kProperty_HostName) {
        SetHostname(value);
        return;
    }
    if (name == kProperty_HostIP) {
        SetHostIP(value);
        return;
    }
    if (name == kProperty_AppName) {
        SetAppName(value);
        return;
    }
    if (name == kProperty_ExitCode) {
        SetExitCode(NStr::StringToInt(value, NStr::fConvErr_NoThrow));
        return;
    }
    if (name == kProperty_ExitSig) {
        SetExitSignal(NStr::StringToInt(value, NStr::fConvErr_NoThrow));
        return;
    }
 
    // Request properties
    if (name == kProperty_AppState) {
        try {
            SetAppState(s_StrToAppState(value));
        }
        catch (const CException&) {
        }
        return;
    }
    if (name == kProperty_ClientIP) {
        GetRequestContext().SetClientIP(value);
        return;
    }
    if (name == kProperty_SessionID) {
        GetRequestContext().SetSessionID(value);
        return;
    }
    if (name == kProperty_ReqStatus) {
        if ( !value.empty() ) {
            GetRequestContext().SetRequestStatus(
                NStr::StringToInt(value, NStr::fConvErr_NoThrow));
        }
        else {
            GetRequestContext().UnsetRequestStatus();
        }
        return;
    }
    if (name == kProperty_BytesRd) {
        GetRequestContext().SetBytesRd(
            NStr::StringToInt8(value, NStr::fConvErr_NoThrow));
        return;
    }
    if (name == kProperty_BytesWr) {
        GetRequestContext().SetBytesWr(
            NStr::StringToInt8(value, NStr::fConvErr_NoThrow));
        return;
    }
    if (name == kProperty_ReqTime) {
        // Cannot set this property
        return;
    }
 
    if ( mode == eProp_Default ) {
        mode = IsGlobalProperty(name) ? eProp_Global : eProp_Thread;
    }
 
    if ( mode == eProp_Global ) {
        CDiagLock lock(CDiagLock::eWrite);
        m_Properties[name] = value;
    }
    if ( sm_Instance  &&  s_AutoWrite_Context->Get() ) {
        CDiagLock lock(CDiagLock::eRead);
        x_PrintMessage(SDiagMessage::eEvent_Extra, name + "=" + value);
    }
}
 
 
string CDiagContext::GetProperty(const string& name,
                                 EPropertyMode mode) const
{
    // Global properties
    if (name == kProperty_UserName) {
        return GetUsername();
    }
    if (name == kProperty_HostName) {
        return GetHostname();
    }
    if (name == kProperty_HostIP) {
        return GetHostIP();
    }
    if (name == kProperty_AppName) {
        return GetAppName();
    }
    if (name == kProperty_ExitCode) {
        return NStr::IntToString(m_ExitCode);
    }
    if (name == kProperty_ExitSig) {
        return NStr::IntToString(m_ExitSig);
    }
 
    // Request properties
    if (name == kProperty_AppState) {
        return s_AppStateToStr(GetAppState());
    }
    if (name == kProperty_ClientIP) {
        return GetRequestContext().GetClientIP();
    }
    if (name == kProperty_SessionID) {
        return GetSessionID();
    }
    if (name == kProperty_ReqStatus) {
        return GetRequestContext().IsSetRequestStatus() ?
            NStr::IntToString(GetRequestContext().GetRequestStatus())
            : kEmptyStr;
    }
    if (name == kProperty_BytesRd) {
        return NStr::Int8ToString(GetRequestContext().GetBytesRd());
    }
    if (name == kProperty_BytesWr) {
        return NStr::Int8ToString(GetRequestContext().GetBytesWr());
    }
    if (name == kProperty_ReqTime) {
        return GetRequestContext().GetRequestTimer().AsString();
    }
 
    // Check global properties
    CDiagLock lock(CDiagLock::eRead);
    TProperties::const_iterator gprop = m_Properties.find(name);
    return gprop != m_Properties.end() ? gprop->second : kEmptyStr;
}
 
 
void CDiagContext::DeleteProperty(const string& name,
                                    EPropertyMode mode)
{
    // Check global properties
    CDiagLock lock(CDiagLock::eRead);
    TProperties::iterator gprop = m_Properties.find(name);
    if (gprop != m_Properties.end()) {
        m_Properties.erase(gprop);
    }
}
 
 
void CDiagContext::PrintProperties(void)
{
    CDiagLock lock(CDiagLock::eRead);
    ITERATE(TProperties, gprop, m_Properties) {
        x_PrintMessage(SDiagMessage::eEvent_Extra,
            gprop->first + "=" + gprop->second);
    }
}
 
 
void CDiagContext::PrintStart(const string& message)
{
    x_PrintMessage(SDiagMessage::eEvent_Start, message);
    // Print extra message. If ncbi_role and/or ncbi_location are set,
    // they will be logged by this extra. Otherwise nothing will be printed.
    Extra().PrintNcbiRoleAndLocation().PrintNcbiAppInfoOnStart().PrintNcbiAppInfoOnRequest().Flush();
 
    static const char* kCloudIdFile = "/etc/ncbi/cloudid";
    CFile cloudid(kCloudIdFile);
    if ( cloudid.Exists() ) {
        CDiagContext_Extra ex = Extra();
        CNcbiIfstream in(kCloudIdFile);
        while (!in.eof() && in.good()) {
            string s;
            getline(in, s);
            size_t sep = s.find('\t');
            if (sep == NPOS) continue;
            string name = NStr::TruncateSpaces(s.substr(0, sep));
            string value = s.substr(sep + 1);
            ex.Print(name, value);
        }
        ex.Flush();
    }
 
    x_LogEnvironment();
 
    // Log NCBI_LOG_FIELDS
    map<string, string> env_map;
    for (char **env = environ; *env; ++env) {
        string n, v;
        NStr::SplitInTwo(*env, "=", n, v, NStr::fSplit_Tokenize);
        NStr::ToLower(n);
        NStr::ReplaceInPlace(n, "_", "-");
        env_map[n] = v;
    }
 
    CNcbiLogFields f("env");
    f.LogFields(env_map);
 
    // Log hit id if already available.
    x_GetDefaultHitID(eHitID_NoCreate);
}
 
 
void CDiagContext::PrintStop(void)
{
    // If no hit id has been logged until app-stop,
    // try to force logging now.
    if (x_IsSetDefaultHitID()) {
        x_LogHitID_WithLock();
    }
    else {
        CRequestContext& ctx = GetRequestContext();
        if (ctx.IsSetHitID(CRequestContext::eHitID_Request)) {
            ctx.x_LogHitID(true);
        }
    }
    x_PrintMessage(SDiagMessage::eEvent_Stop, kEmptyStr);
}
 
 
void CDiagContext::PrintExtra(const string& message)
{
    x_PrintMessage(SDiagMessage::eEvent_Extra, message);
}
 
 
CDiagContext_Extra CDiagContext::PrintRequestStart(void)
{
    return CDiagContext_Extra(SDiagMessage::eEvent_RequestStart);
}
 
 
CDiagContext_Extra::CDiagContext_Extra(SDiagMessage::EEventType event_type)
    : m_EventType(event_type),
      m_Args(0),
      m_Counter(new int(1)),
      m_Typed(false),
      m_PerfStatus(0),
      m_PerfTime(0),
      m_Flushed(false),
      m_AllowBadNames(false)
{
}
 
 
CDiagContext_Extra::CDiagContext_Extra(int         status,
                                       double      timespan,
                                       TExtraArgs& args)
    : m_EventType(SDiagMessage::eEvent_PerfLog),
      m_Args(0),
      m_Counter(new int(1)),
      m_Typed(false),
      m_PerfStatus(status),
      m_PerfTime(timespan),
      m_Flushed(false),
      m_AllowBadNames(false)
{
    if (args.empty()) return;
    m_Args = new TExtraArgs;
    m_Args->splice(m_Args->end(), args);
}
 
 
CDiagContext_Extra::CDiagContext_Extra(const CDiagContext_Extra& args)
    : m_EventType(const_cast<CDiagContext_Extra&>(args).m_EventType),
      m_Args(const_cast<CDiagContext_Extra&>(args).m_Args),
      m_Counter(const_cast<CDiagContext_Extra&>(args).m_Counter),
      m_Typed(args.m_Typed),
      m_PerfStatus(args.m_PerfStatus),
      m_PerfTime(args.m_PerfTime),
      m_Flushed(args.m_Flushed),
      m_AllowBadNames(args.m_AllowBadNames)
{
    (*m_Counter)++;
}
 
 
CDiagContext_Extra& CDiagContext_Extra::AllowBadSymbolsInArgNames(void)
{
    m_AllowBadNames = true;
    return *this;
}
 
 
const TDiagPostFlags kApplogDiagPostFlags =
        eDPF_OmitInfoSev | eDPF_OmitSeparator | eDPF_AppLog;
 
 
CDiagContext_Extra& CDiagContext_Extra::PrintNcbiRoleAndLocation(void)
{
    const string& role = CDiagContext::GetHostRole();
    const string& loc = CDiagContext::GetHostLocation();
    if ( !role.empty() ) {
        Print("ncbi_role", role);
    }
    if ( !loc.empty() ) {
        Print("ncbi_location", loc);
    }
    return *this;
}
 
CDiagContext_Extra& CDiagContext_Extra::PrintNcbiAppInfoOnStart(void)
{
    Print("ncbi_app_username", CSystemInfo::GetUserName());
    CNcbiApplication* ins = CNcbiApplication::Instance();
    if (ins) {
        Print("ncbi_app_path", ins->GetProgramExecutablePath());
        const CVersionAPI& ver = ins->GetFullVersion();
        if (!ver.GetBuildInfo().date.empty()) {
            Print("ncbi_app_build_date", ver.GetBuildInfo().date);
        }
#if NCBI_PACKAGE
        Print("ncbi_app_package_name", ver.GetPackageName());
        string pkv = NStr::NumericToString(ver.GetPackageVersion().GetMajor())
            + "." +  NStr::NumericToString(ver.GetPackageVersion().GetMinor())
            + "." +  NStr::NumericToString(ver.GetPackageVersion().GetPatchLevel());
        Print("ncbi_app_package_version", pkv);
        Print("ncbi_app_package_date", NCBI_SBUILDINFO_DEFAULT().date);
#endif
        const SBuildInfo& bi = ver.GetBuildInfo();
        initializer_list<SBuildInfo::EExtra> bi_num = {
            SBuildInfo::eTeamCityProjectName,
            SBuildInfo::eTeamCityBuildConf,
            SBuildInfo::eTeamCityBuildNumber,
            SBuildInfo::eBuildID,
            SBuildInfo::eBuiltAs
        };
        for(SBuildInfo::EExtra key : bi_num) {
            string value = bi.GetExtraValue(key);
            if (!value.empty()) {
                Print( SBuildInfo::ExtraNameAppLog(key), value);
            }
        }
        return *this;
    }
#if defined(NCBI_TEAMCITY_PROJECT_NAME)
    Print("ncbi_app_tc_project", NCBI_TEAMCITY_PROJECT_NAME);
#endif
#if defined(NCBI_TEAMCITY_BUILDCONF_NAME)
    Print("ncbi_app_tc_conf", NCBI_TEAMCITY_BUILDCONF_NAME);
#endif
#if defined(NCBI_TEAMCITY_BUILD_NUMBER)
    Print("ncbi_app_tc_build", NStr::NumericToString<Uint8>(NCBI_TEAMCITY_BUILD_NUMBER));
#endif
#if defined(NCBI_TEAMCITY_BUILD_ID)
    Print("ncbi_app_build_id", NCBI_TEAMCITY_BUILD_ID);
#endif
 
    return *this;
}
 
CDiagContext_Extra& CDiagContext_Extra::PrintNcbiAppInfoOnRequest(void)
{
    CNcbiApplication* ins = CNcbiApplication::Instance();
    if (ins) {
        const CVersionAPI& ver = ins->GetFullVersion();
        const CVersionInfo& vi = ver.GetVersionInfo();
//#if defined (NCBI_SC_VERSION) && NCBI_SC_VERSION <= 21
#if 1
        string str = NStr::NumericToString(vi.GetMajor()) + "." +
                     NStr::NumericToString(vi.GetMinor()) + "." +
                     NStr::NumericToString(vi.GetPatchLevel());
        Print("ncbi_app_version", str);
#else
        initializer_list<int> vi_num = {vi.GetMajor(), vi.GetMinor(), vi.GetPatchLevel()};
        Print("ncbi_app_version", NStr::JoinNumeric(vi_num.begin(), vi_num.end(), "."));
#endif
 
        const SBuildInfo& bi = ver.GetBuildInfo();
        initializer_list<SBuildInfo::EExtra> bi_num =
            {   SBuildInfo::eProductionVersion,       SBuildInfo::eDevelopmentVersion,
                SBuildInfo::eStableComponentsVersion, SBuildInfo::eSubversionRevision,
                SBuildInfo::eRevision, SBuildInfo::eGitBranch};
        for(SBuildInfo::EExtra key : bi_num) {
            string value = bi.GetExtraValue(key);
            if (!value.empty()) {
                Print( SBuildInfo::ExtraNameAppLog(key), value);
            }
        }
        return *this;
    }
#if defined(NCBI_PRODUCTION_VER)
    Print("ncbi_app_prod_version", NStr::NumericToString<Uint8>(NCBI_PRODUCTION_VER));
#elif defined(NCBI_DEVELOPMENT_VER)
    Print("ncbi_app_dev_version", NStr::NumericToString<Uint8>(NCBI_DEVELOPMENT_VER));
#endif
#if defined(NCBI_SC_VERSION)
    Print("ncbi_app_sc_version", NStr::NumericToString<Uint8>(NCBI_SC_VERSION));
#endif
#if defined(NCBI_SUBVERSION_REVISION)
    Print("ncbi_app_vcs_revision", NStr::NumericToString<Uint8>(NCBI_SUBVERSION_REVISION));
#endif
    return *this;
}
 
 
void CDiagContext_Extra::Flush(void)
{
    if (m_Flushed  ||  CDiagContext::IsSetOldPostFormat()) {
        return;
    }
 
    // Add ncbi-role and ncbi-location just before setting m_Flushed flag.
    if (m_EventType == SDiagMessage::eEvent_RequestStart) {
        PrintNcbiRoleAndLocation().PrintNcbiAppInfoOnRequest();
    }
    // Prevent double-flush
    m_Flushed = true;
 
    // Ignore extra messages without arguments. Allow request-start/request-stop
    // and stop without arguments. Empty start messages are printed only if
    // ncbi_role/ncbi_location are available (see above).
    if ((m_EventType == SDiagMessage::eEvent_Extra  ||
        m_EventType == SDiagMessage::eEvent_Start)  &&
        (!m_Args  ||  m_Args->empty()) ) {
        return;
    }
 
    CDiagContext& ctx = GetDiagContext();
    EDiagAppState app_state = ctx.GetAppState();
    bool app_state_updated = false;
    if (m_EventType == SDiagMessage::eEvent_RequestStart) {
        if (app_state != eDiagAppState_RequestBegin  &&
            app_state != eDiagAppState_Request) {
            ctx.SetAppState(eDiagAppState_RequestBegin);
            app_state_updated = true;
        }
        CDiagContext::x_StartRequest();
    }
    else if (m_EventType == SDiagMessage::eEvent_RequestStop) {
        if (app_state != eDiagAppState_RequestEnd) {
            ctx.SetAppState(eDiagAppState_RequestEnd);
            app_state_updated = true;
        }
    }
 
    string s;
    if (m_EventType == SDiagMessage::eEvent_PerfLog) {
        s.append(to_string(m_PerfStatus)).append(1, ' ')
            .append(NStr::DoubleToString(m_PerfTime, -1, NStr::fDoubleFixed));
    }
 
    if (!s_DisableAppLog->Get()) {
        SDiagMessage mess(eDiag_Info,
                          s.data(), s.size(),
                          0, 0, // file, line
                          CNcbiDiag::ForceImportantFlags(kApplogDiagPostFlags),
                          NULL,
                          0, 0, // err code/subcode
                          NULL,
                          0, 0, 0); // module/class/function
        mess.m_Event = m_EventType;
        if (m_Args  &&  !m_Args->empty()) {
            mess.m_ExtraArgs.splice(mess.m_ExtraArgs.end(), *m_Args);
        }
        mess.m_TypedExtra = m_Typed;
        mess.m_AllowBadExtraNames = m_AllowBadNames;
 
        GetDiagBuffer().DiagHandler(mess);
    }
 
    if ( app_state_updated ) {
        if (m_EventType == SDiagMessage::eEvent_RequestStart) {
            ctx.SetAppState(eDiagAppState_Request);
        }
        else if (m_EventType == SDiagMessage::eEvent_RequestStop) {
            ctx.SetAppState(eDiagAppState_AppRun);
        }
    }
}
 
 
void CDiagContext_Extra::x_Release(void)
{
    if ( m_Counter  &&  --(*m_Counter) == 0) {
        Flush();
        delete m_Args;
        m_Args = 0;
    }
}
 
 
CDiagContext_Extra&
CDiagContext_Extra::operator=(const CDiagContext_Extra& args)
{
    if (this != &args) {
        x_Release();
        m_Args = const_cast<CDiagContext_Extra&>(args).m_Args;
        m_Counter = const_cast<CDiagContext_Extra&>(args).m_Counter;
        m_Typed = args.m_Typed;
        m_PerfStatus = args.m_PerfStatus;
        m_PerfTime = args.m_PerfTime;
        m_Flushed = args.m_Flushed;
        m_AllowBadNames = args.m_AllowBadNames;
        (*m_Counter)++;
    }
    return *this;
}
 
 
CDiagContext_Extra::~CDiagContext_Extra(void)
{
    x_Release();
    if ( *m_Counter == 0) {
        delete m_Counter;
    }
}
 
bool CDiagContext_Extra::x_CanPrint(void)
{
    // Only allow extra events to be printed/flushed multiple times
    if (m_Flushed  &&  m_EventType != SDiagMessage::eEvent_Extra) {
        ERR_POST_ONCE(
            "Attempt to set request start/stop arguments after flushing");
        return false;
    }
 
    // For extra messages reset flushed state.
    m_Flushed = false;
    return true;
}
 
 
static const char* kNcbiApplogKeywordStrings[] = {
    // ncbi_phid, self_url and http_referrer are reported by corelib and cgi
    // and should not be renamed.
    /*
    "ncbi_phid",
    "self_url",
    "http_referrer",
    "prev_phid",
    */
    "app",
    "host",
    "ip",
    "ip_addr",
    "session_id",
    "date",
    "datetime",
    "time",
    "guid",
    "acc_time_secs",
    "bytes_in_bit",
    "bytes_out_bit",
    "day",
    "day_of_week",
    "day_of_year",
    "exec_time_msec_bit",
    "start_time_msec",
    "second",
    "minute",
    "hour",
    "iter",
    "month",
    "pid",
    "status",
    "tid",
    "year",
    "geo_metro_code",
    "geo_latitude_hundredths",
    "geo_longitude_hundredths",
    "session_pageviews",
    "ping_count",
    "session_duration",
    "visit_duration",
    "time_on_page",
    "time_to_last_ping",
    "bytes_in",
    "bytes_out",
    "exec_time_msec",
    "self_url_path",
    "self_url_host",
    "self_url_file",
    "self_url_file_ext",
    "self_url_top_level_dir",
    "self_url_directory",
    "referrer",
    "ref_url",
    "ref_host",
    "http_referer",
    "referer",
    "interactive_hit",
    "statusuidlookup",
    "usageuidlookup",
    "all",
    "has_app_data",
    "has_critical",
    "has_duplicate_nexus",
    "has_duplicate_phid",
    "has_error",
    "has_fatal",
    "has_info",
    "has_multiple_phid",
    "has_ping",
    "has_start",
    "has_stop",
    "has_warning",
    "is_app_hit",
    "is_perf",
    "multiple_session_hit",
    "multiple_session_ip",
    "ncbi_phid_first_render",
    "phid_from_other_request",
    "phid_stack_ambiguous_relationship",
    "phid_stack_has_fake_child",
    "phid_stack_has_fake_parent",
    "phid_stack_missing_child",
    "phid_stack_missing_parent",
    "phid_stack_multivalued",
    "session_bot",
    "session_bot_by_ip",
    "session_bot_by_rate",
    "session_bot_by_user_agent",
    "session_bot_ip",
    "session_has_ping",
    "browser_name",
    "browser_version",
    "browser_major_version",
    "browser_platform",
    "browser_engine",
    "is_mobile",
    "is_tablet",
    "is_phone",
    "is_browser_bot",
    "applog_db_path",
    "applog_db_size",
    "applog_db_size_hit_fraction",
    "applog_db_machine",
    "applog_db_vol_id",
    "applog_db_type",
    "applog_db_date_tag",
    "applog_db_date_range",
    "applog_db_stream",
    "applog_db_create_time",
    "applog_db_modify_time",
    "applog_db_state",
    "applog_db_uid",
    "applog_db_agent_host",
    "applog_db_agent_pid",
    "applog_db_agent_tid",
    "applog_db_volume_served_time",
    "phid_stack_missing_parent",
    "phid_stack_missing_child",
    "phid_stack_has_fake_child",
    "phid_stack_has_fake_parent",
    "phid_stack_ambiguous_relationship",
    "phid_stack_multivalued",
    "ncbi_phid_first_render",
    "multiple_session_hit",
    "has_ping",
    "session_has_ping",
    "has_duplicate_nexus",
    "has_app_data",
    "has_multiple_phid",
    "multi_hit_phid",
    "session_bot_by_rate",
    "session_bot_by_user_agent",
    "session_bot",
    "session_bot_by_ip",
    "session_bot_ip",
    "multiple_session_ip",
    "collapsed_jsevent"
};
 
 
struct SNcbiApplogKeywordsInit
{
    typedef unordered_set<string> TKeywords;
    
    TKeywords* Create(void)
    {
        TKeywords* kw = new TKeywords;
        int sz = sizeof(kNcbiApplogKeywordStrings) / sizeof(kNcbiApplogKeywordStrings[0]);
        for (int i = 0; i < sz; ++i) {
            kw->insert(kNcbiApplogKeywordStrings[i]);
        }
        return kw;
    }
 
    void Cleanup(TKeywords& /*keywords*/) {}
};
 
 
static CSafeStatic<SNcbiApplogKeywordsInit::TKeywords, SNcbiApplogKeywordsInit> s_NcbiApplogKeywords;
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, const string& value)
{
    if ( !x_CanPrint() ) {
        return *this;
    }
 
    if ( !m_Args ) {
        m_Args = new TExtraArgs;
    }
 
    // Optimize inserting new pair into the args list, it is the same as:
    //     m_Args->push_back(TExtraArg(name, value));
    m_Args->push_back(TExtraArg(kEmptyStr, kEmptyStr));
 
    // If arg name is a reserved applog keywork, rename it and log warning.
    SNcbiApplogKeywordsInit::TKeywords& kw = s_NcbiApplogKeywords.Get();
    if (kw.find(name) == kw.end()) {
        m_Args->rbegin()->first.assign(name);
    }
    else {
        string renamed = "auto_renamed_applog_keyword__" + name;
        m_Args->rbegin()->first.assign(renamed);
        ERR_POST("'" << name
            << "' is a reserved NCBI AppLog keyword, so it has been renamed to "
            << renamed);
    }
    m_Args->rbegin()->second.assign(value);
    return *this;
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, const char* value)
{
    return Print(name, string(value)); 
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, int value)
{
    return Print(name, NStr::IntToString(value));
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, unsigned int value)
{
    return Print(name, NStr::UIntToString(value));
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, long value)
{
    return Print(name, NStr::LongToString(value));
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, unsigned long value)
{
    return Print(name, NStr::ULongToString(value));
}
 
#if !NCBI_INT8_IS_LONG
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, Int8 value)
{
    return Print(name, NStr::Int8ToString(value));
}
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, Uint8 value)
{
    return Print(name, NStr::UInt8ToString(value));
}
#elif SIZEOF_LONG_LONG
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, long long value)
{
    return Print(name, NStr::Int8ToString(value));
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, unsigned long long value)
{
    return Print(name, NStr::UInt8ToString(value));
}
#endif
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, char value)
{
    return Print(name, string(1,value)); 
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, signed char value)
{
    return Print(name, string(1,value)); 
}
 
CDiagContext_Extra& 
CDiagContext_Extra::Print(const string& name, unsigned char value)
{
    return Print(name, string(1,value)); 
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, double value)
{
    return Print(name, NStr::DoubleToString(value));
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(const string& name, bool value)
{
    return Print(name, NStr::BoolToString(value));
}
 
CDiagContext_Extra&
CDiagContext_Extra::Print(TExtraArgs& args)
{
    if ( !x_CanPrint() ) {
        return *this;
    }
 
    if ( !m_Args ) {
        m_Args = new TExtraArgs;
    }
    m_Args->splice(m_Args->end(), args);
    return *this;
}
 
 
static const char* kExtraTypeArgName = "NCBIEXTRATYPE";
 
CDiagContext_Extra& CDiagContext_Extra::SetType(const string& type)
{
    m_Typed = true;
    Print(kExtraTypeArgName, type);
    return *this;
}
 
 
void CDiagContext::PrintRequestStart(const string& message)
{
    EDiagAppState app_state = GetAppState();
    bool app_state_updated = false;
    if (app_state != eDiagAppState_RequestBegin  &&
        app_state != eDiagAppState_Request) {
        SetAppState(eDiagAppState_RequestBegin);
        app_state_updated = true;
    }
    x_PrintMessage(SDiagMessage::eEvent_RequestStart, message);
    if ( app_state_updated ) {
        SetAppState(eDiagAppState_Request);
    }
}
 
 
void CDiagContext::PrintRequestStop(void)
{
    EDiagAppState app_state = GetAppState();
    bool app_state_updated = false;
    if (app_state != eDiagAppState_RequestEnd) {
        SetAppState(eDiagAppState_RequestEnd);
        app_state_updated = true;
    }
    x_PrintMessage(SDiagMessage::eEvent_RequestStop, kEmptyStr);
    if ( app_state_updated ) {
        SetAppState(eDiagAppState_AppRun);
        // Now back at application level check if a default hit id
        // needs to be logged.
        x_LogHitID_WithLock();
    }
}
 
 
EDiagAppState CDiagContext::GetGlobalAppState(void) const
{
    return m_AppState;
}
 
 
EDiagAppState CDiagContext::GetAppState(void) const
{
    // This checks thread's state first, then calls GetAppState if necessary.
    return GetRequestContext().GetAppState();
}
 
 
void CDiagContext::SetGlobalAppState(EDiagAppState state)
{
    m_AppState = state;
}
 
 
void CDiagContext::SetAppState(EDiagAppState state)
{
    CRequestContext& ctx = GetRequestContext();
    switch ( state ) {
    case eDiagAppState_AppBegin:
    case eDiagAppState_AppRun:
    case eDiagAppState_AppEnd:
        {
            ctx.SetAppState(eDiagAppState_NotSet);
            m_AppState = state;
            break;
        }
    case eDiagAppState_RequestBegin:
    case eDiagAppState_Request:
    case eDiagAppState_RequestEnd:
        ctx.SetAppState(state);
        break;
    default:
        ERR_POST_X(17, Warning << "Invalid EDiagAppState value");
    }
}
 
 
void CDiagContext::SetAppState(EDiagAppState state, EPropertyMode mode)
{
    switch ( mode ) {
    case eProp_Default:
        SetAppState(state);
        break;
    case eProp_Global:
        SetGlobalAppState(state);
        break;
    case eProp_Thread:
        GetRequestContext().SetAppState(state);
        break;
    }
}
 
 
// Session id passed through HTTP
NCBI_PARAM_DECL(string, Log, Http_Session_Id);
NCBI_PARAM_DEF_EX(string, Log, Http_Session_Id, "", eParam_NoThread,
                  HTTP_NCBI_SID);
static CSafeStatic<NCBI_PARAM_TYPE(Log, Http_Session_Id)> s_HttpSessionId;
 
// Session id set in the environment
NCBI_PARAM_DECL(string, Log, Session_Id);
NCBI_PARAM_DEF_EX(string, Log, Session_Id, "", eParam_NoThread,
                  NCBI_LOG_SESSION_ID);
static CSafeStatic<NCBI_PARAM_TYPE(Log, Session_Id)> s_DefaultSessionId;
 
 
DEFINE_STATIC_MUTEX(s_DefaultSidMutex);
 
string CDiagContext::GetDefaultSessionID(void) const
{
    CMutexGuard lock(s_DefaultSidMutex);
    if (m_DefaultSessionId.get() && !m_DefaultSessionId->IsEmpty()) {
        return m_DefaultSessionId->GetOriginalString();
    }
 
    // Needs initialization.
    if ( !m_DefaultSessionId.get() ) {
        m_DefaultSessionId.reset(new CEncodedString);
    }
    if ( m_DefaultSessionId->IsEmpty() ) {
        string sid = CRequestContext::SelectLastSessionID(
            s_HttpSessionId->Get());
        if ( sid.empty() ) {
            sid = CRequestContext::SelectLastSessionID(
                s_DefaultSessionId->Get());
        }
        m_DefaultSessionId->SetString(sid);
    }
    return m_DefaultSessionId->GetOriginalString();
}
 
 
void CDiagContext::SetDefaultSessionID(const string& session_id)
{
    CMutexGuard lock(s_DefaultSidMutex);
    if ( !m_DefaultSessionId.get() ) {
        m_DefaultSessionId.reset(new CEncodedString);
    }
    m_DefaultSessionId->SetString(session_id);
}
 
 
string CDiagContext::GetSessionID(void) const
{
    CRequestContext& rctx = GetRequestContext();
    if ( rctx.IsSetExplicitSessionID() ) {
        return rctx.GetSessionID();
    }
    return GetDefaultSessionID();
}
 
 
string CDiagContext::GetEncodedSessionID(void) const
{
    CRequestContext& rctx = GetRequestContext();
    if ( rctx.IsSetExplicitSessionID() ) {
        return rctx.GetEncodedSessionID();
    }
    GetDefaultSessionID(); // Make sure the default value is initialized.
    CMutexGuard lock(s_DefaultSidMutex);
    _ASSERT(m_DefaultSessionId.get());
    return m_DefaultSessionId->GetEncodedString();
}
 
 
NCBI_PARAM_DECL(string, Log, Client_Ip);
NCBI_PARAM_DEF_EX(string, Log, Client_Ip, "", eParam_NoThread,
                  NCBI_LOG_CLIENT_IP);
static CSafeStatic<NCBI_PARAM_TYPE(Log, Client_Ip)> s_DefaultClientIp;
 
 
string CDiagContext::GetDefaultClientIP(void)
{
    return s_DefaultClientIp->Get();
}
 
 
void CDiagContext::SetDefaultClientIP(const string& client_ip)
{
    s_DefaultClientIp->Set(client_ip);
}
 
 
// Hit id passed through HTTP
NCBI_PARAM_DECL(string, Log, Http_Hit_Id);
NCBI_PARAM_DEF_EX(string, Log, Http_Hit_Id, "", eParam_NoThread,
                  HTTP_NCBI_PHID);
static CSafeStatic<NCBI_PARAM_TYPE(Log, Http_Hit_Id)> s_HttpHitId;
 
// Hit id set in the environment or registry
NCBI_PARAM_DECL(string, Log, Hit_Id);
NCBI_PARAM_DEF_EX(string, Log, Hit_Id, "", eParam_NoThread,
                  NCBI_LOG_HIT_ID);
static CSafeStatic<NCBI_PARAM_TYPE(Log, Hit_Id)> s_HitId;
 
 
DEFINE_STATIC_MUTEX(s_DefaultHidMutex);
 
bool CDiagContext::x_DiagAtApplicationLevel(void) const
{
    EDiagAppState state = GetAppState();
    return (state == eDiagAppState_AppBegin) ||
        (state == eDiagAppState_AppRun) ||
        (state == eDiagAppState_AppEnd);
}
 
 
void CDiagContext::x_LogHitID(void) const
{
    // NOTE: The method must be always called with s_DefaultHidMutex locked.
 
    // Log the default hit id only when at application level. Otherwise
    // pospone it untill request-stop/app-stop.
    if (m_LoggedHitId || !m_DefaultHitId.get() || m_DefaultHitId->Empty() ||
        !x_DiagAtApplicationLevel()) {
        return;
    }
    Extra().Print(g_GetNcbiString(eNcbiStrings_PHID), m_DefaultHitId->GetHitId());
    m_LoggedHitId = true;
}
 
 
void CDiagContext::x_LogHitID_WithLock(void) const
{
    CMutexGuard guard(s_DefaultHidMutex);
    x_LogHitID();
}
 
 
bool CDiagContext::x_IsSetDefaultHitID(void) const
{
    CMutexGuard guard(s_DefaultHidMutex);
    return m_DefaultHitId.get() && !m_DefaultHitId->Empty();
}
 
 
CSharedHitId CDiagContext::x_GetDefaultHitID(EDefaultHitIDFlags flag) const
{
    CMutexGuard guard(s_DefaultHidMutex);
    if (m_DefaultHitId.get()  &&  !m_DefaultHitId->Empty()) {
        return *m_DefaultHitId;
    }
 
    if ( !m_DefaultHitId.get() ) {
        m_DefaultHitId.reset(new CSharedHitId());
    }
    if ( m_DefaultHitId->Empty() ) {
        m_DefaultHitId->SetHitId(CRequestContext::SelectLastHitID(
            s_HttpHitId->Get()));
        if ( m_DefaultHitId->Empty() ) {
            string phid = CRequestContext::SelectLastHitID(
                s_HitId->Get());
            if ( !phid.empty() ) {
                const char* c_env_job_id = getenv("JOB_ID");
                string env_job_id = c_env_job_id ? string(c_env_job_id): "";
                const char* c_env_task_id = getenv("SGE_TASK_ID");
                string env_task_id = c_env_task_id ? string(c_env_task_id) : "";
                if (env_task_id.find_first_not_of("0123456789") != NPOS) {
                    // If task id is 'undefined', set it to 1 - it's a job with
                    // just one task.
                    env_task_id = "1";
                }
                if (!env_job_id.empty()  &&  !env_task_id.empty()) {
                    // FIX LATER: It's better to use J and T prefix
                    // to indicate job/task, but currently CRequestContext
                    // logs errors if sub-hit id contains non-digits.
                    // Using leading 0s is a temporary solution. Later,
                    // when most apps are recompiled with the new
                    // CRequestContext, we can reconsider using J/T.
                    string jid = ".000" + env_job_id;
                    string tid = ".00" + env_task_id;
                    size_t jid_pos = phid.find(jid);
                    if (jid_pos == NPOS) {
                        // No current job id in the phid.
                        phid += jid + tid;
                    }
                    else {
                        // Job id is already in the phid. Check task id.
                        if (phid.find(tid, jid_pos + jid.size()) == NPOS) {
                            // New task in the same job.
                            phid += tid;
                        }
                        // else - task id already in the phid. Ignore.
                    }
                }
            }
            m_DefaultHitId->SetHitId(phid);
        }
        if (m_DefaultHitId->Empty()  &&  (flag == eHitID_Create)) {
            m_DefaultHitId->SetHitId(x_GetNextHitID(true));
        }
    }
    // Default hit id always uses shared sub-hit counter.
    m_DefaultHitId->SetShared();
    _ASSERT(!m_LoggedHitId);
    // Log hit id if at application level.
    x_LogHitID();
    return *m_DefaultHitId;
}
 
 
void CDiagContext::SetDefaultHitID(const string& hit_id)
{
    CMutexGuard guard(s_DefaultHidMutex);
    if ( !m_DefaultHitId.get() ) {
        m_DefaultHitId.reset(new CSharedHitId());
    }
    m_DefaultHitId->SetHitId(hit_id);
    // Default hit id always uses shared sub-hit counter.
    m_DefaultHitId->SetShared();
    // Log new hit id when at application level.
    m_LoggedHitId = false;
    x_LogHitID();
}
 
 
inline string s_ReadString(const char* filename)
{
    string ret;
    CNcbiIfstream in(filename);
    if ( in.good() ) {
        getline(in, ret);
    }
    return ret;
}
 
 
static CSafeStatic< unique_ptr<string> > s_HostRole;
static CSafeStatic< unique_ptr<string> > s_HostLocation;
 
const string& CDiagContext::GetHostRole(void)
{
    if ( !s_HostRole->get() ) {
        CDiagLock lock(CDiagLock::eWrite);
        if ( !s_HostRole->get() ) {
            unique_ptr<string> role(new string);
            const TXChar* env_role = NcbiSys_getenv(_TX("NCBI_ROLE"));
            if (env_role && *env_role) {
                *role = string(_T_CSTRING(env_role));
            }
            else {
                *role = s_ReadString("/etc/ncbi/role");
            }
            s_HostRole->reset(role.release());
        }
    }
    return **s_HostRole;
}
 
 
const string& CDiagContext::GetHostLocation(void)
{
    if ( !s_HostLocation->get() ) {
        CDiagLock lock(CDiagLock::eWrite);
        if ( !s_HostLocation->get() ) {
            unique_ptr<string> loc(new string);
            const TXChar* env_loc = NcbiSys_getenv(_TX("NCBI_LOCATION"));
            if (env_loc && *env_loc) {
                *loc = string(_T_CSTRING(env_loc));
            }
            else {
                *loc = s_ReadString("/etc/ncbi/location");
            }
            s_HostLocation->reset(loc.release());
        }
    }
    return **s_HostLocation;
}
 
 
const char* CDiagContext::kProperty_UserName    = "user";
const char* CDiagContext::kProperty_HostName    = "host";
const char* CDiagContext::kProperty_HostIP      = "host_ip_addr";
const char* CDiagContext::kProperty_ClientIP    = "client_ip";
const char* CDiagContext::kProperty_SessionID   = "session_id";
const char* CDiagContext::kProperty_AppName     = "app_name";
const char* CDiagContext::kProperty_AppState    = "app_state";
const char* CDiagContext::kProperty_ExitSig     = "exit_signal";
const char* CDiagContext::kProperty_ExitCode    = "exit_code";
const char* CDiagContext::kProperty_ReqStatus   = "request_status";
const char* CDiagContext::kProperty_ReqTime     = "request_time";
const char* CDiagContext::kProperty_BytesRd     = "bytes_rd";
const char* CDiagContext::kProperty_BytesWr     = "bytes_wr";
 
static const char* kDiagTimeFormat = "Y-M-DTh:m:s.rZ";
// Fixed fields' widths
static const int   kDiagW_PID      = 5;
static const int   kDiagW_TID      = 3;
static const int   kDiagW_RID      = 4;
static const int   kDiagW_AppState = 2;
static const int   kDiagW_SN       = 4;
static const int   kDiagW_UID      = 16;
static const int   kDiagW_Host     = 15;
static const int   kDiagW_Client   = 15;
static const int   kDiagW_Session  = 24;
 
static const char* kUnknown_Host    = "UNK_HOST";
static const char* kUnknown_Client  = "UNK_CLIENT";
static const char* kUnknown_Session = "UNK_SESSION";
static const char* kUnknown_App     = "UNK_APP";
 
 
void CDiagContext::WriteStdPrefix(CNcbiOstream& ostr,
                                  const SDiagMessage& msg) const
{
    char uid[17];
    GetStringUID(msg.GetUID(), uid, 17);
    const string& host = msg.GetHost();
    string client = msg.GetClient();
    string session = msg.GetSession();
    const string& app = msg.GetAppName();
    const char* app_state = s_AppStateToStr(msg.GetAppState());
 
    // Print common fields
    ostr << setfill('0') << setw(kDiagW_PID) << msg.m_PID << '/'
         << setw(kDiagW_TID) << msg.m_TID << '/'
         << setw(kDiagW_RID) << msg.m_RequestId
         << "/"
         << setfill(' ') << setw(kDiagW_AppState) << setiosflags(IOS_BASE::left)
         << app_state << resetiosflags(IOS_BASE::left)
         << ' ' << setw(0) << setfill(' ') << uid << ' '
         << setfill('0') << setw(kDiagW_SN) << msg.m_ProcPost << '/'
         << setw(kDiagW_SN) << msg.m_ThrPost << ' '
         << setw(0) << msg.GetTime().AsString(kDiagTimeFormat) << ' '
         << setfill(' ') << setiosflags(IOS_BASE::left)
         << setw(kDiagW_Host)
         << (host.empty() ? kUnknown_Host : host.c_str()) << ' '
         << setw(kDiagW_Client)
         << (client.empty() ? kUnknown_Client : client.c_str()) << ' '
         << setw(kDiagW_Session)
         << (session.empty() ? kUnknown_Session : session.c_str()) << ' '
         << resetiosflags(IOS_BASE::left) << setw(0)
         << (app.empty() ? kUnknown_App : app.c_str()) << ' ';
}
 
 
void CDiagContext::x_StartRequest(void)
{
    // Reset properties
    CRequestContext& ctx = GetRequestContext();
    if ( ctx.IsRunning() ) {
        // The request is already running -
        // duplicate request start or missing request stop
        ERR_POST_ONCE(
            "Duplicate request-start or missing request-stop");
    }
 
    // Use the default client ip if no other value is set.
    if ( !ctx.IsSetExplicitClientIP() ) {
        string ip = GetDefaultClientIP();
        if ( !ip.empty() ) {
            ctx.SetClientIP(ip);
        }
    }
 
    ctx.StartRequest();
    x_LogEnvironment();
}
 
 
void CDiagContext::x_LogEnvironment(void)
{
    // Print selected environment and registry values.
    static CSafeStatic<NCBI_PARAM_TYPE(Log, LogEnvironment)> s_LogEnvironment;
    string log_args = s_LogEnvironment->Get();
    if ( !log_args.empty() ) {
        list<string> log_args_list;
        NStr::Split(log_args, " ", log_args_list,
            NStr::fSplit_MergeDelimiters | NStr::fSplit_Truncate);
        CDiagContext_Extra extra = GetDiagContext().Extra();
        extra.Print("LogEnvironment", "true");
        {{
            // The guard must be released before flushing the extra -
            // otherwise there may be a deadlock when accessing CParam-s
            // from other threads.
            CNcbiApplicationGuard app = CNcbiApplication::InstanceGuard();
            if ( app ) {
                const CNcbiEnvironment& env = app->GetEnvironment();
                ITERATE(list<string>, it, log_args_list) {
                    const string& val = env.Get(*it);
                    extra.Print(*it, val);
                }
            }
        }}
        extra.Flush();
    }
    static CSafeStatic<NCBI_PARAM_TYPE(Log, LogRegistry)> s_LogRegistry;
    log_args = s_LogRegistry->Get();
    if ( !log_args.empty() ) {
        list<string> log_args_list;
        NStr::Split(log_args, " ", log_args_list,
            NStr::fSplit_MergeDelimiters | NStr::fSplit_Truncate);
        CDiagContext_Extra extra = GetDiagContext().Extra();
        extra.Print("LogRegistry", "true");
        {{
            // The guard must be released before flushing the extra -
            // see above.
            CNcbiApplicationGuard app = CNcbiApplication::InstanceGuard();
            if ( app ) {
                const CNcbiRegistry& reg = app->GetConfig();
                ITERATE(list<string>, it, log_args_list) {
                    string section, name;
                    NStr::SplitInTwo(*it, ":", section, name);
                    const string& val = reg.Get(section, name);
                    extra.Print(*it, val);
                }
            }
        }}
        extra.Flush();
    }
}
 
 
void CDiagContext::x_PrintMessage(SDiagMessage::EEventType event,
                                  const string&            message)
{
    if ( IsSetOldPostFormat() ) {
        return;
    }
    string str;
    string prop;
    bool need_space = false;
    CRequestContext& ctx = GetRequestContext();
 
    switch ( event ) {
    case SDiagMessage::eEvent_Start:
    case SDiagMessage::eEvent_Extra:
        break;
    case SDiagMessage::eEvent_RequestStart:
        {
            x_StartRequest();
            break;
        }
    case SDiagMessage::eEvent_Stop:
        str.append(to_string(GetExitCode())).append(1, ' ').append(m_StopWatch->AsString());
        if (GetExitSignal() != 0) {
            str.append(" SIG=").append(to_string(GetExitSignal()));
        }
        need_space = true;
        break;
    case SDiagMessage::eEvent_RequestStop:
        {
            if ( !ctx.IsRunning() ) {
                // The request is not running -
                // duplicate request stop or missing request start
                ERR_POST_ONCE(
                    "Duplicate request-stop or missing request-start");
            }
            str.append(to_string(ctx.GetRequestStatus())).append(1, ' ')
                .append(ctx.GetRequestTimer().AsString()).append(1, ' ')
                .append(to_string(ctx.GetBytesRd())).append(1, ' ')
                .append(to_string(ctx.GetBytesWr()));
            need_space = true;
            break;
        }
    default:
        return; // Prevent warning about other event types.
    }
    if ( !message.empty() ) {
        if (need_space) {
            str.append(1, ' ');
        }
        str.append(message);
    }
 
    if (!s_DisableAppLog->Get()) {
        SDiagMessage mess(eDiag_Info,
            str.data(), str.size(),
            0, 0, // file, line
            CNcbiDiag::ForceImportantFlags(kApplogDiagPostFlags),
            NULL,
            0, 0, // err code/subcode
            NULL,
            0, 0, 0); // module/class/function
        mess.m_Event = event;
        CDiagBuffer::DiagHandler(mess);
    }
 
    if (event == SDiagMessage::eEvent_RequestStop) {
        // Reset request context after stopping the request.
        ctx.StopRequest();
    }
}
 
 
bool CDiagContext::IsSetOldPostFormat(void)
{
    return s_OldPostFormat->Get();
}
 
 
void CDiagContext::SetOldPostFormat(bool value)
{
    s_OldPostFormat->Set(value);
}
 
 
bool CDiagContext::IsUsingSystemThreadId(void)
{
     return s_PrintSystemTID->Get();
}
 
 
void CDiagContext::UseSystemThreadId(bool value)
{
    s_PrintSystemTID->Set(value);
}
 
 
void CDiagContext::InitMessages(size_t max_size)
{
    if ( !m_Messages.get() ) {
        m_Messages.reset(new TMessages);
    }
    m_MaxMessages = max_size;
}
 
 
void CDiagContext::PushMessage(const SDiagMessage& message)
{
    if ( m_Messages.get()  &&  m_Messages->size() < m_MaxMessages) {
        m_Messages->push_back(message);
    }
}
 
 
void CDiagContext::FlushMessages(CDiagHandler& handler)
{
    if ( !m_Messages.get()  ||  m_Messages->empty() ) {
        return;
    }
    CTeeDiagHandler* tee = dynamic_cast<CTeeDiagHandler*>(&handler);
    if (tee  &&  !tee->GetOriginalHandler()) {
        // Tee over STDERR - flushing will create duplicate messages
        return;
    }
    unique_ptr<TMessages> tmp(m_Messages.release());
    //ERR_POST_X(1, Note << "***** BEGIN COLLECTED MESSAGES *****");
    NON_CONST_ITERATE(TMessages, it, *tmp.get()) {
        it->m_NoTee = true; // Do not tee duplicate messages to console.
        handler.Post(*it);
        if (it->m_Flags & eDPF_IsConsole) {
            handler.PostToConsole(*it);
        }
    }
    //ERR_POST_X(2, Note << "***** END COLLECTED MESSAGES *****");
    m_Messages.reset(tmp.release());
}
 
 
void CDiagContext::DiscardMessages(void)
{
    m_Messages.reset();
}
 
 
// Diagnostics setup
 
static const char* kRootLog = "/log/";
 
string GetDefaultLogLocation(CNcbiApplication& app)
{
    static const char* kToolkitRcPath = "/etc/toolkitrc";
    static const char* kWebDirToPort = "Web_dir_to_port";
 
    string log_path = kRootLog;
 
    string exe_path = CFile(app.GetProgramExecutablePath()).GetDir();
    CNcbiIfstream is(kToolkitRcPath, ios::binary);
    CNcbiRegistry reg(is);
    list<string> entries;
    reg.EnumerateEntries(kWebDirToPort, &entries);
    size_t min_pos = exe_path.length();
    string web_dir;
    // Find the first dir name corresponding to one of the entries
    ITERATE(list<string>, it, entries) {
        if (!it->empty()  &&  (*it)[0] != '/') {
            // not an absolute path
            string mask = "/" + *it;
            if (mask[mask.length() - 1] != '/') {
                mask += "/";
            }
            size_t pos = exe_path.find(mask);
            if (pos < min_pos) {
                min_pos = pos;
                web_dir = *it;
            }
        }
        else {
            // absolute path
            if (exe_path.substr(0, it->length()) == *it) {
                web_dir = *it;
                break;
            }
        }
    }
    if ( !web_dir.empty() ) {
        return log_path + reg.GetString(kWebDirToPort, web_dir, kEmptyStr);
    }
    // Could not find a valid web-dir entry, use /log/port or empty string
    // to try /log/srv later.
    const TXChar* port = NcbiSys_getenv(_TX("SERVER_PORT"));
    return port ? log_path + string(_T_CSTRING(port)) : kEmptyStr;
}
 
 
typedef NCBI_PARAM_TYPE(Log, Truncate) TLogTruncateParam;
 
bool CDiagContext::GetLogTruncate(void)
{
    return TLogTruncateParam::GetDefault();
}
 
 
void CDiagContext::SetLogTruncate(bool value)
{
    TLogTruncateParam::SetDefault(value);
}
 
 
bool OpenLogFileFromConfig(const string& logname)
{
    if ( !logname.empty() ) {
        if (NCBI_PARAM_TYPE(Log, NoCreate)::GetDefault()  &&  !CDirEntry(logname).Exists() ) {
            return false;
        }
        return SetLogFile(logname, eDiagFile_All, true);
    }
    return false;
}
 
 
void CDiagContext::SetUseRootLog(void)
{
    if (!s_FinishedSetupDiag) {
        SetupDiag();
    }
}
 
 
void CDiagContext::x_FinalizeSetupDiag(void)
{
    _ASSERT(!s_FinishedSetupDiag);
    s_FinishedSetupDiag = true;
}
 
 
// Load string value from config if not null, or from the environment.
static string s_GetLogConfigString(const CTempString name,
                                   const CTempString defval,
                                   CNcbiRegistry*    config)
{
    if ( config ) {
        return config->GetString("LOG", name, defval);
    }
    string envname = "NCBI_CONFIG__LOG__";
    envname += name;
    const TXChar* val = NcbiSys_getenv(_T_XCSTRING(envname));
    return val ? CTempString(_T_STDSTRING(val)) : defval;
}
 
 
// Load bool value from config if not null, or from the environment.
static bool s_GetLogConfigBool(const CTempString name,
                               bool              defval,
                               CNcbiRegistry*    config)
{
    if ( config ) {
        return config->GetBool("LOG", name, defval);
    }
    string envname = "NCBI_CONFIG__LOG__";
    envname += name;
    const TXChar* val = NcbiSys_getenv(_T_XCSTRING(envname));
    if ( val ) {
        try {
            return NStr::StringToBool(_T_STDSTRING(val));
        }
        catch (const CStringException&) {
        }
    }
    return defval;
}
 
 
void CDiagContext::SetupDiag(EAppDiagStream       ds,
                             CNcbiRegistry*       config,
                             EDiagCollectMessages collect,
                             const char*          cmd_logfile)
{
    CDiagLock lock(CDiagLock::eWrite);
 
    CParamBase::EnableConfigDump(false);
 
    // Check severity level change status now.
    // This used to be done in SetDiag(), but if the first logging event is an
    // Extra(), new post format is enabled and post level is Trace, the initialization
    // results in infinite recursion. To prevent this, call this as soon as possible,
    // before any logging is done.
    if ( CDiagBuffer::sm_PostSeverityChange == eDiagSC_Unknown ) {
        CDiagBuffer::GetSeverityChangeEnabledFirstTime();
    }
 
    CDiagContext& ctx = GetDiagContext();
    // Initialize message collecting
    if (collect == eDCM_Init) {
        ctx.InitMessages();
    }
    else if (collect == eDCM_InitNoLimit) {
        ctx.InitMessages(size_t(-1));
    }
 
    /*
    The default order of checking possible log locations is:
    
      1. CMD - '-logfile <filename>' command line arg
      2. ENV - NCBI_CONFIG__LOG__FILE (or [Log]/File)
      3. LOG - /log/ if writable
      4. Other locations depending on 'ds' flag (e.g. current directory)
 
      IgnoreEnvArg: if CMD should be checked before (true) or after (false) ENV/LOG.
      TryRootLogFirst: if LOG should be checked berofe (true) or after (false) ENV.
 
      The resulting order is:
 
           IgnoreEnvArg: | true              | false
      -------------------+-------------------+---------------
      TryRootLogFirst:   |                   |
                    true | CMD, LOG, ENV     | LOG, ENV, CMD
                   false | CMD, ENV, LOG     | ENV, LOG, CMD
 
      Successfull opening of CMD/ENV/LOG also overrides any eDS_* flags except eDS_User.
    */
 
    bool log_set = false;
    bool to_applog = false;
    string old_log_name;
    string new_log_name;
 
    CDiagHandler* old_handler = GetDiagHandler();
    if ( old_handler ) {
        old_log_name = old_handler->GetLogName();
    }
 
    string config_logfile = s_GetLogConfigString("FILE", kEmptyStr, config);
    if ( config_logfile.empty() ) {
        // Try the old-style name
        config_logfile = s_GetLogConfigString("File", kEmptyStr, config);
    }
    bool cmdline_first = s_GetLogConfigBool("IgnoreEnvArg", true, config);
    bool applog_first = s_GetLogConfigBool("TryRootLogFirst", false, config);
 
    if (ds != eDS_User) {
        // If cmdline_first is not set, it will be checked later, after
        // checking all other possibilities.
        if (cmdline_first  &&  cmd_logfile) {
            if ( SetLogFile(cmd_logfile, eDiagFile_All) ) {
                log_set = true;
                new_log_name = cmd_logfile;
            }
        }
        // If applog_first is set, config will be checked later for eDS_ToStdlog
        // and eDS_Default but only if /log is not available.
        if (!log_set  &&  !applog_first  &&  !config_logfile.empty()) {
            if ( OpenLogFileFromConfig(config_logfile) ) {
                log_set = true;
                new_log_name = config_logfile;
            }
        }
        // The following three eDS_* options should check /log/* before using -logfile.
        if (!log_set  &&  !cmdline_first  &&  cmd_logfile  &&
            ds != eDS_Default  &&  ds != eDS_ToStdlog  &&  ds != eDS_ToSyslog) {
            if ( SetLogFile(cmd_logfile, eDiagFile_All) ) {
                log_set = true;
                new_log_name = cmd_logfile;
            }
        }
    }
 
    if ( !log_set ) {
        switch ( ds ) {
        case eDS_ToStdout:
            if (old_log_name != kLogName_Stdout) {
                NCBI_LSAN_DISABLE_GUARD;
                SetDiagHandler(new CStreamDiagHandler(&cout, true, kLogName_Stdout), true);
                log_set = true;
                new_log_name = kLogName_Stdout;
            }
            break;
        case eDS_ToStderr:
            if (old_log_name != kLogName_Stderr) {
                NCBI_LSAN_DISABLE_GUARD;
                SetDiagHandler(new CStreamDiagHandler(&cerr, true, kLogName_Stderr), true);
                log_set = true;
                new_log_name = kLogName_Stderr;
            }
            break;
        case eDS_ToMemory:
            if (old_log_name != kLogName_Memory) {
                ctx.InitMessages(size_t(-1));
                SetDiagStream(0, false, 0, 0, kLogName_Memory);
                log_set = true;
                new_log_name = kLogName_Memory;
            }
            collect = eDCM_NoChange; // prevent flushing to memory
            break;
        case eDS_Disable:
            if (old_log_name != kLogName_None) {
                SetDiagStream(0, false, 0, 0, kLogName_None);
                log_set = true;
                new_log_name = kLogName_None;
            }
            break;
        case eDS_User:
            collect = eDCM_Discard;
            break;
        case eDS_AppSpecific:
            collect = eDCM_Discard;
            break;
        case eDS_ToSyslog:
            if (old_log_name != CSysLog::kLogName_Syslog) {
                try {
                    NCBI_LSAN_DISABLE_GUARD;
                    SetDiagHandler(new CSysLog);
                    log_set = true;
                    new_log_name = CSysLog::kLogName_Syslog;
                    break;
                } catch (...) {
                    // fall through
                }
            } else {
                break;
            }
        case eDS_ToStdlog:
        case eDS_Default:
            {
                // When using applog, create separate log file for each
                // user to avoid permission problems.
                string euid;
#if defined(NCBI_OS_UNIX)
                euid = "." + NStr::NumericToString(geteuid());
#endif
                string log_base;
                string def_log_dir;
                {{
                    CNcbiApplicationGuard app = CNcbiApplication::InstanceGuard();
                    if ( app ) {
                        log_base = app->GetProgramExecutablePath();
                        def_log_dir = GetDefaultLogLocation(*app);
                    }
                }}
                if ( !log_base.empty() ) {
                    log_base = CFile(log_base).GetBase() + euid + ".log";
                    string log_name;
                    // Try /log/<port>
                    if ( !def_log_dir.empty() ) {
                        log_name = CFile::ConcatPath(def_log_dir, log_base);
                        if ( SetLogFile(log_name) ) {
                            log_set = true;
                            new_log_name = log_name;
                            to_applog = true;
                            break;
                        }
                    }
                    // Try /log/srv if port is unknown or not writable
                    log_name = CFile::ConcatPath(CFile::ConcatPath(kRootLog, "srv"), log_base);
                    if ( SetLogFile(log_name) ) {
                        log_set = true;
                        new_log_name = log_name;
                        to_applog = true;
                        break;
                    }
                    // Have we skipped config_logfile above?
                    if (applog_first &&
                        OpenLogFileFromConfig(config_logfile)) {
                        log_set = true;
                        new_log_name = config_logfile;
                        break;
                    }
                    // Try to switch to /log/fallback/
                    log_name = CFile::ConcatPath(CFile::ConcatPath(kRootLog, "fallback"), log_base);
                    if ( SetLogFile(log_name) ) {
                        log_set = true;
                        new_log_name = log_name;
                        to_applog = true;
                        break;
                    }
                    // Try cwd/ for eDS_ToStdlog only
                    if (ds == eDS_ToStdlog) {
                        // Don't include euid in file name when using cwd.
                        log_name = CFile::ConcatPath(".", CFile(log_base).GetBase() + ".log");
                        if ( SetLogFile(log_name, eDiagFile_All) ) {
                            log_set = true;
                            new_log_name = log_name;
                            break;
                        }
                    }
                    _TRACE_X(3, "Failed to set log file to " +
                        CFile::NormalizePath(log_name));
                }
                // Have we skipped cmd_logfile above?
                if (!log_set  &&  !cmdline_first  &&  cmd_logfile) {
                    if ( SetLogFile(cmd_logfile, eDiagFile_All) ) {
                        log_set = true;
                        new_log_name = cmd_logfile;
                        break;
                    }
                }
                // No command line and no base name.
                // Try to switch to /log/fallback/UNKNOWN.<euid>
                if (!log_set  &&  log_base.empty()) {
                    string default_fallback = CFile::ConcatPath(kRootLog, "fallback/UNKNOWN.log");
                    if ( SetLogFile(default_fallback + euid) ) {
                        log_set = true;
                        new_log_name = default_fallback;
                        to_applog = true;
                        break;
                    }
                    _TRACE_X(4, "Failed to set log file to " <<
                        CFile::NormalizePath(default_fallback));
                }
                const char* log_name = TTeeToStderr::GetDefault() ?
                    kLogName_Tee : kLogName_Stderr;
                if (!log_set  &&  old_log_name != log_name) {
                    NCBI_LSAN_DISABLE_GUARD;
                    SetDiagHandler(new CStreamDiagHandler(&cerr,
                        true, kLogName_Stderr), true);
                    log_set = true;
                    new_log_name = log_name;
                }
                break;
            }
        default:
            ERR_POST_X(5, Warning << "Unknown EAppDiagStream value");
            _ASSERT(0);
            break;
        }
    }
 
    // Unlock severity level
    SetApplogSeverityLocked(false);
    if ( to_applog ) {
        ctx.SetOldPostFormat(false);
        s_LogSizeLimit->Set(0); // No log size limit
        SetDiagPostLevel(eDiag_Warning);
        // Lock severity level
        SetApplogSeverityLocked(true);
    }
    else {
        // Disable throttling
        ctx.SetLogRate_Limit(eLogRate_App, CRequestRateControl::kNoLimit);
        ctx.SetLogRate_Limit(eLogRate_Err, CRequestRateControl::kNoLimit);
        ctx.SetLogRate_Limit(eLogRate_Trace, CRequestRateControl::kNoLimit);
    }
 
    CDiagHandler* new_handler = GetDiagHandler();
    // Flush collected messages to the log if either its name has changed
    // or log file truncation is enabled.
    if (log_set  &&  new_handler  &&  new_handler->GetLogName() == old_log_name) {
        bool is_file = dynamic_cast<CFileHandleDiagHandler*>(new_handler)  ||
            dynamic_cast<CFileDiagHandler*>(new_handler);
        log_set = log_set  &&  is_file  &&  GetLogTruncate();
    }
 
    if (collect == eDCM_Flush) {
        // Flush and discard
        if ( log_set  &&  new_handler ) {
            ctx.FlushMessages(*new_handler);
        }
        collect = eDCM_Discard;
    }
    else if (collect == eDCM_NoChange) {
        // Flush but don't discard
        if ( log_set  &&  new_handler ) {
            ctx.FlushMessages(*new_handler);
        }
    }
    if (collect == eDCM_Discard) {
        ctx.DiscardMessages();
    }
 
    // Refresh rate controls
    ctx.ResetLogRates();
 
    CParamBase::EnableConfigDump(true);
}
 
 
CDiagContext::TCount CDiagContext::GetProcessPostNumber(EPostNumberIncrement inc)
{
    static CAtomicCounter s_ProcessPostCount;
    return (TCount)(inc == ePostNumber_Increment ?
        s_ProcessPostCount.Add(1) : s_ProcessPostCount.Get());
}
 
 
CDiagContext::TCount CDiagContext::GetThreadPostNumber(EPostNumberIncrement inc)
{
    return CDiagContextThreadData::GetThreadData().GetThreadPostNumber(inc);
}
 
 
CDiagContext::TTID CDiagContext::GetTID(void)
{
    return CDiagContextThreadData::GetThreadData().GetTID();
}
 
 
bool CDiagContext::IsUsingRootLog(void)
{
    return GetLogFile().substr(0, 5) == kRootLog;
}
 
 
CDiagContext& GetDiagContext(void)
{
    // Make the context live longer than other diag safe-statics
    // and +1 longer than TLS safe statics which print app stop
    // from their cleanup.
    static CSafeStatic<CDiagContext> s_DiagContext(
        CSafeStaticLifeSpan(CSafeStaticLifeSpan::eLifeSpan_Long, 1));
 
    return s_DiagContext.Get();
}
 
 
///////////////////////////////////////////////////////
//  CNcbiLogFields::
 
#ifdef NCBI_LOG_FIELDS_CUSTOM
NCBI_PARAM_DECL(string, Log, Ncbi_Log_Fields_Custom);
NCBI_PARAM_DEF_EX(string, Log, Ncbi_Log_Fields_Custom, "",
    eParam_NoThread, NCBI_LOG_FIELDS_CUSTOM);
typedef NCBI_PARAM_TYPE(Log, Ncbi_Log_Fields_Custom) TCustomLogFields;
#endif
 
 
CNcbiLogFields::CNcbiLogFields(const string& source)
    : m_Source(source)
{
    const TXChar* env_fields = NcbiSys_getenv(_TX("NCBI_LOG_FIELDS"));
    if ( env_fields ) {
        string fields = _T_CSTRING(env_fields);
        NStr::ToLower(fields);
        NStr::ReplaceInPlace(fields, "_", "-");
        NStr::Split(fields, " ", m_Fields, NStr::fSplit_Tokenize);
    }
#ifdef NCBI_LOG_FIELDS_CUSTOM
    string custom_fields = TCustomLogFields::GetDefault();
    NStr::ToLower(custom_fields);
    NStr::ReplaceInPlace(custom_fields, "_", "-");
    NStr::Split(custom_fields, " ", m_Fields, NStr::fSplit_Tokenize);
#endif
}
 
 
CNcbiLogFields::~CNcbiLogFields(void)
{
}
 
 
void CNcbiLogFields::x_Match(const string& name, const string& value, CDiagContext_Extra& extra) const
{
    ITERATE(TFields, it, m_Fields) {
        if ( it->empty() ) continue; // Skip empty entries since they match anything.
        if (NStr::MatchesMask(name, *it, NStr::eNocase)) {
            extra.Print((m_Source.empty() ? name : m_Source + "." + name), value);
            break; // Stop if a match is found.
        }
    }
}
 
 
///////////////////////////////////////////////////////
//  CDiagBuffer::
 
#if defined(NDEBUG)
EDiagSev       CDiagBuffer::sm_PostSeverity       = eDiag_Error;
#else
EDiagSev       CDiagBuffer::sm_PostSeverity       = eDiag_Warning;
#endif
 
EDiagSevChange CDiagBuffer::sm_PostSeverityChange = eDiagSC_Unknown;
                                                  // to be set on first request
 
static const TDiagPostFlags s_DefaultPostFlags =
    eDPF_Prefix | eDPF_Severity | eDPF_ErrorID |
    eDPF_ErrCodeMessage | eDPF_ErrCodeExplanation |
    eDPF_ErrCodeUseSeverity;
static TDiagPostFlags s_PostFlags = 0;
static bool s_DiagPostFlagsInitialized = false;
 
inline
TDiagPostFlags& CDiagBuffer::sx_GetPostFlags(void)
{
    if (!s_DiagPostFlagsInitialized) {
        s_PostFlags = s_DefaultPostFlags;
        s_DiagPostFlagsInitialized = true;
    }
    return s_PostFlags;
}
 
 
TDiagPostFlags& CDiagBuffer::s_GetPostFlags(void)
{
    return sx_GetPostFlags();
}
 
 
TDiagPostFlags CDiagBuffer::sm_TraceFlags         = eDPF_Trace;
 
bool           CDiagBuffer::sm_IgnoreToDie        = false;
EDiagSev       CDiagBuffer::sm_DieSeverity        = eDiag_Fatal;
 
EDiagTrace     CDiagBuffer::sm_TraceDefault       = eDT_Default;
bool           CDiagBuffer::sm_TraceEnabled;     // to be set on first request
 
 
const char*    CDiagBuffer::sm_SeverityName[eDiag_Trace+1] = {
    "Info", "Warning", "Error", "Critical", "Fatal", "Trace" };
 
 
NCBI_PARAM_ENUM_DECL(EDiagSev, DEBUG, Stack_Trace_Level);
NCBI_PARAM_ENUM_ARRAY(EDiagSev, DEBUG, Stack_Trace_Level)
{
    {"Trace", eDiag_Trace},
    { "Info",     eDiag_Info },
    { "Warning",  eDiag_Warning },
    { "Error",    eDiag_Error },
    { "Critical", eDiag_Critical },
    { "Fatal",    eDiag_Fatal }
};
NCBI_PARAM_ENUM_DEF_EX(EDiagSev,
    DEBUG,
    Stack_Trace_Level,
    eDiag_Fatal,
    eParam_NoThread, // No per-thread values
    DEBUG_STACK_TRACE_LEVEL);
 
 
void* InitDiagHandler(void)
{
    NCBI_LSAN_DISABLE_GUARD;
 
    static bool s_DiagInitialized = false;
    if (!s_DiagInitialized) {
        CDiagContext::SetupDiag(eDS_Default, 0, eDCM_Init);
#ifdef NCBI_OS_MSWIN
        // Check environment variable for silent exit, suppress popup messages if enabled. 
        // _ASSERT uses NCBI Diag API, and this allow it to work properly.
        const TXChar* value = NcbiSys_getenv(_TX("DIAG_SILENT_ABORT"));
        if (value && (*value == _TX('Y') || *value == _TX('y') || *value == _TX('1'))) {
            SuppressSystemMessageBox(fSuppress_All);
        }
#endif
        s_DiagInitialized = true;
    }
    return 0;
}
 
 
// For initialization only
void* s_DiagHandlerInitializer = InitDiagHandler();
 
 
// MT-safe initialization of the default handler
static CDiagHandler* s_CreateDefaultDiagHandler(void);
 
 
// Use s_DefaultHandler only for purposes of comparison, as installing
// another handler will normally delete it.
// NOTE: If SetDiagHandler is never called, the default handler will not
// be destroyed on application termination. This is a tradeoff for having
// the handler always available.
CDiagHandler*      s_DefaultHandler = s_CreateDefaultDiagHandler();
CDiagHandler*      CDiagBuffer::sm_Handler = s_DefaultHandler;
bool               CDiagBuffer::sm_CanDeleteHandler = true;
CDiagErrCodeInfo*  CDiagBuffer::sm_ErrCodeInfo = 0;
bool               CDiagBuffer::sm_CanDeleteErrCodeInfo = false;
 
 
static CDiagHandler* s_CreateDefaultDiagHandler(void)
{
    CDiagLock lock(CDiagLock::eWrite);
    static bool s_DefaultDiagHandlerInitialized = false;
    if ( !s_DefaultDiagHandlerInitialized ) {
        s_DefaultDiagHandlerInitialized = true;
        CDiagHandler* handler = new CStreamDiagHandler(&NcbiCerr, true, kLogName_Stderr);
        if ( TTeeToStderr::GetDefault() ) {
            // Need to tee?
            handler = new CTeeDiagHandler(handler, true);
        }
        return handler;
    }
    return s_DefaultHandler;
}
 
 
 
// Note: Intel Thread Checker detects a memory leak at the line:
//       m_Stream(new CNcbiOstrstream) below
//       This is not a fault of the toolkit code as soon as a code like:
//       int main() {
//           ostrstream *  s = new ostrstream;
//           delete s;
//           return 0;
//       }
//       will also report memory leaks.
// Test environment:
// - Intel Thread Checker for Linux 3.1
// - gcc 4.0.1, gcc 4.1.2, icc 10.1
// - Linux64
CDiagBuffer::CDiagBuffer(void)
    : m_Stream(new CNcbiOstrstream),
      m_InitialStreamFlags(m_Stream->flags()),
      m_InUse(false)
{
    m_Diag = 0;
}
 
CDiagBuffer::~CDiagBuffer(void)
{
#if (_DEBUG > 1)
    if (m_Diag  ||  m_Stream->pcount())
        Abort();
#endif
    delete m_Stream;
    m_Stream = 0;
}
 
void CDiagBuffer::DiagHandler(SDiagMessage& mess)
{
    bool is_console = (mess.m_Flags & eDPF_IsConsole) > 0;
    bool applog = (mess.m_Flags & eDPF_AppLog) > 0;
    bool is_printable = applog  ||  SeverityPrintable(mess.m_Severity);
    if (!is_console  &&  !is_printable) {
        return;
    }
    if ( CDiagBuffer::sm_Handler ) {
        CDiagLock lock(CDiagLock::eRead);
        if ( CDiagBuffer::sm_Handler ) {
            // The mutex must be locked before approving.
            CDiagBuffer& diag_buf = GetDiagBuffer();
            bool show_warning = false;
            CDiagContext& ctx = GetDiagContext();
            const CRequestContext& rctx = ctx.GetRequestContext();
            mess.m_Prefix = diag_buf.m_PostPrefix.empty() ?
                0 : diag_buf.m_PostPrefix.c_str();
            if (is_console) {
                // No throttling for console
                CDiagBuffer::sm_Handler->PostToConsole(mess);
                if ( !is_printable ) {
                    return;
                }
            }
            if ( ctx.ApproveMessage(mess, &show_warning) ) {
                if (mess.m_Severity >= eDiag_Error &&
                    mess.m_Severity != eDiag_Trace &&
                    s_DisableAppLog->Get() &&
                    rctx.x_LogHitIDOnError()) {
                    const CNcbiDiag diag(DIAG_COMPILE_INFO);
                    SDiagMessage phid_msg(eDiag_Error,
                        0, 0,
                        diag.GetFile(),
                        diag.GetLine(),
                        diag.GetPostFlags() | eDPF_AppLog,
                        NULL,
                        0, // Error code
                        0,                                 // Err subcode
                        NULL,
                        diag.GetModule(),
                        diag.GetClass(),
                        diag.GetFunction());
                    phid_msg.m_Event = SDiagMessage::eEvent_Extra;
                    phid_msg.m_ExtraArgs.push_back(SDiagMessage::TExtraArg(
                        g_GetNcbiString(eNcbiStrings_PHID),
                        rctx.GetHitID()));
                    CDiagBuffer::sm_Handler->Post(phid_msg);
                }
                CDiagBuffer::sm_Handler->Post(mess);
                if (auto span = rctx.GetTracerSpan()) {
                    span->PostEvent(mess);
                }
            }
            else if ( show_warning ) {
                // Substitute the original message with the error.
                // ERR_POST cannot be used here since nested posts
                // are blocked. Have to create the message manually.
                string limit_name = "error";
                CDiagContext::ELogRate_Type limit_type =
                    CDiagContext::eLogRate_Err;
                if ( IsSetDiagPostFlag(eDPF_AppLog, mess.m_Flags) ) {
                    limit_name = "applog";
                    limit_type = CDiagContext::eLogRate_App;
                }
                else if (mess.m_Severity == eDiag_Info ||
                    mess.m_Severity == eDiag_Trace) {
                        limit_name = "trace";
                        limit_type = CDiagContext::eLogRate_Trace;
                }
                string txt = "Maximum logging rate for " + limit_name + " ("
                    + NStr::UIntToString(ctx.GetLogRate_Limit(limit_type))
                    + " messages per "
                    + NStr::UIntToString(ctx.GetLogRate_Period(limit_type))
                    + " sec) exceeded, suspending the output.";
                const CNcbiDiag diag(DIAG_COMPILE_INFO);
                SDiagMessage err_msg(eDiag_Error,
                    txt.c_str(), txt.length(),
                    diag.GetFile(),
                    diag.GetLine(),
                    diag.GetPostFlags(),
                    NULL,
                    err_code_x::eErrCodeX_Corelib_Diag, // Error code
                    23,                                 // Err subcode
                    NULL,
                    diag.GetModule(),
                    diag.GetClass(),
                    diag.GetFunction());
                CDiagBuffer::sm_Handler->Post(err_msg);
                return;
            }
        }
    }
    GetDiagContext().PushMessage(mess);
}
 
 
inline
bool CDiagBuffer::SeverityDisabled(EDiagSev sev)
{
    CDiagContextThreadData& thr_data =
        CDiagContextThreadData::GetThreadData();
    CDiagCollectGuard* guard = thr_data.GetCollectGuard();
    EDiagSev post_sev = AdjustApplogPrintableSeverity(sm_PostSeverity);
    bool allow_trace = GetTraceEnabled();
    if ( guard ) {
        post_sev = guard->GetCollectSeverity();
        allow_trace = post_sev == eDiag_Trace;
    }
    if (sev == eDiag_Trace  &&  !allow_trace) {
        return true; // trace is disabled
    }
    if (post_sev == eDiag_Trace  &&  allow_trace) {
        return false; // everything is enabled
    }
    return (sev < post_sev)  &&  (sev < sm_DieSeverity  ||  sm_IgnoreToDie);
}
 
 
inline
bool CDiagBuffer::SeverityPrintable(EDiagSev sev)
{
    CDiagContextThreadData& thr_data =
        CDiagContextThreadData::GetThreadData();
    CDiagCollectGuard* guard = thr_data.GetCollectGuard();
    EDiagSev post_sev = AdjustApplogPrintableSeverity(sm_PostSeverity);
    bool allow_trace = GetTraceEnabled();
    if ( guard ) {
        post_sev = AdjustApplogPrintableSeverity(guard->GetPrintSeverity());
        allow_trace = post_sev == eDiag_Trace;
    }
    if (sev == eDiag_Trace  &&  !allow_trace) {
        return false; // trace is disabled
    }
    if (post_sev == eDiag_Trace  &&  allow_trace) {
        return true; // everything is enabled
    }
    return !((sev < post_sev)  &&  (sev < sm_DieSeverity  ||  sm_IgnoreToDie));
}
 
 
bool CDiagBuffer::SetDiag(const CNcbiDiag& diag)
{
    if ( m_InUse  ||  !m_Stream ) {
        return false;
    }
 
    EDiagSev sev = diag.GetSeverity();
    bool is_console = (diag.GetPostFlags() & eDPF_IsConsole) > 0;
    if (!is_console  &&  SeverityDisabled(sev)) {
        return false;
    }
 
    if (m_Diag != &diag) {
        if ( !IsOssEmpty(*m_Stream) ) {
            Flush();
        }
        m_Diag = &diag;
    }
 
    return true;
}
 
 
class CRecursionGuard
{
public:
    CRecursionGuard(bool& flag) : m_Flag(flag) { m_Flag = true; }
    ~CRecursionGuard(void) { m_Flag = false; }
private:
    bool& m_Flag;
};
 
 
struct SThreadsInSTBuild
{
    static bool Check();
    static SDiagMessage Report(EDiagSev& sev);
 
private:
    static atomic<thread::id> sm_ThreadID;
    static atomic<bool> sm_Reported;
};
 
 
atomic<thread::id> SThreadsInSTBuild::sm_ThreadID;
atomic<bool> SThreadsInSTBuild::sm_Reported;
 
 
bool SThreadsInSTBuild::Check()
{
#ifndef NCBI_THREADS
    thread::id stored_thread_id;
    thread::id this_thread_id = this_thread::get_id();
 
    // If this thread has just initialized sm_ThreadID
    if (sm_ThreadID.compare_exchange_strong(stored_thread_id, this_thread_id)) return false;
 
    // If sm_ThreadID contains same thread ID
    if (stored_thread_id == this_thread_id) return false;
 
    bool reported = false;
 
    // Whether to report this (or it has already been reported)
    if (sm_Reported.compare_exchange_strong(reported, true)) return true;
#endif
 
    return false;
}
 
 
SDiagMessage SThreadsInSTBuild::Report(EDiagSev& sev)
{
#ifdef _DEBUG
    sev = eDiag_Fatal;
#else
    sev = eDiag_Critical;
#endif
 
    const auto msg = "Detected different threads using C++ Toolkit built in single thread mode."sv;
    const CNcbiDiag diag(DIAG_COMPILE_INFO);
    return SDiagMessage(
            sev,
            msg.data(),
            msg.length(),
            diag.GetFile(),
            diag.GetLine(),
            diag.GetPostFlags(),
            nullptr,
            0,
            0,
            nullptr,
            diag.GetModule(),
            diag.GetClass(),
            diag.GetFunction());
}
 
 
void CDiagBuffer::Flush(void)
{
    if ( m_InUse || !m_Diag ) {
        if ( !m_InUse  &&  m_Stream  &&  !IsOssEmpty(*m_Stream) ) {
            string message = CNcbiOstrstreamToString(*m_Stream);
            // Can not use Reset() without CNcbiDiag.
            m_Stream->rdbuf()->PUBSEEKOFF(0, IOS_BASE::beg, IOS_BASE::out);
            // _TRACE("Discarding junk data from CDiagBuffer: " << message);
        }
        return;
    }
    CRecursionGuard guard(m_InUse);
 
    EDiagSev sev = m_Diag->GetSeverity();
    bool is_console = (m_Diag->GetPostFlags() & eDPF_IsConsole) != 0;
    bool is_disabled = SeverityDisabled(sev);
 
    // Do nothing if diag severity is lower than allowed.
    if (!is_console  &&  is_disabled) {
        return;
    }
 
    string message = CNcbiOstrstreamToString(*m_Stream);
 
    TDiagPostFlags flags = m_Diag->GetPostFlags();
    if (sev == eDiag_Trace) {
        flags |= sm_TraceFlags;
    } else if (sev == eDiag_Fatal) {
        // normally only happens once, so might as well pull everything
        // in for the record...
        flags |= sm_TraceFlags | eDPF_Trace;
    }
 
    if ( m_Diag->CheckFilters() ) {
        SDiagMessage mess(sev, message.data(), message.size(),
                          m_Diag->GetFile(),
                          m_Diag->GetLine(),
                          flags,
                          NULL,
                          m_Diag->GetErrorCode(),
                          m_Diag->GetErrorSubCode(),
                          NULL,
                          m_Diag->GetModule(),
                          m_Diag->GetClass(),
                          m_Diag->GetFunction());
        PrintMessage(mess, *m_Diag);
    }
 
    if (SThreadsInSTBuild::Check()) {
        // Change severity and print error message
        auto mess = SThreadsInSTBuild::Report(sev);
        PrintMessage(mess, *m_Diag);
    }
 
#if defined(NCBI_COMPILER_KCC)
    // KCC's implementation of "freeze(false)" makes the ostrstream buffer
    // stuck.  We need to replace the frozen stream with the new one.
    delete ostr;
    m_Stream = new CNcbiOstrstream;
#else
    // reset flags to initial value
    m_Stream->flags(m_InitialStreamFlags);
#  ifdef NCBI_SHUN_OSTRSTREAM
    // m_Stream->rdbuf()->PUBSEEKOFF(0, IOS_BASE::beg);
    m_Stream->str(kEmptyStr);
#  endif
#endif
 
    Reset(*m_Diag);
 
    if (sev >= sm_DieSeverity  &&  sev != eDiag_Trace  &&  !sm_IgnoreToDie) {
        m_Diag = 0;
 
#ifdef NCBI_COMPILER_MSVC
        if (NCBI_PARAM_TYPE(Diag, Assert_On_Abort)::GetDefault() ) {
            int old_mode = _set_error_mode(_OUT_TO_MSGBOX);
            _ASSERT(false); // Show assertion dialog
            _set_error_mode(old_mode);
        }
        else {
            Abort();
        }
#else  // NCBI_COMPILER_MSVC
        Abort();
#endif // NCBI_COMPILER_MSVC
    }
}
 
 
void CDiagBuffer::PrintMessage(SDiagMessage& mess, const CNcbiDiag& diag)
{
    EDiagSev sev = diag.GetSeverity();
    if (!SeverityPrintable(sev)) {
        CDiagContextThreadData& thr_data =
            CDiagContextThreadData::GetThreadData();
        bool can_collect = thr_data.GetCollectGuard() != NULL;
        bool is_console = (diag.GetPostFlags() & eDPF_IsConsole) != 0;
        bool is_disabled = SeverityDisabled(sev);
        if (!is_disabled  ||  (is_console  &&  can_collect)) {
            thr_data.CollectDiagMessage(mess);
            Reset(diag);
            // The message has been collected, don't print to
            // the console now.
            return;
        }
    }
    if ( !diag.GetOmitStackTrace() ) {
        static CSafeStatic<NCBI_PARAM_TYPE(DEBUG, Stack_Trace_Level)> s_StackTraceLevel;
        EDiagSev stack_sev = s_StackTraceLevel->Get();
        mess.m_PrintStackTrace = (sev == stack_sev) || (sev > stack_sev && sev != eDiag_Trace);
    }
    DiagHandler(mess);
}
 
 
bool CDiagBuffer::GetTraceEnabledFirstTime(void)
{
    CDiagLock lock(CDiagLock::eWrite);
    const TXChar* str = NcbiSys_getenv(_T_XCSTRING(DIAG_TRACE));
    if (str  &&  *str) {
        sm_TraceDefault = eDT_Enable;
    } else {
        sm_TraceDefault = eDT_Disable;
    }
    sm_TraceEnabled = (sm_TraceDefault == eDT_Enable);
    return sm_TraceEnabled;
}
 
 
bool CDiagBuffer::GetSeverityChangeEnabledFirstTime(void)
{
    if ( sm_PostSeverityChange != eDiagSC_Unknown ) {
        return sm_PostSeverityChange == eDiagSC_Enable;
    }
    const TXChar* str = NcbiSys_getenv(_T_XCSTRING(DIAG_POST_LEVEL));
    EDiagSev sev;
    if (str  &&  *str  &&  CNcbiDiag::StrToSeverityLevel(_T_CSTRING(str), sev)) {
        SetDiagFixedPostLevel(sev);
    } else {
        sm_PostSeverityChange = eDiagSC_Enable;
    }
    return sm_PostSeverityChange == eDiagSC_Enable;
}
 
 
void CDiagBuffer::UpdatePrefix(void)
{
    m_PostPrefix.erase();
    ITERATE(TPrefixList, prefix, m_PrefixList) {
        if (prefix != m_PrefixList.begin()) {
            m_PostPrefix += "::";
        }
        m_PostPrefix += *prefix;
    }
}
 
 
///////////////////////////////////////////////////////
//  CDiagMessage::
 
 
SDiagMessage::SDiagMessage(EDiagSev severity,
                           const char* buf, size_t len,
                           const char* file, size_t line,
                           TDiagPostFlags flags, const char* prefix,
                           int err_code, int err_subcode,
                           const char* err_text,
                           const char* module, 
                           const char* nclass, 
                           const char* function)
    : m_Event(eEvent_Start),
      m_TypedExtra(false),
      m_NoTee(false),
      m_PrintStackTrace(false),
      m_Data(0),
      m_Format(eFormat_Auto),
      m_AllowBadExtraNames(false)
{
    m_Severity   = severity;
    m_Buffer     = buf;
    m_BufferLen  = len;
    m_File       = file;
    m_Line       = line;
    m_Flags      = flags;
    m_Prefix     = prefix;
    m_ErrCode    = err_code;
    m_ErrSubCode = err_subcode;
    m_ErrText    = err_text;
    m_Module     = module;
    m_Class      = nclass;
    m_Function   = function;
 
    CDiagContextThreadData& thr_data =
        CDiagContextThreadData::GetThreadData();
    CRequestContext& rq_ctx = thr_data.GetRequestContext();
    m_PID = CDiagContext::GetPID();
    m_TID = thr_data.GetTID();
    EDiagAppState app_state = GetAppState();
    switch (app_state) {
    case eDiagAppState_RequestBegin:
    case eDiagAppState_Request:
    case eDiagAppState_RequestEnd:
        if ( rq_ctx.GetAutoIncRequestIDOnPost() ) {
            rq_ctx.SetRequestID();
        }
        m_RequestId = rq_ctx.GetRequestID();
        break;
    default:
        m_RequestId = 0;
    }
    m_ProcPost = CDiagContext::GetProcessPostNumber(ePostNumber_Increment);
    m_ThrPost = thr_data.GetThreadPostNumber(ePostNumber_Increment);
}
 
 
SDiagMessage::SDiagMessage(const string& message, bool* result)
    : m_Severity(eDiagSevMin),
      m_Buffer(0),
      m_BufferLen(0),
      m_File(0),
      m_Module(0),
      m_Class(0),
      m_Function(0),
      m_Line(0),
      m_ErrCode(0),
      m_ErrSubCode(0),
      m_Flags(0),
      m_Prefix(0),
      m_ErrText(0),
      m_PID(0),
      m_TID(0),
      m_ProcPost(0),
      m_ThrPost(0),
      m_RequestId(0),
      m_Event(eEvent_Start),
      m_TypedExtra(false),
      m_NoTee(false),
      m_PrintStackTrace(false),
      m_Data(0),
      m_Format(eFormat_Auto),
      m_AllowBadExtraNames(false)
{
    bool res = ParseMessage(message);
    if ( result ) {
        *result = res;
    }
}
 
 
SDiagMessage::~SDiagMessage(void)
{
    if ( m_Data ) {
        delete m_Data;
    }
}
 
 
SDiagMessage::SDiagMessage(const SDiagMessage& message)
    : m_Severity(eDiagSevMin),
      m_Buffer(0),
      m_BufferLen(0),
      m_File(0),
      m_Module(0),
      m_Class(0),
      m_Function(0),
      m_Line(0),
      m_ErrCode(0),
      m_ErrSubCode(0),
      m_Flags(0),
      m_Prefix(0),
      m_ErrText(0),
      m_PID(0),
      m_TID(0),
      m_ProcPost(0),
      m_ThrPost(0),
      m_RequestId(0),
      m_Event(eEvent_Start),
      m_TypedExtra(false),
      m_NoTee(false),
      m_PrintStackTrace(false),
      m_Data(0),
      m_Format(eFormat_Auto),
      m_AllowBadExtraNames(false)
{
    *this = message;
}
 
 
SDiagMessage& SDiagMessage::operator=(const SDiagMessage& message)
{
    if (&message != this) {
        m_Format = message.m_Format;
        m_AllowBadExtraNames = message.m_AllowBadExtraNames;
        if ( message.m_Data ) {
            m_Data = new SDiagMessageData(*message.m_Data);
            m_Data->m_Host = message.m_Data->m_Host;
            m_Data->m_Client = message.m_Data->m_Client;
            m_Data->m_Session = message.m_Data->m_Session;
            m_Data->m_AppName = message.m_Data->m_AppName;
            m_Data->m_AppState = message.m_Data->m_AppState;
        }
        else {
            x_SaveContextData();
            if (message.m_Buffer) {
                m_Data->m_Message =
                    string(message.m_Buffer, message.m_BufferLen);
            }
            if ( message.m_File ) {
                m_Data->m_File = message.m_File;
            }
            if ( message.m_Module ) {
                m_Data->m_Module = message.m_Module;
            }
            if ( message.m_Class ) {
                m_Data->m_Class = message.m_Class;
            }
            if ( message.m_Function ) {
                m_Data->m_Function = message.m_Function;
            }
            if ( message.m_Prefix ) {
                m_Data->m_Prefix = message.m_Prefix;
            }
            if ( message.m_ErrText ) {
                m_Data->m_ErrText = message.m_ErrText;
            }
        }
        m_Severity = message.m_Severity;
        m_Line = message.m_Line;
        m_ErrCode = message.m_ErrCode;
        m_ErrSubCode = message.m_ErrSubCode;
        m_Flags = message.m_Flags;
        m_PID = message.m_PID;
        m_TID = message.m_TID;
        m_ProcPost = message.m_ProcPost;
        m_ThrPost = message.m_ThrPost;
        m_RequestId = message.m_RequestId;
        m_Event = message.m_Event;
        m_TypedExtra = message.m_TypedExtra;
        m_ExtraArgs.assign(message.m_ExtraArgs.begin(),
            message.m_ExtraArgs.end());
 
        m_Buffer = m_Data->m_Message.empty() ? 0 : m_Data->m_Message.c_str();
        m_BufferLen = m_Data->m_Message.empty() ? 0 : m_Data->m_Message.length();
        m_File = m_Data->m_File.empty() ? 0 : m_Data->m_File.c_str();
        m_Module = m_Data->m_Module.empty() ? 0 : m_Data->m_Module.c_str();
        m_Class = m_Data->m_Class.empty() ? 0 : m_Data->m_Class.c_str();
        m_Function = m_Data->m_Function.empty()
            ? 0 : m_Data->m_Function.c_str();
        m_Prefix = m_Data->m_Prefix.empty() ? 0 : m_Data->m_Prefix.c_str();
        m_ErrText = m_Data->m_ErrText.empty() ? 0 : m_Data->m_ErrText.c_str();
    }
    return *this;
}
 
 
Uint8 s_ParseInt(const string& message,
                 size_t&       pos,    // start position
                 size_t        width,  // fixed width or 0
                 char          sep)    // trailing separator (throw if not found)
{
    if (pos >= message.length()) {
        NCBI_THROW(CException, eUnknown,
            "Failed to parse diagnostic message");
    }
    Uint8 ret = 0;
    if (width > 0) {
        if (message[pos + width] != sep) {
            NCBI_THROW(CException, eUnknown,
                "Missing separator after integer");
        }
    }
    else {
        width = message.find(sep, pos);
        if (width == NPOS) {
            NCBI_THROW(CException, eUnknown,
                "Missing separator after integer");
        }
        width -= pos;
    }
 
    ret = NStr::StringToUInt8(CTempString(message.c_str() + pos, width));
    pos += width + 1;
    return ret;
}
 
 
CTempString s_ParseStr(const string& message,
                       size_t&       pos,              // start position
                       char          sep,              // separator
                       bool          optional = false) // do not throw if not found
{
    if (pos >= message.length()) {
        NCBI_THROW(CException, eUnknown,
            "Failed to parse diagnostic message");
    }
    size_t pos1 = pos;
    pos = message.find(sep, pos1);
    if (pos == NPOS) {
        if ( !optional ) {
            NCBI_THROW(CException, eUnknown,
                "Failed to parse diagnostic message");
        }
        pos = pos1;
        return kEmptyStr;
    }
    if ( pos == pos1 + 1  &&  !optional ) {
        // The separator is in the next position, no empty string allowed
        NCBI_THROW(CException, eUnknown,
            "Failed to parse diagnostic message");
    }
    // remember end position of the string, skip separators
    size_t pos2 = pos;
    pos = message.find_first_not_of(sep, pos);
    if (pos == NPOS) {
        pos = message.length();
    }
    return CTempString(message.c_str() + pos1, pos2 - pos1);
}
 
 
static const char s_ExtraEncodeChars[256][4] = {
    "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
    "%08", "%09", "%0A", "%0B", "%0C", "%0D", "%0E", "%0F",
    "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
    "%18", "%19", "%1A", "%1B", "%1C", "%1D", "%1E", "%1F",
    "+",   "!",   "\"",  "#",   "$",   "%25", "%26", "'",
    "(",   ")",   "*",   "%2B", ",",   "-",   ".",   "/",
    "0",   "1",   "2",   "3",   "4",   "5",   "6",   "7",
    "8",   "9",   ":",   ";",   "<",   "%3D", ">",   "?",
    "@",   "A",   "B",   "C",   "D",   "E",   "F",   "G",
    "H",   "I",   "J",   "K",   "L",   "M",   "N",   "O",
    "P",   "Q",   "R",   "S",   "T",   "U",   "V",   "W",
    "X",   "Y",   "Z",   "[",   "\\",  "]",   "^",   "_",
    "`",   "a",   "b",   "c",   "d",   "e",   "f",   "g",
    "h",   "i",   "j",   "k",   "l",   "m",   "n",   "o",
    "p",   "q",   "r",   "s",   "t",   "u",   "v",   "w",
    "x",   "y",   "z",   "{",   "|",   "}",   "~",   "%7F",
    "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
    "%88", "%89", "%8A", "%8B", "%8C", "%8D", "%8E", "%8F",
    "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
    "%98", "%99", "%9A", "%9B", "%9C", "%9D", "%9E", "%9F",
    "%A0", "%A1", "%A2", "%A3", "%A4", "%A5", "%A6", "%A7",
    "%A8", "%A9", "%AA", "%AB", "%AC", "%AD", "%AE", "%AF",
    "%B0", "%B1", "%B2", "%B3", "%B4", "%B5", "%B6", "%B7",
    "%B8", "%B9", "%BA", "%BB", "%BC", "%BD", "%BE", "%BF",
    "%C0", "%C1", "%C2", "%C3", "%C4", "%C5", "%C6", "%C7",
    "%C8", "%C9", "%CA", "%CB", "%CC", "%CD", "%CE", "%CF",
    "%D0", "%D1", "%D2", "%D3", "%D4", "%D5", "%D6", "%D7",
    "%D8", "%D9", "%DA", "%DB", "%DC", "%DD", "%DE", "%DF",
    "%E0", "%E1", "%E2", "%E3", "%E4", "%E5", "%E6", "%E7",
    "%E8", "%E9", "%EA", "%EB", "%EC", "%ED", "%EE", "%EF",
    "%F0", "%F1", "%F2", "%F3", "%F4", "%F5", "%F6", "%F7",
    "%F8", "%F9", "%FA", "%FB", "%FC", "%FD", "%FE", "%FF"
};
 
 
inline
bool x_IsEncodableChar(char c)
{
    return s_ExtraEncodeChars[(unsigned char)c][0] != c  ||
        s_ExtraEncodeChars[(unsigned char)c][1] != 0;
}
 
 
class CExtraDecoder : public IStringDecoder
{
public:
    virtual string Decode(const CTempString src, EStringType stype) const;
};
 
 
string CExtraDecoder::Decode(const CTempString src, EStringType stype) const
{
    string str = src; // NStr::TruncateSpaces(src);
    size_t len = str.length();
    if ( !len  &&  stype == eName ) {
        NCBI_THROW2(CStringException, eFormat,
            "Empty name in extra-arg", 0);
    }
 
    size_t dst = 0;
    for (size_t p = 0;  p < len;  dst++) {
        switch ( str[p] ) {
        case '%': {
            if (p + 2 > len) {
                NCBI_THROW2(CStringException, eFormat,
                    "Inavild char in extra arg", p);
            }
            int n1 = NStr::HexChar(str[p+1]);
            int n2 = NStr::HexChar(str[p+2]);
            if (n1 < 0 || n2 < 0) {
                NCBI_THROW2(CStringException, eFormat,
                    "Inavild char in extra arg", p);
            }
            str[dst] = char((n1 << 4) | n2);
            p += 3;
            break;
        }
        case '+':
            str[dst] = ' ';
            p++;
            break;
        default:
            str[dst] = str[p++];
            if ( x_IsEncodableChar(str[dst]) ) {
                NCBI_THROW2(CStringException, eFormat,
                    "Unencoded special char in extra arg", p);
            }
        }
    }
    if (dst < len) {
        str[dst] = '\0';
        str.resize(dst);
    }
    return str;
}
 
 
bool SDiagMessage::x_ParseExtraArgs(const string& str, size_t pos)
{
    m_ExtraArgs.clear();
    if (str.find('&', pos) == NPOS  &&  str.find('=', pos) == NPOS) {
        return false;
    }
    CStringPairs<TExtraArgs> parser("&", "=", new CExtraDecoder());
    try {
        parser.Parse(CTempString(str.c_str() + pos));
    }
    catch (const CStringException&) {
        string n, v;
        NStr::SplitInTwo(CTempString(str.c_str() + pos), "=", n, v);
        // Try to decode only the name, leave the value as-is.
        try {
            n = parser.GetDecoder()->Decode(n, CExtraDecoder::eName);
            if (n == kExtraTypeArgName) {
                m_TypedExtra = true;
            }
            m_ExtraArgs.push_back(TExtraArg(n, v));
            return true;
        }
        catch (const CStringException&) {
            return false;
        }
    }
    ITERATE(TExtraArgs, it, parser.GetPairs()) {
        if (it->first == kExtraTypeArgName) {
            m_TypedExtra = true;
        }
        m_ExtraArgs.push_back(TExtraArg(it->first, it->second));
    }
    return true;
}
 
 
bool SDiagMessage::ParseMessage(const string& message)
{
    m_Severity = eDiagSevMin;
    m_Buffer = 0;
    m_BufferLen = 0;
    m_File = 0;
    m_Module = 0;
    m_Class = 0;
    m_Function = 0;
    m_Line = 0;
    m_ErrCode = 0;
    m_ErrSubCode = 0;
    m_Flags = 0;
    m_Prefix = 0;
    m_ErrText = 0;
    m_PID = 0;
    m_TID = 0;
    m_ProcPost = 0;
    m_ThrPost = 0;
    m_RequestId = 0;
    m_Event = eEvent_Start;
    m_TypedExtra = false;
    m_Format = eFormat_Auto;
    if ( m_Data ) {
        delete m_Data;
        m_Data = 0;
    }
    m_Data = new SDiagMessageData;
 
    size_t pos = 0;
    try {
        // Fixed prefix
        m_PID = s_ParseInt(message, pos, 0, '/');
        m_TID = s_ParseInt(message, pos, 0, '/');
        size_t sl_pos = message.find('/', pos);
        size_t sp_pos = message.find(' ', pos);
        if (sl_pos < sp_pos) {
            // Newer format, app state is present.
            m_RequestId = s_ParseInt(message, pos, 0, '/');
            m_Data->m_AppState =
                s_StrToAppState(s_ParseStr(message, pos, ' ', true));
        }
        else {
            // Older format, no app state.
            m_RequestId = s_ParseInt(message, pos, 0, ' ');
            m_Data->m_AppState = eDiagAppState_AppRun;
        }
 
        if (message[pos + kDiagW_UID] != ' ') {
            return false;
        }
        m_Data->m_UID = NStr::StringToUInt8(
            CTempString(message.c_str() + pos, kDiagW_UID), 0, 16);
        pos += kDiagW_UID + 1;
        
        m_ProcPost = s_ParseInt(message, pos, 0, '/');
        m_ThrPost = s_ParseInt(message, pos, 0, ' ');
 
        // Date and time. Try all known formats.
        CTempString tmp = s_ParseStr(message, pos, ' ');
        static const char* s_TimeFormats[4] = {
            "Y/M/D:h:m:s", "Y-M-DTh:m:s", "Y-M-DTh:m:s.l", kDiagTimeFormat
        };
        if (tmp.find('T') == NPOS) {
            m_Data->m_Time = CTime(tmp, s_TimeFormats[0]);
        }
        else if (tmp.find('.') == NPOS) {
            m_Data->m_Time = CTime(tmp, s_TimeFormats[1]);
        }
        else {
            try {
                m_Data->m_Time = CTime(tmp, s_TimeFormats[2]);
            }
            catch (const CTimeException&) {
                m_Data->m_Time = CTime(tmp, s_TimeFormats[3]);
            }
        }
 
        // Host
        m_Data->m_Host = s_ParseStr(message, pos, ' ');
        if (m_Data->m_Host == kUnknown_Host) {
            m_Data->m_Host.clear();
        }
        // Client
        m_Data->m_Client = s_ParseStr(message, pos, ' ');
        if (m_Data->m_Client == kUnknown_Client) {
            m_Data->m_Client.clear();
        }
        // Session ID
        m_Data->m_Session = s_ParseStr(message, pos, ' ');
        if (m_Data->m_Session == kUnknown_Session) {
            m_Data->m_Session.clear();
        }
        // Application name
        m_Data->m_AppName = s_ParseStr(message, pos, ' ');
        if (m_Data->m_AppName == kUnknown_App) {
            m_Data->m_AppName.clear();
        }
 
        // Severity or event type
        bool have_severity = false;
        size_t severity_pos = pos;
        tmp = s_ParseStr(message, pos, ':', true);
        if ( !tmp.empty() ) {
            // Support both old (LOG_POST -> message) and new (NOTE_POST -> note) styles.
            size_t sev_pos = NPOS;
            if (tmp.length() == 10  &&  tmp.find("Message[") == 0) {
                sev_pos = 8;
            }
            else if (tmp.length() == 7  &&  tmp.find("Note[") == 0) {
                sev_pos = 5;
            }
 
            if (sev_pos != NPOS) {
                // Get the real severity
                switch ( tmp[sev_pos] ) {
                case 'T':
                    m_Severity = eDiag_Trace;
                    break;
                case 'I':
                    m_Severity = eDiag_Info;
                    break;
                case 'W':
                    m_Severity = eDiag_Warning;
                    break;
                case 'E':
                    m_Severity = eDiag_Error;
                    break;
                case 'C':
                    m_Severity = eDiag_Critical;
                    break;
                case 'F':
                    m_Severity = eDiag_Fatal;
                    break;
                default:
                    return false;
                }
                m_Flags |= eDPF_IsNote;
                have_severity = true;
            }
            else {
                have_severity =
                    CNcbiDiag::StrToSeverityLevel(string(tmp).c_str(), m_Severity);
            }
        }
        if ( have_severity ) {
            pos = message.find_first_not_of(' ', pos);
            if (pos == NPOS) {
                pos = message.length();
            }
        }
        else {
            // Check event type rather than severity level
            pos = severity_pos;
            tmp = s_ParseStr(message, pos, ' ', true);
            if (tmp.empty()  &&  severity_pos < message.length()) {
                tmp = CTempString(message.c_str() + severity_pos);
                pos = message.length();
            }
            if (tmp == GetEventName(eEvent_Start)) {
                m_Event = eEvent_Start;
            }
            else if (tmp == GetEventName(eEvent_Stop)) {
                m_Event = eEvent_Stop;
            }
            else if (tmp == GetEventName(eEvent_RequestStart)) {
                m_Event = eEvent_RequestStart;
                if (pos < message.length()) {
                    if ( x_ParseExtraArgs(message, pos) ) {
                        pos = message.length();
                    }
                }
            }
            else if (tmp == GetEventName(eEvent_RequestStop)) {
                m_Event = eEvent_RequestStop;
            }
            else if (tmp == GetEventName(eEvent_Extra)) {
                m_Event = eEvent_Extra;
                if (pos < message.length()) {
                    if ( x_ParseExtraArgs(message, pos) ) {
                        pos = message.length();
                    }
                }
            }
            else if (tmp == GetEventName(eEvent_PerfLog)) {
                m_Event = eEvent_PerfLog;
                if (pos < message.length()) {
                    // Put status and time to the message,
                    // parse all the rest as extra.
                    size_t msg_end = message.find_first_not_of(' ', pos);
                    msg_end = message.find_first_of(' ', msg_end);
                    msg_end = message.find_first_not_of(' ', msg_end);
                    msg_end = message.find_first_of(' ', msg_end);
                    size_t extra_pos = message.find_first_not_of(' ', msg_end);
                    m_Data->m_Message = string(message.c_str() + pos).
                        substr(0, msg_end - pos);
                    m_BufferLen = m_Data->m_Message.length();
                    m_Buffer = m_Data->m_Message.empty() ?
                        0 : &m_Data->m_Message[0];
                    if ( x_ParseExtraArgs(message, extra_pos) ) {
                        pos = message.length();
                    }
                }
            }
            else {
                return false;
            }
            m_Flags |= eDPF_AppLog;
            // The rest is the message (do not parse status, bytes etc.)
            if (pos < message.length()) {
                m_Data->m_Message = message.c_str() + pos;
                m_BufferLen = m_Data->m_Message.length();
                m_Buffer = m_Data->m_Message.empty() ?
                    0 : &m_Data->m_Message[0];
            }
            m_Format = eFormat_New;
            return true;
        }
 
        // Find message separator
        size_t sep_pos = message.find(" --- ", pos);
 
        // <module>, <module>(<err_code>.<err_subcode>) or <module>(<err_text>)
        if (pos < sep_pos  &&  message[pos] != '"') {
            size_t mod_pos = pos;
            tmp = s_ParseStr(message, pos, ' ');
            size_t lbr = tmp.find("(");
            if (lbr != NPOS) {
                if (tmp[tmp.length() - 1] != ')') {
                    // Space(s) inside the error text, try to find closing ')'
                    int open_br = 1;
                    while (open_br > 0  &&  pos < message.length()) {
                        if (message[pos] == '(') {
                            open_br++;
                        }
                        else if (message[pos] == ')') {
                            open_br--;
                        }
                        pos++;
                    }
                    if (message[pos] != ' '  ||  pos >= message.length()) {
                        return false;
                    }
                    tmp = CTempString(message.c_str() + mod_pos, pos - mod_pos);
                    // skip space(s)
                    pos = message.find_first_not_of(' ', pos);
                    if (pos == NPOS) {
                        pos = message.length();
                    }
                }
                m_Data->m_Module = tmp.substr(0, lbr);
                tmp = tmp.substr(lbr + 1, tmp.length() - lbr - 2);
                size_t dot_pos = tmp.find('.');
                if (dot_pos != NPOS) {
                    // Try to parse error code/subcode
                    try {
                        m_ErrCode = NStr::StringToInt(tmp.substr(0, dot_pos));
                        m_ErrSubCode = NStr::StringToInt(tmp.substr(dot_pos + 1));
                    }
                    catch (const CStringException&) {
                        m_ErrCode = 0;
                        m_ErrSubCode = 0;
                    }
                }
                if (!m_ErrCode  &&  !m_ErrSubCode) {
                    m_Data->m_ErrText = tmp;
                    m_ErrText = m_Data->m_ErrText.empty() ?
                        0 : m_Data->m_ErrText.c_str();
                }
            }
            else {
                m_Data->m_Module = tmp;
            }
            if ( !m_Data->m_Module.empty() ) {
                m_Module = m_Data->m_Module.c_str();
            }
        }
 
        if (pos < sep_pos  &&  message[pos] == '"') {
            // ["<file>", ][line <line>][:]
            pos++; // skip "
            tmp = s_ParseStr(message, pos, '"');
            m_Data->m_File = tmp;
            m_File = m_Data->m_File.empty() ? 0 : m_Data->m_File.c_str();
            if (CTempString(message.c_str() + pos, 7) != ", line ") {
                return false;
            }
            pos += 7;