Refine search
@Test public void logged_exceptions_are_formatted_per_line_when_treating_throwable_as_lines() throws Exception { ByteArrayOutputStream output = new ByteArrayOutputStream(); LineAwareLayout lineAwareLayout = new LineAwareLayout(); lineAwareLayout.setLineLayout(new PatternLayout("%m" + delimiter)); Appender appender = new WriterAppender(lineAwareLayout, output); appender.setName("TestLog"); appender.setLayout(lineAwareLayout); Logger testLogger = LogManager.getLogger("test-logger"); testLogger.addAppender(appender); testLogger.setLevel(Level.INFO); Exception ex = new Exception("SOMETHING BAD HAPPEN\nNO REALLY IT'S VERY BAD\n\ntrust me"); ex.setStackTrace(new StackTraceElement[]{new StackTraceElement("CLAZZ", "MEETOD", "FEEL", 123)}); testLogger.info(ex, ex); String expectedLog = String.join(delimiter, ex.toString().split("\n")) + delimiter + "\tat CLAZZ.MEETOD(FEEL:123)" + delimiter; assertEquals(expectedLog, output.toString()); }
/** * Prepares the appender for use. */ public void activateOptions() { if (follow) { if (target.equals(SYSTEM_ERR)) { setWriter(createWriter(new SystemErrStream())); } else { setWriter(createWriter(new SystemOutStream())); } } else { if (target.equals(SYSTEM_ERR)) { setWriter(createWriter(System.err)); } else { setWriter(createWriter(System.out)); } } super.activateOptions(); }
/** This method is called by the {@link AppenderSkeleton#doAppend} method. <p>If the output stream exists and is writable then write a log statement to the output stream. Otherwise, write a single warning message to <code>System.err</code>. <p>The format of the output will depend on this appender's layout. */ public void append(LoggingEvent event) { // Reminder: the nesting of calls is: // // doAppend() // - check threshold // - filter // - append(); // - checkEntryConditions(); // - subAppend(); if(!checkEntryConditions()) { return; } subAppend(event); }
/** Close this appender instance. The underlying stream or writer is also closed. <p>Closed appenders cannot be reused. @see #setWriter @since 0.8.4 */ public synchronized void close() { if(this.closed) return; this.closed = true; writeFooter(); reset(); }
/** <p>Sets the Writer where the log output will go. The specified Writer must be opened by the user and be writable. <p>The <code>java.io.Writer</code> will be closed when the appender instance is closed. <p><b>WARNING:</b> Logging to an unopened Writer will fail. <p> @param writer An already opened Writer. */ public synchronized void setWriter(Writer writer) { reset(); this.qw = new QuietWriter(writer, errorHandler); //this.tp = new TracerPrintWriter(qw); writeHeader(); }
clientLogger = MaryUtils.getLogger(this.getName() + " client"); try { clientLogger.addAppender(new WriterAppender(new SimpleLayout(), new PrintWriter(infoSocket.getOutputStream(), true))); clientLogger.setLevel(Level.WARN); clientLogger.setAdditivity(false); } catch (IOException e) { logger.warn("Cannot write warnings to client", e);
public void testSeekForRwServer() throws Exception { Layout layout = Logger.getRootLogger().getAppender("CONSOLE") .getLayout(); ByteArrayOutputStream os = new ByteArrayOutputStream(); WriterAppender appender = new WriterAppender(layout, os); appender.setImmediateFlush(true); appender.setThreshold(Level.INFO); Logger zlogger = Logger.getLogger("org.apache.zookeeper"); zlogger.addAppender(appender);
private void init() { logName = "PurgeUtilityLog." + getThreadName(); logger = Logger.getLogger( logName ); logger.setLevel( logLevel ); IPurgeUtilityLayout layout; if ( layoutClass == PurgeUtilityHTMLLayout.class ) { layout = new PurgeUtilityHTMLLayout( logLevel ); } else { layout = new PurgeUtilityTextLayout( logLevel ); } layout.setTitle( "Purge Utility Log" ); writeAppender = new WriterAppender( (Layout) layout, new OutputStreamWriter( outputStream, Charset.forName( "utf-8" ) ) ); logger.addAppender( writeAppender ); }
@Test public void logExceptionAfterDoAuthenticateThrowsNonAuthenticationException() { Logger logger = Logger.getLogger(AbstractAuthenticator.class); // NOTE: log4j is a test dependency ByteArrayOutputStream out = new ByteArrayOutputStream(); Layout layout = new SimpleLayout(); Appender appender = new WriterAppender(layout, out); logger.addAppender(appender); final String expectedExceptionMessage = "exception thrown for test logExceptionAfterDoAuthenticateThrowsNonAuthenticationException"; abstractAuthenticator = new AbstractAuthenticator() { protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws AuthenticationException { throw new IllegalArgumentException(expectedExceptionMessage); } }; AuthenticationToken token = newToken(); try{ abstractAuthenticator.authenticate(token); fail("the expected AuthenticationException was not thrown"); }catch(AuthenticationException expectedException){ } String logMsg = out.toString(); assertTrue(logMsg.contains("WARN")); assertTrue(logMsg.contains("java.lang.IllegalArgumentException: "+ expectedExceptionMessage)); logger.removeAppender(appender); }
LogCapturer(org.apache.log4j.Logger logger) { this.logger = logger; Appender defaultAppender = org.apache.log4j.Logger.getRootLogger().getAppender("stdout"); if (defaultAppender == null) { defaultAppender = org.apache.log4j.Logger.getRootLogger().getAppender("console"); } final Layout layout = (defaultAppender == null) ? new PatternLayout() : defaultAppender.getLayout(); this.appender = new WriterAppender(layout, sw); this.logger.addAppender(this.appender); }
/** * Cluster topology mismatch shall result in DataStreamer retrying cache update with the latest topology and * no error logged to the console. * * @throws Exception if failed */ @Test public void testRetryWhenTopologyMismatch() throws Exception { final int KEY = 1; final String VAL = "1"; cnt = 0; StringWriter logWriter = new StringWriter(); Appender logAppender = new WriterAppender(new SimpleLayout(), logWriter); Logger.getRootLogger().addAppender(logAppender); startGrids(MAX_CACHE_COUNT - 1); // cache-enabled nodes try (Ignite ignite = startGrid(MAX_CACHE_COUNT); IgniteDataStreamer<Integer, String> streamer = ignite.dataStreamer(DEFAULT_CACHE_NAME)) { needStaleTop = true; // simulate stale topology for the next action streamer.addData(KEY, VAL); } finally { needStaleTop = false; logWriter.flush(); Logger.getRootLogger().removeAppender(logAppender); logAppender.close(); } assertFalse(logWriter.toString().contains("DataStreamer will retry data transfer at stable topology")); }
@Before public void start() { this.writer = new StringWriter(); this.appender = new WriterAppender(new PatternLayout("%p, %m%n"), this.writer); this.writer.getBuffer().setLength(0); Logger.getRootLogger().addAppender(this.appender); }
private WriterAppender getConsoleAppender(ByteArrayOutputStream os, Level level) { String loggingPattern = ((PatternLayout) Logger.getRootLogger().getAppender("CONSOLE").getLayout()).getConversionPattern(); WriterAppender appender = new WriterAppender(new PatternLayout(loggingPattern), os); appender.setThreshold(level); return appender; }
/** * Prepares the appender for use. */ public void activateOptions() { if (follow) { if (target.equals(SYSTEM_ERR)) { setWriter(createWriter(new SystemErrStream())); } else { setWriter(createWriter(new SystemOutStream())); } } else { if (target.equals(SYSTEM_ERR)) { setWriter(createWriter(System.err)); } else { setWriter(createWriter(System.out)); } } super.activateOptions(); }
/** This method differentiates RollingFileAppender from its super class. @since 0.9.0 */ protected void subAppend(LoggingEvent event) { super.subAppend(event); if((fileName != null) && ((CountingQuietWriter) qw).getCount() >= maxFileSize) this.rollOver(); } }
/** * {@inheritDoc} */ protected final void closeWriter() { if (follow) { super.closeWriter(); } }
/** Instantiate a WriterAppender and set the output destination to <code>writer</code>. <p>The <code>writer</code> must have been previously opened by the user. */ public WriterAppender(Layout layout, Writer writer) { this.layout = layout; this.setWriter(writer); }
/** Returns an OutputStreamWriter when passed an OutputStream. The encoding used will depend on the value of the <code>encoding</code> property. If the encoding value is specified incorrectly the writer will be opened using the default system encoding (an error message will be printed to the loglog. */ protected OutputStreamWriter createWriter(OutputStream os) { OutputStreamWriter retval = null; String enc = getEncoding(); if(enc != null) { try { retval = new OutputStreamWriter(os, enc); } catch(IOException e) { if (e instanceof InterruptedIOException) { Thread.currentThread().interrupt(); } LogLog.warn("Error initializing output writer."); LogLog.warn("Unsupported encoding?"); } } if(retval == null) { retval = new OutputStreamWriter(os); } return retval; }
/** Close any previously opened file and call the parent's <code>reset</code>. */ protected void reset() { closeFile(); this.fileName = null; super.reset(); } }
clientLogger = MaryUtils.getLogger(this.getName() + " client"); try { clientLogger.addAppender(new WriterAppender(new SimpleLayout(), new PrintWriter(infoSocket.getOutputStream(), true))); clientLogger.setLevel(Level.WARN); clientLogger.setAdditivity(false); } catch (IOException e) { logger.warn("Cannot write warnings to client", e);