Add LogSource to encapsulate source of a log event

Signed-off-by: Curtis Rueden <ctrueden@wisc.edu>

Author: maarzt

src/main/java/org/scijava/log/AbstractLogService.java

@@ -92,8 +92,8 @@ public void alwaysLog(final int level, final Object msg, final Throwable t) {
 	}
 
 	@Override
-	public String getName() {
-		return rootLogger.getName();
+	public LogSource getSource() {
+		return rootLogger.getSource();
 	}
 
 	@Override
@@ -104,8 +104,8 @@ public int getLevel() {
 	}
 
 	@Override
-	public Logger subLogger(String nameExtension, int level) {
-		return rootLogger.subLogger(nameExtension, level);
+	public Logger subLogger(String name, int level) {
+		return rootLogger.subLogger(name, level);
 	}
 
 	// -- Listenable methods --
@@ -174,7 +174,8 @@ private Map<String, Integer> setupMapFromProperties(Properties properties,
 	private class RootLogger extends DefaultLogger {
 
 		public RootLogger() {
-			super(AbstractLogService.this::notifyListeners, "", LogLevel.NONE);
+			super(AbstractLogService.this::notifyListeners, LogSource.newRoot(),
+				LogLevel.NONE);
 		}
 
 		@Override

src/main/java/org/scijava/log/DefaultLogger.java

@@ -45,25 +45,25 @@ public class DefaultLogger implements Logger, LogListener {
 
 	private final LogListener destination;
 
-	private final String name;
+	private final LogSource source;
 
 	private final int level;
 
 	private final List<LogListener> listeners = new CopyOnWriteArrayList<>();
 
-	public DefaultLogger(final LogListener destination, final String name,
-								   final int level)
+	public DefaultLogger(final LogListener destination,
+		final LogSource source, final int level)
 	{
 		this.destination = destination;
-		this.name = name;
+		this.source = source;
 		this.level = level;
 	}
 
 	// -- Logger methods --
 
 	@Override
-	public String getName() {
-		return name;
+	public LogSource getSource() {
+		return source;
 	}
 
 	@Override
@@ -73,11 +73,11 @@ public int getLevel() {
 
 	@Override
 	public void alwaysLog(final int level, final Object msg, final Throwable t) {
-		messageLogged(new LogMessage(level, msg, t));
+		messageLogged(new LogMessage(source, level, msg, t));
 	}
 
 	public Logger subLogger(final String name, final int level) {
-		return new DefaultLogger(this, name, level);
+		return new DefaultLogger(this, source.subSource(name), level);
 	}
 
 	// -- Listenable methods --

src/main/java/org/scijava/log/LogMessage.java

@@ -45,25 +45,32 @@
  */
 public class LogMessage {
 
+	private final LogSource source;
 	private final int level;
 	private final String message;
 	private final Throwable throwable;
 	private final Date time;
 
 	private Collection<Object> attachments;
 
-	public LogMessage(int level, Object message,
+	public LogMessage(LogSource source, int level, Object message,
 		Throwable throwable)
 	{
+		this.source = source;
 		this.attachments = null;
 		this.level = level;
 		this.message = message == null ? null : message.toString();
 		this.throwable = throwable;
 		this.time = new Date();
 	}
 
-	public LogMessage(int level, Object msg) {
-		this(level, msg, null);
+	public LogMessage(LogSource source, int level, Object msg) {
+		this(source, level, msg, null);
+	}
+
+	/** Represents the source of the message. */
+	public LogSource source() {
+		return source;
 	}
 
 	/**
@@ -121,6 +128,7 @@ public static String format(final LogMessage message) {
 		final PrintWriter printer = new PrintWriter(sw);
 		printer.print("[" + message.time() + "] ");
 		printer.print("[" + LogLevel.prefix(message.level()) + "] ");
+		printer.print("[" + message.source() + "] ");
 		printer.println(message.text());
 		if (message.throwable() != null) {
 			message.throwable().printStackTrace(printer);

src/main/java/org/scijava/log/LogSource.java

@@ -0,0 +1,116 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.log;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringJoiner;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+
+/**
+ * Identifies where a {@link LogMessage} came from.
+ *
+ * @author Matthias Arzt
+ */
+public class LogSource {
+
+	private final LogSource parent;
+
+	private final List<String> path;
+
+	private final ConcurrentMap<String, LogSource> children =
+		new ConcurrentSkipListMap<>();
+
+	private String formatted = null;
+
+	private LogSource(LogSource parent, String name) {
+		this.parent = parent;
+		List<String> parentPath = parent.path();
+		List<String> list = new ArrayList<>(parentPath.size() + 1);
+		list.addAll(parentPath);
+		list.add(name);
+		this.path = Collections.unmodifiableList(list);
+	}
+
+	private LogSource() {
+		this.parent = null;
+		this.path = Collections.emptyList();
+	}
+
+	/** Returns the root log source. This LogSource represents the empty list. */
+	public static LogSource newRoot() {
+		return new LogSource();
+	}
+
+	/** Returns the list of strings which is represented by this LogSource. */
+	public List<String> path() {
+		return path;
+	}
+
+	/** Returns the last entry in the list of strings. */
+	public String name() {
+		if (path.isEmpty()) return "";
+		return path.get(path.size() - 1);
+	}
+
+	/**
+	 * Returns the LogSource which represents the path of this LogSource extended
+	 * by name.
+	 */
+	public LogSource subSource(String name) {
+		LogSource child = children.get(name);
+		if (child != null) return child;
+		child = new LogSource(this, name);
+		children.putIfAbsent(name, child);
+		return children.get(name);
+	}
+
+	@Override
+	public String toString() {
+		if (formatted != null) return formatted;
+		StringJoiner joiner = new StringJoiner(":");
+		path.forEach(s -> joiner.add(s));
+		formatted = joiner.toString();
+		return formatted;
+	}
+
+	public boolean isRoot() {
+		return parent == null;
+	}
+
+	/** Gets the parent of this source, or null if the source is a root. */
+	public LogSource parent() {
+		return parent;
+	}
+}

src/main/java/org/scijava/log/Logger.java

@@ -185,7 +185,12 @@ default void log(final int level, final Object msg, final Throwable t) {
 	void alwaysLog(int level, Object msg, Throwable t);
 
 	/** Returns the name of this logger. */
-	String getName();
+	default String getName() {
+		return getSource().name();
+	}
+
+	/** Returns the {@link LogSource} associated with this logger. */
+	LogSource getSource();
 
 	/** Returns the log level of this logger. see {@link LogLevel} */
 	int getLevel();
@@ -201,6 +206,7 @@ default Logger subLogger(String name) {
 	/**
 	 * Creates a sub logger, that forwards the message it gets to this logger.
 	 *
+	 * @param name The name of the sub logger.
 	 * @param level The log level of the sub logger.
 	 */
 	Logger subLogger(String name, int level);

src/test/java/org/scijava/log/DefaultLoggerTest.java

@@ -31,9 +31,12 @@
 
 package org.scijava.log;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
+import java.util.Arrays;
+
 import org.junit.Before;
 import org.junit.Test;
 
@@ -49,7 +52,7 @@ public class DefaultLoggerTest {
 
 	@Before
 	public void setup() {
-		logger = new DefaultLogger(message -> {}, "", LogLevel.INFO);
+		logger = new DefaultLogger(message -> {}, LogSource.newRoot(), LogLevel.INFO);
 		listener = new TestLogListener();
 		logger.addListener(listener);
 	}
@@ -71,7 +74,20 @@ public void testSubLogger() {
 
 		sub.error("Hello World!");
 
-		assertTrue(listener.hasLogged(m -> m.text().equals("Hello World!")));
+		assertTrue(listener.hasLogged(m -> m.source().path().contains("sub")));
+	}
+
+	@Test
+	public void testHierarchicLogger() {
+		listener.clear();
+		Logger subA = logger.subLogger("subA");
+		Logger subB = subA.subLogger("subB");
+
+		subB.error("Hello World!");
+
+		assertTrue(listener.hasLogged(m -> m.source().equals(subB.getSource())));
+		assertEquals(Arrays.asList("subA"), subA.getSource().path());
+		assertEquals(Arrays.asList("subA", "subB"), subB.getSource().path());
 	}
 
 	@Test

src/test/java/org/scijava/log/LogMessageTest.java

@@ -46,7 +46,7 @@ public class LogMessageTest {
 	public void testToString() {
 		String nameOfThisMethod = "testToString";
 		// setup
-		LogMessage message = new LogMessage(LogLevel.DEBUG, 42, new NullPointerException());
+		LogMessage message = new LogMessage(LogSource.newRoot(), LogLevel.DEBUG, 42, new NullPointerException());
 		// process
 		String s = message.toString();
 		//test
@@ -59,7 +59,7 @@ public void testToString() {
 	@Test
 	public void testToStringOptionalParameters() {
 		// setup
-		LogMessage message = new LogMessage(LogLevel.WARN, null, null);
+		LogMessage message = new LogMessage(LogSource.newRoot(), LogLevel.WARN, null, null);
 
 		// process
 		// Can it still format the message if optional parameters are null?