Examples with Level org.apache.log4j.Level used on opensource projects

Example 16 with Level

use of org.apache.log4j.Level in project adempiere by adempiere.

the class CLogMgtLog4J method enable.

/**
	 * 	Enable/Disable Log4J logging
	 *	@param enableLogging false assumed
	 */
public static void enable(boolean enableLogging) {
    Logger rootLogger = LogManager.getRootLogger();
    if (enableLogging)
        rootLogger.setLevel(s_currentLevelLog4J);
    else {
        Level level = rootLogger.getLevel();
        rootLogger.setLevel(Level.OFF);
        s_currentLevelLog4J = level;
    }
}

Example 17 with Level

use of org.apache.log4j.Level in project apex-core by apache.

the class ApexCli method preImpersonationInit.

public void preImpersonationInit(String[] args) throws IOException {
    Signal.handle(new Signal("INT"), new SignalHandler() {

        @Override
        public void handle(Signal sig) {
            System.out.println("^C");
            if (commandThread != null) {
                commandThread.interrupt();
                mainThread.interrupt();
            } else {
                System.out.print(prompt);
                System.out.flush();
            }
        }
    });
    consolePresent = (System.console() != null);
    Options options = new Options();
    options.addOption("e", true, "Commands are read from the argument");
    options.addOption("v", false, "Verbose mode level 1");
    options.addOption("vv", false, "Verbose mode level 2");
    options.addOption("vvv", false, "Verbose mode level 3");
    options.addOption("vvvv", false, "Verbose mode level 4");
    options.addOption("r", false, "JSON Raw mode");
    options.addOption("p", true, "JSONP padding function");
    options.addOption("h", false, "Print this help");
    options.addOption("f", true, "Use the specified prompt at all time");
    options.addOption("kp", true, "Use the specified kerberos principal");
    options.addOption("kt", true, "Use the specified kerberos keytab");
    CommandLineParser parser = new BasicParser();
    try {
        CommandLine cmd = parser.parse(options, args);
        if (cmd.hasOption("v")) {
            verboseLevel = 1;
        }
        if (cmd.hasOption("vv")) {
            verboseLevel = 2;
        }
        if (cmd.hasOption("vvv")) {
            verboseLevel = 3;
        }
        if (cmd.hasOption("vvvv")) {
            verboseLevel = 4;
        }
        if (cmd.hasOption("r")) {
            raw = true;
        }
        if (cmd.hasOption("e")) {
            commandsToExecute = cmd.getOptionValues("e");
            consolePresent = false;
        }
        if (cmd.hasOption("p")) {
            jsonp = cmd.getOptionValue("p");
        }
        if (cmd.hasOption("f")) {
            forcePrompt = cmd.getOptionValue("f");
        }
        if (cmd.hasOption("h")) {
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp(ApexCli.class.getSimpleName(), options);
            System.exit(0);
        }
        if (cmd.hasOption("kp")) {
            kerberosPrincipal = cmd.getOptionValue("kp");
        }
        if (cmd.hasOption("kt")) {
            kerberosKeyTab = cmd.getOptionValue("kt");
        }
    } catch (ParseException ex) {
        System.err.println("Invalid argument: " + ex);
        System.exit(1);
    }
    if (kerberosPrincipal == null && kerberosKeyTab != null) {
        System.err.println("Kerberos key tab is specified but not the kerberos principal. Please specify it using the -kp option.");
        System.exit(1);
    }
    if (kerberosPrincipal != null && kerberosKeyTab == null) {
        System.err.println("Kerberos principal is specified but not the kerberos key tab. Please specify it using the -kt option.");
        System.exit(1);
    }
    Level logLevel;
    switch(verboseLevel) {
        case 0:
            logLevel = Level.OFF;
            break;
        case 1:
            logLevel = Level.ERROR;
            break;
        case 2:
            logLevel = Level.WARN;
            break;
        case 3:
            logLevel = Level.INFO;
            break;
        default:
            logLevel = Level.DEBUG;
            break;
    }
    for (org.apache.log4j.Logger logger : new org.apache.log4j.Logger[] { org.apache.log4j.Logger.getRootLogger(), org.apache.log4j.Logger.getLogger(ApexCli.class) }) {
        /*
      * Override logLevel specified by user, the same logLevel would be inherited by all
      * appenders related to logger.
      */
        logger.setLevel(logLevel);
        @SuppressWarnings("unchecked") Enumeration<Appender> allAppenders = logger.getAllAppenders();
        while (allAppenders.hasMoreElements()) {
            Appender appender = allAppenders.nextElement();
            if (appender instanceof ConsoleAppender) {
                ((ConsoleAppender) appender).setThreshold(logLevel);
            }
        }
    }
    if (commandsToExecute != null) {
        for (String command : commandsToExecute) {
            LOG.debug("Command to be executed: {}", command);
        }
    }
    if (kerberosPrincipal != null && kerberosKeyTab != null) {
        StramUserLogin.authenticate(kerberosPrincipal, kerberosKeyTab);
    } else {
        Configuration config = new YarnConfiguration();
        StramClientUtils.addDTLocalResources(config);
        StramUserLogin.attemptAuthentication(config);
    }
}

