Java Examples for java.util.logging.SimpleFormatter
The following java examples will help you to understand the usage of java.util.logging.SimpleFormatter. These source code samples are taken from different open source projects.
Example 1
| Project: tradelib-master File: StrategyBacktest.java View source code |
public static void run(Strategy strategy) 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 (Boolean.parseBoolean(BacktestCfg.instance().getProperty("file.log", "true"))) {
FileHandler logHandler = new FileHandler("diag.out", 8 * 1024 * 1024, 2, true);
logHandler.setFormatter(new SimpleFormatter());
logHandler.setLevel(Level.FINEST);
rootLogger.addHandler(logHandler);
}
if (Boolean.parseBoolean(BacktestCfg.instance().getProperty("console.log", "true"))) {
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setFormatter(new SimpleFormatter());
consoleHandler.setLevel(Level.INFO);
rootLogger.addHandler(consoleHandler);
}
rootLogger.setLevel(Level.INFO);
// Setup Hibernate
// Configuration configuration = new Configuration();
// StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
// SessionFactory factory = configuration.buildSessionFactory(builder.build());
Context context = new Context();
context.dbUrl = BacktestCfg.instance().getProperty("db.url");
HistoricalDataFeed hdf = new SQLDataFeed(context);
hdf.configure(BacktestCfg.instance().getProperty("datafeed.config", "config/datafeed.properties"));
context.historicalDataFeed = hdf;
HistoricalReplay hr = new HistoricalReplay(context);
context.broker = hr;
strategy.initialize(context);
strategy.cleanupDb();
long start = System.nanoTime();
strategy.start();
long elapsedTime = System.nanoTime() - start;
System.out.println("backtest took " + String.format("%.2f secs", (double) elapsedTime / 1e9));
start = System.nanoTime();
strategy.updateEndEquity();
strategy.writeExecutionsAndTrades();
strategy.writeEquity();
elapsedTime = System.nanoTime() - start;
System.out.println("writing to the database took " + String.format("%.2f secs", (double) elapsedTime / 1e9));
System.out.println();
// Write the strategy totals to the database
strategy.totalTradeStats();
// Write the strategy report to the database and obtain the JSON
// for writing it to the console.
JsonObject report = strategy.writeStrategyReport();
JsonArray asa = report.getAsJsonArray("annual_stats");
String csvPath = BacktestCfg.instance().getProperty("positions.csv.prefix");
if (!Strings.isNullOrEmpty(csvPath)) {
csvPath += "-" + strategy.getLastTimestamp().toLocalDate().format(DateTimeFormatter.BASIC_ISO_DATE) + ".csv";
}
String ordersCsvPath = BacktestCfg.instance().getProperty("orders.csv.suffix");
if (!Strings.isNullOrEmpty(ordersCsvPath)) {
ordersCsvPath = strategy.getLastTimestamp().toLocalDate().format(DateTimeFormatter.BASIC_ISO_DATE) + "-" + strategy.getName() + ordersCsvPath;
}
String actionsPath = BacktestCfg.instance().getProperty("actions.file.suffix");
if (!Strings.isNullOrEmpty(actionsPath)) {
actionsPath = strategy.getLastTimestamp().toLocalDate().format(DateTimeFormatter.BASIC_ISO_DATE) + "-" + strategy.getName() + actionsPath;
}
// If emails are being send out
String signalText = StrategyText.build(context.dbUrl, strategy.getName(), strategy.getLastTimestamp().toLocalDate(), " ", csvPath, '|');
System.out.println(signalText);
System.out.println();
if (!Strings.isNullOrEmpty(ordersCsvPath)) {
StrategyText.buildOrdersCsv(context.dbUrl, strategy.getName(), strategy.getLastTimestamp().toLocalDate(), ordersCsvPath);
}
File actionsFile = Strings.isNullOrEmpty(actionsPath) ? null : new File(actionsPath);
if (actionsFile != null) {
FileUtils.writeStringToFile(actionsFile, signalText + System.getProperty("line.separator") + System.getProperty("line.separator"));
}
String message = "";
if (asa.size() > 0) {
// Sort the array
TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
for (int ii = 0; ii < asa.size(); ++ii) {
int year = asa.get(ii).getAsJsonObject().get("year").getAsInt();
map.put(year, ii);
}
for (int id : map.values()) {
JsonObject jo = asa.get(id).getAsJsonObject();
String yearStr = String.valueOf(jo.get("year").getAsInt());
String pnlStr = String.format("$%,d", jo.get("pnl").getAsInt());
String pnlPctStr = String.format("%.2f%%", jo.get("pnl_pct").getAsDouble());
String endEqStr = String.format("$%,d", jo.get("end_equity").getAsInt());
String ddStr = String.format("$%,d", jo.get("maxdd").getAsInt());
String ddPctStr = String.format("%.2f%%", jo.get("maxdd_pct").getAsDouble());
String str = yearStr + " PnL: " + pnlStr + ", PnL Pct: " + pnlPctStr + ", End Equity: " + endEqStr + ", MaxDD: " + ddStr + ", Pct MaxDD: " + ddPctStr;
message += str + "\n";
}
String pnlStr = String.format("$%,d", report.get("pnl").getAsInt());
String pnlPctStr = String.format("%.2f%%", report.get("pnl_pct").getAsDouble());
String ddStr = String.format("$%,d", report.get("avgdd").getAsInt());
String ddPctStr = String.format("%.2f%%", report.get("avgdd_pct").getAsDouble());
String gainToPainStr = String.format("%.4f", report.get("gain_to_pain").getAsDouble());
String str = "\nAvg PnL: " + pnlStr + ", Pct Avg PnL: " + pnlPctStr + ", Avg DD: " + ddStr + ", Pct Avg DD: " + ddPctStr + ", Gain to Pain: " + gainToPainStr;
message += str + "\n";
} else {
message += "\n";
}
// Global statistics
JsonObject jo = report.getAsJsonObject("total_peak");
String dateStr = jo.get("date").getAsString();
int maxEndEq = jo.get("equity").getAsInt();
jo = report.getAsJsonObject("total_maxdd");
double cash = jo.get("cash").getAsDouble();
double pct = jo.get("pct").getAsDouble();
message += "\n" + "Total equity peak [" + dateStr + "]: " + String.format("$%,d", maxEndEq) + "\n" + String.format("Current Drawdown: $%,d [%.2f%%]", Math.round(cash), pct) + "\n";
if (report.has("latest_peak") && report.has("latest_maxdd")) {
jo = report.getAsJsonObject("latest_peak");
LocalDate ld = LocalDate.parse(jo.get("date").getAsString(), DateTimeFormatter.ISO_DATE);
maxEndEq = jo.get("equity").getAsInt();
jo = report.getAsJsonObject("latest_maxdd");
cash = jo.get("cash").getAsDouble();
pct = jo.get("pct").getAsDouble();
message += "\n" + Integer.toString(ld.getYear()) + " equity peak [" + ld.format(DateTimeFormatter.ISO_DATE) + "]: " + String.format("$%,d", maxEndEq) + "\n" + String.format("Current Drawdown: $%,d [%.2f%%]", Math.round(cash), pct) + "\n";
}
message += "\n" + "Avg Trade PnL: " + String.format("$%,d", Math.round(report.get("avg_trade_pnl").getAsDouble())) + ", Max DD: " + String.format("$%,d", Math.round(report.get("maxdd").getAsDouble())) + ", Max DD Pct: " + String.format("%.2f%%", report.get("maxdd_pct").getAsDouble()) + ", Num Trades: " + Integer.toString(report.get("num_trades").getAsInt());
System.out.println(message);
if (actionsFile != null) {
FileUtils.writeStringToFile(actionsFile, message + System.getProperty("line.separator"), true);
}
if (Boolean.parseBoolean(BacktestCfg.instance().getProperty("email.enabled", "false"))) {
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", "smtp.sendgrid.net");
props.put("mail.smtp.port", "587");
String user = BacktestCfg.instance().getProperty("email.user");
String pass = BacktestCfg.instance().getProperty("email.pass");
Session session = Session.getInstance(props, new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(user, pass);
}
});
MimeMessage msg = new MimeMessage(session);
try {
msg.setFrom(new InternetAddress(BacktestCfg.instance().getProperty("email.from")));
msg.addRecipients(RecipientType.TO, BacktestCfg.instance().getProperty("email.recipients"));
msg.setSubject(strategy.getName() + " Report [" + strategy.getLastTimestamp().format(DateTimeFormatter.ISO_LOCAL_DATE) + "]");
msg.setText("Positions & Signals\n" + signalText + "\n\nStatistics\n" + message);
Transport.send(msg);
} catch (Exception ee) {
Logger.getLogger("").warning(ee.getMessage());
}
}
if (Boolean.parseBoolean(BacktestCfg.instance().getProperty("sftp.enabled", "false"))) {
HashMap<String, String> fileMap = new HashMap<String, String>();
if (!Strings.isNullOrEmpty(actionsPath))
fileMap.put(actionsPath, actionsPath);
if (!Strings.isNullOrEmpty(ordersCsvPath))
fileMap.put(ordersCsvPath, ordersCsvPath);
String user = BacktestCfg.instance().getProperty("sftp.user");
String pass = BacktestCfg.instance().getProperty("sftp.pass");
String host = BacktestCfg.instance().getProperty("sftp.host");
SftpUploader sftp = new SftpUploader(host, user, pass);
sftp.upload(fileMap);
}
}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: DeviceConnect-Android-master File: ThetaDeviceApplication.java View source code |
@Override
public void onCreate() {
super.onCreate();
if (BuildConfig.DEBUG) {
for (Logger logger : mLoggers) {
AndroidHandler handler = new AndroidHandler(logger.getName());
handler.setFormatter(new SimpleFormatter());
handler.setLevel(Level.ALL);
logger.addHandler(handler);
logger.setLevel(Level.ALL);
}
} else {
for (Logger logger : mLoggers) {
logger.setLevel(Level.OFF);
}
}
Context context = getApplicationContext();
mDeviceMgr = new ThetaDeviceManager(context);
mHeadTracker = new HeadTrackerWrapper(new DefaultHeadTracker(context));
mSphericalViewApi = new SphericalViewApi(context);
}Example 4
| Project: HABtk-master File: LogPanel.java View source code |
private void setupLoggers() {
LogPanelHandler debugHandler = new LogPanelHandler(this, TYPE_DEBUG);
debugHandler.setFormatter(new SimpleFormatter());
Logger.getLogger("Debug").addHandler(debugHandler);
LogPanelHandler primaryHandler = new LogPanelHandler(this, TYPE_PRIMARY);
primaryHandler.setFormatter(new TrackingFormatter());
Logger.getLogger("Primary").addHandler(primaryHandler);
LogPanelHandler secondaryHandler = new LogPanelHandler(this, TYPE_SECONDARY);
secondaryHandler.setFormatter(new TrackingFormatter());
Logger.getLogger("Secondary").addHandler(secondaryHandler);
LogPanelHandler recoveryHandler = new LogPanelHandler(this, TYPE_RECOVERY);
recoveryHandler.setFormatter(new TrackingFormatter());
Logger.getLogger("Recovery").addHandler(recoveryHandler);
}Example 5
| 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 6
| 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 7
| Project: jLEMS-master File: DefaultLogger.java View source code |
public static void initialize() {
if (instance == null) {
infoLogger.setUseParentHandlers(false);
SimpleFormatter fmt = new OneLineFormatter();
StreamHandler sh = new StreamHandler(System.out, fmt);
infoLogger.addHandler(sh);
instance = new DefaultLogger();
E.setMessageHandler(instance);
}
}Example 8
| 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 9
| Project: crash-master File: LogRecordRenderer.java View source code |
@Override
public Iterator<LineRenderer> iterator() {
return new BaseIterator<LineRenderer>() {
final SimpleFormatter formatter = new SimpleFormatter();
@Override
public boolean hasNext() {
return stream.hasNext();
}
@Override
public LineRenderer next() {
LogRecord record = stream.next();
String line = formatter.format(record);
Color color;
if (record.getLevel() == Level.SEVERE) {
color = Color.red;
} else if (record.getLevel() == Level.WARNING) {
color = Color.yellow;
} else if (record.getLevel() == Level.INFO) {
color = Color.green;
} else {
color = Color.blue;
}
return new LabelElement(line).style(color.fg()).renderer();
}
};
}Example 10
| Project: openjdk8-jdk-master File: MemoryHandler.java View source code |
// Private method to configure a MemoryHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
pushLevel = manager.getLevelProperty(cname + ".push", Level.SEVERE);
size = manager.getIntProperty(cname + ".size", DEFAULT_SIZE);
if (size <= 0) {
size = DEFAULT_SIZE;
}
setLevel(manager.getLevelProperty(cname + ".level", Level.ALL));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
}Example 11
| 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 12
| Project: agiga-master File: Util.java View source code |
public static void initializeLogging(Level consoleLevel) {
LogManager.getLogManager().reset();
SimpleFormatter sf = new SimpleFormatter() {
private final long startMillis = System.currentTimeMillis();
public String format(LogRecord record) {
StringBuilder sb = new StringBuilder();
sb.append(record.getMillis() - startMillis);
sb.append(" ");
sb.append(String.format("%-7s", record.getLevel()));
sb.append(" ");
sb.append(record.getLoggerName());
sb.append(" - ");
sb.append(record.getMessage());
sb.append("\n");
return sb.toString();
}
};
Handler ch = new ConsoleHandler();
ch.setFormatter(sf);
Logger globalLog = Logger.getLogger("");
globalLog.addHandler(ch);
ch.setLevel(consoleLevel);
}Example 13
| 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 14
| 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 15
| 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 16
| 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 17
| 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 18
| 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 19
| 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 20
| 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 21
| 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 22
| 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 23
| 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 24
| 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 25
| 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 26
| 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 27
| 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 28
| 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 29
| 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 30
| 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 31
| Project: com.opendoorlogistics-master File: InitialiseCore.java View source code |
private static void initialiseLogging() {
File configFile = new File(AppConstants.ODL_LOGGING_CONFIG);
if (configFile.exists()) {
Properties p = System.getProperties();
if (p.containsKey("java.util.logging.config.class")) {
p.remove("java.util.logging.config.class");
}
p.setProperty("java.util.logging.config.file", configFile.getAbsolutePath());
try {
LogManager.getLogManager().readConfiguration();
} catch (Exception e) {
throw new RuntimeException(e);
}
} else {
class StdLogger extends StreamHandler {
private java.util.logging.Formatter formatter = new SimpleFormatter();
@Override
public void publish(LogRecord record) {
// Only print to error by default if its an error
if (record.getLevel().intValue() < Level.WARNING.intValue()) {
System.out.println(formatter.formatMessage(record));
} else {
System.err.println(formatter.format(record));
}
}
}
java.util.logging.LogManager.getLogManager().reset();
java.util.logging.Logger.getLogger("").addHandler(new StdLogger());
}
logger = Logger.getLogger(InitialiseCore.class.getName());
logger.info("Initialised ODL Studio core logging");
}Example 32
| Project: delcyon-capo-master File: LeveledConsoleHandler.java View source code |
@Override
public void publish(LogRecord record) {
if (getFormatter() == null) {
setFormatter(new SimpleFormatter());
}
try {
String message = getFormatter().format(record);
if (levelHashMap.containsKey(record.getLevel())) {
switch(levelHashMap.get(record.getLevel())) {
case STDERR:
System.err.write(message.getBytes());
break;
case STDOUT:
System.out.write(message.getBytes());
break;
}
} else if (record.getLevel().intValue() >= errorLevel.intValue()) {
System.err.write(message.getBytes());
} else {
System.out.write(message.getBytes());
}
} catch (Exception exception) {
reportError(null, exception, ErrorManager.FORMAT_FAILURE);
return;
}
}Example 33
| 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 34
| 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 35
| Project: jFlowLib-master File: GroupMissingSequenceNumberChecker.java View source code |
public static void main(String args[]) throws SecurityException, IOException {
// 20 x 50MByte
FileHandler fh = new FileHandler("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");
mLogger.log(Level.INFO, "Program Start");
GroupMissingSequenceNumberChecker msnc = new GroupMissingSequenceNumberChecker();
for (long i = (((long) Math.pow(2, 32)) - 1000); i <= Math.pow(2, 32); i++) {
if (i != (Math.pow(2, 32) - 128))
msnc.addSequenceNumber(i);
// msnc.addSequenceNumber(i);
}
for (long i = 0; i <= Math.pow(2, 12); i++) {
if (i != 125)
msnc.addSequenceNumber(i);
}
System.out.println(msnc.getSequenceNumbers().size());
}Example 36
| 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 37
| Project: OpenJML-master File: Main.java View source code |
/**
* The main entry point of the application.
* @param args the command line arguments
*/
public static void main(String[] args) {
try {
FileHandler logh = new FileHandler("freeboogie.log");
logh.setFormatter(new SimpleFormatter());
log.addHandler(logh);
log.setLevel(Level.ALL);
} catch (IOException e) {
Err.warning("Can't create log file. Nevermind.");
log.setLevel(Level.OFF);
}
// parse command line arguments
Options opt = new Options();
opt.regBool("-pp", "pretty print");
opt.regBool("-pst", "print symbol table");
opt.regBool("-pfg", "print flow graphs");
//opt.regBool("-ppi", "print implementations per procedure");
opt.regInt("-v", 4, "verbosity level: 0, 1, 2, 3, 4");
opt.parse(args);
Err.setVerbosity(opt.intVal("-v"));
// process files one by one
PrintWriter pw = new PrintWriter(System.out);
PrettyPrinter pp = new PrettyPrinter(pw);
FlowGraphDumper fgd = new FlowGraphDumper();
TypeChecker tc = new TypeChecker();
for (String file : opt.otherArgs()) {
try {
FbLexer lexer = new FbLexer(new ANTLRFileStream(file));
CommonTokenStream tokens = new CommonTokenStream(lexer);
FbParser parser = new FbParser(tokens);
parser.fileName = file;
Declaration d = parser.program();
// errors while parsing or empty file
if (d == null)
continue;
// pretty print?
if (opt.boolVal("-pp")) {
d.eval(pp);
pw.flush();
}
// typecheck
tc.process(d);
// print symbol table?
if (opt.boolVal("-pst")) {
SymbolTable st = tc.getST();
st.funcs.iterDef(new Printer<AtomFun, Function>("function", st.funcs, new ClosureR<Function, String>() {
@Override
public String go(Function p) {
return p.getSig().getName();
}
}));
st.ids.iterDef(new Printer<AtomId, Declaration>("identifier", st.ids, new ClosureR<Declaration, String>() {
@Override
public String go(Declaration p) {
if (p instanceof VariableDecl)
return ((VariableDecl) p).getName();
else if (p instanceof ConstDecl)
return ((ConstDecl) p).getId();
assert false;
// dumb compiler
return null;
}
}));
st.procs.iterDef(new Printer<CallCmd, Procedure>("procedure", st.procs, new ClosureR<Procedure, String>() {
@Override
public String go(Procedure p) {
return p.getSig().getName();
}
}));
st.types.iterDef(new Printer<UserType, TypeDecl>("type", st.types, new ClosureR<TypeDecl, String>() {
@Override
public String go(TypeDecl p) {
return p.getName();
}
}));
}
// print flow graph?
if (opt.boolVal("-pfg"))
fgd.process(d, tc);
// print implementations per proc?
} catch (FileNotFoundException e) {
Err.error("I couldn't read from " + file + ". Nevermind.");
} catch (Exception e) {
Err.error("Unexpected error while processing " + file);
}
}
}Example 38
| Project: PBLabsProfiler-master File: FlashProfiler.java View source code |
/**
*
* On OS X, run with VM arg -XstartOnFirstThread
* @param args
*/
public static void main(String[] args) {
Display.setAppName("Flash Profiler");
display = new Display();
Shell shell = new Shell(display);
shell.setText("PBLabs Flash Profiler");
shell.setLayout(new FillLayout());
// Show the log area.
final Text consoleLog = new Text(shell, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
Logger.getLogger("").addHandler(new Handler() {
public Text consoleOut = consoleLog;
public SimpleFormatter sf = new SimpleFormatter();
public boolean isLoggable(LogRecord lr) {
return true;
}
public void publish(LogRecord lr) {
final String msg = lr.getLoggerName() + sf.format(lr);
final Text consoleOut2 = consoleOut;
display.asyncExec(new Runnable() {
public void run() {
consoleOut2.append(msg);
}
});
}
public void close() {
consoleOut.append("Done.\n");
}
public void flush() {
}
});
log.info("PBLabs Profiler v1.00");
// Kick up the profiler server.
try {
initNetPort();
} catch (IOException ioe) {
log.info("Failed to open port" + PORT + " for profiler connections.");
}
// Run main loop.
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
display.dispose();
}Example 39
| 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 40
| Project: yiiclipse-master File: YiiclipseBundle.java View source code |
public void start(BundleContext context) throws Exception {
super.start(context);
if (plugin == null) {
logger = Logger.getAnonymousLogger();
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setFormatter(new SimpleFormatter());
logger.addHandler(consoleHandler);
plugin = this;
}
debug("Yiiclipse is up and running.");
}Example 41
| Project: openjdk-master File: SerializeLogRecord.java View source code |
/**
* Serializes a log record, encode the serialized bytes in base 64, and
* prints pseudo java code that can be cut and pasted into this test.
* @param record the log record to serialize, encode in base 64, and for
* which test data will be generated.
* @return A string containing the generated pseudo java code.
* @throws IOException Unexpected.
* @throws ClassNotFoundException Unexpected.
*/
public static String generate(LogRecord record) throws IOException, ClassNotFoundException {
// Format the given logRecord using the SimpleFormatter
SimpleFormatter formatter = new SimpleFormatter();
String str = formatter.format(record);
// Serialize the given LogRecord
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(record);
oos.flush();
oos.close();
// Now we're going to perform a number of smoke tests before
// generating the Java pseudo code.
//
// First checks that the log record can be deserialized
final ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
final ObjectInputStream ois = new ObjectInputStream(bais);
final LogRecord record2 = (LogRecord) ois.readObject();
// Format the deserialized LogRecord using the SimpleFormatter, and
// check that the string representation obtained matches the string
// representation of the original LogRecord
String str2 = formatter.format(record2);
if (!str.equals(str2))
throw new RuntimeException("Unexpected values in deserialized object:" + "\n\tExpected: " + str + "\n\tRetrieved: " + str);
// Now get a Base64 string representation of the serialized bytes.
final String base64 = Base64.getEncoder().encodeToString(baos.toByteArray());
// Check that we can deserialize a log record from the Base64 string
// representation we just computed.
final ByteArrayInputStream bais2 = new ByteArrayInputStream(Base64.getDecoder().decode(base64));
final ObjectInputStream ois2 = new ObjectInputStream(bais2);
final LogRecord record3 = (LogRecord) ois2.readObject();
// Format the new deserialized LogRecord using the SimpleFormatter, and
// check that the string representation obtained matches the string
// representation of the original LogRecord
String str3 = formatter.format(record3);
if (!str.equals(str3))
throw new RuntimeException("Unexpected values in deserialized object:" + "\n\tExpected: " + str + "\n\tRetrieved: " + str);
//System.out.println(base64);
//System.out.println();
// Generates the Java Pseudo code that can be cut & pasted into
// this test (see Jdk8SerializedLog and Jdk9SerializedLog below)
final StringBuilder sb = new StringBuilder();
sb.append(" /**").append('\n');
sb.append(" * Base64 encoded string for LogRecord object.").append('\n');
sb.append(" * Java version: ").append(System.getProperty("java.version")).append('\n');
sb.append(" **/").append('\n');
sb.append(" final String base64 = ").append("\n ");
final int last = base64.length() - 1;
for (int i = 0; i < base64.length(); i++) {
if (i % 64 == 0)
sb.append("\"");
sb.append(base64.charAt(i));
if (i % 64 == 63 || i == last) {
sb.append("\"");
if (i == last)
sb.append(";\n");
else
sb.append("\n + ");
}
}
sb.append('\n');
sb.append(" /**").append('\n');
sb.append(" * SimpleFormatter output for LogRecord object.").append('\n');
sb.append(" * Java version: ").append(System.getProperty("java.version")).append('\n');
sb.append(" **/").append('\n');
sb.append(" final String str = ").append("\n ");
sb.append("\"").append(str.replace("\n", "\\n")).append("\";\n");
return sb.toString();
}Example 42
| Project: androidpn-master File: ServerStarter.java View source code |
public static void main(String[] args) {
try {
// FileHandler fh = new FileHandler("../logs/starter.log");
// fh.setFormatter(new SimpleFormatter());
// logger.addHandler(fh);
StreamHandler sh = new StreamHandler(System.out, new SimpleFormatter());
logger.addHandler(sh);
logger.setLevel(Level.ALL);
new ServerStarter().start();
} catch (Exception ex) {
ex.printStackTrace();
System.exit(1);
}
}Example 43
| Project: api-omdb-master File: TestLogger.java View source code |
/**
* configure the logger with a simple in-memory file for the required log level
*
* @param level The logging level required
* @return True if successful
*/
public static boolean configure(String level) {
StringBuilder config = new StringBuilder("handlers = java.util.logging.ConsoleHandler\n");
config.append(".level = ").append(level).append(CRLF);
config.append("java.util.logging.ConsoleHandler.level = ").append(level).append(CRLF);
// Only works with Java 7 or later
config.append("java.util.logging.SimpleFormatter.format = [%1$tH:%1$tM:%1$tS %4$6s] %2$s - %5$s %6$s%n").append(CRLF);
// Exclude logging messages
config.append("org.apache.http.level = SEVERE").append(CRLF);
InputStream ins = new ByteArrayInputStream(config.toString().getBytes());
try {
LogManager.getLogManager().readConfiguration(ins);
// Exclude http logging
System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "warn");
} catch (IOException ex) {
LOG.warn("Failed to configure log manager due to an IO problem", ex);
return Boolean.FALSE;
} finally {
try {
ins.close();
} catch (IOException ex) {
LOG.info("Failed to close input stream", ex);
}
}
LOG.debug("Logger initialized to '{}' level", level);
return Boolean.TRUE;
}Example 44
| Project: api-tvrage-master File: TestLogger.java View source code |
/**
* Configure the logger with a simple in-memory file for the required log level
*
* @param level The logging level required
* @return True if successful
*/
public static boolean configure(String level) {
StringBuilder config = new StringBuilder("handlers = java.util.logging.ConsoleHandler\n");
config.append(".level = ").append(level).append(CRLF);
config.append("java.util.logging.ConsoleHandler.level = ").append(level).append(CRLF);
// Only works with Java 7 or later
config.append("java.util.logging.SimpleFormatter.format = [%1$tH:%1$tM:%1$tS %4$6s] %2$s - %5$s %6$s%n").append(CRLF);
// Exclude logging messages
// Note: This does not work for apache
config.append("org.apache.http.level = SEVERE").append(CRLF);
InputStream ins = new ByteArrayInputStream(config.toString().getBytes());
try {
LogManager.getLogManager().readConfiguration(ins);
// Exclude http logging
System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "warn");
} catch (IOException ex) {
LOG.warn("Failed to configure log manager due to an IO problem", ex);
return Boolean.FALSE;
} finally {
try {
ins.close();
} catch (IOException ex) {
LOG.info("Failed to close input stream", ex);
}
}
LOG.debug("Logger initialized to '{}' level", level);
return Boolean.TRUE;
}Example 45
| Project: aws-dynamodb-mars-json-demo-master File: DynamoDBJSONRootWorkerTest.java View source code |
@Test
public void testEmptyMissionBody() throws IOException {
final Logger logger = Logger.getLogger(DynamoDBJSONRootWorker.class.getName());
Handler handler;
final ByteArrayOutputStream os = new ByteArrayOutputStream();
final URL url = PowerMock.createMock(URL.class);
PowerMock.mockStatic(JSONUtils.class);
PowerMock.mockStatic(NetworkUtils.class);
String manifest = null;
try {
manifest = WorkerTestUtils.readFile(EMPTY_MISSION_BODY_FILE);
} catch (final IOException e1) {
fail("Could not read file: " + EMPTY_MISSION_BODY_FILE);
}
try {
NetworkUtils.getDataFromURL(url, null, ImageIngester.DEFAULT_CONNECT_TIMEOUT);
PowerMock.expectLastCall().andReturn(manifest.getBytes());
PowerMock.replayAll();
handler = new StreamHandler(os, new SimpleFormatter());
logger.setUseParentHandlers(false);
logger.addHandler(handler);
try {
DynamoDBJSONRootWorker.getMissionToManifestMap(url, ImageIngester.DEFAULT_CONNECT_TIMEOUT);
} catch (final IOException e) {
fail(e.getMessage());
}
handler.flush();
assertTrue(os.toString().contains("WARNING: Missing mission manifest for MERB: {}"));
} finally {
try {
os.close();
} catch (final IOException e) {
fail(e.getMessage());
}
}
}Example 46
| 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 47
| 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 48
| Project: carbon-kernel-master File: CarbonLoggerTest.java View source code |
@BeforeClass
public void doBeforeEachTest() throws IOException {
setupCarbonHome();
logFile = new File(Paths.get(Utils.getCarbonHomeDirectory().toString(), "logs", Constants.CARBON_LOG_FILE_NAME).toString());
logger = Logger.getLogger(CarbonLoggerTest.class.getName());
carbonLogHandler = new CarbonLogHandler(logFile);
carbonLogHandler.setFormatter(new SimpleFormatter());
logger.addHandler(carbonLogHandler);
}Example 49
| 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 50
| 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 51
| 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 52
| Project: gluu-opendj-master File: QuickSetupLog.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(new SimpleFormatter());
Logger logger = Logger.getLogger("org.opends");
logger.addHandler(fileHandler);
disableConsoleLogging();
logger = Logger.getLogger("org.opends.quicksetup");
logger.log(Level.INFO, getInitialLogRecord());
}
}Example 53
| Project: JDK-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 54
| Project: jdrivesync-master File: App.java View source code |
public static void initLogging() {
String filename = "logging.properties";
System.setProperty("java.util.logging.config.file", filename);
System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s(): %5$s%6$s%n");
try {
InputStream inputStream = App.class.getResourceAsStream("/" + filename);
if (inputStream == null) {
throw new JDriveSyncException(JDriveSyncException.Reason.IOException, "Could not find logging configuration file: " + filename);
}
LogManager.getLogManager().readConfiguration(inputStream);
} catch (IOException e) {
throw new JDriveSyncException(JDriveSyncException.Reason.IOException, "Failed to read logging configuration: " + e.getMessage(), e);
}
}Example 55
| 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 56
| Project: OpenDJ-master File: JDKLogging.java View source code |
@Override
public void publish(LogRecord record) {
if (getFormatter() == null) {
setFormatter(new SimpleFormatter());
}
try {
String message = getFormatter().format(record);
if (record.getLevel().intValue() >= Level.WARNING.intValue()) {
System.err.write(message.getBytes());
} else {
System.out.write(message.getBytes());
}
} catch (Exception exception) {
reportError(null, exception, ErrorManager.FORMAT_FAILURE);
return;
}
}Example 57
| 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 58
| 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 59
| 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 60
| Project: streamflow-core-master File: ConsoleServerResource.java View source code |
@Override
protected Representation post(Representation representation, Variant variant) throws ResourceException {
Form form = new Form(representation);
String script = form.getFirstValue("script");
ValueBuilder<ConsoleScriptValue> builder = module.valueBuilderFactory().newValueBuilder(ConsoleScriptValue.class);
builder.prototype().script().set(script);
String firstValue = form.getFirstValue("complete");
builder.prototype().completeUnitOfWork().set(firstValue.equals("yes"));
try {
ConsoleResultValue result = console.executeScript(builder.newInstance());
String log = "";
SimpleFormatter formatter = new SimpleFormatter();
for (LogRecord logRecord : result.log().get()) {
log += formatter.format(logRecord) + "\n";
}
String template = TemplateUtil.getTemplate("console.html", ConsoleServerResource.class);
String content = TemplateUtil.eval(template, "$script", script, "$out", result.out().get(), "$log", log);
return new StringRepresentation(content, MediaType.TEXT_HTML, null, CharacterSet.UTF_8);
} catch (Exception e) {
StringWriter out = new StringWriter();
e.printStackTrace(new PrintWriter(out));
try {
String template = TemplateUtil.getTemplate("console.html", ConsoleServerResource.class);
String content = TemplateUtil.eval(template, "$script", script, "$out", out.toString());
return new StringRepresentation(content, MediaType.TEXT_HTML, null, CharacterSet.UTF_8);
} catch (IOException e1) {
throw new ResourceException(e1);
}
}
}Example 61
| Project: xdccBee-master File: BeeLogger.java View source code |
public static Logger getLogger() {
if (LOGGER == null) {
LOGGER = Logger.getLogger(LOGGER_NAME);
final Formatter formatter = new SimpleFormatter();
LOGGER.setUseParentHandlers(false);
console = new ConsoleHandler();
console.setLevel(Level.ALL);
console.setFormatter(formatter);
LOGGER.addHandler(console);
// TODO: setLevel to log in file only
LOGGER.setLevel(Level.ALL);
try {
logpath = AppConfig.SETTINGS_FOLDER_PATH + "/xdccBee.log";
FileHandler filehandler = new FileHandler(logpath);
filehandler.setFormatter(formatter);
LOGGER.addHandler(filehandler);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return LOGGER;
}Example 62
| 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 63
| Project: ganttproject-master File: GPLogger.java View source code |
public static void setLogFile(String logFileName) {
try {
Handler fileHandler = new FileHandler(logFileName, true);
fileHandler.setFormatter(new java.util.logging.SimpleFormatter());
ourLogger.removeHandler(ourHandler);
ourLogger.addHandler(fileHandler);
ourHandler = fileHandler;
ourLogFileName = logFileName;
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}Example 64
| Project: heron-master File: LoggingHelper.java View source code |
/**
* Initialize a <tt>FileHandler</tt> to write to a set of files
* with optional append. When (approximately) the given limit has
* been written to one file, another file will be opened. The
* output will cycle through a set of count files.
* The pattern of file name should be: ${processId}.log.index
* <p>
* The <tt>FileHandler</tt> is configured based on <tt>LogManager</tt>
* properties (or their default values) except that the given pattern
* argument is used as the filename pattern, the file limit is
* set to the limit argument, and the file count is set to the
* given count argument, and the append mode is set to the given
* <tt>append</tt> argument.
* <p>
* The count must be at least 1.
*
* @param limit the maximum number of bytes to write to any one file
* @param count the number of files to use
* @param append specifies append mode
* @throws IOException if there are IO problems opening the files.
* @throws SecurityException if a security manager exists and if
* the caller does not have <tt>LoggingPermission("control")</tt>.
* @throws IllegalArgumentException if {@code limit < 0}, or {@code count < 1}.
* @throws IllegalArgumentException if pattern is an empty string
*/
public static FileHandler getFileHandler(String processId, String loggingDir, boolean append, ByteAmount limit, int count) throws IOException, SecurityException {
String pattern = loggingDir + "/" + processId + ".log.%g";
FileHandler fileHandler = new FileHandler(pattern, (int) limit.asBytes(), count, append);
fileHandler.setFormatter(new SimpleFormatter());
fileHandler.setEncoding(StandardCharsets.UTF_8.toString());
return fileHandler;
}Example 65
| Project: web2native-bridge-master File: CallingW2NB.java View source code |
public static void main(final String[] args) {
if (args.length != 2) {
System.out.println("1: full proxy/install path\n2: URL-to-NFC-service");
System.exit(3);
}
String step = "initial";
try {
logger.setUseParentHandlers(false);
System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n");
FileHandler fh = new FileHandler(args[0] + File.separator + "logs" + File.separator + "w2nb-caller.log");
logger.addHandler(fh);
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
JSONObjectReader init = post(args[1], new JSONObjectWriter(), STANDARD_TIMEOUT);
logger.info("Invocation:" + init);
String application = init.getString(APPLICATION_JSON);
String invocationUrl = init.getString(INVOCATION_URL_JSON);
String optionalData = init.getString(OPTIONAL_DATA_JSON);
init.checkForUnread();
step = "starting";
Vector<String> commands = new Vector<String>();
commands.add("java");
commands.add("-Djava.util.logging.SimpleFormatter.format=%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n");
if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
commands.add("-Dswing.defaultlaf=com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
}
commands.add("-jar");
commands.add(args[0] + File.separator + "apps" + File.separator + application + File.separator + application + ".jar");
commands.add(args[0]);
commands.add(application);
commands.add(invocationUrl);
commands.add("e30");
commands.add(optionalData);
process = Runtime.getRuntime().exec(commands.toArray(new String[0]));
stdin = new StdinJSONPipe();
stdout = new StdoutJSONPipe();
step = "I/O";
new Thread() {
@Override
public void run() {
while (true) {
try {
JSONObjectReader response = post(args[1], new JSONObjectWriter().setBoolean(CONTROL_JSON, true), BACK_CHANNEL_TIMEOUT);
if (response.hasProperty(NOTHING_JSON)) {
logger.info("Nothing");
} else if (response.hasProperty(CLOSE_JSON)) {
logger.info("Web-side close");
System.exit(3);
} else {
stdout.writeJSONObject(new JSONObjectWriter(response));
}
} catch (Exception e) {
logger.log(Level.SEVERE, "Background", e);
System.exit(3);
}
}
}
}.start();
while (true) {
post(args[1], new JSONObjectWriter().setBoolean(CONTROL_JSON, false).setObject(MESSAGE_JSON, stdin.readJSONObject()), STANDARD_TIMEOUT);
}
} catch (Exception e) {
logger.log(Level.SEVERE, step, e);
try {
post(args[1], new JSONObjectWriter(), STANDARD_TIMEOUT);
} catch (IOException e1) {
}
System.exit(3);
}
}Example 66
| Project: android-15-master File: CookiesTest.java View source code |
/**
* Test that we don't log potentially sensitive cookie values.
* http://b/3095990
*/
public void testCookiesAreNotLogged() throws IOException, URISyntaxException {
// enqueue an HTTP response with a cookie that will be rejected
server.enqueue(new MockResponse().addHeader("Set-Cookie: password=secret; Domain=fake.domain"));
server.play();
ByteArrayOutputStream out = new ByteArrayOutputStream();
Logger logger = Logger.getLogger("org.apache.http");
StreamHandler handler = new StreamHandler(out, new SimpleFormatter());
logger.addHandler(handler);
try {
HttpClient client = new DefaultHttpClient();
client.execute(new HttpGet(server.getUrl("/").toURI()));
handler.close();
String log = out.toString("UTF-8");
assertTrue(log, log.contains("password"));
assertTrue(log, log.contains("fake.domain"));
assertFalse(log, log.contains("secret"));
} finally {
logger.removeHandler(handler);
}
}Example 67
| Project: android-sdk-sources-for-api-level-23-master File: CookiesTest.java View source code |
/**
* Test that we don't log potentially sensitive cookie values.
* http://b/3095990
*/
public void testCookiesAreNotLogged() throws IOException, URISyntaxException {
// enqueue an HTTP response with a cookie that will be rejected
server.enqueue(new MockResponse().addHeader("Set-Cookie: password=secret; Domain=fake.domain"));
server.play();
ByteArrayOutputStream out = new ByteArrayOutputStream();
Logger logger = Logger.getLogger("org.apache.http");
StreamHandler handler = new StreamHandler(out, new SimpleFormatter());
logger.addHandler(handler);
try {
HttpClient client = new DefaultHttpClient();
client.execute(new HttpGet(server.getUrl("/").toURI()));
handler.close();
String log = out.toString("UTF-8");
assertTrue(log, log.contains("password"));
assertTrue(log, log.contains("fake.domain"));
assertFalse(log, log.contains("secret"));
} finally {
logger.removeHandler(handler);
}
}Example 68
| Project: android_frameworks_base-master File: CookiesTest.java View source code |
/**
* Test that we don't log potentially sensitive cookie values.
* http://b/3095990
*/
public void testCookiesAreNotLogged() throws IOException, URISyntaxException {
// enqueue an HTTP response with a cookie that will be rejected
server.enqueue(new MockResponse().addHeader("Set-Cookie: password=secret; Domain=fake.domain"));
server.play();
ByteArrayOutputStream out = new ByteArrayOutputStream();
Logger logger = Logger.getLogger("org.apache.http");
StreamHandler handler = new StreamHandler(out, new SimpleFormatter());
logger.addHandler(handler);
try {
HttpClient client = new DefaultHttpClient();
client.execute(new HttpGet(server.getUrl("/").toURI()));
handler.close();
String log = out.toString("UTF-8");
assertTrue(log, log.contains("password"));
assertTrue(log, log.contains("fake.domain"));
assertFalse(log, log.contains("secret"));
} finally {
logger.removeHandler(handler);
}
}Example 69
| Project: api-fanarttv-master File: TestLogger.java View source code |
/**
* Configure the logger with a simple in-memory file for the required log
* level
*
* @param level The logging level required
* @return True if successful
*/
public static boolean configure(String level) {
StringBuilder config = new StringBuilder("handlers = java.util.logging.ConsoleHandler\n");
config.append(".level = ").append(level).append(CRLF);
config.append("java.util.logging.ConsoleHandler.level = ").append(level).append(CRLF);
// Only works with Java 7 or later
config.append("java.util.logging.SimpleFormatter.format = [%1$tH:%1$tM:%1$tS %4$6s] %2$s - %5$s %6$s%n").append(CRLF);
// Exclude logging messages
config.append("org.apache.http.level = SEVERE").append(CRLF);
InputStream ins = new ByteArrayInputStream(config.toString().getBytes());
try {
LogManager.getLogManager().readConfiguration(ins);
// Exclude http logging
System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "warn");
} catch (IOException ex) {
LOG.warn("Failed to configure log manager due to an IO problem", ex);
return Boolean.FALSE;
} finally {
try {
ins.close();
} catch (IOException ex) {
LOG.info("Failed to close input stream", ex);
}
}
LOG.debug("Logger initialized to '{}' level", level);
return Boolean.TRUE;
}Example 70
| Project: api-themoviedb-master File: TestLogger.java View source code |
/**
* configure the logger with a simple in-memory file for the required log level
*
* @param level The logging level required
* @return True if successful
*/
public static boolean configure(String level) {
StringBuilder config = new StringBuilder("handlers = java.util.logging.ConsoleHandler\n");
config.append(".level = ").append(level).append(CRLF);
config.append("java.util.logging.ConsoleHandler.level = ").append(level).append(CRLF);
// Only works with Java 7 or later
config.append("java.util.logging.SimpleFormatter.format = [%1$tH:%1$tM:%1$tS %4$6s] %2$s - %5$s %6$s%n").append(CRLF);
// Exclude http logging
config.append("sun.net.www.protocol.http.HttpURLConnection.level = OFF").append(CRLF);
config.append("org.apache.http.level = SEVERE").append(CRLF);
try (InputStream ins = new ByteArrayInputStream(config.toString().getBytes())) {
LogManager.getLogManager().readConfiguration(ins);
} catch (IOException e) {
LOG.warn("Failed to configure log manager due to an IO problem", e);
return Boolean.FALSE;
}
LOG.debug("Logger initialized to '{}' level", level);
return Boolean.TRUE;
}Example 71
| Project: api-thetvdb-master File: TestLogger.java View source code |
/**
* configure the logger with a simple in-memory file for the required log level
*
* @param level The logging level required
* @return True if successful
*/
public static boolean configure(String level) {
StringBuilder config = new StringBuilder("handlers = java.util.logging.ConsoleHandler\n");
config.append(".level = ").append(level).append(CRLF);
config.append("java.util.logging.ConsoleHandler.level = ").append(level).append(CRLF);
// Only works with Java 7 or later
config.append("java.util.logging.SimpleFormatter.format = [%1$tH:%1$tM:%1$tS %4$6s] %2$s - %5$s %6$s%n").append(CRLF);
// Exclude http logging
config.append("sun.net.www.protocol.http.HttpURLConnection.level = OFF").append(CRLF);
config.append("org.apache.http.level = SEVERE").append(CRLF);
try (InputStream ins = new ByteArrayInputStream(config.toString().getBytes())) {
LogManager.getLogManager().readConfiguration(ins);
} catch (IOException e) {
LOG.warn("Failed to configure log manager due to an IO problem", e);
return Boolean.FALSE;
}
LOG.debug("Logger initialized to '{}' level", level);
return Boolean.TRUE;
}Example 72
| Project: bio4j-neo4j-master File: UploadRefSeqSequencesToS3.java View source code |
public static void main(String[] args) {
if (args.length != 2) {
System.out.println("This program expects the following parameters: \n" + "1. Bucket name \n" + "2. Folder name with all the .gbk files");
} else {
String bucketName = args[0];
File currentFolder = new File(args[1]);
File[] files = currentFolder.listFiles();
try {
// This block configures the logger with handler and formatter
fh = new FileHandler("UploadRefSeqSequencesToS3.log", false);
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
logger.addHandler(fh);
logger.setLevel(Level.ALL);
//--------creating amazon s3 client--------------
AmazonS3Client amazonS3Client = new AmazonS3Client(new PropertiesCredentials(new File("AwsCredentials.properties")));
Owner bucketOwner = amazonS3Client.getBucketAcl(bucketName).getOwner();
for (File file : files) {
if (file.getName().endsWith(".gbff")) {
logger.log(Level.INFO, ("file: " + file.getName()));
BufferedReader reader = new BufferedReader(new FileReader(file));
String line = null;
while ((line = reader.readLine()) != null) {
//this is the first line where the locus is
//String accessionSt = "";
//String definitionSt = "";
String versionSt = "";
//String commentSt = "";
StringBuilder seqStBuilder = new StringBuilder();
boolean originFound = false;
//Now I get all the lines till I reach the string '//'
do {
boolean readLineFlag = true;
if (line.startsWith(GBCommon.LOCUS_STR)) {
// do nothing right now
} else if (line.startsWith(GBCommon.VERSION_STR)) {
versionSt = line.split(GBCommon.VERSION_STR)[1].trim().split(" ")[0];
} else if (line.startsWith(GBCommon.ORIGIN_STR)) {
//sequence
originFound = true;
do {
line = reader.readLine();
String[] tempArray = line.trim().split(" ");
for (int i = 1; i < tempArray.length; i++) {
seqStBuilder.append(tempArray[i]);
}
} while (line.startsWith(" "));
readLineFlag = false;
}
if (readLineFlag) {
line = reader.readLine();
}
} while (line != null && !line.startsWith(GBCommon.LAST_LINE_STR));
//-----we only save the data when the sequence is found------------
if (originFound) {
//-----saving sequence in S3------------
byte[] byteArray = seqStBuilder.toString().getBytes();
ByteArrayInputStream bs = new ByteArrayInputStream(byteArray);
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setContentLength(byteArray.length);
logger.log(Level.INFO, ("uploading sequence of genome element: " + versionSt + " ..."));
amazonS3Client.putObject(bucketName, versionSt + ".txt", bs, objectMetadata);
AccessControlList accessControlList = new AccessControlList();
accessControlList.grantPermission(GroupGrantee.AllUsers, Permission.Read);
accessControlList.setOwner(bucketOwner);
amazonS3Client.setObjectAcl(bucketName, versionSt + ".txt", accessControlList);
logger.log(Level.INFO, ("done!"));
//--------------------------------------
logger.log(Level.INFO, (versionSt + " sequence uploaded!"));
}
}
reader.close();
}
}
} catch (Exception e) {
logger.log(Level.SEVERE, e.getMessage());
StackTraceElement[] trace = e.getStackTrace();
for (StackTraceElement stackTraceElement : trace) {
logger.log(Level.SEVERE, stackTraceElement.toString());
}
} finally {
// closing logger file handler
fh.close();
}
}
}Example 73
| Project: ChallengeTask_Group2-master File: FSPeer.java View source code |
private static void initLogger(String prefix) {
logger = Logger.getLogger("mainLog");
try {
fh = new FileHandler(prefix + "peer.log", true);
logger.addHandler(fh);
logger.setLevel(Level.INFO);
SimpleFormatter sf = new SimpleFormatter();
fh.setFormatter(sf);
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}Example 74
| Project: classlib6-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 75
| Project: frameworks_base_disabled-master File: CookiesTest.java View source code |
/**
* Test that we don't log potentially sensitive cookie values.
* http://b/3095990
*/
public void testCookiesAreNotLogged() throws IOException, URISyntaxException {
// enqueue an HTTP response with a cookie that will be rejected
server.enqueue(new MockResponse().addHeader("Set-Cookie: password=secret; Domain=fake.domain"));
server.play();
ByteArrayOutputStream out = new ByteArrayOutputStream();
Logger logger = Logger.getLogger("org.apache.http");
StreamHandler handler = new StreamHandler(out, new SimpleFormatter());
logger.addHandler(handler);
try {
HttpClient client = new DefaultHttpClient();
client.execute(new HttpGet(server.getUrl("/").toURI()));
handler.close();
String log = out.toString("UTF-8");
assertTrue(log, log.contains("password"));
assertTrue(log, log.contains("fake.domain"));
assertFalse(log, log.contains("secret"));
} finally {
logger.removeHandler(handler);
}
}Example 76
| Project: httpserver-master File: FixedLengthInputStream.java View source code |
/**
* Http Server
*/
HttpServer startHttpServer() throws IOException {
if (debug) {
Logger logger = Logger.getLogger("com.sun.net.httpserver");
Handler outHandler = new StreamHandler(System.out, new SimpleFormatter());
outHandler.setLevel(Level.FINEST);
logger.setLevel(Level.FINEST);
logger.addHandler(outHandler);
}
HttpServer httpServer = HttpServer.create(new InetSocketAddress(0), 0);
httpServer.createContext("/flis/", new MyHandler(POST_SIZE));
httpServer.start();
return httpServer;
}Example 77
| Project: ikvm-openjdk-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 78
| Project: j2objc-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 79
| Project: jAPS2-master File: ApsSystemUtils.java View source code |
/**
* Inizializzazione della classe di utilità .
* @throws Exception
*/
public void init() throws Exception {
Level logLevel = Level.INFO;
try {
String logName = (String) this._systemParams.get(INIT_PROP_LOG_NAME);
_logger = Logger.getLogger(logName);
String pattern = (String) this._systemParams.get(INIT_PROP_LOG_FILE_PREFIX);
if (pattern != null && !pattern.equals("")) {
_logger.setUseParentHandlers(false);
// Esempio: "c:/dir/nome%g.log";
pattern = pattern + ".%g";
int limit = Integer.parseInt((String) this._systemParams.get(INIT_PROP_LOG_FILE_SIZE));
int count = Integer.parseInt((String) this._systemParams.get(INIT_PROP_LOG_FILES_COUNT));
FileHandler handler = new FileHandler(pattern, limit, count);
handler.setFormatter(new SimpleFormatter());
handler.setEncoding("UTF-8");
_logger.addHandler(handler);
}
String levelString = (String) this._systemParams.get(INIT_PROP_LOG_LEVEL);
logLevel = Level.parse(levelString);
_logger.setLevel(logLevel);
} catch (Exception e) {
try {
_logger = Logger.getLogger(this.getClass().getName());
_logger.log(Level.SEVERE, "Error detected while creating the logger: ", e);
} catch (RuntimeException e1) {
}
}
}Example 80
| Project: jdk7u-jdk-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 81
| Project: jersey-master File: ResourceBundleTest.java View source code |
@Test
public void testBadResource() throws Exception {
final ResourceConfig resourceConfig = new ResourceConfig(BadResource.class);
ByteArrayOutputStream logOutput = new ByteArrayOutputStream();
Handler logHandler = new StreamHandler(logOutput, new SimpleFormatter());
GrizzlyHttpServerFactory.createHttpServer(baseUri, resourceConfig, false);
// TODO: there should be a better way to get the log output!
final Enumeration<String> loggerNames = LogManager.getLogManager().getLoggerNames();
while (loggerNames.hasMoreElements()) {
String name = loggerNames.nextElement();
if (name.startsWith("org.glassfish")) {
LogManager.getLogManager().getLogger(Errors.class.getName()).addHandler(logHandler);
}
}
GrizzlyHttpServerFactory.createHttpServer(baseUri, resourceConfig, false);
logOutput.flush();
final String logOutputAsString = logOutput.toString();
Assert.assertFalse(logOutputAsString.contains("[failed to localize]"));
Assert.assertTrue(logOutputAsString.contains("BadResource"));
}Example 82
| Project: library-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 83
| Project: ManagedRuntimeInitiative-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 84
| 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 85
| Project: platform_frameworks_base-master File: CookiesTest.java View source code |
/**
* Test that we don't log potentially sensitive cookie values.
* http://b/3095990
*/
public void testCookiesAreNotLogged() throws IOException, URISyntaxException {
// enqueue an HTTP response with a cookie that will be rejected
server.enqueue(new MockResponse().addHeader("Set-Cookie: password=secret; Domain=fake.domain"));
server.play();
ByteArrayOutputStream out = new ByteArrayOutputStream();
Logger logger = Logger.getLogger("org.apache.http");
StreamHandler handler = new StreamHandler(out, new SimpleFormatter());
logger.addHandler(handler);
try {
HttpClient client = new DefaultHttpClient();
client.execute(new HttpGet(server.getUrl("/").toURI()));
handler.close();
String log = out.toString("UTF-8");
assertTrue(log, log.contains("password"));
assertTrue(log, log.contains("fake.domain"));
assertFalse(log, log.contains("secret"));
} finally {
logger.removeHandler(handler);
}
}Example 86
| Project: portlet-container-custom-master File: PortletDeployerMain.java View source code |
private static void initLoggerSettings() {
try {
String location = PortletRegistryHelper.getLogLocation();
String logFileName = location + "/" + "portlet-deploy.log";
Handler fh = new FileHandler(logFileName, true);
fh.setFormatter(new SimpleFormatter());
Logger adminLogger = Logger.getLogger("com.sun.portal.portletcontainer.admin");
initLoggerSettings(adminLogger, fh);
Logger mbeansLogger = Logger.getLogger("com.sun.portal.portletcontainer.admin.mbeans");
initLoggerSettings(mbeansLogger, fh);
Logger deploymentLogger = Logger.getLogger("com.sun.portal.portletcontainer.admin.deployment");
initLoggerSettings(deploymentLogger, fh);
Logger registryLogger = Logger.getLogger("com.sun.portal.portletcontainer.admin.registry");
initLoggerSettings(registryLogger, fh);
Logger warUpdaterLogger = Logger.getLogger("com.sun.portal.portletcontainer.warupdater");
initLoggerSettings(warUpdaterLogger, fh);
initLoggerSettings(logger, fh);
} catch (Exception e) {
e.printStackTrace();
}
}Example 87
| Project: property-db-master File: ConsoleHandler.java View source code |
// Private method to configure a ConsoleHandler from LogManager
// properties and/or default values as specified in the class
// javadoc.
private void configure() {
LogManager manager = LogManager.getLogManager();
String cname = getClass().getName();
setLevel(manager.getLevelProperty(cname + ".level", Level.INFO));
setFilter(manager.getFilterProperty(cname + ".filter", null));
setFormatter(manager.getFormatterProperty(cname + ".formatter", new SimpleFormatter()));
try {
setEncoding(manager.getStringProperty(cname + ".encoding", null));
} catch (Exception ex) {
try {
setEncoding(null);
} catch (Exception ex2) {
}
}
}Example 88
| Project: ScreenSlicer-master File: Log.java View source code |
public static void init(String loggerName, boolean allowFileLogging) {
logger = Logger.getLogger(loggerName);
if (allowFileLogging) {
FileHandler fh = null;
try {
fh = new FileHandler("../" + loggerName + ".log", 250000, 9, true);
logger.addHandler(fh);
String logLevel = System.getProperty("slicer.log", "prod");
if (logLevel.equals("prod")) {
logger.setLevel(Level.INFO);
} else if (logLevel.equals("debug")) {
logger.setLevel(Level.ALL);
}
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
} catch (Throwable t) {
t.printStackTrace();
throw new RuntimeException(t);
}
}
}Example 89
| Project: slicer-master File: Log.java View source code |
public static void init(String loggerName, boolean allowFileLogging) {
logger = Logger.getLogger(loggerName);
if (allowFileLogging) {
FileHandler fh = null;
try {
fh = new FileHandler("../" + loggerName + ".log", 250000, 9, true);
logger.addHandler(fh);
String logLevel = System.getProperty("slicer.log", "prod");
if (logLevel.equals("prod")) {
logger.setLevel(Level.INFO);
} else if (logLevel.equals("debug")) {
logger.setLevel(Level.ALL);
}
SimpleFormatter formatter = new SimpleFormatter();
fh.setFormatter(formatter);
} catch (Throwable t) {
t.printStackTrace();
throw new RuntimeException(t);
}
}
}Example 90
| Project: sockjs-servlet-master File: SockJsProtocolTestServer.java View source code |
private static void configureLogging(Level level) throws Exception {
Logger rootLogger = Logger.getLogger("");
String logFile = System.getProperty("logFile");
if (logFile != null) {
rootLogger.addHandler(new FileHandler(logFile));
}
for (Handler handler : rootLogger.getHandlers()) {
handler.setFilter(new Filter() {
private String[] noisyLoggers = new String[] { "com.sun.jmx", "javax.management", "org.xnio" };
@Override
public boolean isLoggable(LogRecord record) {
String loggerName = record.getLoggerName();
for (String noisyLogger : noisyLoggers) {
if (loggerName != null && loggerName.startsWith(noisyLogger)) {
return false;
}
}
return true;
}
});
handler.setLevel(level);
handler.setFormatter(new java.util.logging.Formatter() {
// Totally ripped off from java.util.logging.SimpleFormatter
private final String format = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp %4$s [%2$s] %5$s%6$s%n";
private final Date dat = new Date();
@Override
public synchronized String format(LogRecord record) {
dat.setTime(record.getMillis());
String source = record.getLoggerName();
String message = formatMessage(record);
String throwable = "";
if (record.getThrown() != null) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
pw.println();
record.getThrown().printStackTrace(pw);
pw.close();
throwable = sw.toString();
}
return String.format(format, dat, source, record.getLoggerName(), record.getLevel().getName(), message, throwable);
}
});
}
rootLogger.setLevel(level);
}Example 91
| Project: TransFile-master File: TransFile.java View source code |
/**
* Sets up the base logger for the project (net.sourceforge.transfile)
*
* @throws IOException if an I/O error occurred while trying to access the log file
*/
private static final void configureLogger() throws IOException {
// remove all default handlers
for (Handler handler : Logger.getLogger("").getHandlers()) Logger.getLogger("").removeHandler(handler);
final Level logLevel = Level.parse(Settings.getPreferences().get("log_level", Settings.LOG_LEVEL.getName()));
final Handler consoleHandler = new ConsoleHandler();
final Handler fileHandler = new FileHandler(Settings.getPreferences().get("log_path", Settings.LOG_PATH.getAbsolutePath()));
consoleHandler.setLevel(logLevel);
fileHandler.setLevel(logLevel);
fileHandler.setFormatter(new SimpleFormatter());
Logger.getLogger(PACKAGE_NAME).addHandler(consoleHandler);
Logger.getLogger(PACKAGE_NAME).addHandler(fileHandler);
Logger.getLogger(PACKAGE_NAME).setLevel(logLevel);
}Example 92
| Project: tuscany-sca-2.x-master File: ProblemImpl.java View source code |
@Override
public String toString() {
Logger logger = Logger.getLogger(sourceClassName, bundleName);
LogRecord record = new LogRecord(Level.INFO, messageId);
if (cause == null) {
record.setParameters(messageParams);
} else {
Object[] params = new String[1];
params[0] = cause.toString();
record.setParameters(params);
}
record.setResourceBundle(logger.getResourceBundle());
record.setSourceClassName(sourceClassName);
Formatter formatter = new SimpleFormatter();
return context + " - " + formatter.formatMessage(record);
}Example 93
| Project: umongo-master File: PreferencesDialog.java View source code |
public Handler getApplicationLogHandler() {
if (!getBooleanFieldValue(Item.applicationLogFlag)) {
return null;
}
String path = getStringFieldValue(Item.applicationLogFile);
if (path == null || path.trim().isEmpty()) {
return null;
}
Handler handler;
try {
handler = new FileHandler(path, getIntFieldValue(Item.applicationLogSize) * 1024 * 1024, getIntFieldValue(Item.applicationLogCount), true);
Level lvl = Level.WARNING;
String lvlStr = getStringFieldValue(Item.applicationLogLevel);
if (lvlStr.equals("OFF"))
lvl = Level.OFF;
else if (lvlStr.equals("ALL"))
lvl = Level.ALL;
else if (lvlStr.equals("INFO"))
lvl = Level.INFO;
else if (lvlStr.equals("WARNING"))
lvl = Level.WARNING;
else if (lvlStr.equals("SEVERE"))
lvl = Level.SEVERE;
handler.setLevel(lvl);
Formatter fmt = new SimpleFormatter();
if (getStringFieldValue(Item.applicationLogFormat).equals("XML"))
fmt = new XMLFormatter();
handler.setFormatter(fmt);
return handler;
} catch (Exception ex) {
getLogger().log(Level.WARNING, null, ex);
}
return null;
}Example 94
| Project: vertx-unit-master File: ReportingTest.java View source code |
private String testLog(String name, Runnable runnable) {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
StreamHandler handler = new StreamHandler(buffer, new java.util.logging.SimpleFormatter());
Logger logger = Logger.getLogger(name);
logger.addHandler(handler);
try {
runnable.run();
handler.flush();
return buffer.toString();
} finally {
logger.removeHandler(handler);
}
}Example 95
| Project: VirtMus-master File: Log.java View source code |
/** Turns on full NetBeans logging for debug purposes.
* This creates a VirtMus.log file (typically in the app's var/log directory)
* which contains just the SEVERE entries. Everything else can be found in
* ~/.virtmus/var/log/messages.log (or build/testuserdir/var/log/messages.log)
* and in the IDE log.
*
* To log to VirtMus.log:
* Logger.getLogger("org.netbeans").log(Level.SEVERE, "Test log msg");
*/
public static void enableDebugLogs() {
// Pick the loggers to enable
//Enumeration<String> loggers = LogManager.getLogManager().getLoggerNames();
String[] loggers = {};
try {
boolean append = false;
String fn = StatsLogger.getLogFile("VirtMusDebug-%g.log").getPath();
FileHandler fHandler = new FileHandler(fn, append);
fHandler.setFormatter(new SimpleFormatter());
Handler mHandler = new MemoryHandler(fHandler, 1000, Level.SEVERE);
Logger log;
for (String lgr : loggers) {
log = Logger.getLogger(lgr);
log.addHandler(mHandler);
log.setLevel(Level.ALL);
}
} catch (IOExceptionSecurityException | ex) {
Logger.getLogger("global").log(Level.SEVERE, null, ex);
}
}Example 96
| Project: wpcleaner-master File: WikipediaCleaner.java View source code |
/**
* @param args
*/
public static void main(String[] args) {
// Log levels
Logger.getLogger("org.lobobrowser").setLevel(Level.WARNING);
Logger.getLogger("").setLevel(Level.WARNING);
Configuration config = Configuration.getConfiguration();
EnumLanguage language = EnumLanguage.getDefaultLanguage();
Locale.setDefault(language.getLocale());
// Check that calls are made in the Event Dispatch Thread
if (CHECK_EDT) {
RepaintManager.setCurrentManager(new CheckThreadViolationRepaintManager());
}
// Look & Feel
String lookAndFeelClassName = null;
if (SYSTEM_LF) {
lookAndFeelClassName = UIManager.getSystemLookAndFeelClassName();
}
switch(config.getInt(null, ConfigurationValueInteger.PLAF_TYPE)) {
case ConfigurationConstants.VALUE_PLAF_TYPE_WPCLEANER:
lookAndFeelClassName = getLookAndFeelClassName("Nimbus");
break;
case ConfigurationConstants.VALUE_PLAF_TYPE_USER:
lookAndFeelClassName = getLookAndFeelClassName(config.getString(null, ConfigurationValueString.PLAF_NAME));
break;
}
if (lookAndFeelClassName != null) {
try {
UIManager.setLookAndFeel(lookAndFeelClassName);
} catch (ClassNotFoundException e) {
} catch (InstantiationException e) {
} catch (IllegalAccessException e) {
} catch (UnsupportedLookAndFeelException e) {
}
}
// Font size for defaults
int fontSize = config.getInt(null, ConfigurationValueInteger.FONT_SIZE);
if (fontSize > 0) {
UIDefaults defaults = UIManager.getLookAndFeelDefaults();
for (Object key : defaults.keySet()) {
Font font = defaults.getFont(key);
if (font != null) {
font = font.deriveFont((float) (font.getSize() + fontSize));
defaults.put(key, font);
}
}
}
// Manage copy/paste for OS X
int menuShortcut = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
if (menuShortcut == InputEvent.META_DOWN_MASK) {
InputMap im = (InputMap) UIManager.get("TextField.focusInputMap");
if (im != null) {
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_C, menuShortcut), DefaultEditorKit.copyAction);
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_V, menuShortcut), DefaultEditorKit.pasteAction);
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_X, menuShortcut), DefaultEditorKit.cutAction);
}
}
// Debugging
if (config.getBoolean(null, ConfigurationValueBoolean.DEBUG_DETAILS)) {
Logger.getLogger("org.wikipediacleaner").setLevel(Level.FINE);
}
if (config.getBoolean(null, ConfigurationValueBoolean.DEBUG_FILE)) {
try {
Handler fh = new FileHandler("%t/WPCleaner.log");
fh.setFormatter(new SimpleFormatter());
Logger.getLogger("").addHandler(fh);
} catch (Exception e) {
}
}
// Language
GT.setCurrentLanguage(config.getLanguage());
// Various initializations
ISBNRange.initialize();
// Analyze command line arguments
int currentArg = 0;
// Retrieve wiki
EnumWikipedia wiki = null;
if (args.length > currentArg) {
String wikiCode = args[currentArg];
wiki = EnumWikipedia.getWikipedia(wikiCode);
}
currentArg++;
// Retrieve user name
String userName = null;
if (args.length > currentArg) {
userName = args[currentArg];
}
currentArg++;
// Retrieve password
String password = null;
if (args.length > currentArg) {
password = args[currentArg];
}
currentArg++;
// Running
MainWindow.createMainWindow(wiki, userName, password);
}Example 97
| Project: tomcat60-master File: FileHandler.java View source code |
/**
* Configure from <code>LogManager</code> properties.
*/
private void configure() {
Timestamp ts = new Timestamp(System.currentTimeMillis());
String tsString = ts.toString().substring(0, 19);
date = tsString.substring(0, 10);
//allow classes to override
String className = this.getClass().getName();
ClassLoader cl = Thread.currentThread().getContextClassLoader();
// Retrieve configuration of logging file name
rotatable = Boolean.parseBoolean(getProperty(className + ".rotatable", "true"));
if (directory == null)
directory = getProperty(className + ".directory", "logs");
if (prefix == null)
prefix = getProperty(className + ".prefix", "juli.");
if (suffix == null)
suffix = getProperty(className + ".suffix", ".log");
String sBufferSize = getProperty(className + ".bufferSize", String.valueOf(bufferSize));
try {
bufferSize = Integer.parseInt(sBufferSize);
} catch (NumberFormatException ignore) {
}
// Get encoding for the logging file
String encoding = getProperty(className + ".encoding", null);
if (encoding != null && encoding.length() > 0) {
try {
setEncoding(encoding);
} catch (UnsupportedEncodingException ex) {
}
}
// Get logging level for the handler
setLevel(Level.parse(getProperty(className + ".level", "" + Level.ALL)));
// Get filter configuration
String filterName = getProperty(className + ".filter", null);
if (filterName != null) {
try {
setFilter((Filter) cl.loadClass(filterName).newInstance());
} catch (Exception e) {
}
}
// Set formatter
String formatterName = getProperty(className + ".formatter", null);
if (formatterName != null) {
try {
setFormatter((Formatter) cl.loadClass(formatterName).newInstance());
} catch (Exception e) {
setFormatter(new SimpleFormatter());
}
} else {
setFormatter(new SimpleFormatter());
}
// Set error manager
setErrorManager(new ErrorManager());
}Example 98
| Project: tomcat70-master File: FileHandler.java View source code |
/**
* Configure from <code>LogManager</code> properties.
*/
private void configure() {
Timestamp ts = new Timestamp(System.currentTimeMillis());
String tsString = ts.toString().substring(0, 19);
date = tsString.substring(0, 10);
//allow classes to override
String className = this.getClass().getName();
ClassLoader cl = Thread.currentThread().getContextClassLoader();
// Retrieve configuration of logging file name
rotatable = Boolean.parseBoolean(getProperty(className + ".rotatable", "true"));
if (directory == null)
directory = getProperty(className + ".directory", "logs");
if (prefix == null)
prefix = getProperty(className + ".prefix", "juli.");
if (suffix == null)
suffix = getProperty(className + ".suffix", ".log");
String sBufferSize = getProperty(className + ".bufferSize", String.valueOf(bufferSize));
try {
bufferSize = Integer.parseInt(sBufferSize);
} catch (NumberFormatException ignore) {
}
// Get encoding for the logging file
String encoding = getProperty(className + ".encoding", null);
if (encoding != null && encoding.length() > 0) {
try {
setEncoding(encoding);
} catch (UnsupportedEncodingException ex) {
}
}
// Get logging level for the handler
setLevel(Level.parse(getProperty(className + ".level", "" + Level.ALL)));
// Get filter configuration
String filterName = getProperty(className + ".filter", null);
if (filterName != null) {
try {
setFilter((Filter) cl.loadClass(filterName).newInstance());
} catch (Exception e) {
}
}
// Set formatter
String formatterName = getProperty(className + ".formatter", null);
if (formatterName != null) {
try {
setFormatter((Formatter) cl.loadClass(formatterName).newInstance());
} catch (Exception e) {
setFormatter(new SimpleFormatter());
}
} else {
setFormatter(new SimpleFormatter());
}
// Set error manager
setErrorManager(new ErrorManager());
}Example 99
| Project: tomee-master File: FileHandler.java View source code |
/**
* Configure from <code>LogManager</code> properties.
*/
private void configure() {
final Timestamp ts = new Timestamp(System.currentTimeMillis());
final String tsString = ts.toString().substring(0, 19);
date = tsString.substring(0, 10);
//allow classes to override
final String className = this.getClass().getName();
final ClassLoader cl = Thread.currentThread().getContextClassLoader();
// Retrieve configuration of logging file name
rotatable = Boolean.parseBoolean(getProperty(className + ".rotatable", "true"));
if (directory == null) {
directory = getProperty(className + ".directory", "logs");
}
if (prefix == null) {
prefix = getProperty(className + ".prefix", "juli.");
}
if (suffix == null) {
suffix = getProperty(className + ".suffix", ".log");
}
final String sBufferSize = getProperty(className + ".bufferSize", String.valueOf(bufferSize));
try {
bufferSize = Integer.parseInt(sBufferSize);
} catch (final NumberFormatException ignore) {
}
// Get encoding for the logging file
final String encoding = getProperty(className + ".encoding", null);
if (encoding != null && encoding.length() > 0) {
try {
setEncoding(encoding);
} catch (final UnsupportedEncodingException ex) {
}
}
// Get logging level for the handler
setLevel(Level.parse(getProperty(className + ".level", String.valueOf(Level.ALL))));
// Get filter configuration
final String filterName = getProperty(className + ".filter", null);
if (filterName != null) {
try {
setFilter((Filter) cl.loadClass(filterName).newInstance());
} catch (final Exception e) {
}
}
// Set formatter
final String formatterName = getProperty(className + ".formatter", null);
if (formatterName != null) {
try {
setFormatter((Formatter) cl.loadClass(formatterName).newInstance());
} catch (final Exception e) {
setFormatter(new SimpleFormatter());
}
} else {
setFormatter(new SimpleFormatter());
}
// Set error manager
setErrorManager(new ErrorManager());
}Example 100
| Project: AIGS-master File: Main.java View source code |
/**
* This method is responsible for the logging by setting a FileHandler.
* Usually the log files will be saved to the folder "logs", under the name
* "aigs.log". Logs which exceed 10 MB in size will trigger the creation of
* a new logfile.<br>
* The property {@link ServerConfiguration#getIsXMLlogging() } indicates
* whether the logging will be in the XML format or a more concise form is
* being used.
*/
private static void setUpLogging() {
// Get the standard logger (root logger) from which all loggers inherit
Logger rootLogger = Logger.getLogger("");
try {
// Creates "logs" folder, if it does not already exist
String logDirectory = ServerConfiguration.getInstance().getLogDirectory();
new File(logDirectory).mkdir();
//new File("logs").mkdir();
// Housekeeping: Get the old handlers and remove them.
Handler[] handlers = rootLogger.getHandlers();
for (Handler h : handlers) {
rootLogger.removeHandler(h);
}
// Add a filehandler to the root logger. All logging activity will
// be saved to the file "logs/aigs.log". If the file exceeds 10 MB
// a new file will be created (up to 10).
FileHandler fileHandler = new FileHandler(logDirectory + "/aigs.log", 1073741824, 10);
fileHandler.setEncoding("UTF-8");
// Decides which logging format will be used.
if (ServerConfiguration.getInstance().getIsXMLlogging()) {
fileHandler.setFormatter(new XMLFormatter());
fileHandler.setLevel(Level.ALL);
} else {
fileHandler.setFormatter(new SimpleFormatter());
}
rootLogger.addHandler(fileHandler);
// Add a Console handler so all logs will also be shown on the console.
ConsoleHandler consoleHandler = new ConsoleHandler();
consoleHandler.setLevel(Level.ALL);
consoleHandler.setFormatter(new SimpleFormatter());
rootLogger.addHandler(consoleHandler);
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, "File could not be opened or created. A new log file will be created.", ex);
} catch (SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
} catch (// All other exceptions
Exception // All other exceptions
ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, "An unknown error occured.", ex);
}
Logger.getLogger(Main.class.getName()).log(Level.INFO, "Now logging...");
}Example 101
| 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");
}