private void attachPassiveDbAppender(
                                      DbAppenderConfiguration appenderConfiguration,
                                      long timestamp ) {

    // create the new appender
    PassiveDbAppender attachedAppender = new PassiveDbAppender(ThreadsPerCaller.getCaller());

    // calculate the time stamp offset, between the test executor and the agent
    attachedAppender.calculateTimeOffset(timestamp);

    attachedAppender.setAppenderConfig(appenderConfiguration);
    // use a default pattern, as we log in the db
    attachedAppender.setLayout(new PatternLayout("%c{2}: %m%n"));
    attachedAppender.activateOptions();

    // attach the appender to the logging system
    Category log = Logger.getRootLogger();

    log.setLevel(Level.toLevel(appenderConfiguration.getLoggingThreshold().toInt()));
    log.addAppender(attachedAppender);

}
 

/**
   * Tests LoggingEvent.getLocationInfo() when no FQCN is specified.
   * See bug 41186.
   */
public void testLocationInfoNoFQCN() {
    Category root = Logger.getRootLogger();
 Priority level = Level.INFO;
    LoggingEvent event =
      new LoggingEvent(
        null, root, 0L,  level, "Hello, world.", null);
    LocationInfo info = event.getLocationInformation();
 //
 //  log4j 1.2 returns an object, its layout doesn't check for nulls.
 //  log4j 1.3 returns a null.
 //
 assertNotNull(info);
 if (info != null) {
    assertEquals("?", info.getLineNumber());
 assertEquals("?", info.getClassName());
 assertEquals("?", info.getFileName());
 assertEquals("?", info.getMethodName());
 }
}
 

@Before
public void setUp() throws Exception {
    Level level = Mockito.mock(Level.class);
    Category category = Mockito.mock(Category.class);
    event = Mockito.mock(LoggingEvent.class);
    Mockito.when(event.getLogger()).thenReturn(category);
    Mockito.when(event.getLevel()).thenReturn(level);
    Mockito.when(event.getThreadName()).thenReturn("thread-name");
    Mockito.when(event.getMessage()).thenReturn("message");
}
 

public static boolean enableDebugLoggingIfRequired(
    org.apache.hadoop.conf.Configuration conf) {

  boolean result = false;

  try {

    Level desiredOraOopLoggingLevel =
        Level.toLevel(conf.get(OraOopConstants.ORAOOP_LOGGING_LEVEL),
            Level.INFO);

    Level sqoopLogLevel =
        Logger.getLogger(Sqoop.class.getName()).getParent().getLevel();

    if (desiredOraOopLoggingLevel == Level.DEBUG
        || desiredOraOopLoggingLevel == Level.ALL
        || sqoopLogLevel == Level.DEBUG || sqoopLogLevel == Level.ALL) {

      Category oraOopLogger =
          Logger.getLogger(OraOopManagerFactory.class.getName()).getParent();
      oraOopLogger.setLevel(Level.DEBUG);
      LOG.debug("Enabled OraOop debug logging.");
      result = true;

      conf.set(OraOopConstants.ORAOOP_LOGGING_LEVEL, Level.DEBUG.toString());
    }
  } catch (Exception ex) {
    LOG.error(String.format(
        "Unable to determine whether debug logging should be enabled.\n%s",
        getFullExceptionMessage(ex)));
  }

  return result;
}
 