Example 18 with Level

use of org.apache.log4j.Level in project cloudstack by apache.

the class TestAppender method append.

protected void append(LoggingEvent loggingEvent) {
    checkArgument(loggingEvent != null, "append requires a non-null loggingEvent");
    final Level level = loggingEvent.getLevel();
    checkState(expectedPatternResults.containsKey(level), "level " + level + " not supported by append");
    for (final PatternResult patternResult : expectedPatternResults.get(level)) {
        if (patternResult.getPattern().matcher(loggingEvent.getRenderedMessage()).matches()) {
            patternResult.markFound();
        }
    }
}

Example 19 with Level

use of org.apache.log4j.Level in project voldemort by voldemort.

the class SchemaEvolutionValidator method main.

/**
     * This main method provides an easy command line tool to compare two
     * schemas.
     */
public static void main(String[] args) {
    if (args.length != 2) {
        System.out.println("Usage: SchemaEvolutionValidator pathToOldSchema pathToNewSchema");
        return;
    }
    Schema oldSchema;
    Schema newSchema;
    try {
        oldSchema = Schema.parse(new File(args[0]));
    } catch (Exception ex) {
        oldSchema = null;
        System.out.println("Could not open or parse the old schema (" + args[0] + ") due to " + ex);
    }
    try {
        newSchema = Schema.parse(new File(args[1]));
    } catch (Exception ex) {
        newSchema = null;
        System.out.println("Could not open or parse the new schema (" + args[1] + ") due to " + ex);
    }
    if (oldSchema == null || newSchema == null) {
        return;
    }
    System.out.println("Comparing: ");
    System.out.println("\t" + args[0]);
    System.out.println("\t" + args[1]);
    List<Message> messages = SchemaEvolutionValidator.checkBackwardCompatibility(oldSchema, newSchema, oldSchema.getName());
    Level maxLevel = Level.ALL;
    for (Message message : messages) {
        System.out.println(message.getLevel() + ": " + message.getMessage());
        if (message.getLevel().isGreaterOrEqual(maxLevel)) {
            maxLevel = message.getLevel();
        }
    }
    if (maxLevel.isGreaterOrEqual(Level.ERROR)) {
        System.out.println(Level.ERROR + ": The schema is not backward compatible. New clients will not be able to read existing data.");
    } else if (maxLevel.isGreaterOrEqual(Level.WARN)) {
        System.out.println(Level.WARN + ": The schema is partially backward compatible, but old clients will not be able to read data serialized in the new format.");
    } else {
        System.out.println(Level.INFO + ": The schema is backward compatible. Old and new clients will be able to read records serialized by one another.");
    }
}

Example 20 with Level

use of org.apache.log4j.Level in project eiger by wlloyd.

the class StorageService method setLog4jLevel.

@Override
public void setLog4jLevel(String classQualifier, String rawLevel) {
    Level level = Level.toLevel(rawLevel);
    org.apache.log4j.Logger.getLogger(classQualifier).setLevel(level);
    logger_.info("set log level to " + level + " for classes under '" + classQualifier + "' (if the level doesn't look like '" + rawLevel + "' then log4j couldn't parse '" + rawLevel + "')");
}