org.slf4j.ILoggerFactory#ch.qos.logback.classic.Logger源码实例Demo

@Test
public void customLoggerNameKey() throws IOException {
    encoder.setLoggerNameKey("Logger");
    encoder.start();

    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    final Logger logger = lc.getLogger(LOGGER_NAME);

    final LoggingEvent event = simpleLoggingEvent(logger, null);

    final String logMsg = encodeToStr(event);

    final ObjectMapper om = new ObjectMapper();
    final JsonNode jsonNode = om.readTree(logMsg);
    coreValidation(jsonNode);
    assertNotNull(jsonNode.get("_thread_name").textValue());
    assertEquals(LOGGER_NAME, jsonNode.get("_Logger").textValue());
    assertNull(jsonNode.get("_exception"));
}
 

@Test
public void testCheck() {
	checker.check();
	 Logger root = (Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
	 Level actualLevel = root.getLevel();
	assertThat(actualLevel, is(Level.INFO));
	
	checker.setCorrectLevelStr("DEBUG");
	checker.check();
	actualLevel = root.getLevel();
	assertThat(actualLevel, is(Level.DEBUG));
	
	checker.setActive(false);
	checker.setCorrectLevelStr("WARN");
	checker.check();
	actualLevel = root.getLevel();
	assertThat(actualLevel, is(Level.DEBUG));
}
 

@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<>(BenchmarkConfigs.NUMBER_OF_TRANSACTIONS);

	SimpleValueFactory vf = SimpleValueFactory.getInstance();

	for (int j = 0; j < BenchmarkConfigs.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++) {
			statements.add(
					vf.createStatement(vf.createIRI("http://example.com/" + i + "_" + j), RDF.TYPE, RDFS.RESOURCE));
			statements.add(vf.createStatement(vf.createIRI("http://example.com/" + i + "_" + j), FOAF.AGE,
					vf.createLiteral(i)));
		}
	}
	System.gc();

}
 

@Override
public void validate(NodeContext nodeContext, Configuration change) throws InvalidConfigChangeException {
  String logger = change.getKey();
  String level = change.getValue();

  // verify enum
  if (level != null) {
    try {
      Level.valueOf(level);
    } catch (RuntimeException e) {
      throw new InvalidConfigChangeException("Illegal level: " + level, e);
    }
  }

  // verify we can access the logger
  LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
  Logger logbackLogger = loggerContext.getLogger(logger);

  // verify illegal op
  if (Logger.ROOT_LOGGER_NAME.equals(logbackLogger.getName()) && level == null) {
    throw new InvalidConfigChangeException("Cannot remove the root logger");
  }
}
 

private Logger configureLevels() {

        final Logger root = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
        root.getLoggerContext().reset();

        final LevelChangePropagator propagator = new LevelChangePropagator();
        propagator.setContext(root.getLoggerContext());
        propagator.setResetJUL(true);

        root.getLoggerContext().addListener(propagator);

        root.setLevel(config.getLevel());

        // Decode the packages and levels
        for (Map.Entry<String, Level> entry : config.getLoggers().entrySet()) {
            ((Logger) LoggerFactory.getLogger(entry.getKey())).setLevel(entry.getValue());
        }

        return root;
    }
 

@Test
public void test() throws Exception {
  BaleenLogging logging = new BaleenLogging();
  InMemoryLoggingBuilder builder = new InMemoryLoggingBuilder();
  logging.configure(Collections.singletonList(builder));

  InMemoryAppender<ILoggingEvent> appender = builder.getAppender();
  appender.clear();

  LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  Logger rootLogger = context.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);

  if (rootLogger.isInfoEnabled()) {
    UIMAFramework.getLogger(DummyAnnotator1.class).log(Level.INFO, "Logging from uima");

    assertTrue(
        appender.getAll().stream()
                .filter(l -> l.getMessage().contains("Logging from uima"))
                .count()
            > 0);
  }
}
 

