/** * Test abstract functions (using console implementation) and the functions * of console * */ @Test public void testAbstractAndConsole() { BaleenConsoleLoggerBuilder builder = new BaleenConsoleLoggerBuilder(NAME, BaleenLogging.DEFAULT_PATTERN, new MinMaxFilter(Level.INFO, Level.WARN)); LoggerContext context = new LoggerContext(); Encoder<ILoggingEvent> encoder = new PatternLayoutEncoder(); Appender<ILoggingEvent> appender = builder.build(context, encoder); assertEquals(NAME, builder.getName()); assertTrue(appender instanceof ConsoleAppender); assertEquals(encoder, ((ConsoleAppender<ILoggingEvent>) appender).getEncoder()); assertNotNull(appender); assertEquals(NAME, appender.getName()); Filter<ILoggingEvent> filter = appender.getCopyOfAttachedFiltersList().get(0); assertTrue(filter instanceof MinMaxFilter); assertEquals(Level.INFO, ((MinMaxFilter) filter).getMin()); assertEquals(Level.WARN, ((MinMaxFilter) filter).getMax()); }
private void startAndAddFilter(Filter<ILoggingEvent> filter) { if (filter != null) { if (!filter.isStarted()) { filter.start(); } addFilter(filter); } }
/** * Loop through the filters in the list. As soon as a filter decides on * ACCEPT or DENY, then that value is returned. If all of the filters return * NEUTRAL, then NEUTRAL is returned. */ public FilterReply getFilterChainDecision(E event) { for (Filter<E> f : filterList) { final FilterReply r = f.decide(event); if (r == FilterReply.DENY || r == FilterReply.ACCEPT) { return r; } } return FilterReply.NEUTRAL; }
private List<Filter<ILoggingEvent>> configureFilters(Map<String, Object> config) throws InvalidParameterException { List<Filter<ILoggingEvent>> filters = new ArrayList<>(); List<String> includeLoggers = yamlToList(config.get("includeLoggers")); List<String> excludeLoggers = yamlToList(config.get("excludeLoggers")); if (!includeLoggers.isEmpty()) { LoggerFilter includeFilter = new LoggerFilter(includeLoggers, false); filters.add(includeFilter); } if (!excludeLoggers.isEmpty()) { LoggerFilter excludeFilter = new LoggerFilter(excludeLoggers, true); filters.add(excludeFilter); } String minLevelStr = (String) config.get("minLevel"); String maxLevelStr = (String) config.get("maxLevel"); Level minLevel = convertToLevel(minLevelStr); Level maxLevel = convertToLevel(maxLevelStr); MinMaxFilter levelFilter = new MinMaxFilter(minLevel, maxLevel); filters.add(levelFilter); return filters; }
private BaleenLoggerBuilder configureLogger(Map<String, Object> config) throws InvalidParameterException { // Extract the specified configuration parameters String name = (String) config.get("name"); String pattern = (String) config.getOrDefault("pattern", DEFAULT_PATTERN); String file = (String) config.get("file"); Boolean rolling = (Boolean) config.getOrDefault("daily", false); Double maxSize = parseToDouble(config.get("size")); Integer maxHistory = (Integer) config.get("history"); List<Filter<ILoggingEvent>> filters = configureFilters(config); // Do we have a name, and if so is it a special case (e.g. console) if (Strings.isNullOrEmpty(name)) { LOGGER.warn("Required parameter 'name' not specified for logger - logger will be skipped"); return null; } else if ("console".equalsIgnoreCase(name)) { return new BaleenConsoleLoggerBuilder(name, pattern, filters); } else { if (Strings.isNullOrEmpty(file)) { file = name; } Optional<Integer> integerMaxSize = Optional.empty(); if (maxSize != null) { integerMaxSize = Optional.of((int) (maxSize * 1024)); } return new BaleenFileLoggerBuilder(name, pattern, file, filters, rolling, integerMaxSize, Optional .ofNullable(maxHistory)); } }
@Test public void testNullFilters() { BaleenConsoleLoggerBuilder singleBuilder = new BaleenConsoleLoggerBuilder(BaleenLogging.DEFAULT_PATTERN, (Filter<ILoggingEvent>) null); List<Filter<ILoggingEvent>> list = null; BaleenConsoleLoggerBuilder listBuilder = new BaleenConsoleLoggerBuilder(BaleenLogging.DEFAULT_PATTERN, list); singleBuilder.build(null, null); listBuilder.build(null, null); }
@Test public void testAbstractAndConsoleMultipleFilters() { BaleenConsoleLoggerBuilder builder = new BaleenConsoleLoggerBuilder(NAME, BaleenLogging.DEFAULT_PATTERN, Arrays.asList(new MinMaxFilter(Level.INFO, Level.ERROR), new MinMaxFilter(Level.INFO, Level.WARN))); LoggerContext context = new LoggerContext(); Encoder<ILoggingEvent> encoder = new PatternLayoutEncoder(); Appender<ILoggingEvent> appender = builder.build(context, encoder); assertEquals(NAME, builder.getName()); assertTrue(appender instanceof ConsoleAppender); assertEquals(encoder, ((ConsoleAppender<ILoggingEvent>) appender).getEncoder()); assertNotNull(appender); assertEquals(NAME, appender.getName()); assertEquals(2, appender.getCopyOfAttachedFiltersList().size()); Filter<ILoggingEvent> filter = appender.getCopyOfAttachedFiltersList().get(0); assertTrue(filter instanceof MinMaxFilter); assertEquals(Level.INFO, ((MinMaxFilter) filter).getMin()); assertEquals(Level.ERROR, ((MinMaxFilter) filter).getMax()); filter = appender.getCopyOfAttachedFiltersList().get(1); assertTrue(filter instanceof MinMaxFilter); assertEquals(Level.INFO, ((MinMaxFilter) filter).getMin()); assertEquals(Level.WARN, ((MinMaxFilter) filter).getMax()); // TODO: Test that both filters are being applied }
@Override public List<Filter<ILoggingEvent>> getCopyOfAttachedFiltersList() { return null; }
@Override public List<Filter<E>> getCopyOfAttachedFiltersList() { return null; }
public LambdaConsoleAppender(String pattern, Filter<ILoggingEvent> filter) { this(); addPattern(pattern); startAndAddFilter(filter); }
public void addFilter(Filter<E> newFilter) { fai.addFilter(newFilter); }
public List<Filter<E>> getCopyOfAttachedFiltersList() { return fai.getCopyOfAttachedFiltersList(); }
/** * Add a filter to end of the filter list. */ public void addFilter(Filter<E> newFilter) { filterList.add(newFilter); }
public List<Filter<E>> getCopyOfAttachedFiltersList() { return new ArrayList<Filter<E>>(filterList); }
@Override public void addFilter(Filter<IAccessEvent> newFilter) { fai.addFilter(newFilter); }
@Override public List<Filter<IAccessEvent>> getCopyOfAttachedFiltersList() { return fai.getCopyOfAttachedFiltersList(); }
/** * Creates an {@link OutputStreamAppender} for the required filter, pattern and logger output. * * @param context Logger context to associate the appender with. * @param filter Event log filter. * @param logOutput Logger output information for the destination to write logger events to. * @param patternProperty Logger context property that defines the pattern for formatting logger event output. * @param name The name of the appender. * @return An {@link OutputStreamAppender} for the required parameters. */ private static OutputStreamAppender<ILoggingEvent> createAppender(LoggerContext context, Filter<ILoggingEvent> filter, LoggerOutput logOutput, String patternProperty, String name) { final PatternLayoutEncoder patternLayoutEncoder = createPatternLayoutEncoder(context, patternProperty); final OutputStreamAppender<ILoggingEvent> appender; if (logOutput.isConsole()) { appender = new OutputStreamAppender<>(); appender.setContext(context); appender.setEncoder(patternLayoutEncoder); appender.setOutputStream(logOutput.getPrintStream()); appender.setName(name); appender.addFilter(filter); appender.start(); } else { RollingFileAppender<ILoggingEvent> rAppender = new RollingFileAppender<>(); rAppender.setContext(context); rAppender.setEncoder(patternLayoutEncoder); rAppender.setFile(logOutput.getOutputName()+"."+logOutput.getOutputType()); rAppender.setName(name); rAppender.addFilter(filter); final FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy(); rollingPolicy.setContext(context); rollingPolicy.setParent(rAppender); rollingPolicy.setFileNamePattern(logOutput.getOutputName()+"%i"+"."+logOutput.getOutputType()); rollingPolicy.setMinIndex(1); rollingPolicy.setMaxIndex(logOutput.getFileCount()); rollingPolicy.start(); final SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<>(); triggeringPolicy.setContext(context); triggeringPolicy.setMaxFileSize(logOutput.getFileLimit()); triggeringPolicy.start(); rAppender.setRollingPolicy(rollingPolicy); rAppender.setTriggeringPolicy(triggeringPolicy); rAppender.start(); appender = rAppender; } return appender; }
private AttachLogFilter(Filter<ILoggingEvent> filter, String configKey) { this.filter = filter; this.configKey = configKey; }
public static AttachLogFilter attach(Filter<ILoggingEvent> filter, String configKey) { return new AttachLogFilter(filter, configKey); }
@Override public void addFilter(Filter<ILoggingEvent> arg0) { // TODO Auto-generated method stub }
@Override public List<Filter<ILoggingEvent>> getCopyOfAttachedFiltersList() { // TODO Auto-generated method stub return null; }
public static void configureStdOutLogging( String loglevel ) { if (!(LoggerFactory.getILoggerFactory() instanceof LoggerContext)) { System.err.println("Logger is not using logback, skipping logging configuration"); return; } try { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); lc.reset(); Logger rootLogger = getRootLogger( loglevel ); PatternLayoutEncoder ple = getPatternLayoutEncoder( lc ); // ops would like us to log to console unless an app // has a specific need not to ConsoleAppender<ILoggingEvent> stdOutAppender = new ConsoleAppender<ILoggingEvent>(); stdOutAppender.setContext( lc ); stdOutAppender.setName( "stdlib-console-out" ); stdOutAppender.setTarget( "System.out" ); stdOutAppender.setEncoder( ple ); Filter<ILoggingEvent> stdOutFilter = new StdOutFilter(); stdOutAppender.addFilter( stdOutFilter ); stdOutFilter.start(); stdOutAppender.start(); ple = getPatternLayoutEncoder( lc ); ConsoleAppender<ILoggingEvent> errorAppender = new ConsoleAppender<ILoggingEvent>(); errorAppender.setContext( lc ); errorAppender.setName( "stdlib-console-err" ); errorAppender.setTarget( "System.err" ); errorAppender.setEncoder( ple ); Filter<ILoggingEvent> stdErrFilter = new ErrOutFilter(); errorAppender.addFilter( stdErrFilter ); stdErrFilter.start(); errorAppender.start(); // Wrap the console appenders in an async appenders AsyncAppender asyncStdOutWrapper = new AsyncAppender(); asyncStdOutWrapper.setContext( lc ); asyncStdOutWrapper.setDiscardingThreshold( 0 ); asyncStdOutWrapper.setQueueSize( 500 ); asyncStdOutWrapper.addAppender( stdOutAppender ); asyncStdOutWrapper.setName( "stdlib-async-out" ); asyncStdOutWrapper.start(); // Wrap the console appenders in an async appenders AsyncAppender asyncStdErrWrapper = new AsyncAppender(); asyncStdErrWrapper.setContext( lc ); asyncStdErrWrapper.setDiscardingThreshold( 0 ); asyncStdErrWrapper.setQueueSize( 500 ); asyncStdErrWrapper.addAppender( errorAppender ); asyncStdErrWrapper.setName( "stdlib-async-err-2" ); asyncStdErrWrapper.start(); // Add the appenders to root logger rootLogger.addAppender( asyncStdOutWrapper ); rootLogger.addAppender( asyncStdErrWrapper ); } catch ( Exception e ) { System.err.println( "Failed to add appender!!" ); e.printStackTrace(); } // wrap stdout & stderr in log4j appenders StdOutErrLog.tieSystemOutAndErrToLog(); }
protected AbstractAwsEncodingStringAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) { this.awsSupport = awsSupport; this.sdkLoggingFilter = sdkLoggingFilter; addFilter(sdkLoggingFilter); }
protected SqsAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) { super(awsSupport, sdkLoggingFilter); }
protected DynamoDbAppender(AwsSupport awsSupport, Filter<ILoggingEvent> sdkLoggingFilter) { super(awsSupport, sdkLoggingFilter); setMaxPayloadSize(DEFAULT_MAX_PAYLOAD_SIZE); }
protected CloudWatchAppender(AwsSupport awsSupport, Filter<ILoggingEvent> sdkLoggingFilter) { super(awsSupport, sdkLoggingFilter); }
protected AbstractCloudWatchAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) { super(awsSupport, sdkLoggingFilter); }
protected CloudWatchAccessAppender(AwsSupport awsSupport, Filter<IAccessEvent> sdkLoggingFilter) { super(awsSupport, sdkLoggingFilter); }
protected SnsAppender(AwsSupport awsSupport, Filter<E> sdkLoggingFilter) { super(awsSupport, sdkLoggingFilter); }
private void addDroppingRavenLoggingFilter(Appender<ILoggingEvent> appender) { final Filter<ILoggingEvent> filter = new DroppingRavenLoggingFilter(); filter.start(); appender.addFilter(filter); }
@Override public void addFilter(final Filter<ILoggingEvent> filter) { throw new UnsupportedOperationException("Not implemented"); }
@Override public List<Filter<ILoggingEvent>> getCopyOfAttachedFiltersList() { throw new UnsupportedOperationException("Not implemented"); }
public void addFilter(Filter<ILoggingEvent> filter) { this.ca.addFilter(filter); }