public ConsoleManager(GlowServer server) {
this.server = server;
// install Ansi code handler, which makes colors work on Windows
AnsiConsole.systemInstall();
for (Handler h : logger.getHandlers()) {
logger.removeHandler(h);
}
// used until/unless gui is created
consoleHandler = new FancyConsoleHandler();
// consoleHandler.setFormatter(new DateOutputFormatter(CONSOLE_DATE));
logger.addHandler(consoleHandler);
// todo: why is this here?
Runtime.getRuntime().addShutdownHook(new ServerShutdownThread());
// reader must be initialized before standard streams are changed
try {
reader = new ConsoleReader();
} catch (IOException ex) {
logger.log(Level.SEVERE, "Exception initializing console reader", ex);
}
reader.addCompleter(new CommandCompleter());
// set system output streams
System.setOut(new PrintStream(new LoggerOutputStream(Level.INFO), true));
System.setErr(new PrintStream(new LoggerOutputStream(Level.WARNING), true));
}
public static synchronized void createLoggers(boolean reinit) {
if (m_initialized == true && reinit == false) {
return;
}
if (!m_initialized) {
Logger.getLogger("").removeHandler(Logger.getLogger("").getHandlers()[0]);
}
if (m_initialized) {
m_severeLogger.removeHandler(m_severeLogger.getHandlers()[0]);
m_nonSevereLogger.removeHandler(m_nonSevereLogger.getHandlers()[0]);
}
Handler severeHandler = new AMyConsoleHandler(System.err);
severeHandler.setFormatter(new SingleLineFormatter());
m_severeLogger.addHandler(severeHandler);
m_severeLogger.setLevel(getLoggingLevel());
Handler nonSevereHandler = new AMyConsoleHandler(System.out);
nonSevereHandler.setFormatter(new SingleLineFormatter());
m_nonSevereLogger.addHandler(nonSevereHandler);
m_nonSevereLogger.setLevel(getLoggingLevel());
m_initialized = true;
}
/** Sets up the file logging for debugging purposes. */
private static void setUpLogger() {
try {
LogManager.getLogManager().reset();
logger.setUseParentHandlers(false);
// Log file
FileHandler loggingFileHandler = new FileHandler("./log" + playerNumber + ".log");
loggingFileHandler.setLevel(Level.ALL);
// Console logging
ConsoleHandler loggingConsoleHandler = new ConsoleHandler();
loggingConsoleHandler.setLevel(Level.OFF);
// Remove old handlers
Handler[] handlers = Logger.getGlobal().getHandlers();
for (Handler handler : handlers) {
Logger.getGlobal().removeHandler(handler);
}
// Add logging handlers
logger.addHandler(loggingFileHandler);
logger.addHandler(loggingConsoleHandler);
System.setProperty(
"java.util.logging.SimpleFormatter.format",
"%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %2$s %4$s: %5$s%n");
SimpleFormatter simpleFormatter = new SimpleFormatter();
loggingFileHandler.setFormatter(simpleFormatter);
logger.setLevel(Level.ALL);
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void testCMSAdaptiveSizePolicyPrintHeapAtGC() throws Exception {
TestLogHandler handler = new TestLogHandler();
handler.setLevel(Level.WARNING);
IMP_LOGGER.addHandler(handler);
DATA_READER_FACTORY_LOGGER.addHandler(handler);
ByteArrayInputStream in =
new ByteArrayInputStream(
("2012-04-18T14:48:31.855+0200: 29.592: [GC 29.592: [ASParNew: 52825K->6499K(59008K), 0.0268761 secs] 120805K->120749K(517760K), 0.0269605 secs] [Times: user=0.05 sys=0.00, real=0.03 secs]"
+ "\nHeap"
+ "\nadaptive size par new generation total 59008K, used 15368K [0x00000000d8000000, 0x00000000dc000000, 0x00000000dc000000)"
+ "\n eden space 52480K, 16% used [0x00000000d8000000, 0x00000000d88a95a0, 0x00000000db340000)"
+ "\n from space 6528K, 99% used [0x00000000db340000, 0x00000000db998cb0, 0x00000000db9a0000)"
+ "\n to space 6528K, 0% used [0x00000000db9a0000, 0x00000000db9a0000, 0x00000000dc000000)"
+ "\nconcurrent mark-sweep generation total 458752K, used 259541K [0x00000000dc000000, 0x00000000f8000000, 0x00000000f8000000)"
+ "\nconcurrent-mark-sweep perm gen total 65536K, used 2621K [0x00000000f8000000, 0x00000000fc000000, 0x0000000100000000)")
.getBytes());
final DataReader reader = new DataReaderSun1_6_0(in, GcLogType.SUN1_6);
GCModel model = reader.read();
assertEquals("GC count", 1, model.size());
assertEquals("GC pause", 0.0269605, model.getGCPause().getMin(), 0.000000001);
assertEquals("number of errors", 0, handler.getCount());
}
public void handleInit(QuickServer quickserver) throws Exception {
Logger logger = null;
FileHandler xmlLog = null;
File log = new File("./log/");
if (!log.canRead()) log.mkdir();
try {
logger = Logger.getLogger("");
logger.setLevel(Level.FINEST);
logger = Logger.getLogger("org.quickserver.net.qsadmin");
xmlLog = new FileHandler("log/FtpServer_QSAdmin%u%g.xml", 1024 * 1024, 20, true);
xmlLog.setLevel(Level.FINEST);
logger.addHandler(xmlLog);
logger = Logger.getLogger("org.quickserver");
xmlLog = new FileHandler("log/FtpServer_QuickServer%u%g.xml", 1024 * 1024, 20, true);
xmlLog.setLevel(Level.FINEST);
logger.addHandler(xmlLog);
logger = Logger.getLogger("ftpserver");
xmlLog = new FileHandler("log/FtpServer%u%g.xml", 1024 * 1024, 20, true);
xmlLog.setLevel(Level.FINEST);
logger.addHandler(xmlLog);
quickserver.setAppLogger(logger); // img
} catch (IOException e) {
System.err.println("Could not create txtLog FileHandler : " + e);
throw e;
}
}
/**
* Test parsing of a malformed type. The test just expects an INFO to be logged - nothing else.
*/
@Test
public void testMalformedType() throws Exception {
TestLogHandler handler = new TestLogHandler();
handler.setLevel(Level.INFO);
IMP_LOGGER.addHandler(handler);
DATA_READER_FACTORY_LOGGER.addHandler(handler);
ByteArrayInputStream in =
new ByteArrayInputStream(
("[memory ][Thu Feb 21 15:06:38 2013][11844] 6.290-6.424: GC-malformed 3128161K->296406K (3145728K), sum of pauses 59.084 ms")
.getBytes());
DataReader reader = new DataReaderJRockit1_5_0(in);
reader.read();
// 3 INFO events:
// Reading JRockit ... format
// Failed to determine type ...
// Reading done.
assertEquals("number of infos", 3, handler.getCount());
List<LogRecord> logRecords = handler.getLogRecords();
assertEquals(
"should start with 'Failed to determine type'",
0,
logRecords.get(1).getMessage().indexOf("Failed to determine type"));
}
/**
* Private constructor
*
* @throws SimulatorException
*/
private SimulatorLogger() throws SimulatorException {
try {
config = SimulatorConfig.getInstance();
logger = Logger.getLogger("it.univaq.mancoosi.simulator");
if (config.isConsoleLog() || config.isSaveFileLog()) {
if (config.isConsoleLog()) {
logger.setUseParentHandlers(false);
Handler ch = new MyHandler();
logger.addHandler(ch);
}
if (config.isSaveFileLog()) {
fh = new FileHandler(config.getDirLog() + "log_" + getTime() + ".txt");
fh.setFormatter(new SimpleFormatter());
logger.addHandler(fh);
}
logger.setLevel(Level.ALL);
} else {
logger.setLevel(Level.OFF);
}
} catch (SecurityException e) {
throw new SimulatorException("Error logger security ", e);
} catch (IOException e) {
throw new SimulatorException("IO error in logger", e);
}
}
// init logger
public CommandParser() {
try {
FileHandler fileHandler = new FileHandler(LOGGERNAME);
logger.addHandler(fileHandler);
SimpleFormatter formatter = new SimpleFormatter();
fileHandler.setFormatter(formatter);
logger.addHandler(fileHandler);
} catch (Exception e) {
e.printStackTrace();
}
}
@Before
public void setUp() throws FileNotFoundException, IOException {
outStream = new FileOutputStream(basedir + "/target/run-junit-embed.log", true);
Handler handler = new StreamHandler(outStream, new SimpleFormatter());
logger0.addHandler(handler);
logger0.setUseParentHandlers(false);
logger0.setLevel(Level.INFO);
logger1.setUseParentHandlers(false);
logger1.addHandler(new ConsoleHandler());
logger1.setLevel(Level.WARNING);
writer = new FileWriter(basedir + "/target/run-junit-embed.txt", true);
}
@Before
public void setUp() throws FileNotFoundException {
System.setProperty("org.jruby.embed.localcontext.scope", "threadsafe");
outStream = new FileOutputStream(basedir + "/build/test-results/run-junit-embed.log", true);
Handler handler = new StreamHandler(outStream, new SimpleFormatter());
logger0.addHandler(handler);
logger0.setUseParentHandlers(false);
logger0.setLevel(Level.INFO);
logger1.setUseParentHandlers(false);
logger1.addHandler(new ConsoleHandler());
logger1.setLevel(Level.WARNING);
}
@SuppressWarnings("unused")
private void InitializeLogger() {
logger = Logger.getLogger(getClass().getName());
// remove root handlers and disable any references to root handlers
logger.setUseParentHandlers(false);
Logger globalLogger = Logger.getLogger("global");
Handler[] handlers = globalLogger.getHandlers();
for (Handler handler : handlers) {
globalLogger.removeHandler(handler);
}
// add handlers
try {
fileHandler = new FileHandler(logFile, 10000, 1);
} catch (SecurityException e1) {
System.out.println("FileHandler SecurityException!");
e1.printStackTrace();
} catch (IOException e1) {
System.out.println("FileHandler IOException!");
e1.printStackTrace();
}
try {
fileHandler.setEncoding("UTF8");
} catch (SecurityException e1) {
System.out.println("setEncoding SecurityException!");
e1.printStackTrace();
} catch (UnsupportedEncodingException e1) {
System.out.println("setEncoding IOException!");
e1.printStackTrace();
}
logger.addHandler(fileHandler);
logger.addHandler(fileHandler);
if (Debug && Explanation) {
logLevel = Level.FINEST;
} else if (Debug && !Explanation) {
logLevel = Level.FINE;
} else if (!Debug && Explanation) {
logLevel = Level.INFO;
} else if (!Debug && !Explanation) {
logLevel = Level.SEVERE;
}
// set level and formatter
logger.setLevel(logLevel);
OysterExplanationFormatter formatter = new OysterExplanationFormatter();
fileHandler.setFormatter(formatter);
}
private static void initLogger() {
try {
File logFile = new File(DATA_SOURCE + "log.log");
FileHandler fileHandler = new FileHandler(logFile.getCanonicalPath(), true);
fileHandler.setFormatter(new LogFormatter());
LOG.addHandler(fileHandler);
LOG.addHandler(new ConsoleHandler());
LOG.setLevel(Level.INFO);
LOG.setUseParentHandlers(false);
} catch (IOException e) {
System.err.println("ERROR: Setting the logger failed!");
throw new ServiceFailureException("Setting the logger failed!");
}
}
@Test
public void testPrintHeapAtGC() throws Exception {
TestLogHandler handler = new TestLogHandler();
handler.setLevel(Level.WARNING);
IMP_LOGGER.addHandler(handler);
DATA_READER_FACTORY_LOGGER.addHandler(handler);
final InputStream in = getClass().getResourceAsStream("SampleSun1_6_0PrintHeapAtGC.txt");
final DataReader reader = new DataReaderSun1_6_0(in, GcLogType.SUN1_6);
GCModel model = reader.read();
assertEquals("GC count", 2, model.size());
assertEquals("GC pause", 0.0134287, model.getGCPause().getMin(), 0.000000001);
assertEquals("number of errors", 0, handler.getCount());
}
{
logger.setUseParentHandlers(false);
logger.setLevel(Level.INFO);
ConsoleHandler handler = new ConsoleHandler();
handler.setLevel(Level.INFO);
logger.addHandler(handler);
}
public void testReset() throws SecurityException, IOException {
// mock LogManager
mockManager.readConfiguration(EnvironmentHelper.PropertiesToInputStream(props));
assertNotNull(mockManager.getProperty("handlers"));
Logger foo = new MockLogger(FOO, null);
assertNull(foo.getLevel());
assertEquals(0, foo.getHandlers().length);
foo.setLevel(Level.ALL);
foo.addHandler(new ConsoleHandler());
assertTrue(mockManager.addLogger(foo));
assertEquals(Level.WARNING, foo.getLevel());
assertEquals(2, foo.getHandlers().length);
// reset
mockManager.reset();
// properties is cleared
assertNull(mockManager.getProperty("handlers"));
// level is null
assertNull(foo.getLevel());
// handlers are all closed
assertEquals(0, foo.getHandlers().length);
// for root logger
manager.reset();
assertNull(manager.getProperty("handlers"));
Logger root = manager.getLogger("");
// level reset to info
assertEquals(Level.INFO, root.getLevel());
// also close root's handler
assertEquals(0, root.getHandlers().length);
}
@Command(
aliases = {"reload"},
desc = "Reload WorldGuard configuration",
max = 0)
@CommandPermissions({"worldguard.reload"})
public void reload(CommandContext args, CommandSender sender) throws CommandException {
LoggerToChatHandler handler = null;
Logger minecraftLogger = null;
if (sender instanceof Player) {
handler = new LoggerToChatHandler(sender);
handler.setLevel(Level.ALL);
minecraftLogger = Logger.getLogger("Minecraft");
minecraftLogger.addHandler(handler);
}
try {
plugin.getGlobalStateManager().unload();
plugin.getGlobalRegionManager().unload();
plugin.getGlobalStateManager().load();
plugin.getGlobalRegionManager().preload();
WGBukkit.cleanCache();
sender.sendMessage("WorldGuard configuration reloaded.");
} catch (Throwable t) {
sender.sendMessage("Error while reloading: " + t.getMessage());
} finally {
if (minecraftLogger != null) {
minecraftLogger.removeHandler(handler);
}
}
}
void initLogger() {
final boolean VERBOSE_LOGGING = true;
final int LOG_SIZE = 512 * 1024; // max log file size (in bytes)
Logger globalLogger = Logger.getLogger("");
// Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME); // doesn't work on os x
if (VERBOSE_LOGGING) {
globalLogger.setLevel(Level.INFO);
} else {
globalLogger.setLevel(Level.WARNING);
}
// enable logging to file
try {
// settings is writable for built-in modes, mode folder is not writable
File logFolder = Base.getSettingsFile("debug");
if (!logFolder.exists()) {
logFolder.mkdir();
}
File logFile = new File(logFolder, "DebugMode.%g.log");
Handler handler = new FileHandler(logFile.getAbsolutePath(), LOG_SIZE, 10, false);
globalLogger.addHandler(handler);
} catch (IOException ex) {
Logger.getLogger(JavaMode.class.getName()).log(Level.SEVERE, null, ex);
} catch (SecurityException ex) {
Logger.getLogger(JavaMode.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void preprocess(Run run) {
File logFile = new File(getRunDir(run), "genetik.log");
try {
SimpleFileHandler fh = new SimpleFileHandler(logFile);
fh.setFormatter(new CompactFormatter());
Logger logger = Logger.getLogger(GenetikConstants.LOGGER);
logger.setLevel(Level.INFO);
logger.setUseParentHandlers(false);
Handler handlers[] = logger.getHandlers();
logger.addHandler(fh);
for (Handler h : handlers) {
logger.removeHandler(h);
if (h instanceof SimpleFileHandler) h.close(); // close our old one
}
} catch (Exception exp) {
throw new IllegalArgumentException(
"Unable to create log file at " + logFile.getAbsolutePath());
}
super.preprocess(run);
}
@Override
public File[] getFiles(uSkyBlock plugin) {
log = plugin.getLogger();
try {
if (handler == null) {
handler =
new FileHandler(plugin.getDataFolder() + File.separator + "name2uuid-report.log", true);
handler.setFormatter(new SimpleFormatter());
} else {
log.removeHandler(handler);
}
log.addHandler(handler);
log.setUseParentHandlers(false);
} catch (IOException e) {
log.severe("Unable to create file-logging to a report.log file");
}
name2uuid.clear();
this.plugin = plugin;
File[] playerFiles = new File(plugin.getDataFolder(), "players").listFiles(YML_FILES);
File[] islandFiles = new File(plugin.getDataFolder(), "islands").listFiles(YML_FILES);
File[] files = new File[islandFiles.length + playerFiles.length];
System.arraycopy(playerFiles, 0, files, 0, playerFiles.length);
System.arraycopy(islandFiles, 0, files, playerFiles.length, islandFiles.length);
return files;
}
private synchronized void enterSimulationLog(int simulationID) {
exitSimulationLog();
if (rootFileHandler != null) {
LogFormatter.separator(log, Level.FINE, "Entering log for simulation " + simulationID);
try {
Logger root = Logger.getLogger("");
String name = logSimPrefix + "_SIM_" + simulationID + ".log";
simLogHandler = new FileHandler(name, true);
simLogHandler.setFormatter(formatter);
simLogHandler.setLevel(rootFileHandler.getLevel());
simLogName = name;
root.addHandler(simLogHandler);
root.removeHandler(rootFileHandler);
LogFormatter.separator(
log,
Level.FINE,
"Log for simulation "
+ simulationID
+ " at "
+ serverHost
+ ':'
+ serverPort
+ " started");
} catch (Exception e) {
log.log(Level.SEVERE, "could not open log file for simulation " + simulationID, e);
}
}
}
@Override
public void close() {
Logger l = this.logger;
if (getLevel() != Level.OFF && l != null) {
l.addHandler(this);
}
}
/** Construct a new BasicWMSRenderer */
public BasicWMSRenderer2() {
ClassLoader current = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(WebMapServer.class.getClassLoader());
Logger logger = Logger.getLogger("org.geotools.data.ows"); // $NON-NLS-1$
if (WMSPlugin.isDebugging(Trace.RENDER)) {
logger.setLevel(Level.FINE);
logger.addHandler(
new Handler() {
@Override
public void publish(LogRecord record) {
System.err.println(record.getMessage());
}
@Override
public void flush() {
System.err.flush();
}
@Override
public void close() throws SecurityException {}
});
} else {
logger.setLevel(Level.SEVERE);
}
} finally {
Thread.currentThread().setContextClassLoader(current);
}
}
private UnexpectedErrorLogger() throws SecurityException, IOException {
handler = new FileHandler("UnexpecterErrorLogger");
formatter = new SimpleFormatter();
handler.setFormatter(formatter);
logger.addHandler(handler);
}
/** Sets the level and the handler of the root-logger. */
private void configLogger() {
Logger rootLogger = Logger.getLogger("");
rootLogger.setLevel(Level.FINE);
rootLogger.addHandler(LogHandler.get());
GWT.setUncaughtExceptionHandler(this);
}
private void setupLogging() throws IOException {
System.out.println("Setting up logging...");
Level level = LogHelper.getLogLevel(m_testData.getLogLevel());
if (level == null) {
System.err.println("No such log level and will use Level.INFO instead");
level = Level.INFO;
}
fh = new FileHandler(m_testData.getLogFile(), false);
// have to change the log level of the handler to let log come out as designed
fh.setLevel(level);
// change the formatter from default xml to simple text
fh.setFormatter(new SimpleFormatter());
theLogger.setLevel(level);
theLogger.addHandler(fh);
// close the Console handler so that we only need log in file
Handler[] handlers = Logger.getLogger("").getHandlers();
for (Handler handler : handlers) {
if (handler instanceof ConsoleHandler) {
handler.setLevel(Level.OFF);
break;
}
}
}
@BeforeClass
public static void setUp() {
Logger logger = NanoBench.getLogger();
logger.setUseParentHandlers(false);
logger.setLevel(Level.INFO);
logger.addHandler(new ConsoleHandler());
}
@Test
public void testServiceWithDSLLogger() throws Exception {
final Logger logger = Logger.getLogger(BaseDslScript.class.getName());
final DSLLoggerHandler handler = new DSLLoggerHandler();
logger.addHandler(handler);
final File dir = new File(TEST_PARSING_RESOURCE_BASE + "logger");
final Service service = ServiceReader.getServiceFromDirectory(dir).getService();
Assert.assertNotNull(service);
Assert.assertTrue(
"Println logger not found", handler.getMessages().contains("println logger call"));
Assert.assertTrue(
"Print logger not found", handler.getMessages().contains("print logger call"));
Assert.assertTrue(
"Class println not found", handler.getMessages().contains("Test Class println"));
Assert.assertTrue("Class print not found", handler.getMessages().contains("Test Class print"));
Assert.assertFalse(
"preInstall event message appeared before expected",
handler.getMessages().contains("This is the preInstall event"));
final ExecutableDSLEntry preInstall = service.getLifecycle().getPreInstall();
final ClosureExecutableEntry preInstallClosureEntry = (ClosureExecutableEntry) preInstall;
preInstallClosureEntry.getCommand().call();
Assert.assertTrue(
"preInstall event message not found",
handler.getMessages().contains("This is the preInstall event"));
}
/**
* Creates a fileLogger.
*
* @return A Logger named with 'id'.
* @throws IOException
* @throws SecurityException
*/
public static Logger createFileLogger(String id, String filePattern, boolean append)
throws SecurityException, IOException {
Logger logger = Logger.getLogger(id);
Handler handler = new FileHandler(filePattern, append);
logger.addHandler(handler);
return logger;
}
/**
* Writes log file when tweets sent.
*
* @param numberOfTweets Number of tweets sent
* @param tweetedTrends Trends tweeted about
*/
public void log(int numberOfTweets, String[] tweetedTrends) {
String trends = "";
for (String tweetedTrend : tweetedTrends) {
if (tweetedTrend.equals("")) break;
else trends += tweetedTrend + ", ";
}
if (!(trends.equals(""))) trends = trends.substring(0, trends.length() - 2) + ".";
try {
fh = new FileHandler(PATH_TO_LOG_FILE, LOG_FILE_SIZE_LIMIT, 1, true);
logger.addHandler(fh);
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
if (numberOfTweets == 0) logger.warning("No tweets sent.");
else logger.info("Tweets sent: " + numberOfTweets + ". Trends tweeted about: " + trends);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void init() {
try {
DateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy HH-mm-ss");
Calendar cal = Calendar.getInstance();
String fileName = "log " + dateFormat.format(cal.getTime()) + ".txt";
File f = new File("logs");
if (!f.exists()) f.mkdir();
fh = new FileHandler("logs/" + fileName);
logger = Logger.getLogger("MyLog");
logger.addHandler(fh);
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
// Comment next line to make logger put into file everything from level INFO
// Now it will log only errors (severe)
logger.setLevel(Level.WARNING);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}