/**
 * 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);

	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, FOAF.AGE, vf.createLiteral(i)));
	}));

	System.gc();

}
 

private void figureoutLogConfiguration(Logger Logger, LinkedList<LogProfileInfo> list, String appid) {

        Iterator<Appender<ILoggingEvent>> appenders = Logger.iteratorForAppenders();
        while (appenders != null && appenders.hasNext()) {
            Appender<ILoggingEvent> appender = appenders.next();
            if (appender instanceof FileAppender<?>) {
                getAppenderInfo((FileAppender<ILoggingEvent>)appender, list, appid);
            }
            else if(appender instanceof AsyncAppender) {
                Iterator<Appender<ILoggingEvent>> itAppenders = (Iterator<Appender<ILoggingEvent>>)((AsyncAppender) appender).iteratorForAppenders();
                while (itAppenders != null && itAppenders.hasNext()) {
                    Appender<ILoggingEvent> ap = itAppenders.next();
                    if (ap instanceof FileAppender<?>) {
                        getAppenderInfo((FileAppender<ILoggingEvent>)ap, list, appid);
                    }
                } 
            }
        }
    }
 

@Setup(Level.Iteration)
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, FOAF.AGE, vf.createLiteral(i)));
	}));

	System.gc();

}
 

@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();

}
 

@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();

}
 

@Override
public void init() {
    LoggerContext loggerContext = (LoggerContext)LoggerFactory.getILoggerFactory();
    if (loggerContext == null)
        return;
    List<Logger> loggerList = loggerContext.getLoggerList();
    ch.qos.logback.classic.Logger loggerKafka =
        loggerContext.getLogger("org.apache.kafka.clients.producer.ProducerConfig");
    if (loggerKafka != null) {
        loggerKafka.setLevel(ch.qos.logback.classic.Level.ERROR);
    }
    createBizLogger();
    for (Logger logger : loggerList) {
        AppenderAttachable appenderAttachable = logger;
        setLayout(loggerContext,appenderAttachable.iteratorForAppenders());
    }
}
 

@Test
public void constructCert() throws Exception {
    Security.addProvider(new BouncyCastleProvider());
    ((Logger)LoggerFactory.getLogger(CertificateGenerator.class)).setLevel(Level.DEBUG);
    File file = new File("/tmp/dm-agent.jks");//Files.createTempFile("dm-agent", ".jks");

    KeyPair keypair = createKeypair();
    JcaX509v3CertificateBuilder cb = createRootCert(keypair);
    ContentSigner signer = new JcaContentSignerBuilder("SHA256withRSA").build(keypair.getPrivate());
    X509CertificateHolder rootCert = cb.build(signer);
    KeystoreConfig cert = CertificateGenerator.constructCert(rootCert,
      keypair.getPrivate(),
      file,
      ImmutableSet.of("test1", "test2"));
    assertNotNull(cert);
}
 

public Graylog2Plugin(Application app) {
    final Configuration config = app.configuration();

    accessLogEnabled = config.getBoolean("graylog2.appender.send-access-log", false);
    queueCapacity = config.getInt("graylog2.appender.queue-size", 512);
    reconnectInterval = config.getMilliseconds("graylog2.appender.reconnect-interval", 500L);
    connectTimeout = config.getMilliseconds("graylog2.appender.connect-timeout", 1000L);
    isTcpNoDelay = config.getBoolean("graylog2.appender.tcp-nodelay", false);
    sendBufferSize = config.getInt("graylog2.appender.sendbuffersize", 0); // causes the socket default to be used
    try {
        canonicalHostName = config.getString("graylog2.appender.sourcehost", InetAddress.getLocalHost().getCanonicalHostName());
    } catch (UnknownHostException e) {
        canonicalHostName = "localhost";
        log.error("Unable to resolve canonical localhost name. " +
                "Please set it manually via graylog2.appender.sourcehost or fix your lookup service, falling back to {}", canonicalHostName);
    }
    // TODO make this a list and dynamically accessible from the application
    final String hostString = config.getString("graylog2.appender.host", "127.0.0.1:12201");
    final String protocol = config.getString("graylog2.appender.protocol", "tcp");

    final HostAndPort hostAndPort = HostAndPort.fromString(hostString);

    final GelfTransports gelfTransport = GelfTransports.valueOf(protocol.toUpperCase());

    final GelfConfiguration gelfConfiguration = new GelfConfiguration(hostAndPort.getHostText(), hostAndPort.getPort())
            .transport(gelfTransport)
            .reconnectDelay(reconnectInterval.intValue())
            .queueSize(queueCapacity)
            .connectTimeout(connectTimeout.intValue())
            .tcpNoDelay(isTcpNoDelay)
            .sendBufferSize(sendBufferSize);

    this.transport = GelfTransports.create(gelfConfiguration);

    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    rootLogger = lc.getLogger(Logger.ROOT_LOGGER_NAME);

    gelfAppender = new GelfclientAppender(transport, getLocalHostName());
    gelfAppender.setContext(lc);
}
 

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);
}
 

@Override
public void set(String value) throws IllegalArgumentException {
	// Assume Logback
	Level logLevel = LOG_LEVELS.get(value.toLowerCase());
	if (logLevel != null) {
		Logger logbackRootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
		logbackRootLogger.setLevel(logLevel);
	} else {
		throw new IllegalArgumentException("unknown logging level: " + value);
	}
}
 

@Test
public void getNameTest() throws Exception {
    LoggerVM vm = new LoggerVM();
    assertNull(vm.getName());

    Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    vm = new LoggerVM(logger);
    assertEquals(Logger.ROOT_LOGGER_NAME, vm.getName());
}
 

public static Level getLogLevel()
{
    synchronized (CBDriver.class)
    {
        Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.couchbase");
        return logger.getLevel();
    }
}
 

@Test
public void toStringTestTest() throws Exception {
    Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    LoggerVM vm = new LoggerVM(logger);
    assertTrue(vm.toString().startsWith(LoggerVM.class.getSimpleName()));
    String json = vm.toString().replace(LoggerVM.class.getSimpleName(), "");
    assertTrue(TestUtils.isValid(json));
}
 

public static void bootstrap() {

        // Initially configure for WARN+ console logging
        final LoggingConfiguration.ConsoleConfiguration console = new LoggingConfiguration.ConsoleConfiguration();
        console.setEnabled(true);
        console.setTimeZone(TimeZone.getDefault());
        //console.setThreshold(Level.DEBUG);

        final Logger root = getCleanRoot();
        root.addAppender(LogbackFactory.buildConsoleAppender(console, root.getLoggerContext(), null));
    }
 

public static void enableDBLogging() {
    ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) org.slf4j.LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    if (root.getAppender(SQLITE_APPENDER_NAME) == null) {
        LoggerContext context = (LoggerContext) org.slf4j.LoggerFactory.getILoggerFactory();
        SQLiteAppender appender = new SQLiteAppender();
        appender.setName(SQLITE_APPENDER_NAME);
        appender.setMaxHistory("7 days"); //keep 7 days' worth of history
        appender.setContext(context);
        appender.start();
        root.addAppender(appender);
    }
}
 

@Before
public void setUp() throws Exception {

    MockitoAnnotations.initMocks(this);

    final Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
    logger.addAppender(mockAppender);

    final File hivemqHomefolder = folder.newFolder();
    confFolder = new File(hivemqHomefolder, "conf");
    assertTrue(confFolder.mkdir());

    when(systemInformation.getHiveMQHomeFolder()).thenReturn(hivemqHomefolder);
    when(systemInformation.getConfigFolder()).thenReturn(confFolder);
}
 

@After
public void tearDown() {
	TextToSpeech.silence(false);
	TrainingExerciseBase.silence(false);
	System.setOut(originalOut);

	Logger rootLogger = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
	rootLogger.detachAndStopAllAppenders();
}
 

@BeforeAll
public static void setup() {
    // close some specific loggers so that we can clearly see Hibernate: SQL queries
    ((Logger) LoggerFactory.getLogger("org.hibernate.SQL")).setLevel(Level.OFF);
    ((Logger) LoggerFactory.getLogger("org.hibernate.type.descriptor.sql")).setLevel(Level.OFF);
    ((Logger) LoggerFactory.getLogger("org.hibernate.stat")).setLevel(Level.OFF);

    entityManagerFactory = Persistence.createEntityManagerFactory("com.baeldung.hibernate.entitymanager.game_player_mysql");
}
 

@Bean
@ConditionalOnClass(Logger.class)
public CommonsRequestLoggingFilter springLogging() {
    Logger logger = (Logger) LoggerFactory.getLogger(CommonsRequestLoggingFilter.class);
    logger.setLevel(Level.DEBUG);
    log.info("Http logging enabled {}.", properties);
    return requestLoggingFilter();
}
 

public EntityCacheTestClass() {
    appender = new TestAppender();
    appender.start();
    LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
    Logger logger = context.getLogger("eclipselink.sql");
    logger.addAppender(appender);
}
 

public static void setLogLevel(Level logLevel)
{
    synchronized (CBDriver.class)
    {
        Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.couchbase");
        logger.setLevel(logLevel);
        //logLevelSet = true;
    }
}
 

@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);
}
 

@Test
public void exception() throws IOException {
    encoder.start();

    final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
    final Logger logger = lc.getLogger(LOGGER_NAME);

    final String logMsg;
    try {
        throw new IllegalArgumentException("Example Exception");
    } catch (final IllegalArgumentException e) {
        logMsg = encodeToStr(new LoggingEvent(
            LOGGER_NAME,
            logger,
            Level.DEBUG,
            "message {}",
            e,
            new Object[]{1}));
    }

    final ObjectMapper om = new ObjectMapper();
    final JsonNode jsonNode = om.readTree(logMsg);
    basicValidation(jsonNode);

    final LineReader msg =
        new LineReader(new StringReader(jsonNode.get("full_message").textValue()));

    assertEquals("message 1", msg.readLine());
    assertEquals("java.lang.IllegalArgumentException: Example Exception", msg.readLine());
    final String line = msg.readLine();
    assertTrue(line.matches("^\tat de.siegmar.logbackgelf.GelfEncoderTest.exception"
        + "\\(GelfEncoderTest.java:\\d+\\)$"), "Unexpected line: " + line);
}