Merge pull request #1123 from rcordovano/logger_thread_safety

Logger thread safety

Core/src/org/sleuthkit/autopsy/casemodule/Case.java

@@ -226,6 +226,7 @@ public class Case implements SleuthkitCase.ErrorObserver {
         if (newCase != null) {
             currentCase = newCase;
 
+            Logger.setLogDirectory(currentCase.getLogDirectoryPath());
             
             try {
                 pcs.firePropertyChange(Events.CURRENT_CASE.toString(), null, currentCase);
@@ -253,6 +254,8 @@ public class Case implements SleuthkitCase.ErrorObserver {
             doCaseNameChange(currentCase.name);
 
             RecentCases.getInstance().addRecentCase(currentCase.name, currentCase.configFilePath); // update the recent cases
+        } else {
+            Logger.setLogDirectory(PlatformUtil.getLogDirectory());
         }
     }
 

Core/src/org/sleuthkit/autopsy/coreutils/Logger.java

@@ -18,8 +18,6 @@
  */
 package org.sleuthkit.autopsy.coreutils;
 
-import java.beans.PropertyChangeEvent;
-import java.beans.PropertyChangeListener;
 import java.io.File;
 import java.io.IOException;
 import java.util.logging.FileHandler;
@@ -28,7 +26,6 @@ import java.util.logging.Handler;
 import java.sql.Timestamp;
 import java.util.Date;
 import java.util.logging.LogRecord;
-import org.sleuthkit.autopsy.casemodule.Case;
 
 /**
  * Autopsy specialization of the Java Logger class with custom file handlers.
@@ -40,40 +37,11 @@ public final class Logger extends java.util.logging.Logger {
     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_WITH_STACK_TRACES = "autopsy_traces.log"; //NON-NLS
-    private static final CaseChangeListener caseChangeListener = new CaseChangeListener();
     private static final Handler console = new java.util.logging.ConsoleHandler();
+    private static final Object fileHandlerLock = new Object();
     private static FileHandler userFriendlyLogFile = createFileHandler(PlatformUtil.getLogDirectory(), LOG_WITHOUT_STACK_TRACES);
     private static FileHandler developersLogFile = createFileHandler(PlatformUtil.getLogDirectory(), LOG_WITH_STACK_TRACES);
 
-    static {
-        Case.addPropertyChangeListener(caseChangeListener);
-    }
-
-    private static class CaseChangeListener implements PropertyChangeListener {
-
-        @Override
-        public void propertyChange(PropertyChangeEvent event) {
-            if (event.getPropertyName().equals(Case.Events.CURRENT_CASE.toString())) {
-                // Write to logs in the Logs directory of the current case, or 
-                // to logs in the user directory when there is no case.
-                if (event.getNewValue() != null) {
-                    String logDirectoryPath = ((Case) event.getNewValue()).getLogDirectoryPath();
-                    if (!logDirectoryPath.isEmpty()) {
-                        userFriendlyLogFile.close();
-                        userFriendlyLogFile = createFileHandler(logDirectoryPath, LOG_WITHOUT_STACK_TRACES);
-                        developersLogFile.close();
-                        developersLogFile = createFileHandler(logDirectoryPath, LOG_WITH_STACK_TRACES);
-                    }
-                } else {
-                    userFriendlyLogFile.close();
-                    userFriendlyLogFile = createFileHandler(PlatformUtil.getLogDirectory(), LOG_WITHOUT_STACK_TRACES);
-                    developersLogFile.close();
-                    developersLogFile = createFileHandler(PlatformUtil.getLogDirectory(), LOG_WITH_STACK_TRACES);
-                }
-            }
-        }
-    }
-
     private static FileHandler createFileHandler(String logDirectory, String fileName) {
         try {
             FileHandler f = new FileHandler(logDirectory + File.separator + fileName, LOG_SIZE, LOG_FILE_COUNT);
@@ -83,36 +51,8 @@ public final class Logger extends java.util.logging.Logger {
                     f.setFormatter(new Formatter() {
                         @Override
                         public String format(LogRecord record) {
-                            return (new Date(record.getMillis())).toString() + " "
+                            synchronized (fileHandlerLock) {
-                                    + record.getSourceClassName() + " "
+                                return (new Date(record.getMillis())).toString() + " "
-                                    + record.getSourceMethodName() + "\n"
-                                    + record.getLevel() + ": "
-                                    + this.formatMessage(record) + "\n";
-                        }
-                    });
-                    break;
-                case LOG_WITH_STACK_TRACES:
-                    f.setFormatter(new Formatter() {
-                        @Override
-                        public String format(LogRecord record) {
-                            if (record.getThrown() != null) {
-
-                                StackTraceElement ele[] = record.getThrown().getStackTrace();
-                                String StackTrace = "";
-                                for (StackTraceElement ele1 : ele) {
-                                    StackTrace += "\t" + ele1.toString() + "\n";
-                                }
-
-                                return (new Timestamp(record.getMillis())).toString() + " "
-                                        + record.getSourceClassName() + " "
-                                        + record.getSourceMethodName() + "\n"
-                                        + record.getLevel() + ": "
-                                        + this.formatMessage(record) + "\n"
-                                        + record.getThrown().toString() + ": "
-                                        + StackTrace
-                                        + "\n";
-                            } else {
-                                return (new Timestamp(record.getMillis())).toString() + " "
                                         + record.getSourceClassName() + " "
                                         + record.getSourceMethodName() + "\n"
                                         + record.getLevel() + ": "
@@ -121,6 +61,38 @@ public final class Logger extends java.util.logging.Logger {
                         }
                     });
                     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 = "";
+                                    for (StackTraceElement ele1 : ele) {
+                                        StackTrace += "\t" + ele1.toString() + "\n";
+                                    }
+
+                                    return (new Timestamp(record.getMillis())).toString() + " "
+                                            + record.getSourceClassName() + " "
+                                            + record.getSourceMethodName() + "\n"
+                                            + record.getLevel() + ": "
+                                            + this.formatMessage(record) + "\n"
+                                            + record.getThrown().toString() + ": "
+                                            + StackTrace
+                                            + "\n";
+                                } else {
+                                    return (new Timestamp(record.getMillis())).toString() + " "
+                                            + record.getSourceClassName() + " "
+                                            + record.getSourceMethodName() + "\n"
+                                            + record.getLevel() + ": "
+                                            + this.formatMessage(record) + "\n";
+                                }
+                            }
+                        }
+                    });
+                    break;
             }
             return f;
         } catch (IOException e) {
@@ -128,6 +100,25 @@ public final class Logger extends java.util.logging.Logger {
         }
     }
 
+    /**
+     * Sets the log directory where the log files will be written.
+     *
+     * @param directoryPath The path to the desired log directory as a string.
+     */
+    public static void setLogDirectory(String directoryPath) {
+        if (null != directoryPath && !directoryPath.isEmpty()) {
+            File directory = new File(directoryPath);
+            if (directory.exists() && directory.canWrite()) {
+                synchronized (fileHandlerLock) {
+                    userFriendlyLogFile.close();
+                    userFriendlyLogFile = createFileHandler(directoryPath, LOG_WITHOUT_STACK_TRACES);
+                    developersLogFile.close();
+                    developersLogFile = createFileHandler(directoryPath, LOG_WITH_STACK_TRACES);
+                }
+            }
+        }
+    }
+
     /**
      * Factory method to retrieve a org.sleuthkit.autopsy.coreutils.Logger
      * instance derived from java.util.logging.Logger. Hides the base class
@@ -162,8 +153,10 @@ public final class Logger extends java.util.logging.Logger {
         if (Version.getBuildType() == Version.Type.DEVELOPMENT) {
             super.addHandler(console);
         }
-        super.setUseParentHandlers(false);
+        synchronized (fileHandlerLock) {
-        super.addHandler(userFriendlyLogFile);
+            super.setUseParentHandlers(false);
-        super.addHandler(developersLogFile);
+            super.addHandler(userFriendlyLogFile);
+            super.addHandler(developersLogFile);
+        }
     }
 }