Make logger code thread-safe

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

@@ -1,7 +1,7 @@
 /*
  * Autopsy Forensic Browser
  *
- * Copyright 2012-2014 Basis Technology Corp.
+ * Copyright 2012-2015 Basis Technology Corp.
  * Contact: carrier <at> sleuthkit <dot> org
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,17 +18,20 @@
  */
 package org.sleuthkit.autopsy.coreutils;
 
-import java.io.File;
 import java.io.IOException;
+import java.nio.file.Paths;
 import java.util.logging.FileHandler;
 import java.util.logging.Formatter;
 import java.util.logging.Handler;
 import java.sql.Timestamp;
 import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.logging.LogRecord;
 
 /**
  * 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 {
 
@@ -37,66 +40,81 @@ 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 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 {
-            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:
-                    f.setFormatter(new Formatter() {
                 @Override
                 public String format(LogRecord record) {
-                            synchronized (fileHandlerLock) {
                     return (new Date(record.getMillis())).toString() + " "
                             + record.getSourceClassName() + " "
                             + record.getSourceMethodName() + "\n"
                             + record.getLevel() + ": "
                             + this.formatMessage(record) + "\n";
                 }
-                        }
             });
-                    break;
+            return fileHandler;
-                case LOG_WITH_STACK_TRACES:
+        } catch (IOException ex) {
-                    f.setFormatter(new Formatter() {
+            throw new RuntimeException(String.format("Error initializing file handler for %s", logFilePath), ex); //NON-NLS
+        }
+    }
+
+    /**
+     * Creates a custom file handler with a custom message formatter that
+     * incldues stack traces.
+     *
+     * @param logDirectory The directory where the log files should reside.
+     *
+     * @return A custom file handler.
+     */
+    private static FileHandler createFileHandlerWithTraces(String logDirectory) {
+        String logFilePath = Paths.get(logDirectory, LOG_WITH_STACK_TRACES).toString();
+        try {
+            FileHandler fileHandler = new FileHandler(logFilePath, LOG_SIZE, LOG_FILE_COUNT);
+            fileHandler.setEncoding(LOG_ENCODING);
+            fileHandler.setFormatter(new Formatter() {
                 @Override
                 public String format(LogRecord record) {
-                            synchronized (fileHandlerLock) {
                     if (record.getThrown() != null) {
-
+                        String stackTrace = ""; //NON-NLS
-                                    StackTraceElement ele[] = record.getThrown().getStackTrace();
+                        for (StackTraceElement traceElem : record.getThrown().getStackTrace()) {
-                                    String StackTrace = "";
+                            stackTrace += "\t" + traceElem.toString() + "\n"; //NON-NLS
-                                    for (StackTraceElement ele1 : ele) {
-                                        StackTrace += "\t" + ele1.toString() + "\n";
                         }
-
+                        return (new Timestamp(record.getMillis())).toString() + " " //NON-NLS
-                                    return (new Timestamp(record.getMillis())).toString() + " "
+                                + record.getSourceClassName() + " " //NON-NLS
-                                            + record.getSourceClassName() + " "
+                                + record.getSourceMethodName() + "\n" //NON-NLS
-                                            + record.getSourceMethodName() + "\n"
+                                + record.getLevel() + ": " //NON-NLS
-                                            + record.getLevel() + ": "
+                                + this.formatMessage(record) + "\n" //NON-NLS
-                                            + this.formatMessage(record) + "\n"
+                                + record.getThrown().toString() + ":\n" //NON-NLS
-                                            + record.getThrown().toString() + ":\n"
+                                + stackTrace
-                                            + StackTrace
+                                + "\n"; //NON-NLS
-                                            + "\n";
                     } else {
-                                    return (new Timestamp(record.getMillis())).toString() + " "
+                        return (new Timestamp(record.getMillis())).toString() + " " //NON-NLS
-                                            + record.getSourceClassName() + " "
+                                + record.getSourceClassName() + " " //NON-NLS
-                                            + record.getSourceMethodName() + "\n"
+                                + record.getSourceMethodName() + "\n" //NON-NLS
-                                            + record.getLevel() + ": "
+                                + record.getLevel() + ": " //NON-NLS
-                                            + this.formatMessage(record) + "\n";
+                                + this.formatMessage(record) + "\n"; //NON-NLS
-                                }
                     }
                 }
             });
-                    break;
+            return fileHandler;
-            }
+        } catch (IOException ex) {
-            return f;
+            throw new RuntimeException(String.format("Error initializing file handler for %s", logFilePath), ex); //NON-NLS
-        } catch (IOException e) {
-            throw new RuntimeException("Error initializing " + fileName + " file handler", e); //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.
      */
-    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
      */
-    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
-     *                           null if none of the messages require
+     *                           null.
-     *                           localization.
      *
      * @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) {
         super(name, resourceBundleName);
-        if (Version.getBuildType() == Version.Type.DEVELOPMENT) {
-            super.addHandler(console);
-        }
-        synchronized (fileHandlerLock) {
         super.setUseParentHandlers(false);
-            super.addHandler(userFriendlyLogFile);
+        if (Version.getBuildType() == Version.Type.DEVELOPMENT) {
-            super.addHandler(developersLogFile);
+            super.addHandler(consoleHandler);
         }
     }
 }