Refine search
public static PatternLayoutEncoder encoder(String pattern) { PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(LOGGER_CONTEXT); encoder.setPattern(pattern); encoder.start(); return encoder; }
@Test public void startup_logger_prints_to_only_to_system_out() { LoggerContext ctx = underTest.configure(props); Logger startup = ctx.getLogger("startup"); assertThat(startup.isAdditive()).isFalse(); Appender appender = startup.getAppender("CONSOLE"); assertThat(appender).isInstanceOf(ConsoleAppender.class); ConsoleAppender<ILoggingEvent> consoleAppender = (ConsoleAppender<ILoggingEvent>) appender; assertThat(consoleAppender.getTarget()).isEqualTo("System.out"); assertThat(consoleAppender.getEncoder()).isInstanceOf(PatternLayoutEncoder.class); PatternLayoutEncoder patternEncoder = (PatternLayoutEncoder) consoleAppender.getEncoder(); assertThat(patternEncoder.getPattern()).isEqualTo("%d{yyyy.MM.dd HH:mm:ss} %-5level app[][%logger{20}] %msg%n"); }
(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(ROOT_LOGGER_NAME); final LoggerContext context = rootLogger.getLoggerContext(); context.reset(); final PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setContext(context); ple.setPattern("%d{HH:mm:ss.SSS} %-5level %logger{1} %F:%L - %msg%n"); ple.start(); fileAppender.start(); rootLogger.setLevel(Level.DEBUG); rootLogger.addAppender(fileAppender);
private Appender<ILoggingEvent> consoleAppender(LogbackConfigurator config) { ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<>(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); String logPattern = this.patterns.getProperty("logging.pattern.console", CONSOLE_LOG_PATTERN); encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext())); config.start(encoder); appender.setEncoder(encoder); config.appender("CONSOLE", appender); return appender; }
private TmmUILogCollector() { Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); // create a new TmmUILogAppender - so we need not to put it in the logback.xml: PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(rootLogger.getLoggerContext()); encoder.setPattern("%d{HH:mm:ss.SSS} %-5level %logger{60} - %msg%n"); encoder.start(); logAppender = new TmmUILogAppender(); logAppender.setContext(rootLogger.getLoggerContext()); logAppender.setEncoder(encoder); logAppender.start(); rootLogger.addAppender(logAppender); }
static public void main(String[] args) throws Exception { Logger rootLogger = (Logger) LoggerFactory.getLogger("root"); LoggerContext loggerContext = rootLogger.getLoggerContext(); loggerContext.reset(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern("%-5level [%thread]: %message%n"); encoder.start(); ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>(); appender.setContext(loggerContext); appender.setEncoder(encoder); appender.start(); rootLogger.addAppender(appender); rootLogger.debug("Message 1"); rootLogger.warn("Message 2"); } }
private static void configureLogging(File logFile, Level level) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); OutputStreamAppender<ILoggingEvent> appender; if (logFile == null) { appender = configureConsoleLogging(loggerContext); } else { appender = configureFileLogging(logFile, loggerContext); } System.out.println("Logging: The log level is set to " + level); PatternLayoutEncoder patternLayoutEncoder = new PatternLayoutEncoder(); patternLayoutEncoder.setPattern(LogDescription.LOG_PATTERN); patternLayoutEncoder.setContext(loggerContext); patternLayoutEncoder.start(); appender.setEncoder(patternLayoutEncoder); appender.start(); ch.qos.logback.classic.Logger rootLogger = loggerContext.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); loggerContext.stop(); rootLogger.detachAndStopAllAppenders(); rootLogger.addAppender(appender); rootLogger.setLevel(level); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); LevelChangePropagator levelChangePropagator = new LevelChangePropagator(); levelChangePropagator.setResetJUL(true); levelChangePropagator.setContext(loggerContext); levelChangePropagator.start(); loggerContext.addListener(levelChangePropagator); loggerContext.start(); }
LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("%date %level [%thread] %logger{10} [%file:%line] %msg%n"); ple.setContext(lc); ple.start(); FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); String filename = file.toAbsolutePath().toString(); if (!lc.isStarted()) { lc.start(); fileAppender.start(); for (ch.qos.logback.classic.Logger log : lc.getLoggerList()) { if (log.getLevel() != null) { log.addAppender(fileAppender);
public LogMessageBroadcaster(PatternLayoutEncoder encoder) { this.encoder = encoder; LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); encoder.setContext(loggerContext); setContext(loggerContext); encoder.start(); ((LoggerContext) this.getContext()).getLogger(Logger.ROOT_LOGGER_NAME).addAppender(this); }
/** * Configure the LessCompilerImpl logger with a ConsoleAppender * * @param verbose set logger level to Level.ALL if true, otherwise Level.OFF * @param daemon set the level of the compilationTaskLogger to Level.INFO if true, otherwise Level.OFF */ public static void configure(boolean verbose, boolean daemon) { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); ConsoleAppender<ILoggingEvent> ca = new ConsoleAppender<ILoggingEvent>(); ca.setContext(lc); ca.setName("less console"); PatternLayoutEncoder pl = new PatternLayoutEncoder(); pl.setContext(lc); pl.setPattern("%msg%n"); pl.start(); ca.setEncoder(pl); ca.start(); //prevent double log output lc.getLogger(Logger.ROOT_LOGGER_NAME).detachAndStopAllAppenders(); configureCompilerLogger(verbose, lc, ca); configureCompilationTaskLogger(daemon, lc, ca); configureLessCompilationEngineLogger(verbose, lc, ca); }
@Test public void test() { BaleenLogging logging = new BaleenLogging(); InMemoryLoggingBuilder builder = new InMemoryLoggingBuilder(); logging.configure( Arrays.asList( builder, new BaleenConsoleLoggerBuilder(PATTERN, new MinMaxFilter(Level.INFO, Level.ERROR)))); LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = context.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); int count = 0; Iterator<Appender<ILoggingEvent>> it = rootLogger.iteratorForAppenders(); while (it.hasNext()) { Appender<ILoggingEvent> appender = it.next(); if (appender instanceof OutputStreamAppender) { Encoder<ILoggingEvent> e = ((OutputStreamAppender<ILoggingEvent>) appender).getEncoder(); assertTrue(e instanceof PatternLayoutEncoder); assertEquals(PATTERN, ((PatternLayoutEncoder) e).getPattern()); } count++; } // 3 = 2 + instrumented appender assertEquals(3, count); }
private static void setOutput(final String... paths) { LOG_ROOT.getLoggerContext().reset(); final PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setPattern("%date %level [%thread] [%file:%line] %msg%n"); encoder.setContext(LOG_ROOT.getLoggerContext()); encoder.start(); for (final String path : paths) { // create FileAppender final FileAppender<ILoggingEvent> logfileOut = new FileAppender<>(); logfileOut.setAppend(false); logfileOut.setFile(path); logfileOut.setContext(LOG_ROOT.getLoggerContext()); logfileOut.setEncoder(encoder); logfileOut.start(); // attach the rolling file appender to the root logger LOG_ROOT.addAppender(logfileOut); } }
Appender<ILoggingEvent> appender = logger.getAppender(appenderName); if (appender == null) { throw new IllegalArgumentException("Appender not found: " + appenderName); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(_context); encoder.setPattern(pattern); encoder.start(); return "pattern of appender " + loggerName + '.' + appenderName + " set to " + encoder.getPattern();
@Test public void log_to_ce_file() { LoggerContext ctx = underTest.configure(props); Logger root = ctx.getLogger(Logger.ROOT_LOGGER_NAME); Appender<ILoggingEvent> appender = root.getAppender("file_ce"); assertThat(appender).isInstanceOf(FileAppender.class); FileAppender fileAppender = (FileAppender) appender; assertThat(fileAppender.getFile()).isEqualTo(new File(logDir, "ce.log").getAbsolutePath()); assertThat(fileAppender.getEncoder()).isInstanceOf(PatternLayoutEncoder.class); PatternLayoutEncoder encoder = (PatternLayoutEncoder) fileAppender.getEncoder(); assertThat(encoder.getPattern()).isEqualTo("%d{yyyy.MM.dd HH:mm:ss} %-5level ce[%X{ceTaskUuid}][%logger{20}] %msg%n"); }
ch.qos.logback.core.FileAppender<ILoggingEvent> fileApp; Map<Logger, List<Appender<ILoggingEvent>>> appendersAll = new HashMap<>(); for (Logger log : context.getLoggerList()) { List<Appender<ILoggingEvent>> appenders = new ArrayList<>(); Iterator<Appender<ILoggingEvent>> iter = log.iteratorForAppenders(); while (iter.hasNext()) { Appender<ILoggingEvent> element = iter.next(); app.setAppend(rollingApp.isAppend()); PatternLayoutEncoder encoder = (PatternLayoutEncoder) rollingApp.getEncoder(); app.setEncoderPattern(encoder.getPattern()); app.setFileName(rollingApp.getFile()); if (rollingApp.getRollingPolicy() instanceof FixedWindowRollingPolicy) { app.setFileName(fileApp.getFile()); PatternLayoutEncoder encoder = (PatternLayoutEncoder) fileApp.getEncoder(); app.setEncoderPattern(encoder.getPattern()); this.fileDTOs.put(fileApp.getName(), app); consoleApp.getCopyOfAttachedFiltersList(); PatternLayoutEncoder encoder = (PatternLayoutEncoder) consoleApp.getEncoder(); app.setEncoderPattern(encoder.getPattern()); app.setName(consoleApp.getName()); app.setThresholdFilter(context.getLogger(Logger.ROOT_LOGGER_NAME).getEffectiveLevel().levelStr); this.consoleDTOs.put(consoleApp.getName(), app);
if ((this.encoder == null) || (this.encoder.getLayout() == null)) { addError("No layout set for the appender named [" + name + "]."); return; final Layout<?> layout = this.tagEncoder.getLayout(); String pattern = this.tagEncoder.getPattern(); if (!pattern.contains("%nopex")) { this.tagEncoder.stop(); this.tagEncoder.setPattern(pattern + "%nopex"); this.tagEncoder.start();
@Before public void setUp() { ple.setPattern("%m"); ple.setContext(context); }
void init(ByteArrayOutputStream baos) throws IOException { ple.start(); ((PatternLayout) ple.getLayout()).setOutputPatternAsHeader(false); byte[] header = ple.headerBytes(); baos.write(header); }
public String ac_log_get_pattern_$_2(Args args) { String loggerName = args.argv(0); String appenderName = args.argv(1); Logger logger = getLogger(loggerName); if (logger == null) { throw new IllegalArgumentException("Logger not found: " + loggerName); } Appender<ILoggingEvent> appender = logger.getAppender(appenderName); if (appender == null) { throw new IllegalArgumentException("Appender not found: " + appenderName); } Encoder<?> encoder; if (appender instanceof ConsoleAppender) { encoder = ((ConsoleAppender<?>)appender).getEncoder(); } else if (appender instanceof FileAppender) { encoder = ((FileAppender<?>)appender).getEncoder(); } else { throw new IllegalArgumentException("Appender " + appenderName + " does not support encoders."); } PatternLayoutEncoder patternLayoutEncoder; if (encoder instanceof PatternLayoutEncoder) { patternLayoutEncoder = (PatternLayoutEncoder)encoder; } else { throw new IllegalArgumentException("Appender " + appenderName + " does not provide a pattern encoder."); } return "pattern of appender " + appenderName + " is " + patternLayoutEncoder.getPattern(); }
private void verifyFormattedLogEncoder(Encoder<ILoggingEvent> encoder, String logPattern) { assertThat(encoder).isInstanceOf(PatternLayoutEncoder.class); PatternLayoutEncoder patternEncoder = (PatternLayoutEncoder) encoder; assertThat(patternEncoder.getPattern()).isEqualTo(logPattern); }