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

Example 1 with LogWriterLogger

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

the class LogWriterFactory method createLogWriterLogger.

/**
   * Creates the log writer for a distributed system based on the system's parsed configuration. The
   * initial banner and messages are also entered into the log by this method.
   * 
   * @param isLoner Whether the distributed system is a loner or not
   * @param isSecure Whether a logger for security related messages has to be created
   * @param config The DistributionConfig for the target distributed system
   * @param logConfig if true log the configuration
   */
public static InternalLogWriter createLogWriterLogger(final boolean isLoner, final boolean isSecure, final LogConfig config, final boolean logConfig) {
    // if isSecurity then use "org.apache.geode.security" else use "org.apache.geode"
    String name = null;
    if (isSecure) {
        name = LogService.SECURITY_LOGGER_NAME;
    } else {
        name = LogService.MAIN_LOGGER_NAME;
    }
    // create the LogWriterLogger
    final LogWriterLogger logger = LogService.createLogWriterLogger(name, config.getName(), isSecure);
    if (isSecure) {
        logger.setLogWriterLevel(((DistributionConfig) config).getSecurityLogLevel());
    } else {
        boolean defaultSource = false;
        if (config instanceof DistributionConfig) {
            ConfigSource source = ((DistributionConfig) config).getConfigSource(LOG_LEVEL);
            if (source == null) {
                defaultSource = true;
            }
        }
        if (!defaultSource) {
            // LOG: fix bug #51709 by not setting if log-level was not specified
            // LOG: let log4j2.xml specify log level which defaults to INFO
            logger.setLogWriterLevel(config.getLogLevel());
        }
    }
    // log the banner
    if (!Boolean.getBoolean(InternalLocator.INHIBIT_DM_BANNER)) {
        if (// avoid filling up logs
        InternalDistributedSystem.getReconnectAttemptCounter() == 0 && // during auto-reconnect
        !// && !isLoner /* do this on a loner to fix bug 35602 */
        isSecure) {
            // LOG:CONFIG:
            logger.info(LogMarker.CONFIG, Banner.getString(null));
        }
    } else {
        logger.debug("skipping banner - " + InternalLocator.INHIBIT_DM_BANNER + " is set to true");
    }
    // log the config
    if (logConfig) {
        if (!isLoner) {
            // LOG:CONFIG: changed from config to info
            logger.info(LogMarker.CONFIG, LocalizedMessage.create(LocalizedStrings.InternalDistributedSystem_STARTUP_CONFIGURATIONN_0, config.toLoggerString()));
        }
    }
    return logger;
}

Example 2 with LogWriterLogger

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

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithSecurityFineLevelAndLogAtInfoLevelButNoSecurityLog.

/**
   * tests scenario where security log has not been set but a level has been set to a more granular
   * level than that of the regular log. Verifies that the correct logs for security show up in the
   * regular log as expected
   * 
   * @throws Exception
   */
@Test
public void testDistributedSystemWithSecurityFineLevelAndLogAtInfoLevelButNoSecurityLog() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "info");
    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 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.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.INFO_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.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(securityLogWriter.fineEnabled());
    assertFalse(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) securityLogWriter).isDebugEnabled());
    assertFalse(((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 logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log files to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    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(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        securityLogWriter.finer(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(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        securityLogWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        securityLogWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        securityLogWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        securityLogWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        securityLogWriter.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);
        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));
    }
    this.system.disconnect();
    this.system = null;
}

Example 3 with LogWriterLogger

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

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithDebugLogLevel.

@Test
public void testDistributedSystemWithDebugLogLevel() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "debug");
    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.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getLogLevel());
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(logWriter);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(logWriter instanceof FastLogger);
    assertTrue(((FastLogger) logWriter).isDelegating());
    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(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 + "]";
        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));
    }
    // 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());
    {
        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));
    }
    this.system.disconnect();
    this.system = null;
}

Example 4 with LogWriterLogger

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

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithFineLogLevel.

@Test
public void testDistributedSystemWithFineLogLevel() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(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 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.getLogLevel());
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(logWriter);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(logWriter instanceof FastLogger);
    assertTrue(((FastLogger) logWriter).isDelegating());
    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(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 + "]";
        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));
    }
    // 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());
    {
        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));
    }
    this.system.disconnect();
    this.system = null;
}

Example 5 with LogWriterLogger

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

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithSecurityInfoLevelAndLogAtFineLevelButNoSecurityLog.

/**
   * tests scenario where security log has not been set but a level has been set to a less granular
   * level than that of the regular log. Verifies that the correct logs for security show up in the
   * regular log as expected
   * 
   * @throws Exception
   */
@Test
public void testDistributedSystemWithSecurityInfoLevelAndLogAtFineLevelButNoSecurityLog() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = 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_LEVEL, "info");
    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.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.INFO_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);
    assertTrue(((FastLogger) securityLogWriter).isDelegating());
    assertTrue(((FastLogger) logWriter).isDelegating());
    Wait.waitForCriterion(new WaitCriterion() {

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

        @Override
        public String description() {
            return "waiting for log files to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    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(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        securityLogWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        securityLogWriter.fine(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(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        securityLogWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        securityLogWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        securityLogWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        securityLogWriter.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));
    }
    this.system.disconnect();
    this.system = null;
}