Java 类org.apache.log4j.AppenderSkeleton 实例源码

项目：convertigo-eclipse 文件：EngineLogView.java

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

项目：flink 文件：TwoPhaseCommitSinkFunctionTest.java

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

项目：Camel 文件：LogVerifier.java

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

项目：scheduling 文件：SchedulerStateRestLiveLogsTest.java

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

项目：h2ha 文件：DbLargeSyncTests.java

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

项目：h2ha 文件：DbLargeSyncTestsPageStore.java

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

项目：h2ha 文件：PermanentLoadGenerator.java

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

项目：h2ha 文件：FailoverTestsPageStore.java

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

项目：h2ha 文件：FailoverTests.java

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

项目：FSTestTools 文件：MockingBaseContextTest.java

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

项目：cikm16-wdvd-feature-extraction 文件：FeatureExtractor.java

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

}

项目：apex-core 文件：LoggerUtilTest.java

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

项目：apex-core 文件：LoggerUtilTest.java

@AfterClass
public static void teardown()
{
  for (Map.Entry<AppenderSkeleton, Priority> e : appenderLevelMap.entrySet()) {
    e.getKey().setThreshold(e.getValue());
  }
}

项目：OpenSPIFe 文件：EnsembleUsageLogger.java

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

项目：h2ha 文件：SingleServerTests.java

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

项目：h2ha 文件：SingleServerTestsPageStore.java

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

项目：Rapture 文件：BasePipelineIntTest.java

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

项目：Rapture 文件：BasePipeline2IntTest.java

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

项目：project-bianca 文件：LoggingLog4J.java

@Override
public void addAppender(Object console) {
    Logger.getRootLogger().addAppender((AppenderSkeleton) console);
}

项目：project-bianca 文件：LoggingLog4J.java

@Override
public void removeAppender(Object console) {
    Logger.getRootLogger().removeAppender((AppenderSkeleton) console);
}

项目：power-matchmaker 文件：GoogleAddressLookupMungeStepTest.java

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

项目：h2o-3 文件：CustomHttpFilterTest.java

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

}

项目：pi 文件：TaskProcessingQueueHelperTest.java

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

项目：p2p-core 文件：TaskProcessingQueueHelperTest.java

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