Java Code Examples for ch.qos.logback.classic.Logger#setLevel()

private void doConfigure(LogLevel logLevel) {
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger rootLogger = context.getLogger(Logger.ROOT_LOGGER_NAME);

    if (currentLevel == null) {
        context.reset();
        context.addTurboFilter(new GradleFilter());
        context.getLogger("org.apache.http.wire").setLevel(Level.OFF);
        context.getLogger("org.codehaus.groovy.runtime.m12n.MetaInfExtensionModule").setLevel(Level.ERROR);
        GradleAppender appender = new GradleAppender();
        appender.setContext(context);
        appender.start();
        rootLogger.addAppender(appender);
    }

    currentLevel = logLevel;
    rootLogger.setLevel(LogLevelConverter.toLogbackLevel(logLevel));
}
 

/**
 * Frees the given logger from the appender used to be displayed directly by
 * this controller.
 *
 * @param name The name of the logger we want to free from being captured
 * @return The list of log levels configured and their settings
 */
@RequestMapping(value = "free/{name}/", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET,
    headers = "Accept=application/json")
@ResponseBody
public ResponseEntity<LogResponse> free(@PathVariable("name")
final String name) {
    final LoggerContext ctx = (LoggerContext) LoggerFactory.getILoggerFactory();
    synchronized (ctx) {
        Logger logger = ctx.getLogger(name);
        if (logger != null) {
            logger.setLevel(null);
            logger.detachAppender(logbackMemoryAppenderImpl.getName());
        }
    }
    return new ResponseEntity<>(listLoggers(ctx), HttpStatus.OK);
}
 

@Setup(Level.Iteration)
public void setUp() {
	Logger root = (Logger) LoggerFactory.getLogger(ShaclSailConnection.class.getName());
	root.setLevel(ch.qos.logback.classic.Level.INFO);

	allStatements = new ArrayList<>(NUMBER_OF_TRANSACTIONS);

	SimpleValueFactory vf = SimpleValueFactory.getInstance();

	for (int j = 0; j < NUMBER_OF_TRANSACTIONS; j++) {
		List<Statement> statements = new ArrayList<>(BenchmarkConfigs.STATEMENTS_PER_TRANSACTION);
		allStatements.add(statements);
		for (int i = 0; i < BenchmarkConfigs.STATEMENTS_PER_TRANSACTION; i++) {
			IRI iri = vf.createIRI("http://example.com/" + i + "_" + j);
			statements.add(vf.createStatement(iri, RDF.TYPE, RDFS.RESOURCE));
			statements.add(vf.createStatement(iri, FOAF.AGE,
					vf.createLiteral(i)));
		}
	}
	System.gc();

}
 

@Override
public void handle(String optionValue, Options options) {
    if (optionValue == null) {
        return;
    }

    if (optionValue.isEmpty()) {
        org.slf4j.Logger slf4jLogger = LoggerFactory.getLogger("io.redskap.swagger.brake");
        if (slf4jLogger instanceof Logger) {
            Logger logger = (Logger) slf4jLogger;
            logger.setLevel(Level.DEBUG);
            Appender<ILoggingEvent> verboseAppender = getVerboseAppender();
            if (verboseAppender != null) {
                logger.detachAppender("INFO_STDOUT");
                logger.addAppender(verboseAppender);
            }
        }
    }
}
 

@Setup(Level.Invocation)
public void setUp() {
	Logger root = (Logger) LoggerFactory.getLogger(ShaclSailConnection.class.getName());
	root.setLevel(ch.qos.logback.classic.Level.INFO);

	SimpleValueFactory vf = SimpleValueFactory.getInstance();

	allStatements = BenchmarkConfigs.generateStatements(((statements, i, j) -> {
		IRI iri = vf.createIRI("http://example.com/" + i + "_" + j);
		statements.add(vf.createStatement(iri, RDF.TYPE, RDFS.RESOURCE));
		statements.add(vf.createStatement(iri, RDFS.LABEL, vf.createLiteral("label" + i)));
	}));

	System.gc();

}
 

