mstoeck3/autopsy-flatpak
1
0
Fork 0
mirror of https://github.com/overcuriousity/autopsy-flatpak.git synced 2025-07-15 09:17:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make logger code thread-safe

Browse Source
This commit is contained in:
Richard Cordovano 2015-09-24 16:06:29 -04:00
parent 96fb192e2a
commit 1e99aeb8ff
1 changed files with 137 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

231
Core/src/org/sleuthkit/autopsy/coreutils/Logger.java
View File

@ -1,7 +1,7 @@
/* /*
* Autopsy Forensic Browser * Autopsy Forensic Browser
* *
* Copyright 2012-2014 Basis Technology Corp. * Copyright 2012-2015 Basis Technology Corp.
* Contact: carrier <at> sleuthkit <dot> org * Contact: carrier <at> sleuthkit <dot> org
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
@ -18,17 +18,20 @@
*/ */
package org.sleuthkit.autopsy.coreutils; package org.sleuthkit.autopsy.coreutils;
import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.nio.file.Paths;
import java.util.logging.FileHandler; import java.util.logging.FileHandler;
import java.util.logging.Formatter; import java.util.logging.Formatter;
import java.util.logging.Handler; import java.util.logging.Handler;
import java.sql.Timestamp; import java.sql.Timestamp;
import java.util.Date; import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.LogRecord; import java.util.logging.LogRecord;
/** /**
* Autopsy specialization of the Java Logger class with custom file handlers. * Autopsy specialization of the Java Logger class with custom file handlers.
* Note that the custom loggers are not obtained from the global log manager.
*/ */
public final class Logger extends java.util.logging.Logger { public final class Logger extends java.util.logging.Logger {
@ -37,66 +40,81 @@ public final class Logger extends java.util.logging.Logger {
private static final int LOG_FILE_COUNT = 10; private static final int LOG_FILE_COUNT = 10;
private static final String LOG_WITHOUT_STACK_TRACES = "autopsy.log"; //NON-NLS private static final String LOG_WITHOUT_STACK_TRACES = "autopsy.log"; //NON-NLS
private static final String LOG_WITH_STACK_TRACES = "autopsy_traces.log"; //NON-NLS private static final String LOG_WITH_STACK_TRACES = "autopsy_traces.log"; //NON-NLS
private static final Handler console = new java.util.logging.ConsoleHandler(); private static final Map<String, Logger> namesToLoggers = new HashMap<>();
private static final Object fileHandlerLock = new Object(); private static final Handler consoleHandler = new java.util.logging.ConsoleHandler();
private static FileHandler userFriendlyLogFile = createFileHandler(PlatformUtil.getLogDirectory(), LOG_WITHOUT_STACK_TRACES); private static FileHandler userFriendlyHandler = createFileHandlerWithoutTraces(PlatformUtil.getLogDirectory());
private static FileHandler developersLogFile = createFileHandler(PlatformUtil.getLogDirectory(), LOG_WITH_STACK_TRACES); private static FileHandler developerFriendlyHandler = createFileHandlerWithTraces(PlatformUtil.getLogDirectory());
private static FileHandler createFileHandler(String logDirectory, String fileName) { /**
* Creates a custom file handler with a custom message formatter that does
* not include stack traces.
*
* @param logDirectory The directory where the log files should reside.
*
* @return A custom file handler.
*/
private static FileHandler createFileHandlerWithoutTraces(String logDirectory) {
String logFilePath = Paths.get(logDirectory, LOG_WITHOUT_STACK_TRACES).toString();
try { try {
FileHandler f = new FileHandler(logDirectory + File.separator + fileName, LOG_SIZE, LOG_FILE_COUNT); FileHandler fileHandler = new FileHandler(logFilePath, LOG_SIZE, LOG_FILE_COUNT);
f.setEncoding(LOG_ENCODING); fileHandler.setEncoding(LOG_ENCODING);
switch (fileName) { fileHandler.setFormatter(new Formatter() {
case LOG_WITHOUT_STACK_TRACES: @Override
f.setFormatter(new Formatter() { public String format(LogRecord record) {
@Override return (new Date(record.getMillis())).toString() + " "
public String format(LogRecord record) { + record.getSourceClassName() + " "
synchronized (fileHandlerLock) { + record.getSourceMethodName() + "\n"
return (new Date(record.getMillis())).toString() + " " + record.getLevel() + ": "
+ record.getSourceClassName() + " " + this.formatMessage(record) + "\n";
+ record.getSourceMethodName() + "\n" }
+ record.getLevel() + ": " });
+ this.formatMessage(record) + "\n"; return fileHandler;
} } catch (IOException ex) {
} throw new RuntimeException(String.format("Error initializing file handler for %s", logFilePath), ex); //NON-NLS
}); }
break; }
case LOG_WITH_STACK_TRACES:
f.setFormatter(new Formatter() {
@Override
public String format(LogRecord record) {
synchronized (fileHandlerLock) {
if (record.getThrown() != null) {
StackTraceElement ele[] = record.getThrown().getStackTrace(); /**
String StackTrace = ""; * Creates a custom file handler with a custom message formatter that
for (StackTraceElement ele1 : ele) { * incldues stack traces.
StackTrace += "\t" + ele1.toString() + "\n"; *
} * @param logDirectory The directory where the log files should reside.
*
return (new Timestamp(record.getMillis())).toString() + " " * @return A custom file handler.
+ record.getSourceClassName() + " " */
+ record.getSourceMethodName() + "\n" private static FileHandler createFileHandlerWithTraces(String logDirectory) {
+ record.getLevel() + ": " String logFilePath = Paths.get(logDirectory, LOG_WITH_STACK_TRACES).toString();
+ this.formatMessage(record) + "\n" try {
+ record.getThrown().toString() + ":\n" FileHandler fileHandler = new FileHandler(logFilePath, LOG_SIZE, LOG_FILE_COUNT);
+ StackTrace fileHandler.setEncoding(LOG_ENCODING);
+ "\n"; fileHandler.setFormatter(new Formatter() {
} else { @Override
return (new Timestamp(record.getMillis())).toString() + " " public String format(LogRecord record) {
+ record.getSourceClassName() + " " if (record.getThrown() != null) {
+ record.getSourceMethodName() + "\n" String stackTrace = ""; //NON-NLS
+ record.getLevel() + ": " for (StackTraceElement traceElem : record.getThrown().getStackTrace()) {
+ this.formatMessage(record) + "\n"; stackTrace += "\t" + traceElem.toString() + "\n"; //NON-NLS
}
}
} }
}); return (new Timestamp(record.getMillis())).toString() + " " //NON-NLS
break; + record.getSourceClassName() + " " //NON-NLS
} + record.getSourceMethodName() + "\n" //NON-NLS
return f; + record.getLevel() + ": " //NON-NLS
} catch (IOException e) { + this.formatMessage(record) + "\n" //NON-NLS
throw new RuntimeException("Error initializing " + fileName + " file handler", e); //NON-NLS + record.getThrown().toString() + ":\n" //NON-NLS
+ stackTrace
+ "\n"; //NON-NLS
} else {
return (new Timestamp(record.getMillis())).toString() + " " //NON-NLS
+ record.getSourceClassName() + " " //NON-NLS
+ record.getSourceMethodName() + "\n" //NON-NLS
+ record.getLevel() + ": " //NON-NLS
+ this.formatMessage(record) + "\n"; //NON-NLS
}
}
});
return fileHandler;
} catch (IOException ex) {
throw new RuntimeException(String.format("Error initializing file handler for %s", logFilePath), ex); //NON-NLS
} }
} }
@ -105,63 +123,88 @@ public final class Logger extends java.util.logging.Logger {
* *
* @param directoryPath The path to the desired log directory as a string. * @param directoryPath The path to the desired log directory as a string.
*/ */
public static void setLogDirectory(String directoryPath) { synchronized public static void setLogDirectory(String directoryPath) {
if (null != directoryPath && !directoryPath.isEmpty()) { /*
File directory = new File(directoryPath); * Create file handlers for the new directory and swap them into all of
if (directory.exists() && directory.canWrite()) { * the existing loggers using thread-safe Logger methods. The new
synchronized (fileHandlerLock) { * handlers are added before the old handlers so that no messages will
userFriendlyLogFile.close(); * be lost, but this makes it possible for log messages to be written
userFriendlyLogFile = createFileHandler(directoryPath, LOG_WITHOUT_STACK_TRACES); * via the old handlers if logging calls are interleaved with the
developersLogFile.close(); * add/remove handler calls (currently, the base class handlers
developersLogFile = createFileHandler(directoryPath, LOG_WITH_STACK_TRACES); * collection is a CopyOnWriteArrayList).
} */
} FileHandler newUserFriendlyHandler = createFileHandlerWithoutTraces(directoryPath);
FileHandler newDeveloperFriendlyHandler = createFileHandlerWithTraces(directoryPath);
for (Logger logger : namesToLoggers.values()) {
logger.addHandler(newUserFriendlyHandler);
logger.addHandler(newDeveloperFriendlyHandler);
logger.removeHandler(userFriendlyHandler);
logger.removeHandler(userFriendlyHandler);
} }
/*
* Close the old file handlers and save references to the new handlers
* so they can be added to any new loggers. This swap is why this method
* and the two overloads of getLogger() are synchronized, serializing
* access to userFriendlyHandler and developerFriendlyHandler.
*/
userFriendlyHandler.close();
userFriendlyHandler = newUserFriendlyHandler;
developerFriendlyHandler.close();
developerFriendlyHandler = newDeveloperFriendlyHandler;
} }
/** /**
* Factory method to retrieve a org.sleuthkit.autopsy.coreutils.Logger * Finds or creates a customized logger. Hides the base class factory
* instance derived from java.util.logging.Logger. Hides the base class * method.
* factory method.
* *
* @param name A name for the logger. This should be a dot-separated name * @param name A name for the logger. This should normally be a
* and should normally be based on the package name or class * dot-separated name based on a package name or class name.
* name.
* *
* @return org.sleuthkit.autopsy.coreutils.Logger instance * @return org.sleuthkit.autopsy.coreutils.Logger instance
*/ */
public static Logger getLogger(String name) { synchronized public static Logger getLogger(String name) {
return new Logger(name, null); return getLogger(name, null);
} }
/** /**
* Factory method to retrieve a org.sleuthkit.autopsy.coreutils.Logger * Finds or creates a customized logger. Hides the base class factory
* instance derived from java.util.logging.Logger. Hides the base class * method.
* factory method.
* *
* @param name A name for the logger. This should be a * @param name A name for the logger. This should normally be
* dot-separated name and should normally be based * a dot-separated name based on a package name or
* on the package name or class name. * class name.
* @param resourceBundleName - name of ResourceBundle to be used for * @param resourceBundleName Name of ResourceBundle to be used for
* localizing messages for this logger. May be * localizing messages for this logger. May be
* null if none of the messages require * null.
* localization.
* *
* @return org.sleuthkit.autopsy.coreutils.Logger instance * @return org.sleuthkit.autopsy.coreutils.Logger instance
*/ */
public static Logger getLogger(String name, String resourceBundleName) { synchronized public static Logger getLogger(String name, String resourceBundleName) {
return new Logger(name, resourceBundleName); if (!namesToLoggers.containsKey(name)) {
Logger logger = new Logger(name, resourceBundleName);
logger.addHandler(userFriendlyHandler);
logger.addHandler(developerFriendlyHandler);
namesToLoggers.put(name, logger);
}
return namesToLoggers.get(name);
} }
/**
* Constructs a customized logger.
*
* @param name A name for the logger. This should normally be
* a dot-separated name based on a package name or
* class name.
* @param resourceBundleName Name of ResourceBundle to be used for
* localizing messages for this logger. May be
* null.
*/
private Logger(String name, String resourceBundleName) { private Logger(String name, String resourceBundleName) {
super(name, resourceBundleName); super(name, resourceBundleName);
super.setUseParentHandlers(false);
if (Version.getBuildType() == Version.Type.DEVELOPMENT) { if (Version.getBuildType() == Version.Type.DEVELOPMENT) {
super.addHandler(console); super.addHandler(consoleHandler);
}
synchronized (fileHandlerLock) {
super.setUseParentHandlers(false);
super.addHandler(userFriendlyLogFile);
super.addHandler(developersLogFile);
} }
} }
} }