/**
* test TaskLogAppender 
*/
 @SuppressWarnings("deprecation")
 @Test (timeout=5000)
 public void testTaskLogAppender(){
   TaskLogAppender appender= new TaskLogAppender();
   
   System.setProperty(TaskLogAppender.TASKID_PROPERTY,"attempt_01_02_m03_04_001");
   System.setProperty(TaskLogAppender.LOGSIZE_PROPERTY, "1003");
   appender.activateOptions();
   assertEquals(appender.getTaskId(), "attempt_01_02_m03_04_001");
   assertEquals(appender.getTotalLogFileSize(),1000);
   assertEquals(appender.getIsCleanup(),false);
   
   // test writer   
   Writer writer= new StringWriter();
   appender.setWriter(writer);
   Layout layout =  new PatternLayout("%-5p [%t]: %m%n");
   appender.setLayout(layout);
   Category logger= Logger.getLogger(getClass().getName());
   LoggingEvent event = new LoggingEvent("fqnOfCategoryClass", logger, Priority.INFO, "message", new Throwable());
   appender.append(event);
   appender.flush() ;
   appender.close();
   assertTrue(writer.toString().length()>0);
   
   // test cleanup should not changed 
   appender= new TaskLogAppender();
   appender.setIsCleanup(true);
   appender.activateOptions();
   assertEquals(appender.getIsCleanup(),true);

 
 }
 

/**
* test TaskLogAppender 
*/
 @SuppressWarnings("deprecation")
 @Test (timeout=5000)
 public void testTaskLogAppender(){
   TaskLogAppender appender= new TaskLogAppender();
   
   System.setProperty(TaskLogAppender.TASKID_PROPERTY,"attempt_01_02_m03_04_001");
   System.setProperty(TaskLogAppender.LOGSIZE_PROPERTY, "1003");
   appender.activateOptions();
   assertEquals(appender.getTaskId(), "attempt_01_02_m03_04_001");
   assertEquals(appender.getTotalLogFileSize(),1000);
   assertEquals(appender.getIsCleanup(),false);
   
   // test writer   
   Writer writer= new StringWriter();
   appender.setWriter(writer);
   Layout layout =  new PatternLayout("%-5p [%t]: %m%n");
   appender.setLayout(layout);
   Category logger= Logger.getLogger(getClass().getName());
   LoggingEvent event = new LoggingEvent("fqnOfCategoryClass", logger, Priority.INFO, "message", new Throwable());
   appender.append(event);
   appender.flush() ;
   appender.close();
   assertTrue(writer.toString().length()>0);
   
   // test cleanup should not changed 
   appender= new TaskLogAppender();
   appender.setIsCleanup(true);
   appender.activateOptions();
   assertEquals(appender.getIsCleanup(),true);

 
 }
 

private static ArrayList<Appender> appenderHierarchy(final Logger logger) {
  ArrayList<Appender> _xblockexpression = null;
  {
    final ArrayList<Appender> appenders = CollectionLiterals.<Appender>newArrayList();
    for (Category current = logger; (current != null); current = current.getParent()) {
      appenders.addAll(Collections.<Appender>list(current.getAllAppenders()));
    }
    _xblockexpression = appenders;
  }
  return _xblockexpression;
}
 

private static ArrayList<Appender> appenderHierarchy(final Logger logger) {
  ArrayList<Appender> _xblockexpression = null;
  {
    final ArrayList<Appender> appenders = CollectionLiterals.<Appender>newArrayList();
    for (Category current = logger; (current != null); current = current.getParent()) {
      appenders.addAll(Collections.<Appender>list(current.getAllAppenders()));
    }
    _xblockexpression = appenders;
  }
  return _xblockexpression;
}
 

protected
void printOptions(PrintWriter out, Category cat) {
  Enumeration appenders = cat.getAllAppenders();
  Level prio = cat.getLevel();
  String appenderString = (prio == null ? "" : prio.toString());
  
  while (appenders.hasMoreElements()) {
    Appender app = (Appender) appenders.nextElement();
    String name;
    
    if ((name = (String) appenderNames.get(app)) == null) {
    
      // first assign name to the appender
      if ((name = app.getName()) == null || isGenAppName(name)) {
          name = genAppName();
      }
      appenderNames.put(app, name);
      
      printOptions(out, app, "log4j.appender."+name);
      if (app.getLayout() != null) {
        printOptions(out, app.getLayout(), "log4j.appender."+name+".layout");
      }
    }
    appenderString += ", " + name;
  }
  String catKey = (cat == Logger.getRootLogger())
      ? "log4j.rootLogger"
      : "log4j.logger." + cat.getName();
  if (appenderString != "") {
    out.println(catKey + "=" + appenderString);
  }
  if (!cat.getAdditivity() && cat != Logger.getRootLogger()) {
  	out.println("log4j.additivity." + cat.getName() + "=false");    
  }
}
 