public static void configDefaultLog(String fileName, String packageLogPackages, String packageLogLevels) {
    Log.DEFAULT_BASIC_LOGGER = LoggerBuilder.getLogger(fileName);
    Log.DEFAULT_BASIC_LOGGER.addBasicPath(Log.class.getName());

    if (StringUtils.isNotBlank(packageLogPackages) && StringUtils.isNotBlank(packageLogLevels)) {
        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
        String[] packages = packageLogPackages.split(",");
        String[] levels = packageLogLevels.split(",");
        int levelsLength = levels.length;
        String packagePath;
        String logLevel;
        Logger packageLogger;
        for (int i = 0, length = packages.length; i < length; i++) {
            packagePath = packages[i];
            if(i >= levelsLength) {
                logLevel = "INFO";
            } else {
                logLevel = levels[i];
            }
            packageLogger = context.getLogger(packagePath);
            packageLogger.setLevel(Level.toLevel(logLevel));
        }
    }
}
 

@POST
@Path("/{name}")
@Consumes(APPLICATION_JSON)
@Produces(APPLICATION_JSON)
@ApiOperation(value = "Create a new logger level")
@ApiResponses({
  @ApiResponse(code = 200, message = "The logger successfully created"),
})
public LoggerDto createLogger(
    @ApiParam(value = "logger name") @PathParam("name") String name, LoggerDto createdLogger)
    throws NotFoundException {
  Logger logger = getLogger(name, false);
  logger.setLevel(Level.toLevel(createdLogger.getLevel()));
  return asDto(logger);
}
 

@BeforeEach
void setUp(TestInfo testInfo) {
    rootLogger.getLoggerContext().getStatusManager().clear();
    MDC.clear();
    testLogger = (Logger) LoggerFactory.getLogger("loggerTest." + testInfo.getDisplayName());
    testLogger.setLevel(Level.ALL);
}
 

@BeforeEach
public void setup() throws Exception {
    System.setProperty(FileHandler.SAE_HOME, System.getProperty("java.io.tmpdir"));
    this.mockMvc = webAppContextSetup(webApplicationContext).build();
    this.now = LocalDateTime.now();

    Logger root = (Logger) LoggerFactory.getLogger("de.avanux");
    root.setLevel(Level.DEBUG);
}
 

@Override
public void configure(LoggerContext loggerContext) {
    addInfo("Setting up default configuration.");

    DefaultConsoleAppender consoleAppender = new DefaultConsoleAppender();
    consoleAppender.setContext(loggerContext);
    consoleAppender.setName("CONSOLE");
    consoleAppender.start();

    Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.setLevel(Level.INFO);
    rootLogger.addAppender(consoleAppender);
}
 

public TestLogAppender() {
    sb = new StringBuilder();
    logger = (Logger) LoggerFactory.getLogger("com.intuit.karate");
    setName("karate-test");
    LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    setContext(lc);
    encoder = new PatternLayoutEncoder();
    encoder.setPattern("%msg");
    encoder.setContext(context);
    encoder.start();
    start();
    logger.addAppender(this);
    logger.setLevel(Level.DEBUG);
}
 

/**
 * Initializer logback
 * 
 * @param file
 * @param level
 * @param maxHistory
 */
private void doInitializer(String file, String level, int maxHistory) {
	LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
	Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
	rootLogger.detachAndStopAllAppenders();

	// appender
	RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<ILoggingEvent>();
	fileAppender.setContext(loggerContext);
	fileAppender.setName("application");
	fileAppender.setFile(file);
	fileAppender.setAppend(true);

	// policy
	TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<ILoggingEvent>();
	policy.setContext(loggerContext);
	policy.setMaxHistory(maxHistory);
	policy.setFileNamePattern(file + ".%d{yyyy-MM-dd}");
	policy.setParent(fileAppender);
	policy.start();
	fileAppender.setRollingPolicy(policy);

	// encoder
	PatternLayoutEncoder encoder = new PatternLayoutEncoder();
	encoder.setContext(loggerContext);
	encoder.setPattern("%date [%thread] %-5level %logger (%file:%line\\) - %msg%n");
	encoder.start();
	fileAppender.setEncoder(encoder);
	
	fileAppender.start();

	rootLogger.addAppender(fileAppender);
	rootLogger.setLevel(Level.toLevel(level));
	rootLogger.setAdditive(false);
}
 

