@Override public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) { // cannot use logger.isEnabledFor(level), as it would cause a StackOverflowError by calling this filter again! if(level.isGreaterOrEqual(logger.getEffectiveLevel()) && format != null) { switch (level.toInt()) { case Level.ERROR_INT: errorCounter.increment(); break; case Level.WARN_INT: warnCounter.increment(); break; case Level.INFO_INT: infoCounter.increment(); break; case Level.DEBUG_INT: debugCounter.increment(); break; case Level.TRACE_INT: traceCounter.increment(); break; } } return FilterReply.NEUTRAL; }
private void setMetricsMarkerLogbackFilter(LoggerContext context) { log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME); OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator(); onMarkerMetricsEvaluator.setContext(context); onMarkerMetricsEvaluator.addMarker("metrics"); onMarkerMetricsEvaluator.start(); EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>(); metricsFilter.setContext(context); metricsFilter.setEvaluator(onMarkerMetricsEvaluator); metricsFilter.setOnMatch(FilterReply.DENY); metricsFilter.start(); for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) { for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext();) { Appender<ILoggingEvent> appender = it.next(); if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) { log.debug("Filter metrics logs from the {} appender", appender.getName()); appender.setContext(context); appender.addFilter(metricsFilter); appender.start(); } } } }
@Override public void postInvoke(Request request, Response response) throws IOException, ServletException { final HttpServletRequest httpRequest = (HttpServletRequest) request.getRequest(); try { CatalinaAdapter adapter = new CatalinaAdapter(request, response); IAccessEvent accessEvent = new AccessEvent(httpRequest, (HttpServletResponse) response.getResponse(), adapter); if (ctx.getFilterChainDecision(accessEvent) == FilterReply.DENY) { return; } // TODO better tion handling ctx.callAppenders(accessEvent); } finally { httpRequest.removeAttribute(AccessConstants.LOGBACK_STATUS_MANAGER_KEY); } }
private void setMetricsMarkerLogbackFilter(LoggerContext context) { log.info("Filtering metrics logs from all appenders except the {} appender", LOGSTASH_APPENDER_NAME); OnMarkerEvaluator onMarkerMetricsEvaluator = new OnMarkerEvaluator(); onMarkerMetricsEvaluator.setContext(context); onMarkerMetricsEvaluator.addMarker("metrics"); onMarkerMetricsEvaluator.start(); EvaluatorFilter<ILoggingEvent> metricsFilter = new EvaluatorFilter<>(); metricsFilter.setContext(context); metricsFilter.setEvaluator(onMarkerMetricsEvaluator); metricsFilter.setOnMatch(FilterReply.DENY); metricsFilter.start(); for (ch.qos.logback.classic.Logger logger : context.getLoggerList()) { for (Iterator<Appender<ILoggingEvent>> it = logger.iteratorForAppenders(); it.hasNext(); ) { Appender<ILoggingEvent> appender = it.next(); if (!appender.getName().equals(ASYNC_LOGSTASH_APPENDER_NAME)) { log.debug("Filter metrics logs from the {} appender", appender.getName()); appender.setContext(context); appender.addFilter(metricsFilter); appender.start(); } } } }
@Override public FilterReply decide(ILoggingEvent event) { if (event.getFormattedMessage().contains("Received 404 error, please notify the developer and include the URL (")) return FilterReply.DENY; if (event.getMarker() != Markers.NO_ANNOUNCE && Launcher.getInstance().getClient().isReady() && event.getLevel() == Level.ERROR) { String msg = event.getFormattedMessage(); if (event.getThrowableProxy() != null && event.getThrowableProxy() instanceof ThrowableProxy) { @SuppressWarnings("ThrowableResultOfMethodCallIgnored") Throwable throwable = ((ThrowableProxy) event.getThrowableProxy()).getThrowable(); if (throwable != null) { msg += ' '; StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); throwable.printStackTrace(pw); msg += sw.toString(); pw.close(); } } Messages.send(msg, Launcher.getInstance().getClient().getChannelByID("233632081110892546")); } return FilterReply.NEUTRAL; }
@Override public FilterReply decide(ILoggingEvent event) { String msg = event.getFormattedMessage(); if (msg.startsWith("Received 40")) { return FilterReply.DENY; } if (msg.startsWith("Attempt to send message on closed")) { return FilterReply.DENY; } if (event.getMarker() != Markers.NO_ANNOUNCE && FlareBot.getInstance().getClient() != null && FlareBot.getInstance().getClient().isReady() && event.getLevel() == Level.ERROR) { EXECUTOR.submit(() -> { Throwable throwable = null; if (event.getThrowableProxy() != null && event.getThrowableProxy() instanceof ThrowableProxy) { throwable = ((ThrowableProxy) event.getThrowableProxy()).getThrowable(); } if (throwable != null) { MessageUtils.sendException(msg, throwable, FlareBot.getInstance().getUpdateChannel()); } else MessageUtils.sendMessage(msg, FlareBot.getInstance().getUpdateChannel()); }); } return FilterReply.NEUTRAL; }
@Override public FilterReply decide(E eventObject) { if (!isStarted()) { return FilterReply.NEUTRAL; } LoggingEvent event = (LoggingEvent) eventObject; if (this.levelMin != null && !event.getLevel().isGreaterOrEqual(levelMin)) { return DENY; } if (this.levelMax != null && event.getLevel().toInt() > levelMax.toInt()) { return DENY; } if (acceptOnMatch) { return ACCEPT; } else { return NEUTRAL; } }
@Override public FilterReply decide(final ILoggingEvent event) { String marker = MDC.get(MDC_MARKER_ID); if (MDC.get(TASK_LOG_WITH_PROGRESS_MDC) != null && INTERNAL_PROGRESS.getName().equals(marker)) { // internal progress logs for TaskLogType.TASK_LOG_WITH_PROGRESS are wanted return NEUTRAL; } if (PROGRESS.getName().equals(marker) || TASK_LOG_ONLY.getName().equals(marker) || MDC.get(TASK_LOG_ONLY_MDC) != null) { return DENY; } return NEUTRAL; }
@Override public FilterReply decide(final ILoggingEvent event) { String marker = MDC.get(MDC_MARKER_ID); if (PROGRESS.getName().equals(marker)) { // store the progress value in the threadlocal TaskLoggerHelper.progress(toTaskLoggerEvent(event)); } if (MDC.get(LOGBACK_TASK_DISCRIMINATOR_ID) == null) { // not executing in a task... return DENY; } if (NEXUS_LOG_ONLY.getName().equals(marker) || INTERNAL_PROGRESS.getName().equals(marker)) { // not meant for task log return DENY; } return NEUTRAL; }
public FilterReply decide(E event) { // let us not throw an exception // see also bug #17. if (!isStarted() || !evaluator.isStarted()) { return FilterReply.NEUTRAL; } try { if (evaluator.evaluate(event)) { return onMatch; } else { return onMismatch; } } catch (EvaluationException e) { addError("Evaluator " + evaluator.getName() + " threw an exception", e); return FilterReply.NEUTRAL; } }
/** * The next methods are not merged into one because of the time we gain by not * creating a new Object[] with the params. This reduces the cost of not * logging by about 20 nanoseconds. */ private void filterAndLog_0_Or3Plus(final String localFQCN, final Marker marker, final Level level, final String msg, final Object[] params, final Throwable t) { final FilterReply decision = loggerContext .getTurboFilterChainDecision_0_3OrMore(marker, this, level, msg, params, t); if (decision == FilterReply.NEUTRAL) { if (effectiveLevelInt > level.levelInt) { return; } } else if (decision == FilterReply.DENY) { return; } buildLoggingEventAndAppend(localFQCN, marker, level, msg, params, t); }
private void filterAndLog_1(final String localFQCN, final Marker marker, final Level level, final String msg, final Object param, final Throwable t) { final FilterReply decision = loggerContext.getTurboFilterChainDecision_1( marker, this, level, msg, param, t); if (decision == FilterReply.NEUTRAL) { if (effectiveLevelInt > level.levelInt) { return; } } else if (decision == FilterReply.DENY) { return; } buildLoggingEventAndAppend(localFQCN, marker, level, msg, new Object[] { param }, t); }
private void filterAndLog_2(final String localFQCN, final Marker marker, final Level level, final String msg, final Object param1, final Object param2, final Throwable t) { final FilterReply decision = loggerContext.getTurboFilterChainDecision_2( marker, this, level, msg, param1, param2, t); if (decision == FilterReply.NEUTRAL) { if (effectiveLevelInt > level.levelInt) { return; } } else if (decision == FilterReply.DENY) { return; } buildLoggingEventAndAppend(localFQCN, marker, level, msg, new Object[] { param1, param2 }, t); }
/** * This method first finds the MDC value for 'key'. It then finds the level * threshold associated with this MDC value from the list of MDCValueLevelPair * passed to this filter. This value is stored in a variable called * 'levelAssociatedWithMDCValue'. If it null, then it is set to the * * @{link #defaultThreshold} value. * * If no such value exists, then * * * @param marker * @param logger * @param level * @param s * @param objects * @param throwable * * @return FilterReply - this filter's decision */ @Override public FilterReply decide(Marker marker, Logger logger, Level level, String s, Object[] objects, Throwable throwable) { String mdcValue = MDC.get(this.key); if (!isStarted()) { return FilterReply.NEUTRAL; } Level levelAssociatedWithMDCValue = null; if (mdcValue != null) { levelAssociatedWithMDCValue = valueLevelMap.get(mdcValue); } if (levelAssociatedWithMDCValue == null) { levelAssociatedWithMDCValue = defaultThreshold; } if (level.isGreaterOrEqual(levelAssociatedWithMDCValue)) { return onHigherOrEqual; } else { return onLower; } }
@Override public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) { if(!isStarted()) { return FilterReply.NEUTRAL; } if(marker == null) { return onMismatch; } if(marker.contains(markerToMatch)) { return onMatch; } else { return onMismatch; } }
@Test public void evaluatorFilterWithNullMarker_LBCORE_118() throws Exception { EvaluatorFilter<ILoggingEvent> ef = new EvaluatorFilter<ILoggingEvent>(); ef.setContext(loggerContext); ef.setOnMatch(FilterReply.ACCEPT); ef.setOnMismatch(FilterReply.DENY); jee.setExpression("marker.contains(\"BLUE\")"); jee.start(); ef.setEvaluator(jee); ef.start(); ILoggingEvent event = makeLoggingEvent(null); assertEquals(FilterReply.NEUTRAL, ef.decide(event)); }
@Test public void many() { DuplicateMessageFilter dmf = new DuplicateMessageFilter(); dmf.setAllowedRepetitions(0); int cacheSize = 10; int margin = 2; dmf.setCacheSize(cacheSize); dmf.start(); for (int i = 0; i < cacheSize + margin; i++) { assertEquals(FilterReply.NEUTRAL, dmf.decide(null, null, null, "a" + i, null, null)); } for (int i = cacheSize - 1; i >= margin; i--) { assertEquals(FilterReply.DENY, dmf.decide(null, null, null, "a" + i, null, null)); } for (int i = margin - 1; i >= 0; i--) { assertEquals(FilterReply.NEUTRAL, dmf.decide(null, null, null, "a" + i, null, null)); } }
@Test public void testComposite() { String compositeMarkerName = COMPOSITE; Marker compositeMarker = MarkerFactory.getMarker(compositeMarkerName); compositeMarker.add(totoMarker); MarkerFilter mkt = new MarkerFilter(); mkt.setMarker(TOTO); mkt.setOnMatch("ACCEPT"); mkt.setOnMismatch("DENY"); mkt.start(); assertTrue(mkt.isStarted()); assertEquals(FilterReply.DENY, mkt.decide(null, null, null, null, null, null)); assertEquals(FilterReply.ACCEPT, mkt.decide(totoMarker, null, null, null, null, null)); assertEquals(FilterReply.ACCEPT, mkt.decide(compositeMarker, null, null, null, null, null)); }
@Test public void testDecide() { final LogFilter filter = new LogFilter(); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent())); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.ENTRY.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.EXIT.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.DATA.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.THROWING.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.INFO.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.WARNING.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.ERROR.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.FFDC.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, MarkerFactory.getMarker("unknown"), "message", new Object[] { null }))); }
@Test public void testDecide() { final TraceFilter filter = new TraceFilter(); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent())); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.ENTRY.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.EXIT.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.DATA.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.ACCEPT, filter.decide(new MockILoggingEvent(null, LogMarker.THROWING.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.INFO.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.WARNING.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.ERROR.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, LogMarker.FFDC.getValue(), "message", new Object[] { null }))); assertEquals("Unexpected filter response", FilterReply.DENY, filter.decide(new MockILoggingEvent(null, MarkerFactory.getMarker("unknown"), "message", new Object[] { null }))); }
@Override public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) { if (mdcFilter == null) { return FilterReply.NEUTRAL; } if(CassandraAppender.isInTryCatch()) return onMatch; String value = MDC.get(mdcFilter); if (this.value.equals(value)) { if(level.levelInt <= this.level.levelInt) return onMatch; } return onMismatch; }
@Override public FilterReply decide(Object event) { if (!isStarted()) { return FilterReply.NEUTRAL; } LoggingEvent loggingEvent = (LoggingEvent) event; List<Level> eventsToKeep = Arrays.asList(Level.TRACE, Level.DEBUG, Level.INFO); if (eventsToKeep.contains(loggingEvent.getLevel())) { return FilterReply.NEUTRAL; } else { return FilterReply.DENY; } }
@Override public FilterReply decide(Object event) { if (!isStarted()) { return FilterReply.NEUTRAL; } LoggingEvent loggingEvent = (LoggingEvent) event; List<Level> eventsToKeep = Arrays.asList( Level.WARN, Level.ERROR ); if (eventsToKeep.contains(loggingEvent.getLevel())) { return FilterReply.NEUTRAL; } else { return FilterReply.DENY; } }
@Test public void testAppenderSecurityEvent() { LOGGER.info(SecurityMarkers.SECURITY_SUCCESS, "This statement is a security event"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.NEUTRAL, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderConfidentialEvent() { LOGGER.info(SecurityMarkers.CONFIDENTIAL, "This statement is confidential"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.DENY, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderMultipleEvent() { Marker multi = SecurityMarkers.getMarker( SecurityMarkers.SECURITY_AUDIT, SecurityMarkers.CONFIDENTIAL); LOGGER.info(multi, "This statement contains multiple markers: audit and confidential"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.DENY, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderSecuritySuccess() { LOGGER.info(SecurityMarkers.SECURITY_SUCCESS, "This statement is a security success"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.ACCEPT, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderSecurityFailure() { LOGGER.info(SecurityMarkers.SECURITY_FAILURE, "This statement is a security failure"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.ACCEPT, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderSecurityAudit() { LOGGER.info(SecurityMarkers.SECURITY_AUDIT, "This statement is a security audit"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.ACCEPT, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderMultipleEvent() { Marker multi = SecurityMarkers.getMarker( SecurityMarkers.SECURITY_AUDIT, SecurityMarkers.CONFIDENTIAL); LOGGER.info(multi, "This statement contains multiple markers: security audit and confidential"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.ACCEPT, mockAppender.getFilterChainDecision(loggingEvent)); }
@Test public void testAppenderMultipleNonSecurityEvent() { Marker multi = SecurityMarkers.getMarker(SecurityMarkers.EVENT_SUCCESS, SecurityMarkers.CONFIDENTIAL); System.out.println("MARKER: " + multi); LOGGER.info(multi, "This statement contains multiple markers: event success and confidential"); // Now verify our logging interactions verify(mockAppender).doAppend(captorLoggingEvent.capture()); // Get the logging event from the captor LoggingEvent loggingEvent = captorLoggingEvent.getValue(); System.out.println("testAppender(): loggingEvent: " + loggingEvent); // check the filter chain decision for this event assertEquals(FilterReply.DENY, mockAppender.getFilterChainDecision(loggingEvent)); }
@Override public void addErrorLogAppender(Object aAppender) { Appender appender = (Appender)aAppender; LevelFilter filter = new LevelFilter(); filter.setContext((LoggerContext) LoggerFactory.getILoggerFactory()); filter.setLevel(Level.ERROR); filter.setOnMatch(FilterReply.ACCEPT); filter.setOnMismatch(FilterReply.DENY); filter.start(); appender.addFilter(filter); appender.setContext((LoggerContext) LoggerFactory.getILoggerFactory()); appender.start(); ((Logger)LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME)).addAppender(appender); }
@Override public FilterReply decide(ILoggingEvent event) { if(!isStarted()) return FilterReply.NEUTRAL; if(logger != null && !event.getLoggerName().startsWith(logger)) return FilterReply.NEUTRAL; if(exceptLogger != null && event.getLoggerName().startsWith(exceptLogger)) return FilterReply.NEUTRAL; if(level != null && !event.getLevel().isGreaterOrEqual(level)) return FilterReply.DENY; return FilterReply.NEUTRAL; }
@Override public FilterReply decide(final ILoggingEvent event) { if (!isStarted()) { return FilterReply.NEUTRAL; } if (levelMin != null && event.getLevel().levelInt < levelMin.levelInt) { return FilterReply.DENY; } if (levelMax != null && event.getLevel().levelInt > levelMax.levelInt) { return FilterReply.DENY; } return FilterReply.NEUTRAL; }
@Test public void verifyFilteringAllAtWarn() { final LoggerThresholdFilter filter = new LoggerThresholdFilter(); filter.setLevel(WARN); filter.start(); for(Level level : allLevels) { final LoggingEvent evt = new LoggingEvent(); evt.setLevel(level); for(String logger : variousLoggers) { evt.setLoggerName(logger); if(level.isGreaterOrEqual(WARN)) assertEquals(FilterReply.NEUTRAL, filter.decide(evt)); else assertEquals(FilterReply.DENY, filter.decide(evt)); } } }
@Override public FilterReply decide(final ILoggingEvent event) { final Marker marker = event.getMarker(); if (!isStarted()) { return FilterReply.NEUTRAL; } if (marker == null) { return onMismatch; } if (markerToMatch.contains(marker)) { return onMatch; } return onMismatch; }
@Override public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) { //System.out.println("** Being called "+logger+"**"+level+"**"+marker); ConfigValueTuple override = loggerOverrides.get(logger); if(override != null) { Level configLevel = Level.toLevel(override.getLevel()); if(level.isGreaterOrEqual(configLevel)) return FilterReply.ACCEPT; else return FilterReply.DENY; } else return FilterReply.NEUTRAL; }