Examples with LogWriterLogger org.apache.geode.internal.logging.log4j.LogWriterLogger used on opensource projects

Example 6 with LogWriterLogger

use of org.apache.geode.internal.logging.log4j.LogWriterLogger in project geode by apache.

the class ChangeLogLevelFunction method execute.

@Override
public void execute(FunctionContext context) {
    Cache cache = CacheFactory.getAnyInstance();
    Map<String, String> result = new HashMap<String, String>();
    try {
        LogWriterLogger logwriterLogger = (LogWriterLogger) cache.getLogger();
        Object[] args = (Object[]) context.getArguments();
        final String logLevel = (String) args[0];
        Level log4jLevel = LogLevel.getLevel(logLevel);
        logwriterLogger.setLevel(log4jLevel);
        System.setProperty(DistributionConfig.GEMFIRE_PREFIX + LOG_LEVEL, logLevel);
        // LOG:CONFIG:
        logger.info(LogMarker.CONFIG, "GFSH Changed log level to {}", log4jLevel);
        result.put(cache.getDistributedSystem().getDistributedMember().getId(), "New log level is " + log4jLevel);
        context.getResultSender().lastResult(result);
    } catch (Exception ex) {
        // LOG:CONFIG:
        logger.info(LogMarker.CONFIG, "GFSH Changing log level exception {}", ex.getMessage(), ex);
        result.put(cache.getDistributedSystem().getDistributedMember().getId(), "ChangeLogLevelFunction exception " + ex.getMessage());
        context.getResultSender().lastResult(result);
    }
}

Example 7 with LogWriterLogger

use of org.apache.geode.internal.logging.log4j.LogWriterLogger in project geode by apache.

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithSecurityLogDefaultLevel.

@Test
public void testDistributedSystemWithSecurityLogDefaultLevel() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final String securityLogFileName = "security" + name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "fine");
    properties.put(SECURITY_LOG_FILE, securityLogFileName);
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, "");
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File securityLogFile = new File(securityLogFileName);
    if (securityLogFile.exists()) {
        securityLogFile.delete();
    }
    assertFalse(securityLogFile.exists());
    final File logFile = new File(logFileName);
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.system = DistributedSystem.connect(properties);
    assertNotNull(this.system);
    DistributionConfig config = ((InternalDistributedSystem) this.system).getConfig();
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.CONFIG_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.CONFIG_LEVEL, config.getSecurityLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getLogLevel());
    InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter();
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(securityLogWriter);
    assertNotNull(logWriter);
    assertTrue(securityLogWriter instanceof LogWriterLogger);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.INFO_LEVEL, securityLogWriter.getLogWriterLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertFalse(securityLogWriter.fineEnabled());
    assertTrue(logWriter.fineEnabled());
    assertFalse(((LogWriterLogger) securityLogWriter).isDebugEnabled());
    assertTrue(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(securityLogWriter instanceof FastLogger);
    assertTrue(logWriter instanceof FastLogger);
    // Because debug available is a static volatile, it is shared between the two writers
    // However we should not see any debug level logging due to the config level set in
    // the log writer itself
    assertTrue(((FastLogger) securityLogWriter).isDelegating());
    assertTrue(((FastLogger) logWriter).isDelegating());
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return securityLogFile.exists() && logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log files to exist: " + securityLogFile + ", " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(securityLogFile.exists());
    assertTrue(logFile.exists());
    securityLogWriter.info("test: security log file created at info");
    // assert not empty
    FileInputStream fis = new FileInputStream(securityLogFile);
    try {
        assertTrue(fis.available() > 0);
    } finally {
        fis.close();
    }
    final Logger logger = LogService.getLogger();
    int i = 0;
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        securityLogWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(securityLogFile, FINEST_STRING));
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        securityLogWriter.fine(FINE_STRING);
        assertFalse(fileContainsString(securityLogFile, FINE_STRING));
        assertFalse(fileContainsString(logFile, FINE_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        securityLogWriter.info(INFO_STRING);
        assertTrue(fileContainsString(securityLogFile, INFO_STRING));
        assertFalse(fileContainsString(logFile, INFO_STRING));
        i++;
        final String FINE_STRING_FOR_LOGGER = "testLogLevels Message logged at FINE level [" + i + "]";
        logger.debug(FINE_STRING_FOR_LOGGER);
        assertFalse(fileContainsString(securityLogFile, FINE_STRING_FOR_LOGGER));
        assertTrue(fileContainsString(logFile, FINE_STRING_FOR_LOGGER));
    }
    this.system.disconnect();
    this.system = null;
}

Example 8 with LogWriterLogger

use of org.apache.geode.internal.logging.log4j.LogWriterLogger in project geode by apache.

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithSecurityLogFineLevel.

