/** * Loads the test-specific Log4J configuration and resets the environment. */ public void setUp(String propertiesName) throws Exception { URL config = ClassLoader.getSystemResource(propertiesName); assertNotNull("missing configuration: " + propertiesName, config); LogManager.resetConfiguration(); PropertyConfigurator.configure(config); localLogger = Logger.getLogger(getClass()); runId = String.valueOf(System.currentTimeMillis()); resourceName = "SNSAppenderIntegrationTest-" + runId; System.setProperty("SNSAppenderIntegrationTest.resourceName", resourceName); localSNSclient = AmazonSNSClientBuilder.defaultClient(); localSQSclient = AmazonSQSClientBuilder.defaultClient(); }
/** * On change event */ void handleOnChange(File logFile) { try { long lastModif = logFile.lastModified(); if (lastModif > logFileLastModified) { logFileLastModified = lastModif; logger.debug("Reload log4j configuration from " + logFile.getAbsolutePath()); new PropertyConfigurator().doConfigure( logFile.getAbsolutePath(), LogManager.getLoggerRepository()); logFileWarning = false; } } catch (Exception e) { if (!logFileWarning) { logFileWarning = true; logger.error(logFile.getAbsolutePath(), e); } } }
@Before public void setup() { initMocks(this); lifeCycleListener.setServerId("1"); lifeCycleListener.setServerName("testJvm"); lifeCycleListener.setJgroupsPreferIpv4Stack("true"); lifeCycleListener.setJgroupsConfigXml("tcp.xml"); lifeCycleListener.setJgroupsCoordinatorIp(prop.getProperty("coordinator.ip")); lifeCycleListener.setJgroupsCoordinatorHostname("testHostname"); lifeCycleListener.setJgroupsCoordinatorPort("30000"); lifeCycleListener.setJgroupsClusterName("testCluster"); lifeCycleListener.setSchedulerDelayInitial("1"); lifeCycleListener.setSchedulerDelaySubsequent("1"); lifeCycleListener.setSchedulerDelayUnit("SECONDS"); lifeCycleListener.setSchedulerThreadCount("1"); LogManager.getRootLogger().addAppender(mockAppender); }
@SuppressWarnings("unchecked") public Log4jLoggerAdapter() { try { org.apache.log4j.Logger logger = LogManager.getRootLogger(); if (logger != null) { Enumeration<Appender> appenders = logger.getAllAppenders(); if (appenders != null) { while (appenders.hasMoreElements()) { Appender appender = appenders.nextElement(); if (appender instanceof FileAppender) { FileAppender fileAppender = (FileAppender)appender; String filename = fileAppender.getFile(); file = new File(filename); break; } } } } } catch (Throwable t) { } }
/** * Configures root logger, either for FILE output or just console. */ public static void configureLogger() { LogManager.shutdown(); String logFile; if (getConfigBoolean("log.save", false)) { logFile = "log4j.file.properties"; } else { logFile = "log4j.properties"; } InputStream stream = Utils.class.getClassLoader().getResourceAsStream(logFile); if (stream == null) { PropertyConfigurator.configure("src/main/resources/" + logFile); } else { PropertyConfigurator.configure(stream); } logger.info("Loaded " + logFile); try { stream.close(); } catch (IOException e) { } }
@Test(timeout = 10000) public void testRunWithLevelDebug() { // remember current level Level originalLevel = LogManager.getRootLogger().getLevel(); try { // set logging to TRACE LogManager.getRootLogger().setLevel(Level.DEBUG); // execute run method testRun(); } finally { // restore level LogManager.getRootLogger().setLevel(originalLevel); } }
@Test(timeout = 10000) public void testRunWithLevelTrace() { // remember current level Level originalLevel = LogManager.getRootLogger().getLevel(); try { // set logging to TRACE LogManager.getRootLogger().setLevel(Level.TRACE); // execute run method testRun(); } finally { // restore level LogManager.getRootLogger().setLevel(originalLevel); } }
private void configureAuditLogs() throws IOException { // Shutdown the LogManager to release all logger open file handles. // Unfortunately, Apache commons logging library does not provide // means to release underlying loggers. For additional info look up // commons library FAQ. LogManager.shutdown(); File file = new File(auditLogFile); if (file.exists()) { assertTrue(file.delete()); } Logger logger = ((Log4JLogger) FSNamesystem.auditLog).getLogger(); // disable logging while the cluster startup preps files logger.setLevel(Level.OFF); PatternLayout layout = new PatternLayout("%m%n"); RollingFileAppender appender = new RollingFileAppender(layout, auditLogFile); logger.addAppender(appender); }
@SuppressWarnings("unchecked") public LogPageHandler() { try { org.apache.log4j.Logger logger = LogManager.getRootLogger(); if (logger != null) { Enumeration<Appender> appenders = logger.getAllAppenders(); if (appenders != null) { while (appenders.hasMoreElements()) { Appender appender = appenders.nextElement(); if (appender instanceof FileAppender) { FileAppender fileAppender = (FileAppender)appender; String filename = fileAppender.getFile(); file = new File(filename); break; } } } } } catch (Throwable t) { } }
/** * @param args Command line args */ public static void main(String[] args) { boolean result = false; try { ApplicationMaster appMaster = new ApplicationMaster(); LOG.info("Initializing ApplicationMaster"); boolean doRun = appMaster.init(args); if (!doRun) { System.exit(0); } appMaster.run(); result = appMaster.finish(); } catch (Throwable t) { LOG.fatal("Error running ApplicationMaster", t); LogManager.shutdown(); ExitUtil.terminate(1, t); } if (result) { LOG.info("Application Master completed successfully. exiting"); System.exit(0); } else { LOG.info("Application Master failed. exiting"); System.exit(2); } }
/** * On change event */ void handleOnChange(File logFile) { try { long lastModif = logFile.lastModified(); if (lastModif > logFileLastModified) { logFileLastModified = lastModif; LOGGER.debug("Reload log4j configuration from " + logFile.getAbsolutePath()); new PropertyConfigurator().doConfigure(logFile.getAbsolutePath(), LogManager.getLoggerRepository()); logFileWarning = false; } } catch (Exception e) { if (!logFileWarning) { logFileWarning = true; LOGGER.error(logFile.getAbsolutePath(), e); } } }
/** * On change event */ void handleOnChange(File logFile) { try { long lastModif = logFile.lastModified(); if (lastModif > logFileLastModified) { logFileLastModified = lastModif; LOGGER.debug("Reload log4j configuration from " + logFile.getAbsolutePath()); new PropertyConfigurator().doConfigure( logFile.getAbsolutePath(), LogManager.getLoggerRepository()); logFileWarning = false; } } catch (Exception e) { if (!logFileWarning) { logFileWarning = true; LOGGER.error(logFile.getAbsolutePath(), e); } } }
@Test(expected = EventDeliveryException.class) public void testSlowness() throws Throwable { ch = new SlowMemoryChannel(2000); Configurables.configure(ch, new Context()); configureSource(); props.put("log4j.appender.out2.Timeout", "1000"); props.put("log4j.appender.out2.layout", "org.apache.log4j.PatternLayout"); props.put("log4j.appender.out2.layout.ConversionPattern", "%-5p [%t]: %m%n"); PropertyConfigurator.configure(props); Logger logger = LogManager.getLogger(TestLog4jAppender.class); Thread.currentThread().setName("Log4jAppenderTest"); int level = 10000; String msg = "This is log message number" + String.valueOf(1); try { logger.log(Level.toLevel(level), msg); } catch (FlumeException ex) { throw ex.getCause(); } }
/** * Returns true if it appears that log4j have been previously configured. This code checks to see if there are any appenders defined for log4j * which is the definitive way to tell if log4j is already initialized. See http://wiki.apache.org/logging-log4j/UsefulCode * * @return true if Log4J is configured, false otherwise. */ private static boolean isLog4JConfigured() { final Enumeration<?> appenders = Logger.getRootLogger().getAllAppenders(); if (appenders.hasMoreElements()) { return true; } else { final Enumeration<?> loggers = LogManager.getCurrentLoggers(); while (loggers.hasMoreElements()) { final Logger c = (Logger) loggers.nextElement(); if (c.getAllAppenders().hasMoreElements()) { return true; } } } return false; }
@SuppressWarnings("unchecked") public synchronized static void syncLogs(String logLocation, TaskAttemptID taskid, boolean isCleanup) throws IOException { System.out.flush(); System.err.flush(); Enumeration<Logger> allLoggers = LogManager.getCurrentLoggers(); while (allLoggers.hasMoreElements()) { Logger l = allLoggers.nextElement(); Enumeration<Appender> allAppenders = l.getAllAppenders(); while (allAppenders.hasMoreElements()) { Appender a = allAppenders.nextElement(); if (a instanceof TaskLogAppender) { ((TaskLogAppender)a).flush(); } } } if (currentTaskid != taskid) { currentTaskid = taskid; resetPrevLengths(logLocation); } writeToIndexFile(logLocation, isCleanup); }
/** * Initializes Log4j logging. * * @throws ServerException thrown if Log4j could not be initialized. */ protected void initLog() throws ServerException { verifyDir(logDir); LogManager.resetConfiguration(); File log4jFile = new File(configDir, name + "-log4j.properties"); if (log4jFile.exists()) { PropertyConfigurator.configureAndWatch(log4jFile.toString(), 10 * 1000); //every 10 secs log = LoggerFactory.getLogger(Server.class); } else { Properties props = new Properties(); try { InputStream is = getResource(DEFAULT_LOG4J_PROPERTIES); try { props.load(is); } finally { is.close(); } } catch (IOException ex) { throw new ServerException(ServerException.ERROR.S03, DEFAULT_LOG4J_PROPERTIES, ex.getMessage(), ex); } PropertyConfigurator.configure(props); log = LoggerFactory.getLogger(Server.class); log.warn("Log4j [{}] configuration file not found, using default configuration from classpath", log4jFile); } }
public synchronized static void initializeLogger() { if(isInitialized) return; InputStream configStream = null; try { configStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("log4j.xml"); if(configStream != null){ new DOMConfigurator().doConfigure(configStream, LogManager.getLoggerRepository()); } else { System.out.println("Error reading log configurstion file. Could not initialize logger."); } } finally{ if(configStream != null){ try { configStream.close(); } catch (IOException e) { e.printStackTrace(); } } } isInitialized = true; }
/** * Flush the appenders for all of the active loggers */ public static void flushAllLogs() { LoggerRepository loggerRepo = LogManager.getLoggerRepository(); for (Logger logger : CollectionUtil.iterable(loggerRepo.getCurrentLoggers(), Logger.class)) { LoggerUtil.flushLogs(logger); } // FOR }
/** * Destroys the server. * <p> * All services are destroyed in reverse order of initialization, then the * Log4j framework is shutdown. */ public void destroy() { ensureOperational(); destroyServices(); log.info("Server [{}] shutdown!", name); log.info("======================================================"); if (!Boolean.getBoolean("test.circus")) { LogManager.shutdown(); } status = Status.SHUTDOWN; }
public Page handle(URL url) { long size = 0; String content = ""; String modified = "Not exist"; if (file != null && file.exists()) { try { FileInputStream fis = new FileInputStream(file); FileChannel channel = fis.getChannel(); size = channel.size(); ByteBuffer bb; if (size <= SHOW_LOG_LENGTH) { bb = ByteBuffer.allocate((int) size); channel.read(bb, 0); } else { int pos = (int) (size - SHOW_LOG_LENGTH); bb = ByteBuffer.allocate(SHOW_LOG_LENGTH); channel.read(bb, pos); } bb.flip(); content = new String(bb.array()).replace("<", "<") .replace(">", ">").replace("\n", "<br/><br/>"); modified = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") .format(new Date(file.lastModified())); } catch (IOException e) { } } Level level = LogManager.getRootLogger().getLevel(); List<List<String>> rows = new ArrayList<List<String>>(); List<String> row = new ArrayList<String>(); row.add(content); rows.add(row); return new Page("Log", "Log", new String[] {(file == null ? "" : file.getName()) + ", " + size + " bytes, " + modified + ", " + level}, rows); }
/** * Send an event to the logging system * * @param event the event to send */ private void sendEvent( LoggingEvent event ) { // check if this level is allowed for the repository at all if (LogManager.getLoggerRepository().isDisabled(event.getLevel().toInt())) { return; } // check if the event level is allowed for this logger if (event.getLevel().isGreaterOrEqual(logger.getEffectiveLevel())) { logger.callAppenders(event); } }
@Test public void testWriteHeaderAndFooter() throws Exception { initialize("TestCloudWatchAppender/testWriteHeaderAndFooter.properties"); logger.debug("blah blah blah"); // must retrieve writer before we shut down MockCloudWatchWriter mockWriter = appender.getMockWriter(); LogManager.shutdown(); assertEquals("number of messages written to log", 3, mockWriter.messages.size()); assertEquals("header is first", HeaderFooterLayout.HEADER, mockWriter.getMessage(0)); assertEquals("footer is last", HeaderFooterLayout.FOOTER, mockWriter.getMessage(2)); }
/** * Set logging level to given value. If not explicitly * specified, default level is used from *logger* properties file. * (As of the time writing - simplelogger.properties is used as default.) * <p/> * NOTE: SLF4J is not capable of changing log levels programatically! * We have to change the System/File property of given underlying logger. * * @param logLevel logging level to be logger set to */ public static void setLogLevel(String logLevel) { org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger("com.redhat.mqe.jms"); Level level; switch (logLevel.toLowerCase()) { case "all": level = Level.ALL; break; case "trace": level = Level.TRACE; break; case "debug": level = Level.DEBUG; break; case "info": level = Level.INFO; break; case "warn": level = Level.WARN; break; case "error": level = Level.ERROR; break; case "fatal": level = Level.FATAL; break; case "off": level = Level.OFF; break; default: level = Level.INFO; } LogManager.getRootLogger().setLevel(level); logger.setLevel(level); }
@Test public void testWriteHeaderAndFooter() throws Exception { initialize("TestKinesisAppender/testWriteHeaderAndFooter.properties"); logger.debug("blah blah blah"); // must retrieve writer before we shut down MockKinesisWriter writer = appender.getMockWriter(); LogManager.shutdown(); assertEquals("number of messages written to log", 3, writer.messages.size()); assertEquals("header is first", HeaderFooterLayout.HEADER, writer.getMessage(0)); assertEquals("footer is last", HeaderFooterLayout.FOOTER, writer.getMessage(2)); }
/** * Loads the test-specific Log4J configuration and resets the environment. */ public void setUp(String propertiesName, String logGroupName) throws Exception { URL config = ClassLoader.getSystemResource(propertiesName); assertNotNull("missing configuration: " + propertiesName, config); LogManager.resetConfiguration(); PropertyConfigurator.configure(config); localLogger = Logger.getLogger(getClass()); localClient = AWSLogsClientBuilder.defaultClient(); deleteLogGroupIfExists(logGroupName); }
/** * Loads the test-specific Log4J configuration and resets the environment. */ public void setUp(String propertiesName, String streamName) throws Exception { URL config = ClassLoader.getSystemResource(propertiesName); assertNotNull("missing configuration: " + propertiesName, config); LogManager.resetConfiguration(); PropertyConfigurator.configure(config); localLogger = Logger.getLogger(getClass()); localClient = AmazonKinesisClientBuilder.defaultClient(); deleteStreamIfExists(streamName); }
public static void main(String[] args) { System.setProperty("hadoop.home.dir", "E:\\sumitK\\Hadoop"); SparkSession sparkSession = SparkSession .builder() .master("local") .config("spark.sql.warehouse.dir","file:///E:/sumitK/Hadoop/warehouse") .appName("JavaALSExample") .getOrCreate(); Logger rootLogger = LogManager.getRootLogger(); rootLogger.setLevel(Level.WARN); HashMap<String, String> params = new HashMap<String, String>(); params.put("rowTag", "food"); params.put("failFast", "true"); Dataset<Row> docDF = sparkSession.read() .format("com.databricks.spark.xml") .options(params) .load("C:/Users/sumit.kumar/git/learning/src/main/resources/breakfast_menu.xml"); docDF.printSchema(); docDF.show(); docDF.write().format("com.databricks.spark.xml") .option("rootTag", "food") .option("rowTag", "food") .save("C:/Users/sumit.kumar/git/learning/src/main/resources/newMenu.xml"); }
public static void main(String[] args) { //Window Specific property if Hadoop is not instaalled or HADOOP_HOME is not set System.setProperty("hadoop.home.dir", "E:\\hadoop"); //Logger rootLogger = LogManager.getRootLogger(); //rootLogger.setLevel(Level.WARN); SparkConf conf = new SparkConf().setAppName("KafkaExample").setMaster("local[*]"); String inputDirectory="E:\\hadoop\\streamFolder\\"; JavaSparkContext sc = new JavaSparkContext(conf); JavaStreamingContext streamingContext = new JavaStreamingContext(sc, Durations.seconds(1)); // streamingContext.checkpoint("E:\\hadoop\\checkpoint"); Logger rootLogger = LogManager.getRootLogger(); rootLogger.setLevel(Level.WARN); JavaDStream<String> streamfile = streamingContext.textFileStream(inputDirectory); streamfile.print(); streamfile.foreachRDD(rdd-> rdd.foreach(x -> System.out.println(x))); JavaPairDStream<LongWritable, Text> streamedFile = streamingContext.fileStream(inputDirectory, LongWritable.class, Text.class, TextInputFormat.class); streamedFile.print(); streamingContext.start(); try { streamingContext.awaitTermination(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public static synchronized void syncLogsShutdown( ScheduledExecutorService scheduler) { // flush standard streams // System.out.flush(); System.err.flush(); if (scheduler != null) { scheduler.shutdownNow(); } // flush & close all appenders LogManager.shutdown(); }
@Test public void testLog4jAppenderFailureUnsafeMode() throws Throwable { configureSource(); props.setProperty("log4j.appender.out2.UnsafeMode", String.valueOf(true)); PropertyConfigurator.configure(props); Logger logger = LogManager.getLogger(TestLog4jAppender.class); source.stop(); sendAndAssertFail(logger); }