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;
}
}
}
public DebugLog(String l, String f) {
super(l, null);
try {
handler = new FileHandler(f, true);
addHandler(handler);
setLevel(Level.ALL);
handler.setFormatter(formatter);
} catch (Exception e) {
System.out.println("Error creating logger '" + l + "': ");
e.printStackTrace();
}
}
private static void configLogging() {
// Logger globalLogger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
Logger globalLogger = Logger.getLogger("");
try {
for (Handler h : globalLogger.getHandlers()) globalLogger.removeHandler(h);
FileHandler fh = new FileHandler("schedule-creation-log.txt");
fh.setFormatter(new CleanFormatter());
globalLogger.addHandler(fh);
globalLogger.setLevel(Level.ALL);
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
/**
* startLogger initializes and returns a file at logLoc with the results of logging at level
* logLevel.
*
* @param logLoc location of the output log file- a string
* @param logLevel logging level (is parsed by level.parse())
* @return Logger object to log to.
*/
public Logger startLogger(String logLoc, String logLevel) {
try {
fh = new FileHandler(logLoc); // sets output log file at logLoc
} catch (SecurityException e) {
e.printStackTrace();
System.err.println("SecurityException establishing logger. Exiting...\n");
System.exit(1);
} catch (IOException e) {
e.printStackTrace();
System.err.println("IOException establishing logger. Exiting...\n");
System.exit(1);
}
fh.setFormatter(new SimpleFormatter()); // format of log is 'human-readable' simpleformat
logger.addHandler(fh); // attach formatter to logger
logger.setLevel(Level.parse(logLevel)); // set log level
return logger;
}
/** Set up reflection methods required by the loader */
@SuppressWarnings("unchecked")
private boolean prepareLoader() {
try {
// addURL method is used by the class loader to
mAddUrl = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
mAddUrl.setAccessible(true);
Formatter minecraftLogFormatter = null;
try {
Class<? extends Formatter> formatterClass =
(Class<? extends Formatter>)
Minecraft.class
.getClassLoader()
.loadClass(
ModUtilities.getObfuscatedFieldName(
"net.minecraft.src.ConsoleLogFormatter", "em"));
Constructor<? extends Formatter> defaultConstructor =
formatterClass.getDeclaredConstructor();
defaultConstructor.setAccessible(true);
minecraftLogFormatter = defaultConstructor.newInstance();
} catch (Exception ex) {
ConsoleLogManager.init();
minecraftLogFormatter = ConsoleLogManager.loggerLogManager.getHandlers()[0].getFormatter();
}
logger.setUseParentHandlers(false);
StreamHandler consoleHandler = new ConsoleHandler();
if (minecraftLogFormatter != null) consoleHandler.setFormatter(minecraftLogFormatter);
logger.addHandler(consoleHandler);
FileHandler logFileHandler =
new FileHandler(
new File(Minecraft.getMinecraftDir(), "LiteLoader.txt").getAbsolutePath());
if (minecraftLogFormatter != null) logFileHandler.setFormatter(minecraftLogFormatter);
logger.addHandler(logFileHandler);
} catch (Throwable th) {
logger.log(Level.SEVERE, "Error initialising LiteLoader", th);
return false;
}
return true;
}
public static FileHandler getIrcFileHandler() {
createLogDir();
try {
FileHandler file = new FileHandler(LOG_FILE_IRC, MAX_LOG_SIZE, 2, true);
file.setFormatter(
new Formatter() {
@Override
public String format(LogRecord record) {
return String.format(
"[%1$tT] %2$s\n", new Date(record.getMillis()), record.getMessage());
}
});
file.setLevel(Level.INFO);
return file;
} catch (IOException | SecurityException ex) {
Logger.getLogger(Logging.class.getName()).log(Level.WARNING, null, ex);
}
return null;
}
private void initLogger() {
ConsoleHandler consoleHandler = null;
Logger rootLogger = LogManager.getLogManager().getLogger("");
Handler[] handlers = rootLogger.getHandlers();
for (Handler handler : handlers) {
if (handler instanceof ConsoleHandler) {
consoleHandler = (ConsoleHandler) handler;
rootLogger.removeHandler(handler);
}
}
logger = Logger.getLogger(contextId);
logger.setLevel(logLevel);
if (!logLevel.equals(Level.OFF)) {
LogFormatter formatter = new LogFormatter();
if (consoleLog) {
if (consoleHandler == null) {
consoleHandler = new ConsoleHandler();
}
consoleHandler.setFormatter(formatter);
consoleHandler.setLevel(logLevel);
logger.addHandler(consoleHandler);
}
String userHomePath = getProperty("user.home", ".");
File logDir = new File(userHomePath, '.' + contextId + "/log");
logDir.mkdirs();
String logFilePattern = new File(logDir, contextId + "-%g.log").getPath();
try {
FileHandler fileHandler = new FileHandler(logFilePattern);
fileHandler.setFormatter(formatter);
fileHandler.setLevel(logLevel);
logger.addHandler(fileHandler);
} catch (IOException e) {
System.err.println("Error: Failed to create log file: " + logFilePattern);
}
}
}
/**
* If param b is set to true, starts the necessary threads to monitor the process' stdout/stderr
* and transfer the contents to a log file.
*/
protected void setNativeLoggingUsed(boolean b) {
if (b) {
mServerStatus.setLogNative(shouldIndicateNativeLogging());
FileHandler fileHandler = null;
try {
String logLocation = LogUtil.getLogLocation();
int logFileSize = -1;
try {
logFileSize = DCPLib.getIntProperty("Logging.Servers." + mName + ".logFileSize");
} catch (NoSuchProperty nsp) {
logFileSize =
DCPLib.getIntProperty(
"Logging.Defaults.logFileSize", CiscoLogger.DEFAULT_LOG_FILE_SIZE);
}
int logFileNumber = -1;
try {
logFileNumber = DCPLib.getIntProperty("Logging.Servers." + mName + ".logFileNumber");
} catch (NoSuchProperty nsp) {
logFileNumber =
DCPLib.getIntProperty(
"Logging.Defaults.logFileNumber", CiscoLogger.DEFAULT_LOG_FILE_NUMBER);
}
if (LogUtil.getAppType().equals("unknown")) {
fileHandler =
new FileHandler(
logLocation + File.separator + getProcessNameForLog(),
logFileSize,
logFileNumber);
} else {
fileHandler =
new FileHandler(
logLocation
+ File.separator
+ LogUtil.getAppType()
+ "."
+ LogUtil.getAppInst()
+ "."
+ getProcessNameForLog(),
logFileSize,
logFileNumber);
}
fileHandler.setFormatter(
new java.util.logging.SimpleFormatter() {
public synchronized String format(LogRecord record) {
return formatMessage(record) + "\n";
}
});
} catch (Exception ex) {
mLogger.severe("Could not set up native handler for external process", ex);
}
mStdout = new ServerOutputThread(mName + ".stdout", mLogger, fileHandler);
mStderr = new ServerOutputThread(mName + ".stderr", mLogger, fileHandler);
// Get them running
mStdout.start();
mStderr.start();
}
mNativeLoggingUsed = b;
}
public Logging(final TwitchClient client) {
createLogDir();
// Remove default handlers
LogManager.getLogManager().reset();
// Add console handler with custom formatter
ConsoleHandler c = new ConsoleHandler();
c.setFormatter(new TextFormatter());
c.setFilter(
new Filter() {
@Override
public boolean isLoggable(LogRecord record) {
return record.getLevel() != USERINFO;
}
});
Logger.getLogger("").addHandler(c);
// Add file handler with custom formatter
try {
FileHandler file = new FileHandler(LOG_FILE, MAX_LOG_SIZE, MAX_LOG_FILES, true);
file.setFormatter(new TextFormatter());
file.setLevel(Level.INFO);
file.setFilter(new FileFilter());
Logger.getLogger("").addHandler(file);
FileHandler fileSession = new FileHandler(LOG_FILE_SESSION, MAX_SESSION_LOG_SIZE, 1);
fileSession.setFormatter(new TextFormatter());
fileSession.setLevel(Level.INFO);
fileSession.setFilter(new FileFilter());
Logger.getLogger("").addHandler(fileSession);
} catch (IOException | SecurityException ex) {
Logger.getLogger(Logging.class.getName()).log(Level.WARNING, null, ex);
}
// Add handler for the GUI (display errors, log into debug window)
Logger.getLogger("")
.addHandler(
new Handler() {
@Override
public void publish(LogRecord record) {
if (record.getLevel() != USERINFO) {
client.debug(record.getMessage());
// WebsocketClient/WebsocketManager
if (record.getSourceClassName().startsWith("chatty.util.ffz.Websocket")) {
client.debugFFZ(record.getMessage());
}
}
if (record.getLevel() == Level.SEVERE) {
if (client.g != null) {
client.g.error(record, lastMessages.getItems());
}
} else if (record.getLevel() == USERINFO) {
client.warning(record.getMessage());
} else {
lastMessages.add(record);
}
}
@Override
public void flush() {}
@Override
public void close() throws SecurityException {}
});
}