@Test
public void testDistributedSystemWithSecurityLogFineLevel() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final String securityLogFileName = "security" + name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "fine");
    properties.put(SECURITY_LOG_FILE, securityLogFileName);
    properties.put(SECURITY_LOG_LEVEL, "fine");
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, "");
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File securityLogFile = new File(securityLogFileName);
    if (securityLogFile.exists()) {
        securityLogFile.delete();
    }
    assertFalse(securityLogFile.exists());
    final File logFile = new File(logFileName);
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.system = DistributedSystem.connect(properties);
    assertNotNull(this.system);
    DistributionConfig config = ((InternalDistributedSystem) this.system).getConfig();
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getSecurityLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getLogLevel());
    InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter();
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(securityLogWriter);
    assertNotNull(logWriter);
    assertTrue(securityLogWriter instanceof LogWriterLogger);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, securityLogWriter.getLogWriterLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(securityLogWriter.fineEnabled());
    assertTrue(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) securityLogWriter).isDebugEnabled());
    assertTrue(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(securityLogWriter instanceof FastLogger);
    assertTrue(logWriter instanceof FastLogger);
    assertTrue(((FastLogger) securityLogWriter).isDelegating());
    assertTrue(((FastLogger) logWriter).isDelegating());
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return securityLogFile.exists() && logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log files to exist: " + securityLogFile + ", " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(securityLogFile.exists());
    assertTrue(logFile.exists());
    // assert not empty
    FileInputStream fis = new FileInputStream(securityLogFile);
    try {
        assertTrue(fis.available() > 0);
    } finally {
        fis.close();
    }
    final Logger logger = LogService.getLogger();
    int i = 0;
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        securityLogWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(securityLogFile, FINEST_STRING));
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        securityLogWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(securityLogFile, FINER_STRING));
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        securityLogWriter.fine(FINE_STRING);
        assertTrue(fileContainsString(securityLogFile, FINE_STRING));
        assertFalse(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        securityLogWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(securityLogFile, CONFIG_STRING));
        assertFalse(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        securityLogWriter.info(INFO_STRING);
        assertTrue(fileContainsString(securityLogFile, INFO_STRING));
        assertFalse(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        securityLogWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(securityLogFile, WARNING_STRING));
        assertFalse(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        securityLogWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(securityLogFile, ERROR_STRING));
        assertFalse(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        securityLogWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(securityLogFile, SEVERE_STRING));
        assertFalse(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(securityLogFile, TRACE_STRING));
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertFalse(fileContainsString(securityLogFile, DEBUG_STRING));
        assertTrue(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertFalse(fileContainsString(securityLogFile, INFO_STRING_J));
        assertTrue(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertFalse(fileContainsString(securityLogFile, WARN_STRING));
        assertTrue(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertFalse(fileContainsString(securityLogFile, ERROR_STRING_J));
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertFalse(fileContainsString(securityLogFile, FATAL_STRING));
        assertTrue(fileContainsString(logFile, FATAL_STRING));
    }
    this.system.disconnect();
    this.system = null;
}

Example 9 with LogWriterLogger

use of org.apache.geode.internal.logging.log4j.LogWriterLogger in project geode by apache.

the class DistributedSystemLogFileJUnitTest method testDistributedSystemCreatesLogFile.

@Test
public void testDistributedSystemCreatesLogFile() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-0.log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "config");
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, "");
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File logFile = new File(logFileName);
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.system = DistributedSystem.connect(properties);
    assertNotNull(this.system);
    DistributionConfig config = ((InternalDistributedSystem) this.system).getConfig();
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.CONFIG_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.CONFIG_LEVEL, config.getLogLevel());
    // CONFIG has been replaced with INFO -- all CONFIG statements are now logged at INFO as well
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(logWriter);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel());
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log file to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    // assert not empty
    FileInputStream fis = new FileInputStream(logFile);
    try {
        assertTrue("log file is empty: " + logFile.getAbsoluteFile(), fis.available() > 0);
    } finally {
        fis.close();
    }
    final Logger logger = LogService.getLogger();
    final Logger appLogger = LogManager.getLogger("net.customer");
    assertEquals(Level.INFO, appLogger.getLevel());
    int i = 0;
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertFalse(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "ExpectedStrings: testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertFalse(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertTrue(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertTrue(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
        i++;
        final String TRACE_STRING_A = "Message logged at TRACE level [" + i + "]";
        appLogger.trace(TRACE_STRING_A);
        assertFalse(fileContainsString(logFile, TRACE_STRING_A));
        i++;
        final String DEBUG_STRING_A = "Message logged at DEBUG level [" + i + "]";
        appLogger.debug(DEBUG_STRING_A);
        assertFalse(fileContainsString(logFile, DEBUG_STRING_A));
        i++;
        final String INFO_STRING_A = "Message logged at INFO level [" + i + "]";
        appLogger.info(INFO_STRING_A);
        assertTrue(fileContainsString(logFile, INFO_STRING_A));
        i++;
        final String WARN_STRING_A = "ExpectedStrings: Message logged at WARN level [" + i + "]";
        appLogger.warn(WARN_STRING_A);
        assertTrue(fileContainsString(logFile, WARN_STRING_A));
        i++;
        final String ERROR_STRING_A = "ExpectedStrings: Message logged at ERROR level [" + i + "]";
        appLogger.error(ERROR_STRING_A);
        assertTrue(fileContainsString(logFile, ERROR_STRING_A));
        i++;
        final String FATAL_STRING_A = "ExpectedStrings: Message logged at FATAL level [" + i + "]";
        appLogger.fatal(FATAL_STRING_A);
        assertTrue(fileContainsString(logFile, FATAL_STRING_A));
    }
    // change log level to fine and verify
    config.setLogLevel(InternalLogWriter.FINE_LEVEL);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertEquals(Level.DEBUG, appLogger.getLevel());
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertTrue(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertTrue(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertTrue(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertTrue(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
        i++;
        final String TRACE_STRING_A = "Message logged at TRACE level [" + i + "]";
        appLogger.trace(TRACE_STRING_A);
        assertFalse(fileContainsString(logFile, TRACE_STRING_A));
        i++;
        final String DEBUG_STRING_A = "Message logged at DEBUG level [" + i + "]";
        appLogger.debug(DEBUG_STRING_A);
        assertTrue(fileContainsString(logFile, DEBUG_STRING_A));
        i++;
        final String INFO_STRING_A = "Message logged at INFO level [" + i + "]";
        appLogger.info(INFO_STRING_A);
        assertTrue(fileContainsString(logFile, INFO_STRING_A));
        i++;
        final String WARN_STRING_A = "ExpectedStrings: Message logged at WARN level [" + i + "]";
        appLogger.warn(WARN_STRING_A);
        assertTrue(fileContainsString(logFile, WARN_STRING_A));
        i++;
        final String ERROR_STRING_A = "ExpectedStrings: Message logged at ERROR level [" + i + "]";
        appLogger.error(ERROR_STRING_A);
        assertTrue(fileContainsString(logFile, ERROR_STRING_A));
        i++;
        final String FATAL_STRING_A = "ExpectedStrings: Message logged at FATAL level [" + i + "]";
        appLogger.fatal(FATAL_STRING_A);
        assertTrue(fileContainsString(logFile, FATAL_STRING_A));
    }
    // change log level to error and verify
    config.setLogLevel(InternalLogWriter.ERROR_LEVEL);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.ERROR_LEVEL, config.getLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.ERROR_LEVEL, logWriter.getLogWriterLevel());
    assertEquals(Level.ERROR, appLogger.getLevel());
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertFalse(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertFalse(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertFalse(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertFalse(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertFalse(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertFalse(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertFalse(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
        i++;
        final String TRACE_STRING_A = "Message logged at TRACE level [" + i + "]";
        appLogger.trace(TRACE_STRING_A);
        assertFalse(fileContainsString(logFile, TRACE_STRING_A));
        i++;
        final String DEBUG_STRING_A = "Message logged at DEBUG level [" + i + "]";
        appLogger.debug(DEBUG_STRING_A);
        assertFalse(fileContainsString(logFile, DEBUG_STRING_A));
        i++;
        final String INFO_STRING_A = "Message logged at INFO level [" + i + "]";
        appLogger.info(INFO_STRING_A);
        assertFalse(fileContainsString(logFile, INFO_STRING_A));
        i++;
        final String WARN_STRING_A = "ExpectedStrings: Message logged at WARN level [" + i + "]";
        appLogger.warn(WARN_STRING_A);
        assertFalse(fileContainsString(logFile, WARN_STRING_A));
        i++;
        final String ERROR_STRING_A = "ExpectedStrings: Message logged at ERROR level [" + i + "]";
        appLogger.error(ERROR_STRING_A);
        assertTrue(fileContainsString(logFile, ERROR_STRING_A));
        i++;
        final String FATAL_STRING_A = "ExpectedStrings: Message logged at FATAL level [" + i + "]";
        appLogger.fatal(FATAL_STRING_A);
        assertTrue(fileContainsString(logFile, FATAL_STRING_A));
    }
    this.system.disconnect();
    this.system = null;
}

Example 10 with LogWriterLogger

use of org.apache.geode.internal.logging.log4j.LogWriterLogger in project geode by apache.

the class LocatorLogFileJUnitTest method testLocatorCreatesLogFile.

@Test
public void testLocatorCreatesLogFile() throws Exception {
    final int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
    final String locators = "localhost[" + port + "]";
    final Properties properties = new Properties();
    properties.put(LOG_LEVEL, "config");
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, locators);
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File logFile = new File(name.getMethodName() + "-locator-" + port + ".log");
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.locator = Locator.startLocatorAndDS(port, logFile, properties);
    InternalDistributedSystem ds = (InternalDistributedSystem) this.locator.getDistributedSystem();
    assertNotNull(ds);
    DistributionConfig config = ds.getConfig();
    assertNotNull(config);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.CONFIG_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.CONFIG_LEVEL, config.getLogLevel());
    // CONFIG has been replaced with INFO -- all CONFIG statements are now logged at INFO as well
    InternalLogWriter logWriter = (InternalLogWriter) ds.getLogWriter();
    assertNotNull(logWriter);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel());
    assertNotNull(this.locator);
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log file to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    // assert not empty
    this.fis = new FileInputStream(logFile);
    assertTrue(fis.available() > 0);
    this.locator.stop();
    this.locator = null;
    this.fis.close();
    this.fis = null;
}