src/jdk.jpackage/windows/native/libjpackage/Log.cpp
branchJDK-8200758-branch
changeset 57909 c7de06ed4b54
parent 57413 45c74e654794
equal deleted inserted replaced
57908:9a005146bc1c 57909:c7de06ed4b54
    96 StderrLogAppender::StderrLogAppender() {
    96 StderrLogAppender::StderrLogAppender() {
    97 }
    97 }
    98 
    98 
    99 
    99 
   100 /*static*/
   100 /*static*/
   101 Logger& Logger::defaultLogger()
   101 Logger& Logger::defaultLogger() {
   102 {
       
   103     Logger* reply = reinterpret_cast<Logger*>(defaultLoggerMemory);
   102     Logger* reply = reinterpret_cast<Logger*>(defaultLoggerMemory);
   104 
   103 
   105     if (!reply->appender) {
   104     if (!reply->appender) {
   106         // Memory leak by design. Not an issue at all as this is global
   105         // Memory leak by design. Not an issue at all as this is global
   107         // object. OS will do resources clean up anyways when application
   106         // object. OS will do resources clean up anyways when application
   119         tstring mname = retrieveModuleName();
   118         tstring mname = retrieveModuleName();
   120         mname.resize(_countof(moduleName) - 1);
   119         mname.resize(_countof(moduleName) - 1);
   121         std::memcpy(moduleName, mname.c_str(), mname.size());
   120         std::memcpy(moduleName, mname.c_str(), mname.size());
   122         moduleName[mname.size()] = TCHAR(0);
   121         moduleName[mname.size()] = TCHAR(0);
   123 
   122 
   124         // if JPACKAGE_DEBUG environment variable is NOT set to "true" disable 
   123         // if JPACKAGE_DEBUG environment variable is NOT set to "true" disable
   125         // logging.
   124         // logging.
   126         if (SysInfo::getEnvVariable(std::nothrow, L"JPACKAGE_DEBUG") != L"true") {
   125         if (SysInfo::getEnvVariable(std::nothrow,
       
   126                 L"JPACKAGE_DEBUG") != L"true") {
   127             reply->appender = &nopLogApender;
   127             reply->appender = &nopLogApender;
   128         }
   128         }
   129 
   129 
   130         state = Initialized;
   130         state = Initialized;
   131     }
   131     }
   132 
   132 
   133     return *reply;
   133     return *reply;
   134 }
   134 }
   135 
   135 
   136 Logger::Logger(LogAppender& appender, LogLevel logLevel)
   136 Logger::Logger(LogAppender& appender, LogLevel logLevel)
   137     : level(logLevel), appender(&appender)
   137         : level(logLevel), appender(&appender) {
   138 {
   138 }
   139 }
   139 
   140 
   140 void Logger::setLogLevel(LogLevel logLevel) {
   141 void Logger::setLogLevel(LogLevel logLevel)
       
   142 {
       
   143     level = logLevel;
   141     level = logLevel;
   144 }
   142 }
   145 
   143 
   146 Logger::~Logger()
   144 Logger::~Logger() {
   147 {
   145 }
   148 }
   146 
   149 
   147 
   150 
   148 bool Logger::isLoggable(LogLevel logLevel) const {
   151 bool Logger::isLoggable(LogLevel logLevel) const
       
   152 {
       
   153     return logLevel >= level;
   149     return logLevel >= level;
   154 }
   150 }
   155 
   151 
   156 void Logger::log(LogLevel logLevel, LPCTSTR fileName, int lineNum, LPCTSTR funcName, const tstring& message) const
   152 void Logger::log(LogLevel logLevel, LPCTSTR fileName, int lineNum,
   157 {
   153         LPCTSTR funcName, const tstring& message) const {
   158     LogEvent logEvent;
   154     LogEvent logEvent;
   159 
   155 
   160     // [YYYY/MM/DD HH:MM:SS.ms, <module> (PID: processID, TID: threadID), fileName:lineNum (funcName)]
   156     // [YYYY/MM/DD HH:MM:SS.ms, <module> (PID: processID, TID: threadID),
   161     // <tab>LEVEL: message
   157     // fileName:lineNum (funcName)] <tab>LEVEL: message
   162     GetLocalTime(&logEvent.ts);
   158     GetLocalTime(&logEvent.ts);
   163 
   159 
   164     logEvent.pid = GetCurrentProcessId();
   160     logEvent.pid = GetCurrentProcessId();
   165     logEvent.tid = GetCurrentThreadId();
   161     logEvent.tid = GetCurrentThreadId();
   166     logEvent.moduleName = moduleName;
   162     logEvent.moduleName = moduleName;
   175 
   171 
   176 
   172 
   177 void StderrLogAppender::append(const LogEvent& v)
   173 void StderrLogAppender::append(const LogEvent& v)
   178 {
   174 {
   179     const tstring out = tstrings::unsafe_format(format,
   175     const tstring out = tstrings::unsafe_format(format,
   180         unsigned(v.ts.wYear), unsigned(v.ts.wMonth), unsigned(v.ts.wDay),                       // date
   176         unsigned(v.ts.wYear), unsigned(v.ts.wMonth), unsigned(v.ts.wDay),
   181         unsigned(v.ts.wHour), unsigned(v.ts.wMinute), unsigned(v.ts.wSecond), unsigned(v.ts.wMilliseconds), // time
   177         unsigned(v.ts.wHour), unsigned(v.ts.wMinute), unsigned(v.ts.wSecond),
       
   178                 unsigned(v.ts.wMilliseconds),
   182         v.moduleName.c_str(), v.pid, v.tid,
   179         v.moduleName.c_str(), v.pid, v.tid,
   183         v.fileName.c_str(), v.lineNum, v.funcName.c_str(),
   180         v.fileName.c_str(), v.lineNum, v.funcName.c_str(),
   184         v.logLevel.c_str(),
   181         v.logLevel.c_str(),
   185         v.message.c_str());
   182         v.message.c_str());
   186 
   183 
   187     std::cerr << tstrings::toUtf8(out);
   184     std::cerr << tstrings::toUtf8(out);
   188 }
   185 }
   189 
   186 
   190 
   187 
   191 // Logger::ScopeTracer
   188 // Logger::ScopeTracer
   192 Logger::ScopeTracer::ScopeTracer(Logger &logger, LogLevel logLevel, LPCTSTR fileName, int lineNum, LPCTSTR funcName, const tstring& scopeName)
   189 Logger::ScopeTracer::ScopeTracer(Logger &logger, LogLevel logLevel,
   193     : log(logger), level(logLevel), file(fileName), line(lineNum), func(funcName), scope(scopeName), needLog(logger.isLoggable(logLevel))
   190         LPCTSTR fileName, int lineNum, LPCTSTR funcName,
   194 {
   191         const tstring& scopeName) : log(logger), level(logLevel),
       
   192         file(fileName), line(lineNum),
       
   193         func(funcName), scope(scopeName), needLog(logger.isLoggable(logLevel)) {
   195     if (needLog) {
   194     if (needLog) {
   196         log.log(level, file.c_str(), line, func.c_str(), tstrings::any() << "Entering " << scope);
   195         log.log(level, file.c_str(), line, func.c_str(),
       
   196                 tstrings::any() << "Entering " << scope);
   197     }
   197     }
   198 }
   198 }
   199 
   199 
   200 Logger::ScopeTracer::~ScopeTracer() {
   200 Logger::ScopeTracer::~ScopeTracer() {
   201     if (needLog) {
   201     if (needLog) {
   202         // we don't know what line is end of scope at, so specify line 0
   202         // we don't know what line is end of scope at, so specify line 0
   203         // and add note about line when the scope begins
   203         // and add note about line when the scope begins
   204         log.log(level, file.c_str(), 0, func.c_str(),
   204         log.log(level, file.c_str(), 0, func.c_str(),
   205             tstrings::any() << "Exiting " << scope << " (entered at " << FileUtils::basename(file) << ":" << line << ")");
   205                 tstrings::any() << "Exiting " << scope << " (entered at "
   206     }
   206                 << FileUtils::basename(file) << ":" << line << ")");
   207 }
   207     }
       
   208 }