/** * Start a specific file logging, typically for the processing of a given book. * * @param name appender name (typically the book radix) * @param logFolder target folder where the log file is to be written */ public static void addAppender (String name, Path logFolder) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger( Logger.ROOT_LOGGER_NAME); FileAppender fileAppender = new FileAppender(); PatternLayoutEncoder fileEncoder = new PatternLayoutEncoder(); fileAppender.setName(name); fileAppender.setContext(loggerContext); fileAppender.setAppend(false); String now = new SimpleDateFormat("yyyyMMdd'T'HHmm").format(new Date()); Path logFile = logFolder.resolve(name + "-" + now + ".log"); fileAppender.setFile(logFile.toAbsolutePath().toString()); fileEncoder.setContext(loggerContext); fileEncoder.setPattern("%date %level [%X{BOOK}%X{SHEET}] %25file:%-4line | %msg%n%ex"); fileEncoder.start(); fileAppender.setEncoder(fileEncoder); fileAppender.start(); root.addAppender(fileAppender); }
/** * Add a specific appender meant for FILE. */ public static void addFileAppender () { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger( Logger.ROOT_LOGGER_NAME); FileAppender fileAppender = new FileAppender(); PatternLayoutEncoder fileEncoder = new PatternLayoutEncoder(); fileAppender.setName("FILE"); fileAppender.setContext(loggerContext); fileAppender.setAppend(false); String now = new SimpleDateFormat("yyyyMMdd'T'HHmmss").format(new Date()); Path logPath = WellKnowns.LOG_FOLDER.resolve(now + ".log").toAbsolutePath(); fileAppender.setFile(logPath.toString()); fileEncoder.setContext(loggerContext); fileEncoder.setPattern("%date %-5level [%X{BOOK}%X{SHEET}] %25replace(%file){'\\.java$',''} %-4line | %msg%n%ex"); fileEncoder.start(); fileAppender.setEncoder(fileEncoder); fileAppender.start(); root.addAppender(fileAppender); System.out.println("LogUtil. Logging to " + logPath); }
public FileAppender<ILoggingEvent> buildFileAppender(LoggerContext context, String file) { FileAppender<ILoggingEvent> fileAppender = new FileAppender<>(); fileAppender.setFile(file); fileAppender.setContext(context); fileAppender.setPrudent(true); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(context); encoder.setPattern(primaryConfiguration.getLoggingPattern().or(baseConfiguration.getLoggingPattern()).or(JavaUtils.LOGBACK_LOGGING_PATTERN)); encoder.start(); fileAppender.setEncoder(encoder); fileAppender.start(); return fileAppender; }
static void logToFile(Parameters parameters) { 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<>(); fileAppender.setFile(parameters.getWorkingDirectory() + "/jlineup.log"); fileAppender.setEncoder(ple); fileAppender.setContext(lc); fileAppender.start(); ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME); logger.addAppender(fileAppender); logger.setLevel(Level.DEBUG); }
private static void setupLogging(TestConfig testConfig) { val logFile = new java.io.File(testConfig.getTestLogPath()); if (logFile.delete()) { TestLogger.log("Main", "Deleted log file %s.", logFile.getAbsolutePath()); } // Configure slf4j to not log anything (console or whatever). This interferes with the console interaction. LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); context.getLoggerList().get(0).detachAndStopAllAppenders(); val fa = new FileAppender<ILoggingEvent>(); fa.setContext(context); fa.setName("selftest"); fa.setFile(logFile.getAbsolutePath()); val encoder = new PatternLayoutEncoder(); encoder.setContext(context); encoder.setPattern("%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %level - %msg%n"); encoder.start(); fa.setEncoder(encoder); fa.start(); context.getLoggerList().get(0).addAppender(fa); context.getLoggerList().get(0).setLevel(Level.INFO); //context.reset(); }
private Appender<ILoggingEvent> configureAppender(LoggerContext loggerContext, String name, Config config) throws ReflectiveOperationException { List<Object> children = new ArrayList<>(); @SuppressWarnings("unchecked") Class<Appender<ILoggingEvent>> clazz = (Class<Appender<ILoggingEvent>>) Class .forName(config.getString("class")); Appender<ILoggingEvent> appender = this.configureObject(loggerContext, clazz, config, children); appender.setName(name); for (Object child : children) { if (child instanceof RollingPolicy) { ((RollingPolicy) child).setParent((FileAppender<?>) appender); } if (child instanceof LifeCycle) { ((LifeCycle) child).start(); } } appender.start(); return appender; }
private Logger createLogger(File logFile) { LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); ch.qos.logback.classic.Logger log = loggers.get(); log.setAdditive(false); FileAppender fileAppender = new FileAppender(); fileAppender.setContext(context); fileAppender.setName(Thread.currentThread().getName()); fileAppender.setFile(logFile.getAbsolutePath()); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(context); encoder.setPattern(LOG_PATTERN); encoder.start(); fileAppender.setEncoder(encoder); fileAppender.start(); log.detachAndStopAllAppenders(); log.addAppender(fileAppender); return log; }
/** * Creates a new logger. * * @param name a name for the logger * @param level the logging level for the logger * @param file the file to output all logging to * @return the created logger */ public static Logger createLogger(String name, Level level, String file) { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("%date %level [%thread] %logger{10} [%file:%line]%n%msg%n%n"); ple.setContext(lc); ple.start(); FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setFile(file); fileAppender.setEncoder(ple); fileAppender.setAppend(false); fileAppender.setContext(lc); fileAppender.start(); logger = (Logger) LoggerFactory.getLogger(name); logger.detachAndStopAllAppenders(); // detach console (doesn't seem to work) logger.addAppender(fileAppender); // attach file appender logger.setLevel(level); logger.setAdditive(true); // set to true if root should log too return logger; }
@Test public void smoke() { String filename = CoreTestConstants.OUTPUT_DIR_PREFIX + "/fat-smoke.log"; FileAppender<Object> appender = new FileAppender<Object>(); appender.setEncoder(new DummyEncoder<Object>()); appender.setAppend(false); appender.setFile(filename); appender.setName("smoke"); appender.setContext(context); appender.start(); appender.doAppend(new Object()); appender.stop(); File file = new File(filename); assertTrue(file.exists()); assertTrue("failed to delete " + file.getAbsolutePath(), file.delete()); }
@Test public void testCreateParentFolders() { String filename = CoreTestConstants.OUTPUT_DIR_PREFIX + "/fat-testCreateParentFolders-" + diff + "/testCreateParentFolders.txt"; File file = new File(filename); assertFalse(file.getParentFile().exists()); assertFalse(file.exists()); FileAppender<Object> appender = new FileAppender<Object>(); appender.setEncoder(new DummyEncoder<Object>()); appender.setAppend(false); appender.setFile(filename); appender.setName("testCreateParentFolders"); appender.setContext(context); appender.start(); appender.doAppend(new Object()); appender.stop(); assertTrue(file.getParentFile().exists()); assertTrue(file.exists()); // cleanup assertTrue("failed to delete " + file.getAbsolutePath(), file.delete()); File parent = file.getParentFile(); assertTrue("failed to delete " + parent.getAbsolutePath(), parent.delete()); }
static LoggerContext buildLoggerContext(String stamp, String filename, boolean safetyMode) { LoggerContext loggerContext = new LoggerContext(); FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>(); PatternLayoutEncoder patternLayout = new PatternLayoutEncoder(); patternLayout.setPattern(stamp + " %5p - %m%n"); patternLayout.setContext(loggerContext); patternLayout.start(); fa.setEncoder(patternLayout); fa.setFile(filename); fa.setAppend(true); fa.setPrudent(safetyMode); fa.setContext(loggerContext); fa.start(); ch.qos.logback.classic.Logger root = loggerContext .getLogger(Logger.ROOT_LOGGER_NAME); root.addAppender(fa); return loggerContext; }
static LoggerContext buildLoggerContext(String filename, boolean safetyMode) { LoggerContext loggerContext = new LoggerContext(); FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>(); PatternLayoutEncoder patternLayout = new PatternLayoutEncoder(); patternLayout.setPattern("%5p %c - %m%n"); patternLayout.setContext(loggerContext); patternLayout.start(); fa.setEncoder(patternLayout); fa.setFile(filename); fa.setAppend(false); fa.setPrudent(safetyMode); fa.setContext(loggerContext); fa.start(); ch.qos.logback.classic.Logger root = loggerContext .getLogger(Logger.ROOT_LOGGER_NAME); root.addAppender(fa); return loggerContext; }
@SuppressWarnings("rawtypes") @Test public void conditionalConsoleApp_IF_THEN_True() throws JoranException, IOException, InterruptedException { InetAddress localhost = InetAddress.getLocalHost(); System.out.println("In conditionalConsoleApp_IF_THEN_True, canonicalHostName=\"" + localhost.getCanonicalHostName() + "] and hostNmae=\"" + localhost.getHostName() + "\""); context.putProperty("aHost", localhost.getHostName()); String configFileAsStr = ClassicTestConstants.JORAN_INPUT_PREFIX + "conditional/conditionalConsoleApp.xml"; configure(configFileAsStr); FileAppender fileAppender = (FileAppender) root.getAppender("FILE"); assertNotNull(fileAppender); ConsoleAppender consoleAppender = (ConsoleAppender) root.getAppender("CON"); assertNotNull(consoleAppender); StatusChecker checker = new StatusChecker(context); checker.assertIsErrorFree(); }
@SuppressWarnings("rawtypes") @Test public void conditionalConsoleApp_IF_THEN_False() throws JoranException, IOException, InterruptedException { String configFileAsStr = ClassicTestConstants.JORAN_INPUT_PREFIX + "conditional/conditionalConsoleApp.xml"; configure(configFileAsStr); FileAppender fileAppender = (FileAppender) root.getAppender("FILE"); assertNotNull(fileAppender); ConsoleAppender consoleAppender = (ConsoleAppender) root.getAppender("CON"); assertNull(consoleAppender); StatusChecker checker = new StatusChecker(context); checker.assertIsErrorFree(); }
@SuppressWarnings("rawtypes") @Test public void conditionalConsoleApp_IF_THEN_ELSE() throws JoranException, IOException, InterruptedException { String configFileAsStr = ClassicTestConstants.JORAN_INPUT_PREFIX + "conditional/conditionalConsoleApp_ELSE.xml"; configure(configFileAsStr); FileAppender fileAppender = (FileAppender) root.getAppender("FILE"); assertNotNull(fileAppender); ConsoleAppender consoleAppender = (ConsoleAppender) root.getAppender("CON"); assertNull(consoleAppender); ListAppender listAppender = (ListAppender) root.getAppender("LIST"); assertNotNull(listAppender); // StatusPrinter.printIfErrorsOccured(context); StatusChecker checker = new StatusChecker(context); checker.assertIsErrorFree(); }
static Logger buildLoggerContext(LoggerContext lc) { Logger root = lc.getLogger(Logger.ROOT_LOGGER_NAME); PatternLayoutEncoder patternLayout = new PatternLayoutEncoder(); patternLayout.setContext(lc); patternLayout.setPattern("%d %l [%t] - %msg%n"); patternLayout.start(); FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setContext(lc); fileAppender.setFile("target/lbclassic135.log"); fileAppender.setEncoder(patternLayout); fileAppender.setAppend(false); fileAppender.start(); root.addAppender(fileAppender); return lc.getLogger(LoggingToFileThroughput.class); }
public IOPerformance(boolean _immediateFlush, long _len) { this.len = _len; this.immediateFlush = _immediateFlush; context = new LoggerContext(); logger = context.getLogger("logger-" + getName()); // A FileAppender is created according to the buffering and // immediate flush setting of this IO instance. FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>(); fa.setName("FILE"); PatternLayoutEncoder pa = new PatternLayoutEncoder(); pa.setPattern("%r %5p %c [%t] - %m%n"); pa.setContext(context); pa.start(); fa.setEncoder(pa); fa.setFile(LOG_FILE); fa.setAppend(true); fa.setContext(context); fa.start(); ((ch.qos.logback.classic.Logger) logger).addAppender(fa); StatusPrinter.print(context); }
/** * @{inheritDoc} */ public void store(Item item, String alias) { if (initialized) { FileAppender<ILoggingEvent> appender = appenders.get(alias); if (appender==null) { synchronized(appenders) { // do a second check in case one exists by now if (!appenders.containsKey(alias)) { appender = createNewAppender(alias); appenders.put(alias, appender); } } } ItemLoggingEvent event = new ItemLoggingEvent(item); appender.doAppend(event); logger.debug("Logged item '{}' to file '{}.log'", new String[] { item.getName(), alias }); } }
protected FileAppender<ILoggingEvent> createNewAppender(String alias) { LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(context); encoder.setPattern(pattern); encoder.start(); FileAppender<ILoggingEvent> appender = new FileAppender<ILoggingEvent>(); appender.setAppend(true); appender.setFile(LOG_FOLDER + File.separator + alias + LOG_FILEEXT); appender.setEncoder(encoder); appender.setContext(context); appender.start(); return appender; }
@Override public Appender<ILoggingEvent> buildAppender(Context logcingContext, String fileName) throws JoranException { // first sets up the paterns for log layout PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setPattern(logTemplate); encoder.setContext(logcingContext); encoder.start(); // then create a file appender for the given filename FileAppender<ILoggingEvent> appender = new FileAppender<ILoggingEvent>(); appender.setContext(logcingContext); appender.setAppend(false); appender.setFile(logFolderName + "/" + fileName + ".log"); appender.setEncoder(encoder); appender.start(); return appender; }
/** * Finds or creates a logger for the test case called tcName with an appender writing * to file named <tcName>.log * * @param tcName * @return */ private Logger getTestCaseLogger(String tcName, String sutName, String sutDir, String testScheduleName) { FileAppender<ILoggingEvent> fileAppender = appenderMap.get(tcName); if (fileAppender == null) { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("%date %level [%logger{36}] [%file:%line] %X{testcase}: %msg%n"); ple.setContext(lc); ple.start(); fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setFile(sutDir + '/' + testScheduleName + '/' + tcName + ".log"); fileAppender.setEncoder(ple); fileAppender.setContext(lc); fileAppender.start(); appenderMap.put(tcName, fileAppender); } Logger logger = (Logger) LoggerFactory.getLogger(tcName); logger.addAppender(fileAppender); return logger; }
protected FileAppender<ILoggingEvent> createRollingFileAppender(Encoder<ILoggingEvent> encoder, LoggerContext context, RollingPolicyFactory rollingPolicy) { RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>(); appender.setFile(file); appender.setContext(context); appender.setEncoder(encoder); // Setup rolling policy RollingPolicy policy = rollingPolicy.createRollingPolicy(context); appender.setRollingPolicy(policy); policy.setParent(appender); // Setup triggering policy TriggeringPolicy<ILoggingEvent> triggeringPolicy = rollingPolicy.createTriggeringPolicy(context); if (triggeringPolicy != null) { appender.setTriggeringPolicy(triggeringPolicy); triggeringPolicy.start(); } policy.start(); appender.start(); return appender; }
/** * Get the actively used log file from the underlying logging mechanism */ private Optional<String> getActiveLogFile() { Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); Iterator<Appender<ILoggingEvent>> itr = rootLogger.iteratorForAppenders(); // Iterate over the appenders while (itr.hasNext()) { Appender<ILoggingEvent> appender = itr.next(); // found a file appender if (appender instanceof FileAppender) { FileAppender<ILoggingEvent> fileAppender = (FileAppender<ILoggingEvent>) appender; return Optional.of(fileAppender.getFile()); } } // no file appender return Optional.absent(); }
private static void setOutput(final String... paths) throws IOException { 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); } }
private static void initializeLogFile() { final LoggerContext loggerContext = ROOT_LOGGER.getLoggerContext(); final PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"); encoder.setContext(loggerContext); encoder.start(); final FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setFile("migration.log"); fileAppender.setName("file"); fileAppender.setEncoder(encoder); fileAppender.setContext(loggerContext); fileAppender.start(); ROOT_LOGGER.addAppender(fileAppender); }
private static void setupFileLogging(Logger root, ThresholdFilter filter, String logfilePath) { MinimalLayout formatter = new MinimalLayout(root.getLoggerContext()); formatter.start(); // setup the file appender FileAppender<ILoggingEvent> appender = new FileAppender<>(); appender.setFile(logfilePath); appender.setContext(root.getLoggerContext()); appender.setLayout(formatter); appender.start(); // wrap it in an async appender final AsyncAppender asyncAppender = new AsyncAppender(); asyncAppender.setContext(root.getLoggerContext()); asyncAppender.addAppender(appender); asyncAppender.addFilter(filter); asyncAppender.start(); // now, add it to the root logger root.addAppender(asyncAppender); }
/** * Configure file logging and stop console logging. * * @param filename * Log to this file. */ @SuppressWarnings("unchecked") static void logToFile(String filename) { Logger rootLogger = (Logger) LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); FileAppender<ILoggingEvent> fileappender = new FileAppender<>(); fileappender.setContext(rootLogger.getLoggerContext()); fileappender.setFile(filename); fileappender.setName("FILE"); ConsoleAppender<?> console = (ConsoleAppender<?>) rootLogger.getAppender("STDOUT"); fileappender.setEncoder((Encoder<ILoggingEvent>) console.getEncoder()); fileappender.start(); rootLogger.addAppender(fileappender); console.stop(); }
private Appender<ILoggingEvent> createAppender(String loggerName, String prefix) { Appender<ILoggingEvent> appender; FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setName(loggerName); File file = new File(logDir, prefix + "-" + loggerName + ".log"); fileAppender.setFile(file.getPath()); fileAppender.setContext(loggerFactory); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerFactory); encoder.setPattern("%-5level %d{HH:mm:ss.SSS} [%t] %logger{36} - %msg%n%rEx"); fileAppender.setEncoder(encoder); appender = fileAppender; encoder.start(); appender.start(); return appender; }
private FileAppender<ILoggingEvent> getAppender(String pluginId) { File pluginLogFileLocation = pluginLogFile(pluginId); RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<>(); rollingFileAppender.setEncoder(LogHelper.encoder()); rollingFileAppender.setContext(LogHelper.LOGGER_CONTEXT); rollingFileAppender.setFile(pluginLogFileLocation.getPath()); rollingFileAppender.setName(rollingFileAppenderName(pluginId)); LogHelper.rollingPolicyForAppender( rollingFileAppender, "5 MB", "20 MB", 7 ); rollingFileAppender.start(); return rollingFileAppender; }
private void assertPluginLogFile(String pluginId, String expectedPluginLogFileName) { SystemEnvironment systemEnvironment = mock(SystemEnvironment.class); DefaultPluginLoggingService loggingService = new DefaultPluginLoggingService(systemEnvironment); loggingService.debug(pluginId, "some-logger-name", "message"); ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("plugin." + pluginId); ArrayList<Appender<ILoggingEvent>> appenders = new ArrayList<>(); logger.iteratorForAppenders().forEachRemaining(new Consumer<Appender<ILoggingEvent>>() { @Override public void accept(Appender<ILoggingEvent> iLoggingEventAppender) { appenders.add(iLoggingEventAppender); } }); String loggingDirectory = loggingService.getCurrentLogDirectory(); assertThat(appenders.size(), is(1)); assertThat(new File(((FileAppender) appenders.get(0)).rawFileProperty()), is(new File(loggingDirectory, expectedPluginLogFileName))); }
@Override public Map<String, Object> asJson() { LinkedHashMap<String, Object> json = new LinkedHashMap<>(); json.put("loc.config.dir", systemEnvironment.configDir().getAbsolutePath()); List<Logger> loggers = LOGGER_CONTEXT.getLoggerList(); Appender[] appenders = getAppenders(loggers); for (int i = 0; i < appenders.length; i++) { Appender appender = appenders[i]; if (!isFileAppender(appender)) { continue; } FileAppender fileAppender = (FileAppender) appender; File logFile = new File(fileAppender.rawFileProperty()); json.put("loc.log.root." + i, new File(logFile.getAbsolutePath()).getParent()); json.put("loc.log.basename." + i, logFile.getName()); } return json; }
private static String createRootLogger() { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder ple = new PatternLayoutEncoder(); ple.setPattern("%d{HH:mm:ss} %-12.-12([%thread])[%-5level] %logger{0} -%msg%n"); ple.setContext(loggerContext); ple.start(); String fileName = String.format("logs/h2h-log %s.txt", new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss").format(System.currentTimeMillis())); FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setFile(fileName); fileAppender.setEncoder(ple); fileAppender.setContext(loggerContext); fileAppender.start(); Logger logbackLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME); logbackLogger.addAppender(fileAppender); logbackLogger.setLevel(Level.DEBUG); logbackLogger.setAdditive(false); return fileName; }
public Optional<String> findLoggingFileLocation() { final Optional<String> fileLocation; if (LOGGER instanceof ch.qos.logback.classic.Logger) { final ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) LOGGER; final Appender<ILoggingEvent> appender = logbackLogger.getAppender("UPLOAD_REPORTER"); if (appender != null && appender instanceof FileAppender) { final FileAppender fileAppender = (FileAppender) appender; fileLocation = Optional.of(fileAppender.getFile()); } else { fileLocation = Optional.empty(); } } else { fileLocation = Optional.empty(); } return fileLocation; }
public static void addFileAppender(String filePath, boolean append) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); FileAppender<ILoggingEvent> fileAppender = new FileAppender<ILoggingEvent>(); fileAppender.setContext(loggerContext); fileAppender.setName("css-analyzer"); // set the file name fileAppender.setFile(filePath); fileAppender.setAppend(append); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); //encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level - %msg [%C{1}]%n"); encoder.setPattern("%d{HH:mm:ss.SSS} [%thread] %-5level - %msg%n"); encoder.start(); fileAppender.setEncoder(encoder); fileAppender.start(); appenders.add(fileAppender); logBackLogger.addAppender(fileAppender); }
/** * @{inheritDoc} */ @Override public void store(Item item, String alias) { if (initialized) { FileAppender<ILoggingEvent> appender = appenders.get(alias); if (appender == null) { synchronized (appenders) { // do a second check in case one exists by now if (!appenders.containsKey(alias)) { appender = createNewAppender(alias); appenders.put(alias, appender); } } } ItemLoggingEvent event = new ItemLoggingEvent(item); appender.doAppend(event); logger.debug("Logged item '{}' to file '{}.log'", new String[] { item.getName(), alias }); } }
public static Logger createLogger(Path pathLogs, String clientName) { Logger log = (Logger) LoggerFactory.getLogger("Botico-" + clientName); log.setLevel(Level.DEBUG); LoggerContext cont = (LoggerContext) LoggerFactory.getILoggerFactory(); PatternLayoutEncoder pat = new PatternLayoutEncoder(); pat.setPattern("[%date] [%logger{10}|%thread] [%level] %msg%n"); pat.setContext(cont); pat.start(); FileAppender<ILoggingEvent> fapp = new FileAppender<>(); fapp.setFile(pathLogs.resolve("botico-" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss")) + ".log").toString()); fapp.setEncoder(pat); fapp.setContext(cont); fapp.start(); ConsoleAppender<ILoggingEvent> capp = new ConsoleAppender<>(); capp.setTarget("System.out"); capp.setContext(cont); capp.setEncoder(pat); capp.start(); log.addAppender(fapp); log.addAppender(capp); log.setAdditive(false); return log; }
private static Path getLogFromLogback( final File logbackConfig ) { try { LoggerContext loggerContext = new LoggerContext(); JoranConfigurator jc = new JoranConfigurator(); jc.setContext( loggerContext ); loggerContext.reset(); jc.doConfigure( logbackConfig ); for ( Logger logger : loggerContext.getLoggerList() ) { for ( Iterator<Appender<ILoggingEvent>> index = logger.iteratorForAppenders(); index.hasNext(); ) { Appender<ILoggingEvent> appender = index.next(); if ( appender instanceof FileAppender ) { return Paths.get( ( (FileAppender) appender ).getFile() ); } } } return null; } catch ( Exception e ) { return null; } }
private Logger getNewLogger(String jobID,String fileLogLocation) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); FileAppender<ILoggingEvent> fileAppender = new FileAppender<>(); fileAppender.setContext(loggerContext); fileAppender.setFile(fileLogLocation); /*SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); triggeringPolicy.setMaxFileSize("10MB"); triggeringPolicy.start();*/ PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern("%msg%n"); encoder.start(); fileAppender.setEncoder(encoder); fileAppender.start(); // attach the rolling file appender to the logger of your choice Logger logbackLogger = loggerContext.getLogger(jobID); ((ch.qos.logback.classic.Logger) logbackLogger).addAppender(fileAppender); executionTrackingLoggers.put(jobID, logbackLogger); return logbackLogger; }