std::wstring render(bool propper, std::wstring syntax, std::wstring date_format = DATE_FORMAT, DWORD langId = 0) const {
if (propper) {
// To obtain the appropriate message string from the message file, load the message file with the LoadLibrary function and use the FormatMessage function
strEx::replace(syntax, _T("%message%"), render_message(langId));
} else {
strEx::replace(syntax, _T("%message%"), _T("%message% needs the descriptions flag set!"));
}
strEx::replace(syntax, _T("%source%"), get_source());
strEx::replace(syntax, _T("%computer%"), get_computer());
strEx::replace(syntax, _T("%generated%"), strEx::format_date(get_time_generated(), date_format));
strEx::replace(syntax, _T("%written%"), strEx::format_date(get_time_written(), date_format));
strEx::replace(syntax, _T("%generated-raw%"), strEx::itos(pevlr_->TimeGenerated));
strEx::replace(syntax, _T("%written-raw%"), strEx::itos(pevlr_->TimeWritten));
strEx::replace(syntax, _T("%type%"), translateType(eventType()));
strEx::replace(syntax, _T("%category%"), strEx::itos(pevlr_->EventCategory));
strEx::replace(syntax, _T("%facility%"), strEx::itos(facility()));
strEx::replace(syntax, _T("%qualifier%"), strEx::itos(facility()));
strEx::replace(syntax, _T("%customer%"), strEx::itos(customer()));
strEx::replace(syntax, _T("%rawid%"), strEx::itos(raw_id()));
strEx::replace(syntax, _T("%severity%"), translateSeverity(severity()));
strEx::replace(syntax, _T("%strings%"), enumStrings());
strEx::replace(syntax, _T("%log%"), file_);
strEx::replace(syntax, _T("%file%"), file_);
strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
strEx::replace(syntax, _T("%user%"), userSID());
return syntax;
}
void ExampleLink::process()
{
status = Status::Ok;
channelGet->get();
event.wait();
timeStamp.getCurrent();
pvTimeStamp.set(timeStamp);
AlarmSeverity severity(noAlarm);
if(!status.isOK()) {
switch(status.getType()) {
case Status::STATUSTYPE_OK:
severity = noAlarm;
break;
case Status::STATUSTYPE_WARNING:
severity = minorAlarm;
break;
case Status::STATUSTYPE_ERROR:
severity = majorAlarm;
break;
case Status::STATUSTYPE_FATAL:
severity = invalidAlarm;
break;
}
alarm.setSeverity(severity);
} else {
pvValue->copyUnchecked(*getPVValue);
}
alarm.setMessage(status.getMessage());
pvAlarm.set(alarm);
}
LogPartition::LogPartition (std::string const& name)
: mNextLog (headLog)
, mName (canonicalFileName (name.c_str()))
{
severity (Journal::kWarning);
// VFALCO TODO Use an intrusive list.
headLog = this;
}
void ModelLoader::startLogging()
{
Assimp::Logger::LogSeverity severity(Assimp::Logger::VERBOSE);
Assimp::DefaultLogger::create("", severity, aiDefaultLogStream_STDOUT);
Assimp::DefaultLogger::get()->info("ModelLoader logging started.");
logging = true;
}
bool Message::operator== (const Message& rValue) const
{
if (severity() != rValue.severity()) return false;
if (sourceId() != rValue.sourceId()) return false;
if (line() != rValue.line()) return false;
if (column() != rValue.column()) return false;
if (text() != rValue.text()) return false;
return true;
}
DiagnosticContainer Diagnostic::toDiagnosticContainer(const IsAcceptedDiagnostic &isAcceptedChildDiagnostic) const
{
return DiagnosticContainer(text(),
category(),
options(),
severity(),
location().toSourceLocationContainer(),
getSourceRangeContainers(),
getFixItContainers(),
childDiagnostics().toDiagnosticContainers(isAcceptedChildDiagnostic));
}
void cpp_logger::start(const YAML::Node& config) {
const auto sink = config["sink"].as<std::string>("cerr");
if (sink == "cerr") {
logger_ = &std::cerr;
} else if (sink == "cout") {
logger_ = &std::cout;
} else {
std::string error = "Unknown sink type '" + sink + "', using std::cerr as fallback";
log(cppalls::api::logger::ERROR, error.c_str());
}
lvl_ = severity(config["severity"].as<std::string>("trace"));
}
int main(int argc, char** argv) {
InitLogging(argv, android::base::StderrLogger);
std::vector<std::string> args;
android::base::LogSeverity log_severity = android::base::WARNING;
if (argc == 1) {
args.push_back("help");
} else {
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
args.insert(args.begin(), "help");
} else if (strcmp(argv[i], "--log") == 0) {
if (i + 1 < argc) {
++i;
auto it = log_severity_map.find(argv[i]);
if (it != log_severity_map.end()) {
log_severity = it->second;
} else {
LOG(ERROR) << "Unknown log severity: " << argv[i];
return 1;
}
} else {
LOG(ERROR) << "Missing argument for --log option.\n";
return 1;
}
} else {
args.push_back(argv[i]);
}
}
}
android::base::ScopedLogSeverity severity(log_severity);
std::unique_ptr<Command> command = CreateCommandInstance(args[0]);
if (command == nullptr) {
LOG(ERROR) << "malformed command line: unknown command " << args[0];
return 1;
}
std::string command_name = args[0];
args.erase(args.begin());
LOG(DEBUG) << "command '" << command_name << "' starts running";
bool result = command->Run(args);
LOG(DEBUG) << "command '" << command_name << "' "
<< (result ? "finished successfully" : "failed");
return result ? 0 : 1;
}
LOCAL_C void TestWorkAPIsL(CTestExecuteLogger& aLogger,CConsoleBase*& aConsole)
{
aConsole->Write(_L("Testing logger.Write(16BitText) \r\n"));
aLogger.Write(K16BitText);
aConsole->Write(_L("Testing logger.Write(8BitText) \r\n"));
aLogger.Write(K8BitText);
aConsole->Write(_L("Testing logger.WriteFormat(16BitText) \r\n"));
TBuf<20> buf16(K16BitString);
aLogger.WriteFormat(K16BitFormatText,16,&buf16);
aConsole->Write(_L("Testing logger.WriteFormat(8BitText) \r\n"));
TBuf8<20> buf8(K8BitString);
aLogger.WriteFormat(K8BitFormatText,8,&buf8);
aConsole->Write(_L("Testing logger.LogExtra() \r\n"));
aLogger.LogExtra(((TText8*)__FILE__), __LINE__,ESevrInfo,K16BitFormatText,1,&buf16);
aConsole->Write(_L("Testing logger.PrintCurrentScriptLine() \r\n"));
TBuf<30> output(_L("Testing PrintCurrentScriptLine")) ;
aLogger.PrintCurrentScriptLine(output) ;
aConsole->Write(_L("Testing logger.LogTestCaseResult() \r\n"));
TBuf<30> file(_L("TestExcuteLoggingTest.cpp"));
TInt lineNo(68) ;
TBuf<20> testCsNm(_L("TestCaseSomething"));
aLogger.LogTestCaseResult(file, lineNo, ESevrInfo, KTEFEndTestCaseCommand, testCsNm);
aConsole->Write(_L("Testing logger.LogResult() \r\n"));
TBuf<30> panicStringbuf(_L("Panic string")) ;
TBuf<30> fileRes(_L("TestExcuteLoggingTest.cpp"));
TInt lineNum(70) ;
TInt severity(RFileFlogger::ESevrHigh) ;
aLogger.LogResult(EPass,panicStringbuf,lineNum,KTEFRunTestStepCommand,fileRes,RFileFlogger::ESevrHigh);
}
static size_t
show_header(struct mca_record_header *rh)
{
printf(" <header>\n");
show_value(4, "seqnr", "%lld", (long long)rh->rh_seqnr);
show_value(4, "revision", "%d.%d", BCD(rh->rh_major),
BCD(rh->rh_minor));
show_value(4, "severity", "%s", severity(rh->rh_error));
show_value(4, "length", "%lld", (long long)rh->rh_length);
show_value(4, "date", "%d%02d/%02d/%02d",
BCD(rh->rh_time[MCA_RH_TIME_CENT]),
BCD(rh->rh_time[MCA_RH_TIME_YEAR]),
BCD(rh->rh_time[MCA_RH_TIME_MON]),
BCD(rh->rh_time[MCA_RH_TIME_MDAY]));
show_value(4, "time", "%02d:%02d:%02d",
BCD(rh->rh_time[MCA_RH_TIME_HOUR]),
BCD(rh->rh_time[MCA_RH_TIME_MIN]),
BCD(rh->rh_time[MCA_RH_TIME_SEC]));
if (rh->rh_flags & MCA_RH_FLAGS_PLATFORM_ID)
show_value(4, "platform", "%s", uuid(&rh->rh_platform));
printf(" </header>\n");
return (rh->rh_length);
}
LogSeverity LogPartition::getSeverity() const
{
return convertSeverity (severity ());
}
// { int32 ver, string desc } = archiver.info()
xmlrpc_value *get_info(xmlrpc_env *env, xmlrpc_value *args, void *user)
{
#ifdef LOGFILE
LOG_MSG("archiver.info\n");
#endif
int i;
const char *config = get_config_name(env);
if (!config)
return 0;
#ifdef LOGFILE
LOG_MSG("config: '%s'\n", config);
#endif
char description[500];
sprintf(description,
"Channel Archiver Data Server V%d,\n"
"for " EPICS_VERSION_STRING ",\n"
"built " __DATE__ ", " __TIME__ "\n"
"from sources for version " ARCH_VERSION_TXT "\n"
"Config: '%s'\n",
ARCH_VER, config);
AutoXmlRpcValue how(xmlrpc_build_value(env, "(sssss)",
"raw",
"spreadsheet",
"average",
"plot-binning",
"linear"));
if (env->fault_occurred)
return 0;
// 'status': array of all status string.
AutoXmlRpcValue element;
AutoXmlRpcValue status(xmlrpc_build_value(env, "()"));
if (env->fault_occurred)
return 0;
for (i=0; i<=lastEpicsAlarmCond; ++i)
{
element = xmlrpc_build_value(env, "s", epicsAlarmConditionStrings[i]);
xmlrpc_array_append_item(env, status, element);
if (env->fault_occurred)
return 0;
}
// 'severity': array of all severity strings.
AutoXmlRpcValue severity(xmlrpc_build_value(env, "()"));
for (i=0; i<=lastEpicsAlarmSev; ++i)
{
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)i,
"sevr", epicsAlarmSeverityStrings[i],
"has_value", (xmlrpc_bool) 1,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
if (env->fault_occurred)
return 0;
}
// ... including the archive-specific ones.
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_EST_REPEAT,
"sevr", "Est_Repeat",
"has_value", (xmlrpc_bool) 1,
"txt_stat", (xmlrpc_bool) 0);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_REPEAT,
"sevr", "Repeat",
"has_value", (xmlrpc_bool) 1,
"txt_stat", (xmlrpc_bool) 0);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_DISCONNECT,
"sevr", "Disconnected",
"has_value", (xmlrpc_bool) 0,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_STOPPED,
"sevr", "Archive_Off",
"has_value", (xmlrpc_bool) 0,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
element = xmlrpc_build_value(env, "{s:i,s:s,s:b,s:b}",
"num", (xmlrpc_int32)ARCH_DISABLED,
"sevr", "Archive_Disabled",
"has_value", (xmlrpc_bool) 0,
"txt_stat", (xmlrpc_bool) 1);
xmlrpc_array_append_item(env, severity, element);
// Overall result.
return xmlrpc_build_value(env, "{s:i,s:s,s:V,s:V,s:V}",
"ver", ARCH_VER,
"desc", description,
"how", how.get(),
"stat", status.get(),
"sevr", severity.get());
}
void TDiagnostics::print(ID id,
const pp::SourceLocation& loc,
const std::string& text)
{
writeInfo(severity(id), loc, message(id), text, "");
}
bool is_not_clear() {return severity() != AlarmDef::CLEARED;}
void cpp_logger::log(cppalls::api::logger::severity_level lvl, const char* msg) {
if (lvl >= lvl_) {
*logger_ << severity(lvl) << msg << '\n';
}
}
void LogPartition::setMinimumSeverity (LogSeverity level)
{
severity (convertLogSeverity (level));
}
TEST(logging, LOG) {
ASSERT_DEATH(LOG(FATAL) << "foobar", "foobar");
// We can't usefully check the output of any of these on Windows because we
// don't have std::regex, but we can at least make sure we printed at least as
// many characters are in the log message.
{
CapturedStderr cap;
LOG(WARNING) << "foobar";
ASSERT_EQ(0, lseek(cap.fd(), SEEK_SET, 0));
std::string output;
android::base::ReadFdToString(cap.fd(), &output);
ASSERT_GT(output.length(), strlen("foobar"));
#if !defined(_WIN32)
std::regex message_regex(
make_log_pattern(android::base::WARNING, "foobar"));
ASSERT_TRUE(std::regex_search(output, message_regex));
#endif
}
{
CapturedStderr cap;
LOG(INFO) << "foobar";
ASSERT_EQ(0, lseek(cap.fd(), SEEK_SET, 0));
std::string output;
android::base::ReadFdToString(cap.fd(), &output);
ASSERT_GT(output.length(), strlen("foobar"));
#if !defined(_WIN32)
std::regex message_regex(
make_log_pattern(android::base::INFO, "foobar"));
ASSERT_TRUE(std::regex_search(output, message_regex));
#endif
}
{
CapturedStderr cap;
LOG(DEBUG) << "foobar";
ASSERT_EQ(0, lseek(cap.fd(), SEEK_SET, 0));
std::string output;
android::base::ReadFdToString(cap.fd(), &output);
ASSERT_TRUE(output.empty());
}
{
android::base::ScopedLogSeverity severity(android::base::DEBUG);
CapturedStderr cap;
LOG(DEBUG) << "foobar";
ASSERT_EQ(0, lseek(cap.fd(), SEEK_SET, 0));
std::string output;
android::base::ReadFdToString(cap.fd(), &output);
ASSERT_GT(output.length(), strlen("foobar"));
#if !defined(_WIN32)
std::regex message_regex(
make_log_pattern(android::base::DEBUG, "foobar"));
ASSERT_TRUE(std::regex_search(output, message_regex));
#endif
}
}
// Translate ituAlarmPerceivedSeverity to alarmModelState based upon mapping
// defined in section 5.4 of RFC 3877.
// https://tools.ietf.org/html/rfc3877#section-5.4
unsigned int AlarmTableDef::state() const
{
static const unsigned int severity_to_state[] = {2, 1, 2, 6, 5, 4, 3};
unsigned int idx = severity();
return severity_to_state[idx];
}
