public EngineLogView() { labelProvider = new EngineLogViewLabelProvider(); appender = new AppenderSkeleton() { @Override protected void append(LoggingEvent arg0) { synchronized (this) { this.notifyAll(); } } public void close() { } public boolean requiresLayout() { return false; } }; }
/** * Setup {@link org.apache.log4j.Logger}, the default logger implementation for tests, * to append {@link LoggingEvent}s to {@link #loggingEvents} so that we can assert if * the right messages were logged. * * @see #testLogTimeoutAlmostReachedWarningDuringCommit * @see #testLogTimeoutAlmostReachedWarningDuringRecovery */ private void setupLogger() { Logger.getRootLogger().removeAllAppenders(); logger = Logger.getLogger(TwoPhaseCommitSinkFunction.class); testAppender = new AppenderSkeleton() { @Override protected void append(LoggingEvent event) { loggingEvents.add(event); } @Override public void close() { } @Override public boolean requiresLayout() { return false; } }; logger.addAppender(testAppender); logger.setLevel(Level.WARN); }
public LogVerifier() { this.appender = new AppenderSkeleton() { @Override public void close() { } @Override public boolean requiresLayout() { return false; } @Override protected void append(LoggingEvent event) { LogVerifier.this.append(event); } }; }
@Override public AppenderProvider createAppenderProvider(URI serverURI) throws LogForwardingException { return new AppenderProvider() { @Override public Appender getAppender() throws LogForwardingException { return new AppenderSkeleton() { @Override protected void append(LoggingEvent event) { eventProcessor.processEvent(event); } @Override public boolean requiresLayout() { return false; } @Override public void close() { } }; } }; }
@Before public void setUp() throws SQLException, IOException, InterruptedException { Appender a = Logger.getRootLogger().getAppender("STDERR"); if (a instanceof AppenderSkeleton) { ((AppenderSkeleton)a).setThreshold(Level.DEBUG); } dbManager.cleanup(); servers.cleanup(); servers.start(serverArgs); servers.waitUntilActive(); servers.createDatabaseA(); tr.startup(); log.info("######################################################################"); log.info("######################################################################"); log.info("setup done"); }
@Before public void setUp() throws SQLException, IOException, InterruptedException { log.info("######################################################################"); log.info("######################################################################"); log.info("setting up"); Appender a = Logger.getRootLogger().getAppender("STDERR"); if (a instanceof AppenderSkeleton) { ((AppenderSkeleton)a).setThreshold(Level.DEBUG); } log.info("######################################################################"); log.info("######################################################################"); log.info("setting up"); dbManager.cleanup(); tr.startup(); log.info("######################################################################"); log.info("######################################################################"); log.info("setup done"); }
@Before public void setUp() throws SQLException, IOException, InterruptedException { Appender a = Logger.getRootLogger().getAppender("STDERR"); if (a instanceof AppenderSkeleton) { ((AppenderSkeleton)a).setThreshold(Level.DEBUG); } dbManager.cleanup(); servers.cleanup(); servers.start(); servers.waitUntilActive(); servers.createDatabaseA(); tr.startup(); log.info("######################################################################"); log.info("######################################################################"); log.info("setup done"); }
/** * Sets up. * * @throws Exception the exception */ @Before public void setUp() throws Exception { testling = createTestling(environment, enableServiceBrokerFake); testAppender = new AppenderSkeleton() { @Override protected void append(final LoggingEvent loggingEvent) { System.out.println("**** APPEND ****"); logMessage = loggingEvent.getMessage().toString(); } @Override public void close() { } @Override public boolean requiresLayout() { return false; } }; Logger.getLogger(testling.getClass()).setAdditivity(true); Logger.getLogger(testling.getClass()).addAppender(testAppender); }
private static void initLogger(String filename) { final String PATTERN = "[%d{yyyy-MM-dd HH:mm:ss}] [%-5p] [%c{1}] %m%n"; // Stores whether an error has occured AppenderSkeleton errorFlagAppender = new ErrorFlagAppender(); errorFlagAppender.setThreshold(Level.ERROR); errorFlagAppender.activateOptions(); org.apache.log4j.Logger.getRootLogger().addAppender(errorFlagAppender); ConsoleAppender consoleAppender = new ConsoleAppender(); consoleAppender.setEncoding("UTF-8"); consoleAppender.setLayout(new PatternLayout(PATTERN)); consoleAppender.setThreshold(LOG_LEVEL); consoleAppender.activateOptions(); AsyncAppender asyncConsoleAppender = new AsyncAppender(); asyncConsoleAppender.addAppender(consoleAppender); asyncConsoleAppender.setBufferSize(1024); asyncConsoleAppender.activateOptions(); org.apache.log4j.Logger.getRootLogger().addAppender(asyncConsoleAppender); FileAppender fileAppender = new FileAppender(); fileAppender.setEncoding("UTF-8"); fileAppender.setFile(filename); fileAppender.setLayout(new PatternLayout(PATTERN)); fileAppender.setThreshold(LOG_LEVEL); fileAppender.setAppend(false); fileAppender.activateOptions(); AsyncAppender asyncFileAppender = new AsyncAppender(); asyncFileAppender.addAppender(fileAppender); asyncFileAppender.setBufferSize(1024); asyncFileAppender.activateOptions(); org.apache.log4j.Logger.getRootLogger().addAppender(asyncFileAppender); }
@BeforeClass public static void setup() throws Exception { logger.debug("Logger repository before LoggerUtil.changeLoggersLevel() {}", LogManager.getLoggerRepository()); LoggerUtil.changeLoggersLevel(Maps.<String, String>newHashMap()); logger.debug("Logger repository after LoggerUtil.changeLoggersLevel() {}", LogManager.getLoggerRepository()); log4jLogger.setLevel(Level.TRACE); Category category = log4jLogger; while (category != null) { Enumeration appenders = category.getAllAppenders(); while (appenders.hasMoreElements()) { Object o = appenders.nextElement(); if (o instanceof AppenderSkeleton) { AppenderSkeleton appender = (AppenderSkeleton)o; if (!appenderLevelMap.containsKey(appender)) { appenderLevelMap.put(appender, appender.getThreshold()); appender.setThreshold(Level.INFO); } } } if (category.getAdditivity()) { category = category.getParent(); } else { category = null; } } }
@AfterClass public static void teardown() { for (Map.Entry<AppenderSkeleton, Priority> e : appenderLevelMap.entrySet()) { e.getKey().setThreshold(e.getValue()); } }
/** * Add a usage appender for the root logger. This appender will write ERROR and FATAL log messages * to the usage database. */ public static void addErrorAppender() { usageAppender = new AppenderSkeleton() { boolean logAll = Boolean.getBoolean("logAll"); PatternLayout patternLayout = new PatternLayout("[%t] %c - %m"); @Override protected void append(LoggingEvent event) { if (logAll || event.getLevel().equals(Level.ERROR) || event.getLevel().equals(Level.FATAL)) { ThrowableInformation info = event.getThrowableInformation(); StringBuffer buf = new StringBuffer(); if (info == null) buf.append("No stack trace"); else { for (String line : info.getThrowableStrRep()) buf.append(line).append('\n'); } EnsembleUsageLogger.logUsage( event.getLevel().toString(), patternLayout.format(event) +" -- "+ buf.toString()); } } @Override public void close() { /* do nothing */ } @Override public boolean requiresLayout() { return false; } }; Logger.getRootLogger().addAppender(usageAppender); }
@Before public void setUp() throws SQLException, IOException, InterruptedException { Appender a = Logger.getRootLogger().getAppender("STDERR"); if (a instanceof AppenderSkeleton) { ((AppenderSkeleton) a).setThreshold(Level.DEBUG); } dbManager.cleanup(); servers.cleanupA(); servers.startA(); servers.waitUntilAIsActive(); servers.createDatabaseA(); tr.startup(); }
public void testBroadcastMessage() throws IOException { success = false; Logger jcl = Logger.getLogger(JarCacheUpdateHandler.class); String uri = "jar://mytest/testjar1.jar"; sb = new StringBuilder(); final BasePipelineIntTest monitor = this; Appender app = new AppenderSkeleton() { @Override public void close() { } @Override public boolean requiresLayout() { return false; } @Override protected void append(LoggingEvent event) { sb.append(event.getMessage()); success = true; synchronized (this) { this.notify(); } } }; jcl.addAppender(app); RapturePipelineTask task = new RapturePipelineTask(); MimeJarCacheUpdate mime = new MimeJarCacheUpdate(); mime.setJarUri(new RaptureURI(uri, Scheme.JAR)); mime.setDeletion(true); task.setContentType(MimeJarCacheUpdate.getMimeType()); task.addMimeObject(mime); synchronized (app) { Kernel.getPipeline().broadcastMessageToAll(context, task); try { app.wait(5000); } catch (Exception e) { } } assertTrue("log appender was not called after 5s", success); Assert.assertEquals("Updating jar cache for jar uri [jar://mytest/testjar1.jar]", sb.toString()); }
public void testBroadcastMessage() throws IOException { success = false; Logger jcl = Logger.getLogger(JarCacheUpdateHandler.class); String uri = "jar://mytest/testjar1.jar"; sb = new StringBuilder(); final BasePipeline2IntTest monitor = this; Appender app = new AppenderSkeleton() { @Override public void close() { } @Override public boolean requiresLayout() { return false; } @Override protected void append(LoggingEvent event) { sb.append(event.getMessage()); success = true; synchronized (this) { this.notify(); } } }; jcl.addAppender(app); MimeJarCacheUpdate mime = new MimeJarCacheUpdate(); mime.setJarUri(new RaptureURI(uri, Scheme.JAR)); mime.setDeletion(true); synchronized (app) { TaskSubmitter.submitBroadcastToAll(context, mime, MimeJarCacheUpdate.getMimeType(), null); // Kernel.getPipeline2().getTrusted().broadcastMessageToAll(context, task); try { app.wait(20000); } catch (Exception e) { } } assertTrue("log appender was not called after 20s", success); Assert.assertTrue(sb.toString().startsWith("Updating jar cache for jar uri [jar://mytest/testjar1.jar]")); }
@Override public void addAppender(Object console) { Logger.getRootLogger().addAppender((AppenderSkeleton) console); }
@Override public void removeAppender(Object console) { Logger.getRootLogger().removeAppender((AppenderSkeleton) console); }
public void testInvalidLookupCanada() throws Exception { step.setGoogleMapsApiKey("ABQIAAAAC68VN0JS8nvnA3-VgSg5dRSPtI6ZTKhKKG8kdYEzcTLFAXRiHhS13bHpYAqAQNo1st7t_FZ7-22PWw"); step.open(logger); testInput.setData("1234 StreetDoesn't Exist at all, definitely, I'm sure about it"); class ErrorCounter extends AppenderSkeleton { /** * The number of times a logging event with the level of ERROR * has been delivered to this appender. */ int errorCount; @Override protected void append(LoggingEvent evt) { if (evt.getLevel() == Level.ERROR) { errorCount++; } } public void close() { // nothing to do } public boolean requiresLayout() { return false; } }; ErrorCounter ec = new ErrorCounter(); logger.addAppender(ec); try { // call should not throw an exception, but it must log an error step.call(); assertEquals(1, ec.errorCount); } finally { step.mungeCommit(); step.mungeClose(); logger.removeAppender(ec); } }
@Test public void testNoLog() throws Exception { final Logger _logger = Logger.getLogger("water.default"); _logger.addAppender(new AppenderSkeleton() { @Override protected void append(LoggingEvent event) { if(event.getRenderedMessage().contains("GET") ) throw new RuntimeException("All GETs should be filtered"); } @Override public void close() { _logger.removeAppender(this); } @Override public boolean requiresLayout() {return false;} }); // let's filter out all GETs RequestServer.setFilters(RequestServer.defaultFilter(), new RequestServer.HttpLogFilter() { @Override public boolean filter(RequestUri uri, Properties header, Properties parms) { String[] path = uri.getPath(); return path[1].equals("GET"); } }); // mock up a "GET /flow/index.html" call HttpServletRequest request = mock(HttpServletRequest.class); HttpServletResponse response = mock(HttpServletResponse.class); when(request.getServletPath()).thenReturn("/flow/index.html"); when(request.getRequestURI()).thenReturn("/flow/index.html"); // mock up the headers // define the headers you want to be returned HashMap<String, String> headers = new HashMap<>(); headers.put("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.95 Safari/537.36"); headers.put("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"); headers.put("Cookie", "_yummy"); headers.put("Accept-Encoding", "gzip, deflate, sdch"); headers.put("Host", H2O.getIpPortString()); headers.put("Upgrade-Insecure-Requests", "1"); headers.put("Accept-Language", "en-US,en;q=0.8"); headers.put("Connection", "keep-alive"); // create an Enumeration over the header keys final Iterator<String> iterator = headers.keySet().iterator(); Enumeration headerNames = new Enumeration<String>() { @Override public boolean hasMoreElements() { return iterator.hasNext(); } @Override public String nextElement() { return iterator.next(); } }; when(request.getHeaderNames()).thenReturn(headerNames); when(request.getHeader("User-Agent")).thenReturn(headers.get("User-Agent")); when(request.getHeader("Accept")).thenReturn(headers.get("Accept")); when(request.getHeader("Cookie")).thenReturn(headers.get("Cookie")); when(request.getHeader("Accept-Encoding")).thenReturn(headers.get("Accept-Encoding")); when(request.getHeader("Host")).thenReturn(headers.get("Host")); when(request.getHeader("Upgrade-Insecure-Requests")).thenReturn(headers.get("Upgrade-Insecure-Requests")); when(request.getHeader("Accept-Language")).thenReturn(headers.get("Accept-Language")); when(request.getHeader("Connection")).thenReturn(headers.get("Connection")); when(request.getParameterMap()).thenReturn(new HashMap<String, String[]>()); when(response.getOutputStream()).thenReturn(new ServletOutputStream() { @Override public void write(int b) throws IOException { } }); // start the request lifecycle H2O.getJetty().getServer().getChildHandlersByClass(JettyHTTPD.GateHandler.class)[0].handle("/", null, request, response); new RequestServer().doGet(request, response); }
@Test @SuppressWarnings( { "unchecked" }) public void testAddExceedsWarningThreshold() throws Exception { // setup int threshold = 5; this.taskProcessingQueueHelper.setQueueSizeWarningThreshold(threshold); final TaskProcessingQueue taskProcessingQueue = new TaskProcessingQueue("queue:url"); latch = new CountDownLatch(threshold + 1); doAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { UpdateResolvingPiContinuation continuation = (UpdateResolvingPiContinuation) invocation.getArguments()[1]; continuation.update(taskProcessingQueue, null); continuation.receiveResult(taskProcessingQueue); latch.countDown(); return null; } }).when(writer).update(eq(queueId), isA(UpdateResolvingPiContinuation.class)); final List<String> messages = new ArrayList<String>(); AppenderSkeleton appender = new AppenderSkeleton() { @Override public boolean requiresLayout() { return false; } @Override public void close() { } @Override protected void append(LoggingEvent arg0) { if (!arg0.getLevel().equals(Level.WARN)) return; messages.add(arg0.getMessage().toString()); } }; LogManager.getRootLogger().addAppender(appender); // act for (int i = 0; i < threshold + 1; i++) { this.taskProcessingQueueHelper.addUrlToQueue(queueId, url + i); } // assert assertTrue(latch.await(200, TimeUnit.MILLISECONDS)); boolean found = false; for (String message : messages) { if (message.endsWith(String.format("%s has exceeded %d entries, size is now %d", queueId.toStringFull(), threshold, threshold + 1))) { found = true; break; } } assertTrue(found); }