Java Examples for java.util.logging.FileHandler
The following java examples will help you to understand the usage of java.util.logging.FileHandler. These source code samples are taken from different open source projects.
Example 1
| Project: jsystem-master File: JSystemProperties.java View source code |
private void initLogger() {
String loggerStatus = getPreference(FrameworkOptions.LOGGER_STATUS);
if (// the logger was never init
loggerStatus == null) {
setPreference("logger", "true");
setPreference("handlers", "java.util.logging.FileHandler java.util.logging.ConsoleHandler");
setPreference("jsystem.level", "FINER");
setPreference("java.util.logging.FileHandler.limit", "10000000");
setPreference("java.util.logging.FileHandler.count", "4");
setPreference("java.util.logging.FileHandler.append", "true");
// We were suppose to use the BasicFormatter implemented by Guy, but
// for some reason the logger can't find the formatter and rolls
// back to XmlFormatter.
setPreference("java.util.logging.FileHandler.formatter", "java.util.logging.SimpleFormatter");
setPreference("java.util.logging.FileHandler.pattern", "jsystem%g.log");
setPreference("java.util.logging.ConsoleHandler.level", "INFO");
setPreference("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
initLogger();
} else if (loggerStatus.equals("true") || loggerStatus.equals("enable")) {
if (!isReporterVm()) {
String remoteLogConf = "logger=true\n" + "handlers=java.util.logging.FileHandler java.util.logging.ConsoleHandler\n" + "java.util.logging.FileHandler.limit=10000000\n" + "java.util.logging.FileHandler.count=4\n" + "jsystem.level= FINER\n" + "java.util.logging.FileHandler.append=true\n" + "java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter\n" + // "java.util.logging.FileHandler.formatter=jsystem.utils.BasicFormatter\n"
"java.util.logging.FileHandler.pattern=remote%g.log\n" + "java.util.logging.ConsoleHandler.level=INFO\n" + "java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter\n";
try {
LogManager.getLogManager().readConfiguration(new ByteArrayInputStream(remoteLogConf.getBytes()));
} catch (IOException e) {
e.printStackTrace();
return;
}
} else {
try {
log.info("Logger was init");
LogManager.getLogManager().readConfiguration(new FileInputStream(getPreferencesFile()));
} catch (IOException e) {
e.printStackTrace();
return;
}
}
} else {
log.info("Logger was set to off");
Logger.getLogger("").setLevel(Level.OFF);
}
}Example 2
| Project: nina-master File: NINALogger.java View source code |
public static void setup() throws IOException {
// Get the global logger to configure it
java.util.logging.Logger logger = java.util.logging.Logger.getLogger("");
logger.setLevel(Level.INFO);
fileTxt = new java.util.logging.FileHandler("logging.txt");
// Create txt Formatter
formatterTxt = new SimpleFormatter();
fileTxt.setFormatter(formatterTxt);
logger.addHandler(fileTxt);
}Example 3
| Project: js-test-driver-master File: LogConfigBuilder.java View source code |
public LogConfigBuilder useFileHandler() {
handlers.add("java.util.logging.FileHandler");
configLines.add("java.util.logging.FileHandler.pattern=%t/jstd-" + System.currentTimeMillis() + ".log");
configLines.add("java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter");
configLines.add("java.util.logging.FileHandler.level=ALL");
return this;
}Example 4
| Project: js-test-driver-qunit-master File: LogConfigBuilder.java View source code |
public LogConfigBuilder useFileHandler() {
handlers.add("java.util.logging.FileHandler");
configLines.add("java.util.logging.FileHandler.pattern=%t/jstd-" + System.currentTimeMillis() + ".log");
configLines.add("java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter");
configLines.add("java.util.logging.FileHandler.level=ALL");
return this;
}Example 5
| Project: Heritrix-3-master File: LogUtils.java View source code |
/**
* Creates a file logger that use heritrix.properties file logger
* configuration.
* Change the java.util.logging.FileHandler.* properties in
* heritrix.properties to change file handler properties.
* Use this method if you want a class to log to its own file
* rather than use default (console) logger.
* @param logsDir Directory in which to write logs.
* @param baseName Base name to use for log file (Will have
* java.util.logging.FileHandler.pattern or '.log' for suffix).
* @param logger Logger whose handler we'll replace with the
* file handler created herein.
*/
public static FileHandler createFileLogger(File logsDir, String baseName, Logger logger) {
int limit = PropertyUtils.getIntProperty("java.util.logging.FileHandler.limit", 1024 * 1024 * 1024 * 1024);
int count = PropertyUtils.getIntProperty("java.util.logging.FileHandler.count", 1);
try {
String tmp = System.getProperty("java.util.logging.FileHandler.pattern");
File logFile = new File(logsDir, baseName + ((tmp != null && tmp.length() > 0) ? tmp : ".log"));
FileHandler fh = new FileHandler(logFile.getAbsolutePath(), limit, count, true);
// Manage the formatter to use.
tmp = System.getProperty("java.util.logging.FileHandler.formatter");
if (tmp != null && tmp.length() > 0) {
Constructor<?> co = Class.forName(tmp).getConstructor(new Class[] {});
Formatter f = (Formatter) co.newInstance(new Object[] {});
fh.setFormatter(f);
}
logger.addHandler(fh);
logger.setUseParentHandlers(false);
return fh;
} catch (Exception e) {
logger.severe("Failed customization of logger: " + e.getMessage());
return null;
}
}Example 6
| Project: heritrix3-master File: LogUtils.java View source code |
/**
* Creates a file logger that use heritrix.properties file logger
* configuration.
* Change the java.util.logging.FileHandler.* properties in
* heritrix.properties to change file handler properties.
* Use this method if you want a class to log to its own file
* rather than use default (console) logger.
* @param logsDir Directory in which to write logs.
* @param baseName Base name to use for log file (Will have
* java.util.logging.FileHandler.pattern or '.log' for suffix).
* @param logger Logger whose handler we'll replace with the
* file handler created herein.
*/
public static FileHandler createFileLogger(File logsDir, String baseName, Logger logger) {
int limit = PropertyUtils.getIntProperty("java.util.logging.FileHandler.limit", 1024 * 1024 * 1024 * 1024);
int count = PropertyUtils.getIntProperty("java.util.logging.FileHandler.count", 1);
try {
String tmp = System.getProperty("java.util.logging.FileHandler.pattern");
File logFile = new File(logsDir, baseName + ((tmp != null && tmp.length() > 0) ? tmp : ".log"));
FileHandler fh = new FileHandler(logFile.getAbsolutePath(), limit, count, true);
// Manage the formatter to use.
tmp = System.getProperty("java.util.logging.FileHandler.formatter");
if (tmp != null && tmp.length() > 0) {
Constructor<?> co = Class.forName(tmp).getConstructor(new Class[] {});
Formatter f = (Formatter) co.newInstance(new Object[] {});
fh.setFormatter(f);
}
logger.addHandler(fh);
logger.setUseParentHandlers(false);
return fh;
} catch (Exception e) {
logger.severe("Failed customization of logger: " + e.getMessage());
return null;
}
}Example 7
| Project: Hedgehog-Photo-master File: Log.java View source code |
public static synchronized Logger getLogger() {
if (logger == null) {
logger = Logger.getLogger("Hedgehog-logger");
try {
FileHandler fh = new FileHandler("HedgehogPhoto.log", 10000, 1, false);
fh.setFormatter(new EasyFormatter());
logger.addHandler(fh);
} catch (Exception e) {
e.printStackTrace();
}
logger.setLevel(Level.ALL);
logger.setUseParentHandlers(false);
}
return logger;
}Example 8
| Project: android_libcore-master File: LogManagerTest.java View source code |
/*
* @see TestCase#setUp()
*/
@Override
protected void setUp() throws Exception {
super.setUp();
mockManager = new MockLogManager();
// listener = new MockPropertyChangeListener();
handler = new MockHandler();
props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
}Example 9
| Project: HABtk-master File: DebugLog.java View source code |
/**
* Create a global logger
* @param level Severity threshold
*/
public static void setupLogger(int level) {
switch(level) {
case 0:
debugLog.setLevel(Level.ALL);
break;
case 1:
debugLog.setLevel(Level.SEVERE);
break;
case 2:
debugLog.setLevel(Level.WARNING);
break;
case 3:
debugLog.setLevel(Level.INFO);
break;
default:
debugLog.setLevel(Level.OFF);
}
try {
logFile = new FileHandler("log.txt");
} catch (Exception e) {
debugLog.log(Level.SEVERE, "Exception", e);
}
logFormatter = new SimpleFormatter();
logFile.setFormatter(logFormatter);
debugLog.addHandler(logFile);
}Example 10
| Project: JDBQueue-master File: QueueLogger.java View source code |
public static void setup() throws IOException {
// Create Logger
Logger logger = Logger.getLogger("");
logger.setLevel(Level.INFO);
// 1 Mb
int limit = 1000000;
fileTxt = new FileHandler("queue.log", limit, 1);
// Create txt Formatter
formatterTxt = new SimpleFormatter();
fileTxt.setFormatter(formatterTxt);
Handler ch = new ConsoleHandler();
ch.setFormatter(formatterTxt);
logger.addHandler(ch);
logger.addHandler(fileTxt);
}Example 11
| Project: open-mika-master File: LogManagerTest.java View source code |
/*
* @see TestCase#setUp()
*/
@Override
protected void setUp() throws Exception {
super.setUp();
mockManager = new MockLogManager();
// listener = new MockPropertyChangeListener();
handler = new MockHandler();
props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
}Example 12
| Project: OpenGrok-master File: LoggerUtil.java View source code |
public static void setFileHandlerLogPath(String path) throws IOException {
if (path != null) {
File jlp = new File(path);
if (!jlp.exists() && !jlp.mkdirs()) {
throw new IOException("could not make logpath: " + jlp.getAbsolutePath());
}
}
StringBuilder logfile = new StringBuilder();
logfile.append(path == null ? "%t" : path);
logfile.append(File.separatorChar).append("opengrok%g.%u.log");
for (Handler handler : getBaseLogger().getHandlers()) {
if (handler instanceof FileHandler) {
FileHandler fileHandler = (FileHandler) handler;
FileHandler newFileHandler;
try {
int logFilesSizeLimit = loggerIntProperty("java.util.logging.FileHandler.limit", DEFAULT_FILEHANDLER_LIMIT);
int logFilesCount = loggerIntProperty("java.util.logging.FileHandler.count", DEFAULT_FILEHANDLER_COUNT);
newFileHandler = new FileHandler(logfile.toString(), logFilesSizeLimit, logFilesCount);
} catch (IOException e) {
LOGGER.log(Level.WARNING, "Cannot create new logger FileHandler: " + logfile.toString(), e);
return;
}
String formatter = LogManager.getLogManager().getProperty("java.util.logging.FileHandler.formatter");
newFileHandler.setLevel(fileHandler.getLevel());
try {
newFileHandler.setFormatter((Formatter) Class.forName(formatter).newInstance());
} catch (InstantiationExceptionIllegalAccessException | ClassNotFoundException | e) {
newFileHandler.setFormatter(new FileLogFormatter());
}
getBaseLogger().addHandler(newFileHandler);
getBaseLogger().removeHandler(fileHandler);
loggerFile = logfile.toString();
}
}
}Example 13
| Project: TheMinecraft-master File: ConsoleLogManager.java View source code |
/**
* Initialises the console logger.
*/
public static void init() {
ConsoleLogFormatter var0 = new ConsoleLogFormatter();
loggerLogManager.setParent(FMLLog.getLogger());
try {
FileHandler var2 = new FileHandler("server.log", true);
var2.setFormatter(var0);
loggerLogManager.addHandler(var2);
} catch (Exception var3) {
loggerLogManager.log(Level.WARNING, "Failed to log to server.log", var3);
}
}Example 14
| Project: windows-wrapper-master File: LoggingService.java View source code |
/**
* Change the value of property {@code java.util.logging.FileHandler.pattern} to use {@code %NEO4J_HOME%} as parent
* directory and call {@link java.util.logging.LogManager LogManager} to reload the change.
* <p>
* By invoking this method, we ensure no matter where a user starts NEO4J, we will always use {@code %NEO4J_HOME%}
* as parent directory for windows-wrapper logs. Otherwise, we will use the directory where the program
* starts as the parent directory when creating windows-wrapper logs.
* @param logManager
* @throws IOException if we failed to read from the windows-wrapper property file or update configuration
* properties for {@link java.util.logging.LogManager LogManager}
*/
void resetLogNamePatternProperty(LogManager logManager) throws IOException {
// Load all the properties from configuration file
String logConfigFileName = System.getProperty(LOGGING_CONFIG_FILE_KEY, DEFAULT_LOGGING_CONFIG_FILE_PATH);
try (FileInputStream logConfigIn = new FileInputStream(new File(logConfigFileName))) {
Properties logProperties = new Properties();
logProperties.load(logConfigIn);
// Reset the logFileNamePattern to use %NEO4J_HOME% as its parent folder
String workingDir = System.getProperty(ServerProcess.WorkingDir);
// translate to the format used by FileHandler
workingDir = workingDir.replaceAll("%", "%%");
winWrapperLogNamePattern = new File(workingDir, winWrapperLogNamePattern).getAbsolutePath();
// Reload the new change
logProperties.setProperty(LOGGING_FILE_NAME_PATTERN_KEY, winWrapperLogNamePattern);
ByteArrayOutputStream internalOut = new ByteArrayOutputStream();
logProperties.store(internalOut, null);
logManager.readConfiguration(new ByteArrayInputStream(internalOut.toByteArray()));
}
}Example 15
| Project: Buck---It-master File: ConsoleLogManager.java View source code |
// Craftbukkit - change of method signature!
public static void a(MinecraftServer server) {
ConsoleLogFormatter consolelogformatter = new ConsoleLogFormatter();
a.setUseParentHandlers(false);
// CraftBukkit start
ConsoleHandler consolehandler = new TerminalConsoleHandler(server.reader);
for (Handler handler : global.getHandlers()) {
global.removeHandler(handler);
}
consolehandler.setFormatter(new ShortConsoleLogFormatter(server));
global.addHandler(consolehandler);
// CraftBukkit end
a.addHandler(consolehandler);
try {
FileHandler filehandler = new FileHandler("server.log", true);
filehandler.setFormatter(consolelogformatter);
a.addHandler(filehandler);
// CraftBukkit
global.addHandler(filehandler);
} catch (Exception exception) {
a.log(Level.WARNING, "Failed to log to server.log", exception);
}
}Example 16
| Project: Minecraft-Server-Mod-master File: OConsoleLogManager.java View source code |
public static void a() {
OConsoleLogFormatter localOConsoleLogFormatter = new OConsoleLogFormatter();
a.setUseParentHandlers(false);
ConsoleHandler localConsoleHandler = new ConsoleHandler();
localConsoleHandler.setFormatter(localOConsoleLogFormatter);
a.addHandler(localConsoleHandler);
try {
FileHandler localFileHandler = new FileHandler("server.log", true);
localFileHandler.setFormatter(localOConsoleLogFormatter);
a.addHandler(localFileHandler);
} catch (Exception localException) {
a.log(Level.WARNING, "Failed to log to server.log", localException);
}
// hMod: Keep the serveroutput logs.
File log = new File("logs");
try {
if (!log.exists())
log.mkdir();
FileHandler localFileHandler = new FileHandler("logs/server_" + ((int) (System.currentTimeMillis() / 1000L)) + ".log");
localFileHandler.setFormatter(localOConsoleLogFormatter);
a.addHandler(localFileHandler);
} catch (Exception localException) {
a.log(Level.WARNING, "Failed to log to server log", localException);
}
}Example 17
| Project: neembuu-uploader-master File: NULogger.java View source code |
public static void initializeFileHandler(String outputFileName) {
if (logger.getHandlers().length > 1)
throw new IllegalStateException("already inited");
try {
//The Logger should log messages both to console and a log file
FileHandler handler = new FileHandler(outputFileName, false);
handler.setFormatter(new SimpleFormatter());
logger.addHandler(handler);
} catch (Exception ex) {
System.out.println("Exception in creating Log file itself");
}
}Example 18
| Project: Recipear2-master File: RecipearLogger.java View source code |
/**
* @param logger the logger to set
*/
public static void setLogger(Logger logger, String path) {
logger.setUseParentHandlers(false);
Handler fh = null;
try {
fh = new FileHandler(path, 0, 3);
fh.setFormatter(new RecipearFormatter());
logger.addHandler(fh);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
RecipearLogger.logger = logger;
}Example 19
| Project: slf4android-master File: FileLogHandler.java View source code |
private void ensureInitialized() {
if (!triedInititializing) {
synchronized (this) {
if (!triedInititializing) {
try {
fileHandler = new FileHandler(config.fileName, config.limit, config.count, config.append);
fileHandler.setFormatter(config.getFormatterAdapter());
} catch (IOException e) {
Log.e(TAG, "Could not create FileHandler", e);
}
triedInititializing = true;
}
}
}
}Example 20
| Project: tradelib-master File: Utils.java View source code |
public static void setupLogging(boolean logToConsole, String logFile) throws Exception {
// Setup the logging
System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS: %4$s: %5$s%n%6$s%n");
LogManager.getLogManager().reset();
Logger rootLogger = Logger.getLogger("");
if (logFile != null) {
FileHandler logHandler = new FileHandler(logFile, 8 * 1024 * 1024, 2, true);
logHandler.setFormatter(new SimpleFormatter());
logHandler.setLevel(Level.FINEST);
rootLogger.addHandler(logHandler);
}
if (logToConsole) {
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setFormatter(new SimpleFormatter());
consoleHandler.setLevel(Level.INFO);
rootLogger.addHandler(consoleHandler);
}
rootLogger.setLevel(Level.INFO);
}Example 21
| Project: Work_book-master File: LoggingImageViewer.java View source code |
public static void main(String[] args) {
if (System.getProperty("java.util.loggging.config.class") == null && System.getProperty("java.util.loggging.config.file") == null) {
try {
Logger.getLogger("").setLevel(Level.ALL);
final int LOG_ROTATION_COUNT = 10;
Handler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);
Logger.getLogger("").addHandler(handler);
} catch (IOException e) {
Logger.getLogger("com.cebotarenco.java").log(Level.SEVERE, "Can't create log file handler", e);
}
}
Handler windowHandler = new WindowHandler();
windowHandler.setLevel(Level.ALL);
Logger.getLogger("com.cebotarenco.java").addHandler(windowHandler);
JFrame frame = new ImageViewerFrame();
frame.setTitle("LoggingImageViewer");
frame.setSize(300, 400);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Logger.getLogger("com.cebotarenco.java").fine("Showing Frame");
frame.setVisible(true);
}Example 22
| Project: android-libcore64-master File: OldLogManagerTest.java View source code |
@Override
protected void setUp() throws Exception {
super.setUp();
mockManager = new MockLogManager();
handler = new MockHandler();
props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
}Example 23
| Project: android_platform_libcore-master File: OldLogManagerTest.java View source code |
@Override
protected void setUp() throws Exception {
super.setUp();
mockManager = new MockLogManager();
handler = new MockHandler();
props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
}Example 24
| Project: ARTPart-master File: OldLogManagerTest.java View source code |
@Override
protected void setUp() throws Exception {
super.setUp();
mockManager = new MockLogManager();
handler = new MockHandler();
props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
}Example 25
| Project: j2objc-master File: LogManagerTest.java View source code |
static Properties initProps() throws Exception {
Properties props = new Properties();
props.put("handlers", className + "$MockHandler " + className + "$MockHandler");
props.put("java.util.logging.FileHandler.pattern", "%h/java%u.log");
props.put("java.util.logging.FileHandler.limit", "50000");
props.put("java.util.logging.FileHandler.count", "5");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
props.put(".level", "FINE");
props.put("java.util.logging.ConsoleHandler.level", "OFF");
props.put("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
props.put("LogManagerTestFoo.handlers", "java.util.logging.ConsoleHandler");
props.put("LogManagerTestFoo.level", "WARNING");
return props;
}Example 26
| Project: jMetal-master File: JMetalLogger.java View source code |
/**
* This method provides a single-call method to configure the {@link Logger}
* instances. A default configuration is considered, enriched with a custom
* property file for more convenient logging. The custom file is considered
* after the default configuration, so it can override it if necessary. The
* custom file might be provided as an argument of this method, otherwise we
* look for a file named "jMetal.log.ini". If no custom file is provided,
* then only the default configuration is considered.
*
* @param propertyFile
* the property file to use for custom configuration,
* <code>null</code> to use only the default configuration
* @throws IOException
*/
public static void configureLoggers(File propertyFile) throws IOException {
// Prepare default configuration
ByteArrayOutputStream stream = new ByteArrayOutputStream();
PrintStream printer = new PrintStream(stream);
printer.println(".level = INFO");
printer.println("handlers = java.util.logging.FileHandler, java.util.logging.ConsoleHandler");
printer.println("formatters = java.util.logging.SimpleFormatter");
printer.println("java.util.logging.SimpleFormatter.format = %1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS.%1$tL %4$s: %5$s [%2$s]%6$s%n");
printer.println("java.util.logging.FileHandler.pattern = jMetal.log");
printer.println("java.util.logging.FileHandler.level = ALL");
printer.println("java.util.logging.ConsoleHandler.level = ALL");
// Retrieve custom configuration
File defaultFile = new File("jMetal.log.ini");
if (propertyFile != null) {
printer.println(FileUtils.readFileToString(propertyFile));
} else if (defaultFile.exists()) {
printer.println(FileUtils.readFileToString(defaultFile));
} else {
// use only default configuration
}
printer.close();
// Apply configuration
LogManager manager = LogManager.getLogManager();
manager.readConfiguration(IOUtils.toInputStream(new String(stream.toByteArray(), Charset.forName("UTF-8"))));
logger.info("Loggers configured with " + propertyFile);
}Example 27
| Project: openjdk-master File: FileHandlerMaxLocksTest.java View source code |
public static void main(String[] args) throws Exception {
File loggerDir = createLoggerDir();
String configFilePath = loggerDir.getPath() + File.separator + CONFIG_FILE_NAME;
File configFile = new File(configFilePath);
createFile(configFile, false);
System.setProperty("java.util.logging.config.file", configFilePath);
List<FileHandler> fileHandlers = new ArrayList<>();
try (FileWriter writer = new FileWriter(configFile)) {
writer.write(MAX_LOCK_PROPERTY);
writer.flush();
// 200 raises the default limit of 100, we try 102 times
for (int i = 0; i < 102; i++) {
fileHandlers.add(new FileHandler(loggerDir.getPath() + File.separator + "test_%u.log"));
}
} catch (IOException ie) {
throw new RuntimeException("Test Failed: " + ie.getMessage());
} finally {
for (FileHandler fh : fileHandlers) {
fh.close();
}
FileUtils.deleteFileTreeWithRetry(Paths.get(loggerDir.getPath()));
}
}Example 28
| Project: cogroo4-master File: LoggerImpl.java View source code |
private static void init() {
if (!initialized) {
try {
// syntax:
// http://java.sun.com/j2se/1.4.2/docs/api/java/util/logging
// /FileHandler.html
createPath(path);
handler = new FileHandler(replacePath(path), 100000, 5, true);
handler.setFormatter(new SimpleFormatter());
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
initialized = true;
}Example 29
| Project: AC-FOVE-master File: FileLogger.java View source code |
public static void setup(Level level) {
Logger globalLogger = Logger.getLogger("");
Handler[] handlers = globalLogger.getHandlers();
for (Handler handler : handlers) {
globalLogger.removeHandler(handler);
}
try {
handler = new FileHandler("log/acfove.log");
} catch (IOException e) {
System.err.println("Could not write to log file.");
System.exit(-1);
}
handler.setFormatter(new ConsoleFormatter());
globalLogger.addHandler(handler);
globalLogger.setLevel(level);
}Example 30
| Project: amazon-cognito-developer-authentication-sample-master File: AWSCognitoDeveloperAuthenticationSampleLogger.java View source code |
/**
* Get the logger for AWSCognitoDeveloperAuthenticationSample
*/
public static synchronized Logger getLogger() {
if (null != logger) {
return logger;
}
logger = Logger.getLogger("AWSCognitoDeveloperAuthenticationSampleLogger");
FileHandler handler;
try {
handler = new FileHandler("MyLogFile.txt", true);
SimpleFormatter formatter = new SimpleFormatter();
handler.setFormatter(formatter);
logger.addHandler(handler);
logger.setLevel(Level.ALL);
} catch (IOException e) {
throw new RuntimeException("Failed to initialize logger. Aborting.", e);
}
return logger;
}Example 31
| Project: ari-toolkit-master File: ToolkitRuntime.java View source code |
private static synchronized void initialise() {
String pname = ToolkitRuntime.class.getPackage().getName();
Logger envLogger = Logger.getLogger(pname + ".env");
for (Handler hndlr : envLogger.getHandlers()) {
envLogger.removeHandler(hndlr);
}
Handler handler;
try {
handler = new FileHandler("%t/jtkenv.log", 8192, 1, false);
handler.setFormatter(new SimpleFormatter());
handler.setLevel(Level.INFO);
} catch (java.io.IOException ioe) {
handler = new ConsoleHandler();
}
envLogger.setLevel(Level.INFO);
envLogger.addHandler(handler);
String localhost = null;
try {
localhost = InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException uhe) {
localhost = "no internet address";
}
StringBuilder builder = new StringBuilder("\nhost address = " + localhost + "\n");
for (Map.Entry<Object, Object> entry : System.getProperties().entrySet()) {
String prop = entry.getKey().toString() + " = " + entry.getValue().toString() + "\n";
builder.append(prop);
}
envLogger.info(builder.toString());
}Example 32
| Project: candybean-master File: LoggerUnitTest.java View source code |
/**
* A system test for a logger configured using the candybean logger
* configuration.
*
* @throws Exception
*/
@Test
public void cbConfiguredLogger() throws Exception {
String name1 = this.getClass().getSimpleName() + "1";
String name2 = this.getClass().getSimpleName() + "2";
String config1Path = Candybean.ROOT_DIR + File.separator + name1 + ".config";
String config2Path = Candybean.ROOT_DIR + File.separator + name2 + ".config";
String log1Path = Candybean.ROOT_DIR + File.separator + "log" + File.separator + name1 + ".log";
String log2Path = Candybean.ROOT_DIR + File.separator + "log" + File.separator + name2 + ".log";
// Load the initial properties from the candybean config file
Properties initialProperties = candybean.config.getPropertiesCopy();
// Change the FileHandler Formatter to XMLFormatter
initialProperties.setProperty("java.util.logging.FileHandler.formatter", "java.util.logging.XMLFormatter");
initialProperties.setProperty("java.util.logging.ConsoleHandler.formatter", "java.util.logging.XMLFormatter");
// Create a new config file and write props to that file
File config1File = new File(config1Path);
config1File.createNewFile();
initialProperties.store(new FileOutputStream(config1File), null);
// Update the system property that specifies where to load the logging configuration from.
System.setProperty("java.util.logging.config.file", config1Path);
LogManager.getLogManager().readConfiguration();
logger = Logger.getLogger(this.getClass().getSimpleName());
// Log to file and verify text
File log1File = new File(log1Path);
FileHandler firstFileHandler = new FileHandler(log1Path);
logger.addHandler(firstFileHandler);
logger.info("First logged message configured using candybean configuration file");
assertTrue(log1File.exists());
assertEquals(getLinesInLogFile(log1File), 14);
// Change the FileHandler Formatter to SimpleFormatter
initialProperties.setProperty("java.util.logging.FileHandler.formatter", "java.util.logging.SimpleFormatter");
initialProperties.setProperty("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
// Create a second config file and write props to that file
File config2File = new File(config2Path);
config2File.createNewFile();
initialProperties.store(new FileOutputStream(config2File), null);
// Update the system property that specifies where to load the logging configuration from.
System.setProperty("java.util.logging.config.file", config2Path);
LogManager.getLogManager().readConfiguration();
logger = Logger.getLogger(this.getClass().getSimpleName());
// Log to file and verify text
File log2File = new File(log2Path);
FileHandler secondFileHandler = new FileHandler(log2Path);
logger.addHandler(secondFileHandler);
logger.info("Second logged message configured using different candybean configuration file");
assertTrue(log2File.exists());
assertTrue(getLinesInLogFile(log2File) < 13);
// Reset the logging config file path to the default and re-read the configuration
System.setProperty("java.util.logging.config.file", candybean.config.configFile.getCanonicalPath());
LogManager logManager = LogManager.getLogManager();
logManager.readConfiguration();
// Delete all created configuration and log files
config1File.delete();
log1File.delete();
config2File.delete();
log2File.delete();
}Example 33
| Project: ChromecastConverter-master File: Log.java View source code |
private static Logger setup(File folder, String fileName) {
try {
FileHandler fh = new FileHandler(new File(folder, fileName + ".log").getAbsolutePath());
fh.setFormatter(new SimpleFormatter());
Logger logger = Logger.getLogger(fileName);
logger.addHandler(fh);
logger.setUseParentHandlers(false);
return logger;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}Example 34
| Project: Database-Analyzer-master File: MyLogger.java View source code |
public static void setup() throws IOException {
// Create Logger
Logger logger = Logger.getLogger("");
logger.setLevel(logLevel);
//fileTxt = new FileHandler("Logging.txt");
fileHTML = new FileHandler(Options.getInstance().getLogFile().getCanonicalPath());
// Create txt Formatter
//formatterTxt = new SimpleFormatter();
//fileTxt.setFormatter(formatterTxt);
//logger.addHandler(fileTxt);
// Create HTML Formatter
formatterHTML = new MyHtmlFormatter();
fileHTML.setFormatter(formatterHTML);
logger.addHandler(fileHTML);
}Example 35
| Project: dataverse-master File: AuthFilter.java View source code |
@Override
public void init(FilterConfig filterConfig) throws ServletException {
logger.info(AuthFilter.class.getName() + "initialized. filterConfig.getServletContext().getServerInfo(): " + filterConfig.getServletContext().getServerInfo());
try {
String glassfishLogsDirectory = "logs";
FileHandler logFile = new FileHandler(".." + File.separator + glassfishLogsDirectory + File.separator + "authfilter.log");
SimpleFormatter formatterTxt = new SimpleFormatter();
logFile.setFormatter(formatterTxt);
logger.addHandler(logFile);
} catch (IOException ex) {
Logger.getLogger(AuthFilter.class.getName()).log(Level.SEVERE, null, ex);
} catch (SecurityException ex) {
Logger.getLogger(AuthFilter.class.getName()).log(Level.SEVERE, null, ex);
}
}Example 36
| Project: enclojure-master File: launcher.java View source code |
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < args.length; ++i) {
sb.append(args[i]);
sb.append(" ");
}
try {
FileHandler fh = new FileHandler("%t" + java.io.File.separator + "repl%glog");
l.addHandler(fh);
requireFn.invoke(Symbol.create("org.enclojure.repl.main"));
if (args.length > 1) {
String[] _args = new String[args.length - 1];
System.arraycopy(args, 1, _args, 0, _args.length);
applyFn.invoke(setupTrackingFn, args);
}
} catch (Exception ex) {
Logger.getLogger(launcher.class.getName()).log(Level.SEVERE, null, ex);
}
}Example 37
| Project: goos-code-master File: XMPPAuctionHouse.java View source code |
private FileHandler simpleFileHandler() throws XMPPAuctionException { try { FileHandler handler = new FileHandler(LOG_FILE_NAME); handler.setFormatter(new SimpleFormatter()); return handler; } catch (Exception e) { throw new XMPPAuctionException("Could not create logger FileHandler " + FilenameUtils.getFullPath(LOG_FILE_NAME), e); } }
Example 38
| Project: it2901-master File: ConfigManager.java View source code |
/**
* Whether to log to file
* @param on boolean
*/
public static void setLogToFile(boolean on) {
if (on) {
if (file == null) {
try {
@SuppressWarnings("deprecation") String logname = "Client" + new Date().toGMTString().replaceAll(" ", "_") + ".log";
file = new FileHandler(logname, true);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
LOGGER.addHandler(file);
LOGGER.config("Setting Logging to file on");
} else {
if (file != null) {
LOGGER.config("Setting Logging to file off");
LOGGER.removeHandler(file);
}
}
}Example 39
| Project: JPregel-master File: JPregelLogger.java View source code |
public static Logger getLogger(String classId, String logFile) throws IOException {
File logDir = new File(JPregelConstants.LOG_DIR);
if (!logDir.exists() && !logDir.mkdirs()) {
throw new IOException("Can't create root log dir : " + JPregelConstants.LOG_DIR);
}
Logger aLogger = Logger.getLogger(classId);
aLogger.setUseParentHandlers(false);
Handler logHandle = null;
try {
logHandle = new FileHandler(logFile);
} catch (SecurityException e) {
System.err.println("Can't init logger in " + classId);
e.printStackTrace();
} catch (IOException e) {
System.err.println("Can't init logger in " + classId);
e.printStackTrace();
}
logHandle.setFormatter(new SimpleFormatter());
aLogger.addHandler(logHandle);
aLogger.info("init " + classId + " Logger successful");
if (!classId.equals("Master") && !classId.startsWith("Fault")) {
aLogger.setLevel(Level.SEVERE);
}
return aLogger;
}Example 40
| Project: JSTUN-master File: FastDiscoveryTestDemo.java View source code |
public static void main(String args[]) {
try {
Handler fh = new FileHandler("logging.txt");
fh.setFormatter(new SimpleFormatter());
Logger.getLogger("de.javawi.jstun").addHandler(fh);
Logger.getLogger("de.javawi.jstun").setLevel(Level.ALL);
Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces();
while (ifaces.hasMoreElements()) {
NetworkInterface iface = ifaces.nextElement();
Enumeration<InetAddress> iaddresses = iface.getInetAddresses();
while (iaddresses.hasMoreElements()) {
InetAddress iaddress = iaddresses.nextElement();
if (Class.forName("java.net.Inet4Address").isInstance(iaddress)) {
if ((!iaddress.isLoopbackAddress()) && (!iaddress.isLinkLocalAddress())) {
Thread thread = new Thread(new FastDiscoveryTestDemo(iaddress));
thread.start();
}
}
}
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}Example 41
| Project: kelpie-master File: DiscoveryTestDemo.java View source code |
public static void main(String args[]) {
try {
Handler fh = new FileHandler("logging.txt");
fh.setFormatter(new SimpleFormatter());
Logger.getLogger("de.javawi.stun").addHandler(fh);
Logger.getLogger("de.javawi.stun").setLevel(Level.ALL);
Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces();
while (ifaces.hasMoreElements()) {
NetworkInterface iface = ifaces.nextElement();
Enumeration<InetAddress> iaddresses = iface.getInetAddresses();
while (iaddresses.hasMoreElements()) {
InetAddress iaddress = iaddresses.nextElement();
if (Class.forName("java.net.Inet4Address").isInstance(iaddress)) {
if ((!iaddress.isLoopbackAddress()) && (!iaddress.isLinkLocalAddress())) {
Thread thread = new Thread(new DiscoveryTestDemo(iaddress));
thread.start();
}
}
}
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}Example 42
| Project: ovirt-engine-master File: JavaLoggingUtils.java View source code |
/**
* Adds file handler with specified file to root logger
*
* @param fileName
* file name to log into
*/
public static void addFileHandler(String fileName) {
try {
FileHandler fh = new FileHandler(fileName, true);
fh.setFormatter(new TimeZoneBasedFormatter());
Logger.getLogger("").addHandler(fh);
} catch (SecurityExceptionIOException | ex) {
throw new IllegalArgumentException(String.format("Error accessing log file '%s': '%s'", fileName, ex.getMessage()), ex);
}
}Example 43
| Project: phresco-master File: PhrescoLogger.java View source code |
public static void setup() throws IOException {
// Create Logger
Logger logger = Logger.getLogger("");
logger.setLevel(Level.INFO);
fileTxt = new FileHandler("Logging.txt");
fileHTML = new FileHandler("Logging.html");
// Create txt Formatter
formatterTxt = new SimpleFormatter();
fileTxt.setFormatter(formatterTxt);
logger.addHandler(fileTxt);
// Create HTML Formatter
formatterHTML = new CRMHtmlFormatter();
fileHTML.setFormatter(formatterHTML);
logger.addHandler(fileHTML);
}Example 44
| Project: reinvent2013-mobile-photo-share-master File: TokenVendingMachineLogger.java View source code |
/**
* Get the logger for TVM
*/
public static synchronized Logger getLogger() {
if (null != logger) {
return logger;
}
logger = Logger.getLogger("TokenVendingMachineLogger");
FileHandler handler;
try {
handler = new FileHandler("MyLogFile.txt", true);
SimpleFormatter formatter = new SimpleFormatter();
handler.setFormatter(formatter);
logger.addHandler(handler);
logger.setLevel(Level.ALL);
} catch (IOException e) {
throw new RuntimeException("Failed to initialize logger. Aborting.", e);
}
return logger;
}Example 45
| Project: robovm-master File: OldFileHandlerTest.java View source code |
protected void setUp() throws Exception {
super.setUp();
manager.reset();
//initProp
props.clear();
props.put("java.util.logging.FileHandler.level", "FINE");
props.put("java.util.logging.FileHandler.filter", className + "$MockFilter");
props.put("java.util.logging.FileHandler.formatter", className + "$MockFormatter");
props.put("java.util.logging.FileHandler.encoding", "iso-8859-1");
// limit to only two message
props.put("java.util.logging.FileHandler.limit", "1000");
// rotation count is 2
props.put("java.util.logging.FileHandler.count", "2");
// using append mode
props.put("java.util.logging.FileHandler.append", "true");
props.put("java.util.logging.FileHandler.pattern", "%t/log/java%u.test");
HOMEPATH = System.getProperty("user.home");
TEMPPATH = System.getProperty("java.io.tmpdir");
File file = new File(TEMPPATH + SEP + "log");
file.mkdir();
manager.readConfiguration(propertiesToInputStream(props));
handler = new FileHandler();
r = new LogRecord(Level.CONFIG, "msg");
}Example 46
| Project: UBChisel-master File: Zeno410Logger.java View source code |
public static Logger globalLogger() {
Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
logger.setLevel(Level.ALL);
if (!suppress) {
try {
fileTxt = new FileHandler("/Zeno410Logging.txt");
// Create txt Formatter
formatterTxt = new SimpleFormatter();
fileTxt.setFormatter(formatterTxt);
logger.addHandler(fileTxt);
} catch (IOException ex) {
ex.printStackTrace(System.err);
} catch (SecurityException ex) {
ex.printStackTrace(System.err);
}
}
logger.info("Starting");
return logger;
}Example 47
| Project: WorldEditCUI-master File: CUIDebug.java View source code |
@Override
public void initialize() throws InitializationException {
ConsoleLogFormatter formatter = new ConsoleLogFormatter();
ConsoleHandler handler = new ConsoleHandler();
handler.setFormatter(formatter);
logger.setUseParentHandlers(false);
logger.addHandler(handler);
try {
this.debugFile = new File(Obfuscation.getWorldEditCUIDir(), "WorldEditCUI-debug.txt");
this.debugMode = controller.getConfiguration().isDebugMode();
if (this.debugMode) {
FileHandler newHandler = new FileHandler(this.debugFile.getAbsolutePath());
newHandler.setFormatter(formatter);
logger.addHandler(newHandler);
}
} catch (IOException e) {
e.printStackTrace(System.err);
throw new InitializationException();
}
}Example 48
| Project: XMPP-for-Android-master File: DiscoveryTestDemo.java View source code |
public static void main(String args[]) {
try {
final Handler fh = new FileHandler("logging.txt");
fh.setFormatter(new SimpleFormatter());
Logger.getLogger("de.javawi.jstun").addHandler(fh);
Logger.getLogger("de.javawi.jstun").setLevel(Level.ALL);
final Enumeration<NetworkInterface> ifaces = NetworkInterface.getNetworkInterfaces();
while (ifaces.hasMoreElements()) {
final NetworkInterface iface = ifaces.nextElement();
final Enumeration<InetAddress> iaddresses = iface.getInetAddresses();
while (iaddresses.hasMoreElements()) {
final InetAddress iaddress = iaddresses.nextElement();
if (Class.forName("java.net.Inet4Address").isInstance(iaddress)) {
if ((!iaddress.isLoopbackAddress()) && (!iaddress.isLinkLocalAddress())) {
final Thread thread = new Thread(new DiscoveryTestDemo(iaddress));
thread.start();
}
}
}
}
} catch (final Exception e) {
System.out.println(e.getMessage());
}
}Example 49
| Project: sakuli-master File: SakuliPropertyPlaceholderConfigurerTest.java View source code |
@SuppressWarnings("unchecked")
@Test
public void testModifySahiProperties() throws Exception {
Properties props = new Properties();
doNothing().when(testling).modifyPropertiesConfiguration(anyString(), anyListOf(String.class), any(Properties.class));
testling.setWritePropertiesToSahiConfig(true);
testling.modifySahiProperties(props);
ArgumentCaptor<List> argumentCaptorSahiProp = ArgumentCaptor.forClass(List.class);
ArgumentCaptor<List> argumentCaptorLogProp = ArgumentCaptor.forClass(List.class);
verify(testling).modifyPropertiesConfiguration(contains(SahiProxyProperties.SAHI_PROPERTY_FILE_APPENDER), argumentCaptorSahiProp.capture(), eq(props));
verify(testling).modifyPropertiesConfiguration(contains(SahiProxyProperties.SAHI_LOG_PROPERTY_FILE_APPENDER), argumentCaptorLogProp.capture(), eq(props));
assertTrue(argumentCaptorSahiProp.getValue().containsAll(Arrays.asList("logs.dir", "ext.http.proxy.enable", "ext.http.proxy.host", "ext.http.proxy.port", "ext.http.proxy.auth.enable", "ext.http.proxy.auth.name", "ext.http.proxy.auth.password", "ext.https.proxy.enable", "ext.https.proxy.host", "ext.https.proxy.port", "ext.https.proxy.auth.enable", "ext.https.proxy.auth.name", "ext.https.proxy.auth.password", "ext.http.both.proxy.bypass_hosts", "ssl.client.keystore.type", "ssl.client.cert.path", "ssl.client.cert.password")), "currently contains: " + argumentCaptorSahiProp.getValue().toString());
assertTrue(argumentCaptorLogProp.getValue().containsAll(Arrays.asList("handlers", "java.util.logging.ConsoleHandler.level", "java.util.logging.FileHandler.level", "java.util.logging.ConsoleHandler.formatter", "java.util.logging.FileHandler.formatter", "java.util.logging.FileHandler.limit", "java.util.logging.FileHandler.count", "java.util.logging.FileHandler.pattern")), "currently contains: " + argumentCaptorLogProp.getValue().toString());
}Example 50
| Project: haskell-java-parser-master File: FileHandler.java View source code |
/* FIXME: Javadoc missing. */
private static java.io.OutputStream createFileStream(String pattern, int limit, int count, boolean append, int generation) {
String path;
int unique = 0;
/* Throws a SecurityException if the caller does not have
* LoggingPermission("control").
*/
LogManager.getLogManager().checkAccess();
/* Default value from the java.util.logging.FileHandler.pattern
* LogManager configuration property.
*/
if (pattern == null)
pattern = LogManager.getLogManager().getProperty("java.util.logging.FileHandler.pattern");
if (pattern == null)
pattern = "%h/java%u.log";
do {
path = replaceFileNameEscapes(pattern, generation, unique, count);
try {
File file = new File(path);
if (file.createNewFile())
return new FileOutputStream(path, append);
} catch (Exception ex) {
ex.printStackTrace();
}
unique = unique + 1;
if (pattern.indexOf("%u") < 0)
pattern = pattern + ".%u";
} while (true);
}Example 51
| Project: olap4ld-master File: Olap4ldUtil.java View source code |
public static void prepareLogging() {
File loggingConfigurationFile = new File("logging.properties");
System.out.println("Logging properties file absolute path:" + loggingConfigurationFile.getAbsolutePath());
Olap4ldUtil._log = Logger.getLogger("Olap4ldDriver");
Olap4ldUtil._log.setLevel(Level.ALL);
if (!loggingConfigurationFile.exists()) {
Writer output = null;
try {
output = new BufferedWriter(new FileWriter(loggingConfigurationFile));
// The configuration file is a property file.
// The Properties class gives support to
// define and persist the logging configuration.
Properties logConf = new Properties();
logConf.setProperty("handlers", "java.util.logging.FileHandler," + "java.util.logging.ConsoleHandler");
logConf.setProperty(".level", "INFO");
logConf.setProperty("java.util.logging.ConsoleHandler.level", "INFO");
logConf.setProperty("java.util.logging.ConsoleHandler.formatter", "java.util.logging.SimpleFormatter");
// level
logConf.setProperty("java.util.logging.FileHandler.level", "INFO");
// pattern
// Will be for example at /home/benedikt/Programs/eclipse_juno_jdk_20120721/
logConf.setProperty("java.util.logging.FileHandler.pattern", "log/olap4ld_%u.log");
// limit in bytes
logConf.setProperty("java.util.logging.FileHandler.limit", "10000000");
// roll
// logConf.setProperty("java.util.logging.FileHandler.count",
// "0");
// append
logConf.setProperty("java.util.logging.FileHandler.append", "1");
// Maybe better XMLFormatter?
logConf.setProperty("java.util.logging.FileHandler.formatter", "java.util.logging.SimpleFormatter");
logConf.store(output, "Generated");
} catch (IOException ex) {
Olap4ldUtil._log.log(Level.WARNING, "Logging configuration file not created", ex);
} finally {
try {
output.close();
} catch (IOException ex) {
Olap4ldUtil._log.log(Level.WARNING, "Problems to save " + "the logging configuration file in the disc", ex);
}
}
}
// This is the way to define the system
// property without changing the command line.
// It has the same effect of the parameter
// -Djava.util.logging.config.file
Properties prop = System.getProperties();
prop.setProperty("java.util.logging.config.file", "logging.properties");
// It creates the log directory if it doesn't exist
// In the configuration file above we specify this
// folder to store log files:
// logConf.setProperty(
// "java.util.logging.FileHandler.pattern",
// "log/application.log");
File logDir = new File("log");
if (!logDir.exists()) {
Olap4ldUtil._log.info("Creating the logging directory");
logDir.mkdir();
}
// to the one in the configuration file.
try {
LogManager.getLogManager().readConfiguration();
} catch (IOException ex) {
Olap4ldUtil._log.log(Level.WARNING, "Problems to load the logging " + "configuration file", ex);
}
// More specific loggers
// They do not work, properly. Seem to either not log at all or create
// many lck and log files
// Handler handler;
// try {
// Date date = new Date();
// String formattedDate = new
// SimpleDateFormat("yyyy-MM-dd_hh_mm_ss").format(date);
// String pattern = "log/olap4ld_connection_"+ formattedDate + ".log";
// handler = new FileHandler(pattern);
// handler.setFormatter(new java.util.logging.SimpleFormatter());
// handler.setLevel(Level.INFO);
// Olap4ldUtil._log.addHandler(handler);
//
// // one file for logging
// handler = new FileHandler("log/olap4ld_all.log");
// handler.setLevel(Level.INFO);
// handler.setFormatter(new java.util.logging.SimpleFormatter());
// Olap4ldUtil._log.addHandler(handler);
// } catch (SecurityException e1) {
// // TODO Auto-generated catch block
// e1.printStackTrace();
// } catch (IOException e1) {
// // TODO Auto-generated catch block
// e1.printStackTrace();
// }
Olap4ldUtil._log.setLevel(Level.ALL);
Olap4ldUtil._log.config("Logging properties file absolute path:" + loggingConfigurationFile.getAbsolutePath());
// // We want to log to a file.
// try {
// Handler handler = new FileHandler("log/olap4ld.log", LOG_SIZE,
// LOG_ROTATION_COUNT);
// Olap4ldUtil._log.addHandler(handler);
// } catch (SecurityException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// Set the level to that of its parent
// LdOlap4jUtil._log.setLevel(null);
// Turn off all logging
// LdOlap4jUtil._log.setLevel(Level.OFF);
// System.out.println("Test"); <= We get to this point
// Turn on all logging
// LdOlap4jUtil._log.setLevel(Level.ALL);
}Example 52
| Project: vroom-master File: MOCell_main.java View source code |
/**
* @param args Command line arguments. The first (optional) argument specifies
* the problem to solve.
* @throws JMException
* @throws IOException
* @throws SecurityException
* Usage: three options
* - jmetal.metaheuristics.mocell.MOCell_main
* - jmetal.metaheuristics.mocell.MOCell_main problemName
* - jmetal.metaheuristics.mocell.MOCell_main problemName ParetoFrontFile
*/
public static void main(String[] args) throws JMException, SecurityException, IOException, ClassNotFoundException {
// The problem to solve
Problem problem;
// The algorithm to use
Algorithm algorithm;
// Crossover operator
Operator crossover;
// Mutation operator
Operator mutation;
// Selection operator
Operator selection;
// Object to get quality indicators
QualityIndicator indicators;
// Operator parameters
HashMap parameters;
// Logger object and file to store log messages
logger_ = Configuration.logger_;
fileHandler_ = new FileHandler("MOCell_main.log");
logger_.addHandler(fileHandler_);
indicators = null;
if (args.length == 1) {
Object[] params = { "Real" };
problem = (new ProblemFactory()).getProblem(args[0], params);
} else // if
if (args.length == 2) {
Object[] params = { "Real" };
problem = (new ProblemFactory()).getProblem(args[0], params);
indicators = new QualityIndicator(problem, args[1]);
} else // if
{
// Default problem
problem = new Kursawe("Real", 3);
//problem = new Water("Real");
//problem = new ZDT1("ArrayReal", 1000);
//problem = new ZDT4("BinaryReal");
//problem = new WFG1("Real");
//problem = new DTLZ1("Real");
//problem = new OKA2("Real") ;
}
// else
algorithm = new MOCell(problem);
// Algorithm parameters
algorithm.setInputParameter("populationSize", 100);
algorithm.setInputParameter("archiveSize", 100);
algorithm.setInputParameter("maxEvaluations", 25000);
algorithm.setInputParameter("feedBack", 20);
// Mutation and Crossover for Real codification
parameters = new HashMap();
parameters.put("probability", 0.9);
parameters.put("distributionIndex", 20.0);
crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover", parameters);
parameters = new HashMap();
parameters.put("probability", 1.0 / problem.getNumberOfVariables());
parameters.put("distributionIndex", 20.0);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
// Selection Operator
parameters = null;
selection = SelectionFactory.getSelectionOperator("BinaryTournament", parameters);
// Add the operators to the algorithm
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("mutation", mutation);
algorithm.addOperator("selection", selection);
long initTime = System.currentTimeMillis();
SolutionSet population = algorithm.execute();
long estimatedTime = System.currentTimeMillis() - initTime;
// Result messages
logger_.info("Total execution time: " + estimatedTime + "ms");
logger_.info("Objectives values have been writen to file FUN");
population.printObjectivesToFile("FUN");
logger_.info("Variables values have been writen to file VAR");
population.printVariablesToFile("VAR");
if (indicators != null) {
logger_.info("Quality indicators");
logger_.info("Hypervolume: " + indicators.getHypervolume(population));
logger_.info("GD : " + indicators.getGD(population));
logger_.info("IGD : " + indicators.getIGD(population));
logger_.info("Spread : " + indicators.getSpread(population));
logger_.info("Epsilon : " + indicators.getEpsilon(population));
}
// if
}Example 53
| Project: Amoeba-for-Aladdin-master File: Log.java View source code |
/**
* ÅäÖÃLogger¶ÔÏóÊä³öÈÕÖ¾Îļþ·¾¶
* @param logger
* @param level ÔÚÈÕÖ¾ÎļþÖÐÊä³ölevel¼¶±ðÒÔÉϵÄÐÅÏ¢
* @throws SecurityException
* @throws IOException
*/
public static void setLogingProperties(Logger logger, Level level) {
FileHandler fh;
try {
fh = new FileHandler(getLogName(), true);
//ÈÕÖ¾Êä³öÎļþ
logger.addHandler(fh);
//logger.setLevel(level);
//Êä³ö¸ñʽ
fh.setFormatter(new SimpleFormatter());
//logger.addHandler(new ConsoleHandler());//Êä³öµ½¿ØÖÆ̨
} catch (SecurityException e) {
logger.log(Level.SEVERE, "°²È«ÐÔ´íÎó", e);
} catch (IOException e) {
logger.log(Level.SEVERE, "¶ÁÈ¡ÎļþÈÕÖ¾´íÎó", e);
}
}Example 54
| Project: Android-MQTT-Websocket-Client-master File: Utility.java View source code |
public static synchronized java.util.logging.Handler getHandler() {
try {
if (handler == null) {
handler = new FileHandler("framework.log", true);
handler.setFormatter(new org.eclipse.paho.client.mqttv3.test.logging.HumanFormatter());
}
} catch (IOException exception) {
exception.printStackTrace();
}
return handler;
}Example 55
| Project: BPMN-Reference-Validator-master File: ValidationLoggerFactory.java View source code |
/**
* This static method creates a new logger for the given file.
*
* @param fileName
* the name of the file to build the logger for or null (for the
* general part: uses log.txt)
* @param level
* the log level (off, severe or info). Default (null) is off.
* @param language
* the language properties (for the exception messages)
* @return the new logger
* @throws ValidatorException
* if a technical problem exists while creating the logger
*/
public static Logger createLogger(String fileName, Level level, Properties language) throws ValidatorException {
try {
Logger logger;
FileHandler fileTxt;
if (fileName == null) {
logger = Logger.getLogger("log");
} else {
logger = Logger.getLogger(fileName);
}
if (level == null) {
logger.setLevel(Level.OFF);
} else {
logger.setLevel(level);
// if logger is active create the file handler
if (level != Level.OFF) {
File dir = new File("log");
if (!dir.exists()) {
dir.mkdir();
}
if (fileName == null) {
fileTxt = new FileHandler("log/log.txt");
} else {
fileTxt = new FileHandler("log/" + fileName + "-log.txt");
}
SimpleFormatter formatterTxt = new SimpleFormatter();
fileTxt.setFormatter(formatterTxt);
logger.addHandler(fileTxt);
}
}
logger.setUseParentHandlers(false);
return logger;
} catch (SecurityException e) {
if (fileName == null) {
throw new ValidatorException(language.getProperty("logger.security.part1") + "log.txt' " + language.getProperty("logger.security.part2"), e);
} else {
throw new ValidatorException(language.getProperty("logger.security.part1") + fileName + "-log.txt' " + language.getProperty("logger.security.part2"), e);
}
} catch (IOException e) {
if (fileName == null) {
throw new ValidatorException(language.getProperty("logger.io.part1") + "log.txt' " + language.getProperty("logger.io.part2"), e);
} else {
throw new ValidatorException(language.getProperty("logger.io.part1") + fileName + "-log.txt' " + language.getProperty("logger.io.part2"), e);
}
}
}Example 56
| Project: Capturador-master File: EJBErrorAndExceptionHandler.java View source code |
@AroundInvoke
public Object handleErrorOrException(InvocationContext invocationContext) throws Exception {
Class clas = invocationContext.getTarget().getClass();
Method method = invocationContext.getMethod();
// following lines belong to the logger class
Logger theLogger = Logger.getLogger(EJBErrorAndExceptionHandler.class.getName());
theLogger.addHandler(new FileHandler("aralog.xml"));
Handler[] handlers = Logger.getLogger("").getHandlers();
for (int index = 0; index < handlers.length; index++) {
handlers[index].setLevel(Level.FINE);
}
theLogger.setLevel(Level.FINE);
try {
return invocationContext.proceed();
} catch (SQLGrammarException ex) {
JSFMessage.addErrorMessage("not_yet");
if ("searchByCriteria".equals(method.getName())) {
return null;
} else if ("countSpecimensByCriteria".equals(method.getName())) {
return new Long(0);
} else {
return null;
}
} catch (TransactionRolledbackException ex) {
JSFMessage.addErrorMessage("not_yet");
if ("searchByCriteria".equals(method.getName())) {
return null;
} else if ("countSpecimensByCriteria".equals(method.getName())) {
return new Long(0);
} else {
return null;
}
} catch (PersistenceException ex) {
JSFMessage.addErrorMessage("not_yet");
if ("searchByCriteria".equals(method.getName())) {
return null;
} else if ("countSpecimensByCriteria".equals(method.getName())) {
return new Long(0);
} else {
return null;
}
} catch (Exception ex) {
String s = ex.getLocalizedMessage();
String cl = ex.getClass().getName();
theLogger.fine(clas.getName());
theLogger.fine(method.getName());
JSFMessage.addErrorMessage("not_yet");
if ("searchByCriteria".equals(method.getName())) {
return null;
} else if ("countSpecimensByCriteria".equals(method.getName())) {
return new Long(0);
} else {
return null;
}
}
}Example 57
| Project: cdi-tck-master File: ConfigurationLoggingListener.java View source code |
@Override
public void onStart(ISuite suite) {
try {
FileHandler fh = new FileHandler(CONFIGURATION_FILE_PATH);
fh.setFormatter(new SimpleFormatter());
logger.addHandler(fh);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
logger.log(Level.INFO, "CDI-TCK Implementation version: {0}", Package.getPackage("org.jboss.cdi.tck.impl.testng").getImplementationVersion());
logger.log(Level.INFO, "CDI-TCK Specification version: {0}", Package.getPackage("org.jboss.cdi.tck.impl.testng").getSpecificationVersion());
Configuration conf = ConfigurationFactory.get();
logger.log(Level.INFO, conf.toString());
}Example 58
| Project: FernFlowerFixer-master File: FFFixer.java View source code |
public static void main(String[] args) throws Exception {
OptionParser parser = new OptionParser();
parser.accepts("help").forHelp();
parser.accepts("version").forHelp();
parser.accepts("jarIn").withRequiredArg().required();
parser.accepts("jarOut").withRequiredArg();
parser.accepts("log").withRequiredArg();
try {
OptionSet options = parser.parse(args);
if (options.has("help")) {
System.out.println(VERSION);
parser.printHelpOn(System.out);
return;
} else if (options.has("version")) {
System.out.println(VERSION);
return;
}
String jarIn = (String) options.valueOf("jarIn");
String jarOut = (String) options.valueOf("jarOut");
String log = (String) options.valueOf("log");
FFFixer.log.setUseParentHandlers(false);
FFFixer.log.setLevel(Level.ALL);
if (log != null) {
FileHandler filehandler = new FileHandler(log);
filehandler.setFormatter(new Formatter() {
@Override
public synchronized String format(LogRecord record) {
StringBuffer sb = new StringBuffer();
String message = this.formatMessage(record);
sb.append(record.getLevel().getName());
sb.append(": ");
sb.append(message);
sb.append("\n");
if (record.getThrown() != null) {
try {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
record.getThrown().printStackTrace(pw);
pw.close();
sb.append(sw.toString());
} catch (Exception ex) {
}
}
return sb.toString();
}
});
FFFixer.log.addHandler(filehandler);
}
FFFixer.log.addHandler(new Handler() {
@Override
public void publish(LogRecord record) {
if (record.getLevel().intValue() < Level.INFO.intValue())
return;
System.out.println(String.format(record.getMessage(), record.getParameters()));
}
@Override
public void flush() {
}
@Override
public void close() throws SecurityException {
}
});
log(FFFixer.VERSION);
log("Input: " + jarIn);
log("Output: " + jarOut);
log("Log: " + log);
try {
FFFixerImpl.process(jarIn, jarOut, log);
} catch (Exception e) {
System.err.println("ERROR: " + e.getMessage());
e.printStackTrace();
System.exit(1);
}
} catch (OptionException e) {
parser.printHelpOn(System.out);
e.printStackTrace();
}
}Example 59
| Project: Framework-GL-master File: Logging.java View source code |
public void reset() throws IOException {
LogManager.getLogManager().reset();
Configuration config = Fw.config;
if (config.logProperties != null) {
try (FileInputStream fis = new FileInputStream(config.logProperties)) {
LogManager.getLogManager().readConfiguration(fis);
}
return;
}
// Default logger is not "global" for some reason
Logger logger = Logger.getLogger("");
logger.setLevel(config.logLevel);
// Setup console logging
if (config.logConsole) {
Handler console = new ConsoleHandler();
console.setFormatter(simpleFormatter);
console.setLevel(config.logLevel);
logger.addHandler(console);
}
// Setup a log file
if (config.logFile) {
Handler file = new FileHandler(config.logFilename, MAX_LOG_SIZE, MAX_LOG_COUNT);
file.setFormatter(simpleFormatter);
file.setLevel(config.logLevel);
logger.addHandler(file);
}
}Example 60
| Project: hestia-engine-dev-master File: Utility.java View source code |
public static synchronized java.util.logging.Handler getHandler() {
try {
if (handler == null) {
handler = new FileHandler("framework.log", true);
handler.setFormatter(new org.eclipse.paho.client.mqttv3.test.logging.HumanFormatter());
}
} catch (IOException exception) {
exception.printStackTrace();
}
return handler;
}Example 61
| Project: HueImmersive-master File: Debug.java View source code |
public static void activateLogging() {
logging = true;
try // to create a log file
{
String path = Main.class.getProtectionDomain().getCodeSource().getLocation().getPath();
String decodedPath = URLDecoder.decode(path, "UTF-8");
String logpath = new File(decodedPath).getParentFile().getPath();
logpath = logpath.replace("\\", "/");
logger = Logger.getLogger("global");
handler = new FileHandler(logpath + "/HueImmersive.log");
logger.addHandler(handler);
logger.setUseParentHandlers(false);
SimpleFormatter formatter = new SimpleFormatter();
handler.setFormatter(formatter);
} catch (Exception e) {
Debug.exception(e);
}
}Example 62
| Project: ips_dev-master File: Log.java View source code |
/**
* Get an instance of a {@link Logger} configured according to the settings
*
* @return {@link Logger}
*/
public static synchronized Logger getLogger() {
if (logger == null) {
try {
logger = Logger.getLogger("RedpinLogger");
FileHandler fh = new FileHandler(Configuration.LogFile);
if (Configuration.LogFormat == LoggerFormat.PLAIN) {
fh.setFormatter(new SimpleFormatter());
} else if (Configuration.LogFormat == LoggerFormat.XML) {
fh.setFormatter(new XMLFormatter());
} else {
//default
fh.setFormatter(new SimpleFormatter());
}
logger.addHandler(fh);
logger.setLevel(Configuration.LogLevel);
} catch (SecurityException e) {
System.err.println(e.getMessage());
e.printStackTrace();
} catch (IOException e) {
System.err.println(e.getMessage());
e.printStackTrace();
}
}
return logger;
}Example 63
| Project: jFlowLib-master File: SFlowIPFIXMuxer.java View source code |
public static void main(String args[]) {
String cfgPath = "/opt/jipfix-muxer/etc";
String logPath = "/opt/jipfix-muxer/log";
try {
if (args.length == 0) {
System.out.println("Usage: java -jar jipfix.jar [options]\n");
System.out.println("Options:");
System.out.println(" -cfg: path to the jipfix.xml config file");
System.out.println(" -log: path to log file");
System.out.println();
System.exit(0);
} else {
for (int i = 0; i < args.length; i++) {
String str = args[i];
if (str.equals("-cfg")) {
if ((i + 1) < args.length) {
cfgPath = args[i + 1];
}
}
if (str.equals("-log")) {
if ((i + 1) < args.length) {
logPath = args[i + 1];
}
}
}
}
// 20 x 50MByte
FileHandler fh = new FileHandler(logPath + File.separator + "ipfix-muxer.log", 5 * 10485760, 20, true);
fh.setFormatter(new SimpleFormatter());
Logger l = Logger.getLogger("");
l.addHandler(fh);
l.setLevel(Level.FINEST);
System.setProperty("java.net.preferIPv4Stack", "true");
LOGGER.log(Level.FINE, "Program Start");
ConfigParser cp = new ConfigParser();
cp.loadConfig(cfgPath);
ExecutorService executorMuxer = Executors.newFixedThreadPool(2);
SFlowMuxerMultiThreaded sflowMuxer = new SFlowMuxerMultiThreaded(cp);
executorMuxer.submit(sflowMuxer);
LOGGER.log(Level.FINE, "sFlow muxer startet");
IPFIXMuxerMultiThreaded ipfixMuxer = new IPFIXMuxerMultiThreaded(cp);
executorMuxer.submit(ipfixMuxer);
LOGGER.log(Level.FINE, "IPFIX muxer startet");
Pinger pinger = new Pinger(cp);
ScheduledExecutorService executorPinger = Executors.newScheduledThreadPool(1);
executorPinger.scheduleAtFixedRate(pinger, 10, 10, TimeUnit.SECONDS);
LOGGER.log(Level.FINE, "Pinger service startet");
} catch (SAXException se) {
se.printStackTrace();
} catch (ParserConfigurationException pce) {
pce.printStackTrace();
} catch (UtilityException ue) {
ue.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}Example 64
| Project: MoKitchen-master File: LogAgent.java View source code |
/**
* Sets up the logger for usage.
*/
private void setupLogger() {
this.serverLogger.setParent(FMLLog.getLogger());
Handler[] ahandler = this.serverLogger.getHandlers();
int i = ahandler.length;
for (int j = 0; j < i; ++j) {
Handler handler = ahandler[j];
this.serverLogger.removeHandler(handler);
}
LogFormatter logformatter = new LogFormatter(this, (LogAgentINNER1) null);
try {
FileHandler filehandler = new FileHandler(this.logFile, true);
filehandler.setFormatter(logformatter);
this.serverLogger.addHandler(filehandler);
} catch (Exception exception) {
this.serverLogger.log(Level.WARNING, "Failed to log " + this.loggerName + " to " + this.logFile, exception);
}
}Example 65
| Project: monkey-shines-java-port-master File: MonkeyShinesLog.java View source code |
/**
*
* Initialises the logging system. May only be called once during startup. Calling this multiple
* times results an exception. To ensure oneness, only call once from main methods.
*
*/
public static final void initialise() {
if (LOG != null)
throw new IllegalStateException("Logging system already initialised");
try (InputStream configStream = Files.newInputStream(BinaryLocation.BINARY_LOCATION.resolve("logging.properties"))) {
LogManager.getLogManager().readConfiguration(configStream);
} catch (IOException ex) {
System.err.println("WARNING: Could not open configuration file. Dropping to defaults.");
System.err.println("Reason: " + ex.getMessage());
LOG = Logger.getLogger("org.erikaredmark.monkeyshines");
LOG.setLevel(Level.INFO);
FileHandler logFileHandler;
try {
logFileHandler = new FileHandler("monkeyshines.log");
logFileHandler.setFormatter(new SimpleFormatter());
LOG.addHandler(logFileHandler);
System.err.println("File handler set up. Output is to console and 'monkeyshines.log'");
} catch (SecurityExceptionIOException | e) {
System.err.println("File handler could not be set up. Output is to console only.");
}
System.err.println("Log level for system is INFO");
}
LOG.info("Monkey Shines Java Port Log File Initialised");
}Example 66
| Project: OpenJML-master File: Main.java View source code |
/**
* Reads in a grammar file and uses that information to expand the macros in a
* template file.
*
* @param args <code>args[0]</code> is the grammar file and
* <code>args[1..]</code> are template files
*/
public static void main(String[] args) {
if (args.length == 0) {
Err.fatal("Syntax: java freeboogie.ast.gen.Main" + " [-b defaultBaseName] grammar templates", 1);
}
// Setup logging.
try {
Handler logh = new FileHandler("ast_gen.log");
logh.setFormatter(new SimpleFormatter());
log.addHandler(logh);
log.setUseParentHandlers(false);
// for release
log.setLevel(Level.WARNING);
//log.setLevel(Level.ALL); // for debug
} catch (IOException e) {
System.err.println("I can't create a log file. Nevermind.");
}
int arg_idx = 0;
Grammar grammar = null;
if (args[arg_idx].equals("-b")) {
if (++arg_idx == args.length)
Err.fatal("You must give a default base name after '-b'");
defaultBase = args[arg_idx++];
}
// read the grammar
try {
AgParser agParser = new AgParser();
agParser.setInputStream(new FileInputStream(args[arg_idx++]));
agParser.parseAg();
grammar = agParser.getGrammar();
grammar.makeConsistent(defaultBase);
} catch (IOException e) {
Err.fatal("I can't read the abstract grammar.", 2);
}
for (; arg_idx < args.length; ++arg_idx) {
// process a template
try {
TemplateParser template = new TemplateParser(args[arg_idx]);
template.process(grammar);
} catch (FileNotFoundException e) {
Err.error("I can't find " + args[arg_idx] + ". I'll skip this template.");
} catch (IOException e) {
Err.error("I couldn't process (completely) template " + args[arg_idx]);
}
}
}Example 67
| Project: paho.mqtt.java-master File: Utility.java View source code |
public static synchronized java.util.logging.Handler getHandler() {
try {
if (handler == null) {
handler = new FileHandler("framework.log", true);
handler.setFormatter(new org.eclipse.paho.client.mqttv3.test.logging.HumanFormatter());
}
} catch (IOException exception) {
exception.printStackTrace();
}
return handler;
}Example 68
| Project: PwnChat-master File: LogManager.java View source code |
public void start(String fileName) {
if (logfileHandler == null) {
try {
// For now, one logfile, like the old way.
String file = new File(logFolder, fileName).toString();
logfileHandler = new FileHandler(file, true);
SimpleFormatter f = new LogFormatter();
logfileHandler.setFormatter(f);
// Catch all log messages
logfileHandler.setLevel(Level.FINEST);
LogManager.logger.addHandler(logfileHandler);
LogManager.logger.info("Now logging to " + file);
} catch (IOException e) {
LogManager.logger.warning("Unable to open logfile.");
} catch (SecurityException e) {
LogManager.logger.warning("Security Exception while trying to add file Handler");
}
}
}Example 69
| Project: sphereority-master File: SphereorityServer.java View source code |
/*
* Allow the logger level to be set as a command-line paramater.
* The default logger level is CONFIG by default.
*/
public static void initialiseLogger(String[] args) {
// Server application logging
logger = Logger.getLogger(SERVER_LOGGER_NAME);
// Get the log level from the command-line if one is supplied
if (args.length > 0) {
/*
* Logger levels:
* SEVERE (highest value)
* WARNING
* INFO
* CONFIG
* FINE
* FINER
* FINEST (lowest value)
*/
String level = args[0].trim().toUpperCase();
if (level.equals("SEVERE")) {
logger.setLevel(Level.SEVERE);
} else if (level.equals("WARNING")) {
logger.setLevel(Level.WARNING);
} else if (level.equals("INFO")) {
logger.setLevel(Level.INFO);
} else if (level.equals("CONFIG")) {
logger.setLevel(Level.CONFIG);
} else if (level.equals("FINE")) {
logger.setLevel(Level.FINE);
} else if (level.equals("FINER")) {
logger.setLevel(Level.FINER);
} else if (level.equals("FINEST")) {
logger.setLevel(Level.FINEST);
}
} else {
// Set the default log level if it is not specified
logger.setLevel(Level.CONFIG);
}
try {
logger.addHandler(new FileHandler(SERVER_LOG_PATH));
} catch (IOException e) {
e.printStackTrace();
}
}Example 70
| Project: tnoodle-master File: TNoodleLogging.java View source code |
public static void setFileLogLevel(Level level) {
if (fh == null) {
try {
File logFile = getLogFile();
logFile.getParentFile().mkdirs();
fh = new FileHandler(logFile.getAbsolutePath(), MAX_BYTES, FILE_COUNT, true);
setFileLogLevel(DEFAULT_LOG_LEVEL);
fh.setFormatter(formatter);
rootLogger.addHandler(fh);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
fh.setLevel(level);
l.config(getLogFile() + " log level " + level);
}Example 71
| Project: jade_agents-master File: JavaLoggingLogManagerImpl.java View source code |
/**
*
* @return a List of LogInfo
*/
public List getAllLogInfo() {
boolean fhExists = false;
//initilization of root handlers
if (this.rootHandlers == null) {
String handlers = logManager.getProperty("handlers");
if (handlers != null) {
int index = handlers.indexOf(",");
String separator = ",";
//handlers can be separated by comma or spaces.
if (index == -1) {
separator = " ";
}
StringTokenizer st = new StringTokenizer(handlers, separator);
while (st.hasMoreTokens()) {
if (this.rootHandlers == null)
this.rootHandlers = new java.util.ArrayList();
String handlerName = st.nextToken().trim();
fhExists = (handlerName.indexOf("java.util.logging.FileHandler") > -1);
this.rootHandlers.add(handlerName);
}
}
}
if (this.loggers == null) {
//istanzio la struttura e la popolo
this.loggers = new ArrayList();
for (Enumeration e = logManager.getLoggerNames(); e.hasMoreElements(); ) {
String logName = (String) e.nextElement();
try {
Logger theLogger = this.logManager.getLogger(logName);
//retrieving the level
Level level = getLevel(theLogger);
int loggerLevel = level.intValue();
//The value is the one specified for the property level in the configuration file
if (logName == null || logName.length() == 0) {
// This is the ROOT Logger --> Use a non-empty predefined name
logName = DEFAULT_ROOT_LOGGER_NAME;
}
LoggerInfo logInfoElem = new LoggerInfo(logName, loggerLevel);
//if a FileHandler has been specified it's not possibile to retrieve the fileName
//retrieves all the handlers associated to the logger
//root handlers are inheredited by default
List loggerHandlers = (this.rootHandlers == null ? new ArrayList() : new ArrayList(this.rootHandlers));
//root logger handlers have been already set.
if (!logName.equals("")) {
Handler[] handlers = theLogger.getHandlers();
//add the file handler specified by the user only if fileHandler is not a root handler
for (int i = 0; i < handlers.length; i++) {
String temp = handlers[i].toString();
if (!fhExists) {
String userHandler = (temp.indexOf('@') < 0 ? temp : temp.substring(0, temp.indexOf('@')));
loggerHandlers.add(userHandler);
}
}
}
logInfoElem.setHandlers(loggerHandlers);
//non sono in ordine alfabetico (dovrebbe essere la gui a mostrarle in quell'ordine.
this.loggers.add(logInfoElem);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
return this.loggers;
}Example 72
| Project: kernel-master File: TestLoggers.java View source code |
/**
* To launch this test: 1. remove Log4jConfogurator from
* org.exoplatform.services.log. 2. remove log4j dependency from
* exo.kernel.commons. 3. replace slf4j-log4j12 with slf4j-jcl in
* exo.kernel.commons dependencies.
*/
public void _testJCLLog() throws Exception {
String confClass = "org.exoplatform.services.log.impl.Jdk14Configurator";
Properties props = new Properties();
props.put("handlers", "java.util.logging.ConsoleHandler,java.util.logging.FileHandler");
props.put(".level", "INFO");
props.put("java.util.logging.ConsoleHandler.level", "ALL");
props.put("java.util.logging.FileHandler.pattern", "./target/java%u.log");
props.put("java.util.logging.FileHandler.formatter", "java.util.logging.SimpleFormatter");
new LogConfigurationInitializer(logger, confClass, props);
Log log = ExoLogger.getLogger(TestLoggers.class);
log.info("JCL Tests");
logOut(log);
}Example 73
| Project: sos-ws2010-mas-master File: JavaLoggingLogManagerImpl.java View source code |
/**
*
* @return a List of LogInfo
*/
public List getAllLogInfo() {
boolean fhExists = false;
//initilization of root handlers
if (this.rootHandlers == null) {
String handlers = logManager.getProperty("handlers");
if (handlers != null) {
int index = handlers.indexOf(",");
String separator = ",";
//handlers can be separated by comma or spaces.
if (index == -1) {
separator = " ";
}
StringTokenizer st = new StringTokenizer(handlers, separator);
while (st.hasMoreTokens()) {
if (this.rootHandlers == null)
this.rootHandlers = new java.util.ArrayList();
String handlerName = st.nextToken().trim();
fhExists = (handlerName.indexOf("java.util.logging.FileHandler") > -1);
this.rootHandlers.add(handlerName);
}
}
}
if (this.loggers == null) {
//istanzio la struttura e la popolo
this.loggers = new ArrayList();
for (Enumeration e = logManager.getLoggerNames(); e.hasMoreElements(); ) {
String logName = (String) e.nextElement();
try {
Logger theLogger = this.logManager.getLogger(logName);
//retrieving the level
Level level = getLevel(theLogger);
int loggerLevel = level.intValue();
//The value is the one specified for the property level in the configuration file
if (logName == null || logName.length() == 0) {
// This is the ROOT Logger --> Use a non-empty predefined name
logName = DEFAULT_ROOT_LOGGER_NAME;
}
LoggerInfo logInfoElem = new LoggerInfo(logName, loggerLevel);
//if a FileHandler has been specified it's not possibile to retrieve the fileName
//retrieves all the handlers associated to the logger
//root handlers are inheredited by default
List loggerHandlers = (this.rootHandlers == null ? new ArrayList() : new ArrayList(this.rootHandlers));
//root logger handlers have been already set.
if (!logName.equals("")) {
Handler[] handlers = theLogger.getHandlers();
//add the file handler specified by the user only if fileHandler is not a root handler
for (int i = 0; i < handlers.length; i++) {
String temp = handlers[i].toString();
if (!fhExists) {
String userHandler = (temp.indexOf('@') < 0 ? temp : temp.substring(0, temp.indexOf('@')));
loggerHandlers.add(userHandler);
}
}
}
logInfoElem.setHandlers(loggerHandlers);
//non sono in ordine alfabetico (dovrebbe essere la gui a mostrarle in quell'ordine.
this.loggers.add(logInfoElem);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
return this.loggers;
}Example 74
| Project: faban-master File: RunDaemon.java View source code |
/**
* Redirect the log to file named log.xml inside the
* current run output directory.
* @param logFile the output directory for the run
* @param limit the log file size limit
*/
private void redirectLog(String logFile, String limit) {
StringBuilder sb = new StringBuilder();
// sb.append("\nhandlers = java.util.logging.FileHandler\n");
// sb.append("java.util.logging.FileHandler.pattern = ");
// sb.append(logFile + "\n");
sb.append("java.util.logging.FileHandler.append = true\n");
// If a limit is passed add it to the porps.
if (limit != null)
sb.append("java.util.logging.FileHandler.limit = " + limit + "\n");
sb.append("java.util.logging.FileHandler.formatter = " + "com.sun.faban.harness.logging.XMLFormatter\n");
try {
// Check the props for any levels and set them.
Properties logProps = new Properties();
FileInputStream is = new FileInputStream(Config.CONFIG_DIR + "logging.properties");
logProps.load(is);
for (Enumeration en = logProps.propertyNames(); en.hasMoreElements(); ) {
String key = (String) en.nextElement();
if (key.endsWith(".level")) {
sb.append(key + " = " + logProps.getProperty(key) + '\n');
}
}
is.close();
LogManager.getLogManager().readConfiguration(new ByteArrayInputStream(sb.toString().getBytes()));
FileHandler fileHandler = new FileHandler(logFile);
fileHandler.setFormatter(new XMLFormatter());
Logger rootLogger = Logger.getLogger("");
rootLogger.addHandler(fileHandler);
// Set system property so that SocketHandler can write the logs from remote machines
System.setProperty("faban.log.file", logFile);
} catch (IOException e) {
System.err.println("Exception setting log properties.");
e.printStackTrace();
logger.log(Level.WARNING, "Exception setting log properties.", e);
}
}Example 75
| Project: autopsy-master File: AutoIngestSystemLogger.java View source code |
/**
* Gets a logger for the auto ingest system log, separate from both the case
* auto ingest log and the application log.
*
* @return The logger.
*/
static final synchronized Logger getLogger() {
if (!configured) {
Path logFilePath = Paths.get(PlatformUtil.getUserDirectory().getAbsolutePath(), "var", "log", "auto_ingest.log");
try {
FileHandler fileHandler = new FileHandler(logFilePath.toString(), LOG_SIZE, LOG_FILE_COUNT);
fileHandler.setEncoding(PlatformUtil.getLogFileEncoding());
fileHandler.setFormatter(new Formatter() {
@Override
public String format(LogRecord record) {
Throwable thrown = record.getThrown();
//NON-NLS
String stackTrace = "";
while (thrown != null) {
stackTrace += thrown.toString() + NEWLINE;
for (StackTraceElement traceElem : record.getThrown().getStackTrace()) {
//NON-NLS
stackTrace += "\t" + traceElem.toString() + NEWLINE;
}
thrown = thrown.getCause();
}
return //NON-NLS
(new Timestamp(record.getMillis())).toString() + " " + record.getSourceClassName() + //NON-NLS
" " + record.getSourceMethodName() + NEWLINE + record.getLevel() + //NON-NLS
": " + this.formatMessage(record) + NEWLINE + stackTrace;
}
});
LOGGER.addHandler(fileHandler);
LOGGER.setUseParentHandlers(false);
} catch (SecurityExceptionIOException | ex) {
throw new RuntimeException(String.format("Error initializing file handler for %s", logFilePath), ex);
}
configured = true;
}
return LOGGER;
}Example 76
| Project: bbct-master File: BBCTMain.java View source code |
private static void initLogger() throws IOException {
File logFolder = new File(BBCTMain.LOG_FOLDER_NAME);
if (!logFolder.exists()) {
logFolder.mkdir();
}
// TODO: Configure logger using a property file.
boolean append = true;
Handler handler = new FileHandler(BBCTMain.LOG_FILE_NAME, append);
handler.setFormatter(new SimpleFormatter());
Logger logger = Logger.getLogger("");
logger.setLevel(Level.INFO);
logger.addHandler(handler);
// TODO: Should I set this in a property file?
System.setProperty("hsqldb.reconfig_logging", "false");
}Example 77
| Project: Beehive-master File: Log.java View source code |
/**
* Initialization befor loading config
*/
public static void preInit() {
LOGGER.setLevel(Level.INFO);
try {
// Handler for LOGGER_GLOBAL
Handler handler = new FileHandler(Constants.PATH_LOGFILE);
LOGGER.addHandler(handler);
handler.setLevel(LOGGER.getLevel());
} catch (SecurityException e) {
error("SecurityException in Log.preInit() ", e);
System.exit(1);
} catch (IOException e) {
error("IOException in Log.preInit() ", e);
System.exit(1);
}
}Example 78
| Project: caliper-master File: LoggingConfigLoaderTest.java View source code |
@Test
public void testLoadDefaultLogConfiguration() throws SecurityException, IOException {
when(logManager.getLogger("")).thenReturn(logger);
loader.maybeLoadDefaultLogConfiguration(logManager);
verify(logManager).reset();
verify(logger).addHandler(handlerCaptor.capture());
FileHandler fileHandler = (FileHandler) handlerCaptor.getValue();
assertEquals(UTF_8.name(), fileHandler.getEncoding());
assertTrue(fileHandler.getFormatter() instanceof SimpleFormatter);
fileHandler.publish(new LogRecord(INFO, "some message"));
File logFile = new File(new File(caliperDirectory, "log"), ISODateTimeFormat.basicDateTimeNoMillis().print(startTime) + "." + runId + ".log");
assertTrue(logFile.isFile());
assertTrue(Files.toString(logFile, UTF_8).contains("some message"));
}Example 79
| Project: ClassiCubeLauncher-master File: LogUtil.java View source code |
// Sets up logging to file (%AppData%/net.classicube.launcher/launcher.log)
public static void init() throws IOException {
logger.setLevel(Level.ALL);
outProxy = new BroadcastingPrintStream(System.out);
errProxy = new BroadcastingPrintStream(System.err);
System.setOut(outProxy);
System.setErr(errProxy);
final File logFile = new File(SharedUpdaterCode.getLauncherDir(), PathUtil.LOG_FILE_NAME);
final File logOldFile = new File(SharedUpdaterCode.getLauncherDir(), PathUtil.LOG_OLD_FILE_NAME);
// If a logfile already exists, rename it to "launcher.old.log"
if (logFile.exists()) {
if (logOldFile.exists()) {
logOldFile.delete();
}
logFile.renameTo(logOldFile);
}
// Set up log file handler for this session
try {
final FileHandler handler = new FileHandler(logFile.getAbsolutePath());
handler.setFormatter(new SimpleFormatter());
logger.addHandler(handler);
} catch (final IOExceptionSecurityException | ex) {
ErrorScreen.show("Error creating log file", ex.getMessage(), ex);
System.exit(2);
}
}Example 80
| Project: cruisesaver-master File: LogUtilTest.java View source code |
@Test
public void testSetDebug() throws Exception {
Logger logger = Logger.getLogger(LogUtil.BASE_NAME);
Assert.assertEquals(LogUtil.DEFAULT_LEVEL, logger.getLevel());
LogUtil.setDebug(true);
Assert.assertEquals(Level.FINE, logger.getLevel());
Handler[] handlers = logger.getHandlers();
Assert.assertEquals(2, handlers.length);
Assert.assertTrue(handlers[0] instanceof ConfigurableConsoleHandler);
Assert.assertTrue(handlers[1] instanceof FileHandler);
LogUtil.setDebug(false);
Assert.assertEquals(LogUtil.DEFAULT_LEVEL, logger.getLevel());
handlers = logger.getHandlers();
Assert.assertEquals(1, handlers.length);
Assert.assertTrue(handlers[0] instanceof ConfigurableConsoleHandler);
}Example 81
| Project: eclipselink.runtime-master File: SessionsXMLSchemaJavaLogTest.java View source code |
public void test() {
try {
XMLSessionConfigLoader loader = new XMLSessionConfigLoader("org/eclipse/persistence/testing/models/sessionsxml/XMLSchemaJavaLog.xml");
employeeSession = (DatabaseSession) SessionManager.getManager().getSession(loader, "EmployeeSession", getClass().getClassLoader(), false, true);
Logger.getLogger("org.eclipse.persistence").addHandler(new FileHandler(fileName));
employeeSession.login();
} catch (Exception e) {
generationException = e;
}
}Example 82
| Project: eoulsan-master File: MainCLI.java View source code |
@Override
protected Handler getLogHandler(final URI logFile) throws IOException {
if (logFile == null) {
throw new NullPointerException("The log file is null");
}
final File file = new File(logFile);
final File parentFile = file.getParentFile();
// Create parent directory if necessary
if (parentFile != null && !parentFile.exists()) {
if (!parentFile.mkdirs()) {
throw new IOException("Unable to create directory " + parentFile + " for log file:" + logFile);
}
}
return new FileHandler(file.getAbsolutePath());
}Example 83
| Project: esms-master File: LogSupport.java View source code |
/** Initialize logfile file handler. Republishes any previously stored
* records into it.
* @param logOutput where to log; not null
*/
public static void initFileHandler(File logOutput) throws IOException {
Validate.notNull(logOutput);
String pattern = logOutput.getAbsolutePath().replaceAll("%", "%%");
fileHandler = new FileHandler(pattern, true);
fileHandler.setLevel(Level.ALL);
fileHandler.setFormatter(new SimpleFormatter());
fileHandler.setEncoding("UTF-8");
for (Logger log : loggers) {
log.addHandler(fileHandler);
}
for (LogRecord record : logBuffer) {
fileHandler.publish(record);
}
logger.fine("Started logging into " + logOutput.getAbsolutePath());
}Example 84
| Project: FBPwn-master File: LogManager.java View source code |
public static void init() throws IOException {
Logger logger = Logger.getLogger("");
logger.setLevel(Level.CONFIG);
Handler[] handlers = logger.getHandlers();
for (Handler h : handlers) {
logger.removeHandler(h);
}
fh = new FileHandler("log.html");
fh.setFormatter(new HTMLLogFormatter());
logger.addHandler(fh);
logger.addHandler(new Handler() {
@Override
public void publish(LogRecord record) {
if (record.getLevel() == Level.SEVERE) {
ExceptionHandler.reportException(Thread.currentThread(), record.getThrown());
}
}
@Override
public void flush() {
}
@Override
public void close() throws SecurityException {
}
});
}Example 85
| Project: gluu-opendj-master File: UpgradeLog.java View source code |
/**
* Creates a new file handler for writing log messages into
* {@value #UPGRADELOGNAME} file.
*/
static void initLogFileHandler() {
final Logger logger = Logger.getLogger(UpgradeCli.class.getName());
final String SPACE = " ";
if (logFile == null) {
logFile = new File(new StringBuilder(UpgradeUtils.getInstallationPath()).append(File.separator).append(UPGRADELOGNAME).toString());
}
try {
fileHandler = new FileHandler(logFile.getCanonicalPath(), true);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
fileHandler.setFormatter(new Formatter() {
/** {@inheritDoc} */
@Override
public String format(LogRecord record) {
// Format the log ~like the errors logger.
StringBuffer sb = new StringBuffer();
final SimpleDateFormat dateFormat = new SimpleDateFormat("[dd/MMM/yyyy:HH:mm:ss Z]");
sb.append(dateFormat.format(record.getMillis())).append(SPACE);
sb.append("category=UPGRADE").append(SPACE).append("sq=").append(record.getSequenceNumber()).append(SPACE).append("severity=").append(record.getLevel().toString().toUpperCase());
sb.append(SPACE).append("src=").append(record.getSourceClassName()).append(SPACE).append(record.getSourceMethodName()).append("\n");
sb.append(SPACE).append("msg=").append(record.getMessage()).append("\n");
return sb.toString();
}
});
logger.setLevel(Level.CONFIG);
logger.addHandler(fileHandler);
logger.setUseParentHandlers(false);
// Log Config info.
logger.log(Level.CONFIG, "**** Upgrade of OpenDJ started ****");
logger.log(Level.CONFIG, RuntimeMessages.NOTE_INSTALL_DIRECTORY.get(UpgradeUtils.getInstallationPath()).toString());
logger.log(Level.CONFIG, RuntimeMessages.NOTE_INSTANCE_DIRECTORY.get(UpgradeUtils.getInstancePath()).toString());
}Example 86
| Project: gradle-plugins-master File: LogHelper.java View source code |
public void startup() {
System.setProperty("java.util.logging.SimpleFormatter.format", "%4$s: %1$tb %1$td, %1$tY %1$tH:%1$tM:%1$tS %5$s%6$s%n");
// avoid tha the handler be registred more than once
closeAndRemoveFileHandler();
// registry the handlers
LOGGER.setLevel(Level.INFO);
LOGGER.setUseParentHandlers(false);
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setFormatter(new SimpleFormatter());
LOGGER.addHandler(consoleHandler);
Path file = conf.getLogFile();
String logFileName = file.toString();
try {
if (!Files.exists(file.getParent())) {
Files.createDirectories(file.getParent());
}
FileHandler fileHandler = new FileHandler(file.toString());
fileHandler.setFormatter(new SimpleFormatter());
LOGGER.addHandler(fileHandler);
} catch (Exception e) {
throw new RuntimeException("Erro criarndo arquivo de log " + logFileName, e);
}
}Example 87
| Project: kolmafia-master File: DefaultSVNDebugLogger.java View source code |
private static Handler createTestLogger(String testName) throws IOException {
URL mySource = DefaultSVNDebugLogger.class.getProtectionDomain().getCodeSource().getLocation();
File programDir = new File(mySource.getPath()).getParentFile();
File logFile = new File(programDir, "../logs/" + testName.trim() + ".log");
FileHandler fileHandler = new FileHandler(logFile.getAbsolutePath(), 0, 1, true);
fileHandler.setLevel(Level.FINEST);
fileHandler.setFormatter(new DefaultSVNDebugFormatter());
return fileHandler;
}Example 88
| Project: McLauncher-master File: MCLogger.java View source code |
public static void register(File file) {
try {
// Setup Logger
for (final Handler handler : global.getHandlers()) {
global.removeHandler(handler);
}
final ConsoleHandler console = new TerminalConsoleHandler();
global.addHandler(console);
final File logFile = file;
final FileHandler fileHandler = new FileHandler(logFile.getAbsolutePath(), 500000, 5, true);
fileHandler.setFormatter(new LogFormatter(true));
global.addHandler(fileHandler);
System.setOut(new PrintStream(System.out) {
public void print(String s) {
global.info(s);
}
});
System.setErr(new PrintStream(System.err) {
public void print(String s) {
global.severe(s);
}
});
} catch (final IOException e) {
e.printStackTrace();
}
}Example 89
| Project: mil-sym-android-master File: SymbolSVGTable.java View source code |
public synchronized void init(String symbolSVG) {
if (_initCalled == false) {
_instance = new SymbolSVGTable();
_SymbolDefinitions = new HashMap<String, SVGPath>();
//FileHandler.InputStreamToString(xmlStreamB);
String lookupXml = symbolSVG;
//String lookupXml = FileHandler.fileToString("C:\\UnitFontMappings.xml");
populateLookup(lookupXml);
_initCalled = true;
}
}Example 90
| Project: OMS3-master File: Main.java View source code |
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws Exception {
Handler h = new FileHandler(System.getProperty("user.dir") + File.separatorChar + "log.txt", true);
h.setFormatter(new SimpleFormatter());
logger.setUseParentHandlers(false);
logger.addHandler(h);
try {
logger.info("Start Session");
logger.setLevel(Level.parse(System.getProperty("loglevel")));
} catch (Exception E) {
logger.warning("Not a valid log level in '-Dloglevel=???': '" + System.getProperty("loglevel") + "'");
logger.setLevel(Level.INFO);
} finally {
logger.info("Log level: " + logger.getLevel().toString());
}
logger.info("OMS version " + Utils.getOMSAppVersion());
logger.info("User dir: " + System.getProperty("user.dir"));
logger.info("OMS home: " + Console.oms3Home);
logger.info("java.home: " + java_home());
// adjust LnF
String osName = System.getProperty("os.name");
if ((osName != null) && osName.toLowerCase().startsWith("lin")) {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
} else {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
try {
String.class.getMethod("isEmpty", (Class<?>[]) null);
} catch (Exception E) {
JOptionPane.showMessageDialog(null, "You are using an older Java version, however JDK 1.6 is needed!\nPlease install the right JDK, start again ...", "Problem...", JOptionPane.ERROR_MESSAGE);
System.exit(0);
}
String jh = java_home();
if (jh == null) {
JOptionPane.showMessageDialog(null, "You need to install the latest JDK and set 'JAVA_HOME' to your JDK install directory. " + "\nPlease start again ...", "Problem...", JOptionPane.ERROR_MESSAGE);
System.exit(0);
}
if (!new File(jh).exists()) {
JOptionPane.showMessageDialog(null, "'JAVA_HOME' (" + jh + ") does not exists. Please fix this." + "\nPlease start again ...", "Problem...", JOptionPane.ERROR_MESSAGE);
System.exit(0);
}
// open window
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
final Console c = new Console();
c.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
c.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
if (JOptionPane.showConfirmDialog(c, "Exit ?", "Console", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
c.savePrefs();
logger.info("Exit");
System.exit(0);
}
}
});
c.setSize(800, 600);
c.setLocationRelativeTo(null);
c.setVisible(true);
}
});
}Example 91
| Project: OpenDJ-master File: ControlPanelLog.java View source code |
/**
* Creates a new file handler for writing log messages to the file indicated by <code>file</code>.
* @param file log file to which log messages will be written
* @throws IOException if something goes wrong
*/
public static void initLogFileHandler(File file) throws IOException {
if (!isInitialized()) {
logFile = file;
fileHandler = new FileHandler(logFile.getCanonicalPath());
fileHandler.setFormatter(JDKLogging.getFormatter());
boolean initialLogDone = false;
for (String root : JDKLogging.getOpendDJLoggingRoots()) {
Logger logger = Logger.getLogger(root);
if (disableLoggingToConsole()) {
// disable logging to console
logger.setUseParentHandlers(false);
}
logger.addHandler(fileHandler);
if (!initialLogDone) {
logger.info(getInitialLogRecord());
initialLogDone = true;
}
}
}
}Example 92
| Project: OpenEMRConnect-master File: LoggingServer.java View source code |
/**
* Runs the Logging Server.
*
* @param args the command line arguments
*/
public static void main(String[] args) {
// Make sure logging calls don't send to us!
Mediator.suppressLoggingService();
renameOldLogFile();
try {
fileHandler = new FileHandler("oec.log");
// Only log INFO and higher to disk.
fileHandler.setLevel(Level.INFO);
} catch (Exception ex) {
}
LoggingServer ls = new LoggingServer();
Mediator.registerCallback(ls);
Mediator m = new Mediator();
while (true) {
try {
Thread.sleep(Long.MAX_VALUE);
} catch (InterruptedException ex) {
}
}
}Example 93
| Project: Oyster-GUI-master File: OysterMain.java View source code |
@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);
}Example 94
| Project: phyloGeoRef-master File: DemoMain3.java View source code |
/**
* Sets up the logger.
*/
private static void setupLogger() {
LOGGER.setLevel(Level.ALL);
try {
FileHandler fhandler = new FileHandler("Logfile.txt");
SimpleFormatter sformatter = new SimpleFormatter();
fhandler.setFormatter(sformatter);
LOGGER.addHandler(fhandler);
} catch (IOException ex) {
LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
} catch (SecurityException ex) {
LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
}
}Example 95
| Project: proyectoAE2015-master File: PSO_main.java View source code |
/**
* @param args Command line arguments. The first (optional) argument specifies
* the problem to solve.
* @throws JMException
* @throws IOException
* @throws SecurityException
* Usage: three options
* - jmetal.metaheuristics.mocell.MOCell_main
* - jmetal.metaheuristics.mocell.MOCell_main problemName
* - jmetal.metaheuristics.mocell.MOCell_main problemName ParetoFrontFile
*/
public static void main(String[] args) throws JMException, IOException, ClassNotFoundException {
// The problem to solve
Problem problem;
// The algorithm to use
Algorithm algorithm;
// "Turbulence" operator
Mutation mutation;
// Object to get quality indicators
QualityIndicator indicators;
// Operator parameters
HashMap parameters;
// Logger object and file to store log messages
logger_ = Configuration.logger_;
fileHandler_ = new FileHandler("PSO_main.log");
logger_.addHandler(fileHandler_);
//problem = new Sphere("Real", 20) ;
//problem = new Easom("Real") ;
// problem = new Griewank("Real", 10) ;
problem = new Sphere("Real", 20);
algorithm = new PSO(problem);
// Algorithm parameters
algorithm.setInputParameter("swarmSize", 50);
algorithm.setInputParameter("maxIterations", 5000);
parameters = new HashMap();
parameters.put("probability", 1.0 / problem.getNumberOfVariables());
parameters.put("distributionIndex", 20.0);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
algorithm.addOperator("mutation", mutation);
// Execute the Algorithm
long initTime = System.currentTimeMillis();
SolutionSet population = algorithm.execute();
long estimatedTime = System.currentTimeMillis() - initTime;
// Result messages
logger_.info("Total execution time: " + estimatedTime + "ms");
logger_.info("Objectives values have been writen to file FUN");
population.printObjectivesToFile("FUN");
logger_.info("Variables values have been writen to file VAR");
population.printVariablesToFile("VAR");
}Example 96
| Project: SimpleWeibo-master File: NoVelocityLoggingTest.java View source code |
private void doTestDontLog(File log) throws IOException {
// Set things up so that if Velocity is successfully logging then we will see its log output
// in the temporary file we have created. This depends on Velocity falling back on JDK logging,
// so this test won't do anything useful if its classpath contains Log4J or Commons Logging or
// any of the other exotic logging systems that Velocity will pounce on if it sees them.
FileHandler fileHandler = new FileHandler(log.getPath());
fileHandler.setFormatter(new SimpleFormatter());
Logger logger = Logger.getLogger(JdkLogChute.DEFAULT_LOG_NAME);
logger.addHandler(fileHandler);
logger.setLevel(Level.ALL);
LogManager logManager = LogManager.getLogManager();
logManager.addLogger(logger);
// Now do a random compilation that implies using RetroWeiboProcessor.
JavaFileObject javaFileObject = JavaFileObjects.forSourceLines("foo.bar.Baz", "package foo.bar;", "", "import retroweibo.RetroWeibo;", "", "@RetroWeibo", "public abstract class Baz {", " public abstract int buh();", "", " public static Baz create(int buh) {", " return new RetroWeibo_Baz(buh);", " }", "}");
assert_().about(javaSource()).that(javaFileObject).processedWith(new RetroWeiboProcessor()).compilesWithoutError();
// The log file should be empty.
fileHandler.close();
assertEquals("", Files.toString(log, StandardCharsets.UTF_8));
}Example 97
| Project: smart-KV-master File: BFTMapClientCloudFIT.java View source code |
private static void initLog() {
try {
boolean append = true;
FileHandler fh = new FileHandler(BFTMapClientCloudFIT.class.getName() + ".log", append);
fh.setFormatter(new SimpleFormatter());
logger = Logger.getLogger(BFTMapClientCloudFIT.class.getName());
logger.addHandler(fh);
} catch (IOException e) {
System.out.println("PROBLEMS]: " + e.getMessage());
System.exit(-1);
}
}Example 98
| Project: SocialSDK-master File: CustomLogger.java View source code |
/**
* Custom logging initialization
* <p>
* This method associates two different file handlers, both using the same formatter,
* with the root logger and the "org.apache" logger in order to increase
* the log readability.
* The root logger file handler will redirect the logger's output to a file named "bssProvisioning.log".
* The "org.apache" logger file handler will redirect the logger's output to a file named "bssProvisioning.log".
* Then a filter is associated with all the root logger's handlers in order to avoid to have the root logger output
* polluted by the "org.apache" logger output.
*/
public static boolean setup() throws IOException {
boolean loggerFileCreated = false;
// get the root logger to configure it
Logger rootLogger = Logger.getLogger("");
orgApache = Logger.getLogger("org.apache");
rootLogger.setLevel(Level.FINEST);
orgApache.setLevel(Level.FINEST);
fileHandler = new FileHandler("bssProvisioning.log");
orgApacheHandler = new FileHandler("orgApacheOutput.log");
loggerFileCreated = true;
// create a TXT formatter
customFormatter = new CustomFormatter();
customFilter = new CustomFilter();
fileHandler.setFormatter(customFormatter);
orgApacheHandler.setFormatter(customFormatter);
orgApacheHandler.setLevel(Level.FINEST);
rootLogger.addHandler(fileHandler);
orgApache.addHandler(orgApacheHandler);
for (Handler handler : rootLogger.getHandlers()) {
if (handler instanceof ConsoleHandler) {
handler.setLevel(Level.FINEST);
handler.setFormatter(customFormatter);
handler.setFilter(customFilter);
}
if (handler instanceof FileHandler) {
handler.setFilter(customFilter);
}
}
return loggerFileCreated;
}Example 99
| Project: SPINdle-master File: AppLoggerImpl.java View source code |
private static final Logger generateLogger(File file) throws SecurityException, IOException {
if (null == file)
file = new File(logFolder, "dummy_" + Utilities.getRandomString(DomConst.LOG_FILE_ID_LENGTH));
File logFolderF = file.getParentFile();
if (!logFolderF.exists())
logFolderF.mkdirs();
Logger logger = Logger.getLogger(file.toString());
logger.setUseParentHandlers(false);
FileHandler fileHandler = new FileHandler(file.getCanonicalPath());
fileHandler.setFormatter(new LogFormatter());
logger.addHandler(fileHandler);
return logger;
}Example 100
| Project: svnkit-master File: NailgunProcessor.java View source code |
private static Handler createTestLogger(String testName) throws IOException {
File logFile = PythonTests.getLogsDirectory();
String path = PythonTests.getTestType() + "_" + testName.trim() + ".log";
logFile = new File(logFile, path);
FileHandler fileHandler = new FileHandler(logFile.getAbsolutePath(), 0, 1, true);
fileHandler.setLevel(Level.FINEST);
fileHandler.setFormatter(new DefaultSVNDebugFormatter());
return fileHandler;
}Example 101
| Project: torrent-client-master File: Log2.java View source code |
/**
* Initilizes the logger.
*/
public static void init() {
rootLog = Logger.getLogger("");
rootLog.setUseParentHandlers(false);
if (Constants.isFileLoggingEnabled)
try {
rootLog.addHandler(new FileHandler(Constants.logFileName + ".Log"));
} catch (SecurityException e) {
rootLog.severe("Could not Log to File. Security Exception.");
} catch (IOException e) {
rootLog.severe("Could not Log to File. IO Exception.");
}
if (!Constants.isConsoleLoggingEnabled) {
ConsoleHandler formatedHandler = new ConsoleHandler();
rootLog.addHandler(formatedHandler);
}
replaceConsoleHandler(rootLog, Level.OFF);
rootLog.setLevel(Constants.logLevel);
}