@Before public void setUp() throws Exception { OnConsoleStatusListener.addNewInstanceToContext(loggerContext); MDC.clear(); ServerSetup serverSetup = new ServerSetup(port, "localhost", ServerSetup.PROTOCOL_SMTP); greenMailServer = new GreenMail(serverSetup); greenMailServer.start(); // give the server a head start if (EnvUtilForTests.isRunningOnSlowJenkins()) { Thread.sleep(2000); } else { Thread.sleep(50); } }
@Override public void begin(InterpretationContext ec, String name, Attributes attributes) { // See LBCLASSIC-225 (the system property is looked up first. Thus, it overrides // the equivalent property in the config file. This reversal of scope priority is justified // by the use case: the admin trying to chase rogue config file String debugAttrib = System.getProperty(DEBUG_SYSTEM_PROPERTY_KEY); if (debugAttrib == null) { debugAttrib = attributes.getValue(INTERNAL_DEBUG_ATTR); } if (OptionHelper.isEmpty(debugAttrib) || debugAttrib.equals("false") || debugAttrib.equals("null")) { addInfo(INTERNAL_DEBUG_ATTR + " attribute not set"); } else { OnConsoleStatusListener.addNewInstanceToContext(context); } new ContextUtil(context).addHostNameAsProperty(); // the context is appender attachable, so it is pushed on top of the stack ec.pushObject(getContext()); }
protected void configLogbackContext(LoggerContext context, Logger root, Map<String, LoggerFactory> loggers) { context.reset(); if (debugLogback) { StatusListenerConfigHelper.addOnConsoleListenerInstance(context, new OnConsoleStatusListener()); } LevelChangePropagator propagator = new LevelChangePropagator(); propagator.setContext(context); propagator.setResetJUL(true); context.addListener(propagator); root.setLevel(Level.toLevel(level.name(), Level.INFO)); loggers.forEach((name, lf) -> lf.configLogger(name, context)); if (appenders.isEmpty()) { setAppenders(Collections.singletonList(new ConsoleAppenderFactory())); } appenders.forEach(a -> root.addAppender(a.createAppender(context, getLogFormat()))); }
@Before public void addHandler() throws Exception { mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); final String xml = Resources.toString(KafkaAppenderTest.class.getResource("/logback-kafka.xml"), Charsets.UTF_8) .replaceAll("\\$KAFKA\\$", kafka.getBroker().getKafkaBrokerConnect()); final OnConsoleStatusListener listener = new OnConsoleStatusListener(); listener.start(); context.getStatusManager().add(listener); final JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(context); configurator.doConfigure(new ByteArrayInputStream(xml.getBytes(Charsets.UTF_8))); context.start(); }
/** * This implementation does not allow duplicate installations of OnConsoleStatusListener * @param listener */ public void add(StatusListener listener) { synchronized (statusListenerListLock) { if(listener instanceof OnConsoleStatusListener) { boolean alreadyPresent = checkForPresence(statusListenerList, listener.getClass()); if(alreadyPresent) return; } statusListenerList.add(listener); } }
@Before public void setUp() throws InterruptedException { context.getStatusManager().add(new OnConsoleStatusListener()); File outputDir = new File(outputDirStr); outputDir.mkdirs(); fa.setContext(context); fa.setName("FILE"); fa.setEncoder(new EchoEncoder<Object>()); fa.setFile(logfileStr); fa.start(); }
@Before public void setUp() throws InterruptedException { context.getStatusManager().add(new OnConsoleStatusListener()); File outputDir = new File(outputDirStr); outputDir.mkdirs(); fa.setContext(context); fa.setName("FILE"); fa.setPrudent(true); fa.setEncoder(new EchoEncoder<Object>()); fa.setFile(logfileStr); fa.start(); }
public void begin(InterpretationContext ic, String name, Attributes attributes) { threshold = System.currentTimeMillis(); // See LOGBACK-527 (the system property is looked up first. Thus, it overrides // the equivalent property in the config file. This reversal of scope priority is justified // by the use case: the admin trying to chase rogue config file String debugAttrib = getSystemProperty(DEBUG_SYSTEM_PROPERTY_KEY); if (debugAttrib == null) { debugAttrib = ic.subst(attributes.getValue(INTERNAL_DEBUG_ATTR)); } if (OptionHelper.isEmpty(debugAttrib) || debugAttrib.equalsIgnoreCase("false") || debugAttrib.equalsIgnoreCase("null")) { addInfo(INTERNAL_DEBUG_ATTR + " attribute not set"); } else { OnConsoleStatusListener.addNewInstanceToContext(context); } processScanAttrib(ic, attributes); ContextUtil contextUtil = new ContextUtil(context); contextUtil.addHostNameAsProperty(); if(EnvUtil.isGroovyAvailable()) { LoggerContext lc = (LoggerContext) context; contextUtil.addGroovyPackages(lc.getFrameworkPackages()); } // the context is turbo filter attachable, so it is pushed on top of the // stack ic.pushObject(getContext()); }
public static void main(String[] args) throws JoranException { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); StatusManager statusManager = lc.getStatusManager(); OnConsoleStatusListener onConsoleListener = new OnConsoleStatusListener(); statusManager.add(onConsoleListener); Logger logger = LoggerFactory.getLogger("myApp"); logger.info("Entering application."); Foo foo = new Foo(); foo.doIt(); logger.info("Exiting application."); }
@Before public void addHandler() throws Exception { mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); serializedEvents.clear(); final OnConsoleStatusListener listener = new OnConsoleStatusListener(); listener.start(); context.getStatusManager().add(listener); final JsonLogEncoder encoder = new JsonLogEncoder() { @Override public ObjectNode convertToObjectNode(ILoggingEvent event) { ObjectNode node = super.convertToObjectNode(event); serializedEvents.add(node); return node; } }; encoder.setContext(context); final UnsynchronizedAppenderBase<ILoggingEvent> captureAppender = new UnsynchronizedAppenderBase<ILoggingEvent>() { @Override protected void append(ILoggingEvent eventObject) { encoder.encode(eventObject); } }; captureAppender.setContext(context); captureAppender.start(); context.getLogger(Logger.ROOT_LOGGER_NAME).addAppender(captureAppender); new BasicConfigurator().configure(context); context.start(); }
static public void main(String[] args) throws Exception { // Create a SocketAppender connected to hostname:port with a // reconnection delay of 10000 seconds. String hostname = "localhost"; int port = 4321; SocketAppender socketAppender = new SocketAppender(); socketAppender.setRemoteHost(hostname); socketAppender.setPort(port); socketAppender.setIncludeCallerData(true); socketAppender.setReconnectionDelay(new Duration(10000)); LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); socketAppender.setContext(lc); lc.reset(); lc.getStatusManager().add(new OnConsoleStatusListener()); // SocketAppender options become active only after the execution // of the next statement. socketAppender.start(); Logger rootLogger = (Logger) LoggerFactory.getLogger(ROOT_LOGGER_NAME); rootLogger.addAppender(socketAppender); org.slf4j.Logger logger = LoggerFactory.getLogger(LOGGER_NAME); UglyBetty ub = new UglyBetty("ugly-betty-thread-234"); ub.start(); for (int i = 0; i < RUN_LENGTH; i++) { if (i % 3 == 0) { logger.warn(i + " is divisible by 3"); } else { toto(logger, i); } Thread.sleep(SLEEP); } ub.join(); StatusPrinter.print(lc); }
/** * Configures logback-android RollingFileAppender to rollover if * a log event occurs after the second-boundary. */ private void configureLogback() { // reset the default context (which may already have been initialized) // since we want to reconfigure it LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); context.reset(); // Enable debugging to show rollover status OnConsoleStatusListener.addNewInstanceToContext(context); final String LOG_DIR = "/sdcard/logback"; RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>(); rollingFileAppender.setAppend(true); rollingFileAppender.setContext(context); // OPTIONAL: Set an active log file (separate from the rollover files). // If rollingPolicy.fileNamePattern already set, you don't need this. rollingFileAppender.setFile(LOG_DIR + "/log.txt"); // Set the periodicity to seconds. That is, if a log event occurs after the // second-boundary, the log file will rollover. final String PERIODICITY = "yyyy-MM-dd_HH-mm-ss"; TimeBasedRollingPolicy<ILoggingEvent> rollingPolicy = new TimeBasedRollingPolicy<ILoggingEvent>(); rollingPolicy.setFileNamePattern(LOG_DIR + "/log.%d{"+ PERIODICITY +"}.txt"); rollingPolicy.setMaxHistory(5); // no more than 5 rollover files (delete oldest) rollingPolicy.setParent(rollingFileAppender); // parent and context required! rollingPolicy.setContext(context); rollingPolicy.start(); rollingFileAppender.setRollingPolicy(rollingPolicy); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setPattern("%logger{35} - %msg%n"); encoder.setContext(context); encoder.start(); rollingFileAppender.setEncoder(encoder); rollingFileAppender.start(); // add the newly created appenders to the root logger; // qualify Logger to disambiguate from org.slf4j.Logger ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); root.setLevel(Level.TRACE); root.addAppender(rollingFileAppender); }