/**
   * Tests LoggingEvent.fqnOfCategoryClass.
   */
public void testFQNOfCategoryClass() {
    Category root = Logger.getRootLogger();
    Priority info = Level.INFO;
    String catName = Logger.class.toString();
    LoggingEvent event =
      new LoggingEvent(
        catName, root, info, "Hello, world.", null);
    assertEquals(catName, event.fqnOfCategoryClass);
}
 

/**
   * Tests LoggingEvent.level.
   * @deprecated
   */
public void testLevel() {
    Category root = Logger.getRootLogger();
    Priority info = Level.INFO;
    String catName = Logger.class.toString();
    LoggingEvent event =
      new LoggingEvent(
        catName, root, 0L,  info, "Hello, world.", null);
    Priority error = Level.ERROR;
    event.level = error;
    assertEquals(Level.ERROR, event.level);
}
 

@BeforeClass
public static void setup() throws Exception
{
  logger.debug("Logger repository before LoggerUtil.changeLoggersLevel() {}", LogManager.getLoggerRepository());
  LoggerUtil.changeLoggersLevel(Maps.<String, String>newHashMap());
  logger.debug("Logger repository after LoggerUtil.changeLoggersLevel() {}", LogManager.getLoggerRepository());
  log4jLogger.setLevel(Level.TRACE);
  Category category = log4jLogger;
  while (category != null) {
    Enumeration appenders = category.getAllAppenders();
    while (appenders.hasMoreElements()) {
      Object o = appenders.nextElement();
      if (o instanceof AppenderSkeleton) {
        AppenderSkeleton appender = (AppenderSkeleton)o;
        if (!appenderLevelMap.containsKey(appender)) {
          appenderLevelMap.put(appender, appender.getThreshold());
          appender.setThreshold(Level.INFO);
        }
      }
    }
    if (category.getAdditivity()) {
      category = category.getParent();
    } else {
      category = null;
    }
  }
}
 

@Test
public void testParentLevel()
{
  org.apache.log4j.Logger log4jLogger = LogManager.getLogger("com.datatorrent.stram.util.Unknown");
  assertNull(log4jLogger.getLevel());
  Category parent = log4jLogger.getParent();
  while (parent.getLevel() == null) {
    parent = parent.getParent();
  }
  assertSame(log4jLogger.getEffectiveLevel(), parent.getLevel());
}
 

private String getLoggerLevel(Category logger) {
  if (null == logger) {
    return StringUtils.EMPTY;
  }
  Level level = logger.getLevel();
  if (null != level) {
    return level.toString();
  } else {
    return getLoggerLevel(logger.getParent());
  }
}
 

@Test
public void testThrowableSuccess() throws Exception
{
    CassandraAppender appender = new CassandraAppender();
    LoggingEvent event = new LoggingEvent(BasicTest.class.getName(),
                                          Category.getInstance(BasicTest.class),
                                          Priority.WARN,
                                          "test 12",
                                          new Exception("boom"));
    appender.doAppend(event);
}
 

@Test
public void testNoThrowableSuccess() throws Exception
{
    CassandraAppender appender = new CassandraAppender();
    LoggingEvent event = new LoggingEvent(BasicTest.class.getName(),
                                          Category.getInstance(BasicTest.class),
                                          Priority.WARN,
                                          "test 12",
                                          null);
    appender.doAppend(event);
}
 

@Override
public void emitNoAppenderWarning(Category cat)
{
  loggerRepository.emitNoAppenderWarning(cat);
}
 

@Override
public void fireAddAppenderEvent(Category logger, Appender appender)
{
  loggerRepository.fireAddAppenderEvent(logger, appender);
}
 

