int main(int argc, char *argv[])
{
ACS_CHECK_LOGGER;
Logging::Logger::LoggerSmartPtr globalLoggerSmartPtr = getNamedLogger("MainLogger");
printf("-------------------------------------------------------------------------\n");
globalLoggerSmartPtr->log(Logging::Logger::LM_INFO,
"This is a global level log message.");
TestLoggable noName = TestLoggable();
TestLoggable withName = TestLoggable("loggableWithName");
TestLoggable fromLogger = TestLoggable(globalLoggerSmartPtr);
noName.doTestLogs();
withName.doTestLogs();
fromLogger.doTestLogs();
noName.doTestLogs();
withName.doTestLogs();
fromLogger.doTestLogs();
printf("-------------------------------------------------------------------------\n");
printf("Here we test if static log macro(s) work(s)\n");
TestLoggable::doTestStaticLogs();
return 0;
}
void logBatchDirectLog(Logging::Logger::LoggerSmartPtr logger)
{
std::ostringstream oss;
oss.clear();
oss.str(std::string());
oss << "Log batch for logger [" << logger->getName() << "]. USING log() functions.";
logger->log(Logging::Logger::LM_INFO, oss.str());
// Test all messages
//logger->log(Logging::Logger::LM_SHUTDOWN, "Testing LM_SHUTDOWN message: Shutdown messages"); // NOT logging a thing
logger->log(Logging::Logger::LM_TRACE, "Testing LM_TRACE message: Messages indicating function-calling sequence");
logger->log(Logging::Logger::LM_DEBUG, "Testing LM_DEBUG message: Messages that contain information normally of use only when debugging a program");
logger->log(Logging::Logger::LM_INFO, "Testing LM_INFO message: Informational messages");
logger->log(Logging::Logger::LM_NOTICE, "Testing LM_NOTICE message: Conditions that are not error conditions, but that may require");
logger->log(Logging::Logger::LM_WARNING, "Testing LM_WARNING message: Warning messages");
logger->log(Logging::Logger::LM_ERROR, "Testing LM_ERROR message: Error messages");
logger->log(Logging::Logger::LM_CRITICAL, "Testing LM_CRITICAL message: Critical conditions, such as hard device errors");
logger->log(Logging::Logger::LM_ALERT, "Testing LM_ALERT message: A condition that should be corrected immediately, such as a corrupted system database");
logger->log(Logging::Logger::LM_EMERGENCY, "Testing LM_EMERGENCY message: A panic condition. This is normally broadcast to all users");
} // 10 messages
int main(int argc, char *argv[])
{
std::ostringstream oss;
ACS_CHECK_LOGGER;
// First logger
Logging::Logger::LoggerSmartPtr firstLoggerSmartPtr = getLogger();
firstLoggerSmartPtr->setName("FirstLogger");
// Second logger
Logging::Logger::LoggerSmartPtr secondLoggerSmartPtr = getNamedLogger("SecondLogger");
// Third logger
Logging::Logger::LoggerSmartPtr thirdLoggerSmartPtr = getNamedLogger("ThirdLogger");
// BY DEFAULT STATISTICS ARE NOT ACTIVE: Those messages are not counted
{
oss.clear();
oss.str(std::string());
oss << "Statistics for logger [" << firstLoggerSmartPtr->getName() << "] are by default disabled";
firstLoggerSmartPtr->log(Logging::Logger::LM_INFO, oss.str());
logBatchDirectLog(firstLoggerSmartPtr);
} // Batch for first logger
{
oss.clear();
oss.str(std::string());
oss << "Statistics for logger [" << secondLoggerSmartPtr->getName() << "] are by default disabled";
secondLoggerSmartPtr->log(Logging::Logger::LM_INFO, oss.str());
logBatchDirectLog(secondLoggerSmartPtr);
} // Batch for second logger
{
oss.clear();
oss.str(std::string());
oss << "Statistics for logger [" << thirdLoggerSmartPtr->getName() << "] are by default disabled";
thirdLoggerSmartPtr->log(Logging::Logger::LM_INFO, oss.str());
logBatchDirectLog(thirdLoggerSmartPtr);
} // Batch for third logger
// Log to general logger using macros
{
logBatchUsingMacrosGeneralLogger();
} // is the First Logger
// Activate statistics for first logger
firstLoggerSmartPtr->log(Logging::Logger::LM_INFO, "Activate statistics for first logger -----------");
firstLoggerSmartPtr->stats.configureStatistics("testLoggerStats",false, 3, 1);
// and send a second batch
{
logBatchDirectLog(firstLoggerSmartPtr);
logBatchDirectLog(secondLoggerSmartPtr);
logBatchDirectLog(thirdLoggerSmartPtr);
} // only firstLoggerSmartPtr logs will be counted in statistics
// Log to general logger using macros
{
logBatchUsingMacrosGeneralLogger();
} // is the First Logger
// Log to general logger using macros
{
logBatchUsingMacrosStaticLogger();
} // no stats
// Activate statistics for second logger
secondLoggerSmartPtr->log(Logging::Logger::LM_INFO, "Activate statistics for second logger -----------");
secondLoggerSmartPtr->stats.configureStatistics("testLoggerStats",false, 3, 1);
// wait 2 seconds to force statistics to be calculated
unsigned int microseconds = 3100000;
usleep(microseconds);
// and send logs to all three loggers
firstLoggerSmartPtr->log(Logging::Logger::LM_INFO, "FIRST LOGGER STATS ACTIVE");
secondLoggerSmartPtr->log(Logging::Logger::LM_INFO, "SECOND LOGGER STATS ACTIVE");
thirdLoggerSmartPtr->log(Logging::Logger::LM_INFO, "THIRD LOGGER STATS INACTIVE");
// and then send a second batch
{
logBatchDirectLog(firstLoggerSmartPtr);
logBatchDirectLog(secondLoggerSmartPtr);
logBatchDirectLog(thirdLoggerSmartPtr);
} // first and second loggers will use them for stats
// and then send a third batch
{
logBatchDirectLog(firstLoggerSmartPtr);
logBatchDirectLog(secondLoggerSmartPtr);
logBatchDirectLog(thirdLoggerSmartPtr);
} // first and second loggers will use them for stats
// Activate also static logger stats
firstLoggerSmartPtr->log(Logging::Logger::LM_INFO, "Activate statistics for static logger -----------");
Logging::Logger::getStaticLogger()->stats.configureStatistics("testLoggerStats",false, 3, 1);
// and send static batch
{
logBatchUsingMacrosStaticLogger();
} // stats calculated
return 0;
}
/**
*
* Test program and example for guarded logs.
*
*/
int main(int argc, char *argv[])
{
maci::SimpleClient client;
if (client.init(argc,argv) == 0)
{
return -1;
}
else
{
// Log into the manager before doing anything
client.login();
}
/*****************************************************************/
/*
* This example guards a log
* produced using any subclass of Logging::BaseLog
* These are the normal logs
*
* All examples follow this same pattern
*/
/*
* 1. The first step is to instantiate the guard template.
* In this case the guarding is not done for multiple
* executions of this function, since it is the main().
*
* In that case we would have to declare the guard as static.
* The same applies to all following examples
*
* This approach also allows to use the same guard for multiple logs
* (as long as they are of the same logger type)
*/
Logging::RepeatGuardLogger<Logging::BaseLog> guardbl(10000000,10);
/*
* 2. We get the standard logger for this "object"
* and we make a simple normal log, just to see that it works.
*/
Logging::Logger::LoggerSmartPtr logger = getLogger();
logger->log(Logging::Logger::LM_INFO, "Simple test.",
__FILE__,__LINE__,
"main");
/*
* 3. Finally we make a loop with the guarded log
*/
for(int i=0;i<50;i++)
{
guardbl.log(logger, Logging::Logger::LM_INFO,
"Log A without incrementing",
__FILE__,__LINE__,
"main");
guardbl.log(logger, Logging::Logger::LM_INFO,
"Log B without incrementing",
__FILE__,__LINE__,
"main");
guardbl.logAndIncrement(logger, Logging::Logger::LM_INFO,
"LogAndIncrement",
__FILE__,__LINE__,
"main");
}
/*****************************************************************/
/*
* This example guards a type-safe log
* produced using any subclass of Logging::TypeSafeLog
*/
Logging::RepeatGuardLogger<Logging::TypeSafeLog> guard(10000000,10);
repeatGuardLogTypeExample::simpleLog my_simpleLog(__FILE__,__LINE__,"main");
my_simpleLog.log();
guard.log(my_simpleLog);
for(int i=0;i<50;i++)
{
guard.logAndIncrement(my_simpleLog);
}
/*****************************************************************/
/*
* This example guards the logging of an exception
* produced using any subclass of ACSErr::ACSbaseExImpl
*/
Logging::RepeatGuardLogger<ACSErr::ACSbaseExImpl> guardex(10000000,10);
ACSErrTypeCommon::GenericErrorExImpl displayMessageEx(
__FILE__, __LINE__, "main");
displayMessageEx.log();
guardex.log(displayMessageEx);
for(int i=0;i<50;i++)
{
guardex.logAndIncrement(displayMessageEx);
}
/*****************************************************************/
client.logout();
return 0;
}