public MessagesTest() {
    appender = new TestAppender();
    appender.start();

    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger logger = context.getLogger("com.haulmont.cuba.core.sys.AbstractMessages");
    logger.addAppender(appender);
    logger.setLevel(Level.TRACE);
}
 

@Test
public void testLevelsThatDoNotMatchSlf4jAreMapped() {
	Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
	logger.setLevel(Level.WARN);

	setParameters.execute("set", "log");

	verify(mockConsoleIO).writeln("log: warning");
	verifyNoMoreInteractions(mockConsoleIO);
}
 

@BeforeClass
public static void beforeClass(){
    Logger log = (Logger)LoggerFactory.getLogger( WorkflowExecutorImpl.class );
    executorLogLevel = log.getLevel();
    log.setLevel( Level.ERROR );
}
 

public ConfigTest() {
    LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
    rootLogger.setLevel(Level.INFO);
}
 

public static void suppressJenaMessages() {
	Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
	root.setLevel(Level.INFO);
}
 

@Before
public void setup() {
    Logger root = (Logger) LoggerFactory.getLogger(LocalRateLimiter.class);
    root.setLevel(Level.INFO);
    root.addAppender(mockAppender);
}
 

/**
 * Doesn't actually verify the caching helps but can be useful to run to see current
 * numbers.
 */
@Test
public void speedtest() {
	LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
	Logger rootLogger = loggerContext
			.getLogger("org.springframework.cloud.function.compiler");
	rootLogger.setLevel(Level.ERROR);

	// 10 uses of a single function compiler:
	long stime = System.currentTimeMillis();
	FunctionCompiler<String, String> fc = new FunctionCompiler<String, String>(
			String.class.getName());
	for (int i = 0; i < 5; i++) {
		stime = System.currentTimeMillis();
		CompiledFunctionFactory<Function<String, String>> result = fc.compile("foos",
				"flux -> flux.map(v -> v.toUpperCase())", "Flux<String>",
				"Flux<String>");
		assertThat(FunctionFactoryUtils.isFluxFunction(result.getFactoryMethod()))
				.isTrue();
		System.out.println("Reusing FunctionCompiler: #" + (i + 1) + " = "
				+ (System.currentTimeMillis() - stime) + "ms");
	}

	// 3 separate FunctionCompilers:
	stime = System.currentTimeMillis();
	CompiledFunctionFactory<Function<String, String>> compiled = new FunctionCompiler<String, String>(
			String.class.getName()).compile("foos",
					"flux -> flux.map(v -> v.toUpperCase())", "Flux<String>",
					"Flux<String>");
	assertThat(FunctionFactoryUtils.isFluxFunction(compiled.getFactoryMethod()))
			.isTrue();
	long etime = System.currentTimeMillis();
	long time1 = (etime - stime);
	System.out.println("New FunctionCompiler: " + time1 + "ms");

	stime = System.currentTimeMillis();
	compiled = new FunctionCompiler<String, String>(String.class.getName()).compile(
			"foos", "flux -> flux.map(v -> v.toUpperCase())", "Flux<String>",
			"Flux<String>");
	assertThat(FunctionFactoryUtils.isFluxFunction(compiled.getFactoryMethod()))
			.isTrue();
	etime = System.currentTimeMillis();
	long time2 = (etime - stime);
	System.out.println("New FunctionCompiler: " + time2 + "ms");

	stime = System.currentTimeMillis();
	compiled = new FunctionCompiler<String, String>(String.class.getName()).compile(
			"foos", "flux -> flux.map(v -> v.toUpperCase())", "Flux<String>",
			"Flux<String>");
	assertThat(FunctionFactoryUtils.isFluxFunction(compiled.getFactoryMethod()))
			.isTrue();
	etime = System.currentTimeMillis();
	long time3 = (etime - stime);
	System.out.println("New FunctionCompiler: " + time3 + "ms");
}
 

public void run() throws Exception, IOException {

        Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        root.setLevel(Level.INFO);

        globalStartTime = System.nanoTime();

        // kick off the javaFX rendering code --> .start( Stage ) below, blocked on the skil model server round trips for { auth, inference }
        launch();    

    }