/**
 * We will try to find if a DB appender has been configured on the local system
 * 
 * @param customLogLevel log level specified in the test ( or use AgentConfigurationLandscape.getInstance(atsAgent).getDbLogLevel() )
 * @param chunkSize chunk size (for batch db logging) specified in the test ( or use AgentConfigurationLandscape.getInstance(atsAgent).getChunkSize() )
 */
@SuppressWarnings( "unchecked")
public RemoteLoggingConfigurator( LogLevel customLogLevel, int chunkSize ) {

    /*
     * This code is run on:
     *  - Test Executor side prior to calling an agent for first time in this testcase
     *  - Agent side prior to calling another chained agent for first time in this testcase 
     * 
     * we use this code to remember the logging configuration which we will pass to some agent
     */

    // look for the DB appender
    Category log = Logger.getLogger("com.axway.ats");
    boolean dbAppenderIsProcessed = false;
    while (log != null && !dbAppenderIsProcessed) {

        Enumeration<Appender> appenders = log.getAllAppenders();
        while (appenders.hasMoreElements()) {
            Appender appender = appenders.nextElement();

            if (appender.getClass() == ActiveDbAppender.class // running on Test Executor side
                || appender.getClass() == PassiveDbAppender.class // running on Agent side 
            ) {
                //we found the appender, read all properties
                appenderConfiguration = ((AbstractDbAppender) appender).getAppenderConfig();
                if (chunkSize > 0) {
                    // should a warning be logged here if the chunk size is not valid?
                    appenderConfiguration.setChunkSize(chunkSize + "");
                }
                appenderLogger = log.getName();

                int atsDbLogLevel = DEFAULT_LOG_LEVEL;
                if (customLogLevel != null) {
                    // user specified in the test the log level for this agent
                    atsDbLogLevel = customLogLevel.toInt();
                } else if (log.getLevel() != null) {
                    // user specified the log level in log4j configuration file
                    atsDbLogLevel = log.getLevel().toInt();

                }

                //set the effective logging level for threshold if new one is set
                if (appenderConfiguration.getLoggingThreshold() == null
                    || appenderConfiguration.getLoggingThreshold().toInt() != atsDbLogLevel) {

                    /*
                     * Log4j is deprecating the Priority class used by setLoggingThreshold,
                     * but we cannot make an instance of this class as its constructor is not public.
                     * 
                     * So here we first change the log level on the Test Executor,
                     * then get the Priority object, then restore back the value on the Test Executor
                     */
                    final Level currentLevelBackup = log.getLevel();
                    log.setLevel(Level.toLevel(atsDbLogLevel));
                    appenderConfiguration.setLoggingThreshold(log.getEffectiveLevel());
                    log.setLevel(currentLevelBackup);
                }

                //exit the loop
                dbAppenderIsProcessed = true;
                break;
            }
        }

        log = log.getParent();
    }

    // look for any user loggers
    Enumeration<Logger> allLoggers = Logger.getRootLogger().getLoggerRepository().getCurrentLoggers();
    while (allLoggers.hasMoreElements()) {
        Logger logger = allLoggers.nextElement();

        Level level = logger.getLevel();
        if (level != null) {
            // user explicitly specified a level for this logger
            otherLoggerLevels.put(logger.getName(), level.toInt());
        }
    }
}
 

@Override
@SuppressWarnings( "unchecked")
public void apply() {

    /*
     * This code is run on remote agent's side
     */

    if (needsToConfigureDbAppender) {
        //first get all appenders in the root category and apply the filter
        //which will deny logging of system events
        Logger rootLogger = Logger.getRootLogger();
        Enumeration<Appender> appenders = rootLogger.getAllAppenders();
        while (appenders.hasMoreElements()) {
            Appender appender = appenders.nextElement();
            if (! (appender instanceof AbstractDbAppender)) {
                // apply this filter on all appenders which are not coming from ATS
                appender.addFilter(new NoSystemLevelEventsFilter());
            }
        }

        //attach the appender to the logging system
        Category log;
        if ("root".equals(appenderLogger)) {
            log = Logger.getRootLogger();
        } else {
            log = Logger.getLogger(appenderLogger);
        }

        log.setLevel(Level.toLevel(appenderConfiguration.getLoggingThreshold().toInt()));

        final String caller = ThreadsPerCaller.getCaller();

        //create the new appender
        PassiveDbAppender attachedAppender = new PassiveDbAppender(caller);
        attachedAppender.setAppenderConfig(appenderConfiguration);
        //use a default pattern, as we log in the db
        attachedAppender.setLayout(new PatternLayout("%c{2}: %m%n"));
        attachedAppender.activateOptions();

        log.addAppender(attachedAppender);
    }

    if (needsToConfigureUserLoggers) {
        for (Entry<String, Integer> userLogger : otherLoggerLevels.entrySet()) {
            /* 
             * We want to set the level of this logger.
             * It is not important if this logger is already attached to log4j system or 
             * not as the next code will obtain it(in case logger exists) or will create it 
             * and then will set its level
             */
            Logger.getLogger(userLogger.getKey())
                  .setLevel(Level.toLevel(userLogger.getValue()));
        }
    }
}
 

@Override
@SuppressWarnings( "unchecked")
public void revert() {

    /*
     * This code is run on remote agent's side
     */

    /*
     * The outer code will call this method when the "needs applying" method return true.
     * 
     * Currently we could come here because of 2 reasons:
     *  - the DB appenders must be reconfigured
     *  - the user loggers must be reconfigured
     */

    if (appenderLogger != null && needsToConfigureDbAppender) {
        // there is a DB appender and it is out-of-date

        //remove the filter which will deny logging of system events
        Logger rootLogger = Logger.getRootLogger();
        Enumeration<Appender> appenders = rootLogger.getAllAppenders();
        while (appenders.hasMoreElements()) {
            Appender appender = appenders.nextElement();

            //remove the filter
            //FIXME:This is very risky, as someone may have added other filters
            //the current implementation of the filter chain in log4j will not allow
            //us to easily remove a single filter
            appender.clearFilters();
        }

        Category log;
        if ("root".equals(appenderLogger)) {
            log = Logger.getRootLogger();
        } else {
            log = Logger.getLogger(appenderLogger);
        }

        Appender dbAppender = PassiveDbAppender.getCurrentInstance(ThreadsPerCaller.getCaller());
        if (dbAppender != null) {
            //close the appender
            dbAppender.close();

            //remove it
            log.removeAppender(dbAppender);
        }
    }

    // in case we must reconfigure the custom loggers, here we should remove them from log4j, 
    // but log4j does not provide a way to do it - so we do nothing here 
}
 

@Override
public void emitNoAppenderWarning(Category cat) {
}
 

@Override
public void fireAddAppenderEvent(Category logger, Appender appender) {
}
 

@Override
public void emitNoAppenderWarning(Category cat) {
}
 

@Override
public void fireAddAppenderEvent(Category logger, Appender appender) {
}
 

protected void printOptions(PrintWriter out, Logger cat) {
    printOptions(out, (Category) cat);
}
 

@Override
public void emitNoAppenderWarning(Category cat)
{
  loggerRepository.emitNoAppenderWarning(cat);
}
 

@Override
public void fireAddAppenderEvent(Category logger, Appender appender)
{
  loggerRepository.fireAddAppenderEvent(logger, appender);
}
 

@Test
public void test() throws Exception {
    // install decanter
    System.out.println(executeCommand("feature:repo-add decanter " + System.getProperty("decanter.version")));
    System.out.println(executeCommand("feature:install decanter-collector-log-socket", new RolePrincipal("admin")));

    Thread.sleep(2000);

    // create event handler
    List<Event> received = new ArrayList();
    EventHandler eventHandler = new EventHandler() {
        @Override
        public void handleEvent(Event event) {
            received.add(event);
        }
    };
    Hashtable serviceProperties = new Hashtable();
    serviceProperties.put(EventConstants.EVENT_TOPIC, "decanter/collect/*");
    bundleContext.registerService(EventHandler.class, eventHandler, serviceProperties);

    LoggingEvent loggingEvent = new LoggingEvent("test", Category.getInstance("logger"), System.currentTimeMillis(), Level.toLevel("INFO"), "Test", "thread", null, "test", null, new HashMap());
    Socket socket = new Socket("localhost", 4560);
    try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream())) {
        objectOutputStream.writeObject(loggingEvent);
    }

    while (received.size() == 0) {
        Thread.sleep(500);
    }

    Assert.assertEquals(1, received.size());

    Assert.assertEquals("decanter/collect/log/logger", received.get(0).getTopic());
    Assert.assertEquals("INFO", received.get(0).getProperty("level"));
    Assert.assertEquals("log", received.get(0).getProperty("type"));
    Assert.assertEquals("Test", received.get(0).getProperty("message"));
    Assert.assertEquals("thread", received.get(0).getProperty("threadName"));
    Assert.assertEquals("root", received.get(0).getProperty("karafName"));
    Assert.assertEquals("logger", received.get(0).getProperty("loggerName"));
    Assert.assertEquals("Test", received.get(0).getProperty("renderedMessage"));
}
 

@Override
public void onStart(ISuite suite) {
    LOGGER.debug("CarinaListener->onStart(ISuite suite)");
    // register programmatically carina based BeforeSuite/BeforeClass and
    // BeforeMethod to execute those configuration part obligatory
    /*
     * XmlTest xmlTest = new XmlTest(suite.getXmlSuite());
     * xmlTest.setName("Sample Test");
     * 
     * // Create a list which can contain the classes that you want to run.
     * List<XmlClass> myClasses = new ArrayList<XmlClass>();
     * myClasses.add(new
     * XmlClass("com.qaprosoft.carina.core.foundation.AbstractTest"));
     * 
     * // Assign that to the XmlTest Object created earlier.
     * xmlTest.setXmlClasses(myClasses);
     * 
     * suite.getXmlSuite().addTest(xmlTest);
     */

    List<String> coreLogPackages = new ArrayList<String>(
            Arrays.asList(Configuration.get(Parameter.CORE_LOG_PACKAGES).split(",")));
    if (coreLogPackages.size() > 0 && !"INFO".equalsIgnoreCase(Configuration.get(Parameter.CORE_LOG_LEVEL))) {
        // do core log level change only if custom properties are declared
        try {
            Logger root = Logger.getRootLogger();
            Enumeration<?> allLoggers = root.getLoggerRepository().getCurrentCategories();
            while (allLoggers.hasMoreElements()) {
                Category tmpLogger = (Category) allLoggers.nextElement();
                LOGGER.debug("loggerName: " + tmpLogger.getName());
                if ("log4j.logger.org.apache.http.wire".equals(tmpLogger.getName())) {
                    // update this logger to be able to analyse ZafiraClient calls 
                    LOGGER.info("Updaged logger level for '" + tmpLogger.getName() + "' to "
                            + Configuration.get(Parameter.CORE_LOG_LEVEL));
                    tmpLogger.setLevel(Level.toLevel(Configuration.get(Parameter.CORE_LOG_LEVEL)));
                }
                for (String coreLogPackage : coreLogPackages) {
                    if (tmpLogger.getName().contains(coreLogPackage.trim())) {
                        LOGGER.info("Updaged logger level for '" + tmpLogger.getName() + "' to "
                                + Configuration.get(Parameter.CORE_LOG_LEVEL));
                        tmpLogger.setLevel(Level.toLevel(Configuration.get(Parameter.CORE_LOG_LEVEL)));
                    }
                }
            }
        } catch (NoSuchMethodError e) {
            LOGGER.error("Unable to redefine logger level due to the conflicts between log4j and slf4j!");
        }
    }

    setThreadCount(suite);
    onHealthCheck(suite);
    
    LOGGER.info("CARINA_CORE_VERSION: " + getCarinaVersion());
}