Give each Task a Logger for its output

Tasks such as building a Python environment or running an external
process produce output that users sometimes need to see, but which does
not fit into a status message. Task#log() provides a channel for
it, which UIs can listen to via Logger#addLogListener.

Task output is kept separate from the application log, so that e.g. a
package manager's chatter does not flood the console. DefaultTask's
logger passes every level to its listeners, and retains nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: ctrueden

pom.xml

@@ -10,7 +10,7 @@
 	</parent>
 
 	<artifactId>scijava-common</artifactId>
-	<version>2.100.2-SNAPSHOT</version>
+	<version>2.101.0-SNAPSHOT</version>
 
 	<name>SciJava Common</name>
 	<description>SciJava Common is a shared library for SciJava software. It provides a plugin framework, with an extensible mechanism for service discovery, backed by its own annotation processor, so that plugins can be loaded dynamically. It is used by downstream projects in the SciJava ecosystem, such as ImageJ and SCIFIO.</description>

src/main/java/org/scijava/task/DefaultTask.java

@@ -32,6 +32,10 @@
 import java.util.concurrent.Future;
 
 import org.scijava.event.EventService;
+import org.scijava.log.DefaultLogger;
+import org.scijava.log.LogLevel;
+import org.scijava.log.LogSource;
+import org.scijava.log.Logger;
 import org.scijava.task.event.TaskEvent;
 import org.scijava.thread.ThreadService;
 
@@ -85,6 +89,8 @@ public class DefaultTask implements Task {
 
 	private Runnable cancelCallBack;
 
+	private volatile Logger logger;
+
 	/**
 	 * Creates a new task.
 	 *
@@ -199,6 +205,32 @@ public Runnable getCancelCallBack() {
 		return this.cancelCallBack;
 	}
 
+	/**
+	 * {@inheritDoc}
+	 * <p>
+	 * The logger passes messages of every level to its listeners, and retains
+	 * nothing: listeners receive only what is logged after they are added.
+	 * </p>
+	 */
+	@Override
+	public Logger log() {
+		// Note: Double-checked locking, so that logging many lines does not
+		// mean acquiring a lock for each one.
+		Logger result = logger;
+		if (result == null) {
+			synchronized (this) {
+				result = logger;
+				if (result == null) {
+					final String source = name == null ? "task" : name;
+					result = new DefaultLogger(message -> {}, LogSource.newRoot()
+						.subSource(source), LogLevel.TRACE);
+					logger = result;
+				}
+			}
+		}
+		return result;
+	}
+
 	@Override
 	public String getCancelReason() {
 		return cancelReason;

src/main/java/org/scijava/task/Task.java

@@ -33,6 +33,10 @@
 
 import org.scijava.Cancelable;
 import org.scijava.Named;
+import org.scijava.log.DefaultLogger;
+import org.scijava.log.LogLevel;
+import org.scijava.log.LogSource;
+import org.scijava.log.Logger;
 
 /**
  * A self-aware job which reports its status and progress as it runs.
@@ -151,4 +155,22 @@ default Runnable getCancelCallBack() {
 		return () -> {};
 	}
 
+	/**
+	 * Gets the logger for output produced while performing the task, such as
+	 * the lines printed by an external process it runs. Called by task
+	 * implementors to emit output, and by interested parties (e.g. a UI showing
+	 * the task) to listen for it via {@link Logger#addLogListener}.
+	 * <p>
+	 * Task output is kept separate from the application log: messages logged
+	 * here reach this logger's listeners only.
+	 * </p>
+	 * <p>
+	 * The default implementation returns a logger that discards everything.
+	 * </p>
+	 */
+	default Logger log() {
+		return new DefaultLogger(message -> {}, LogSource.newRoot(),
+			LogLevel.NONE);
+	}
+
 }

src/test/java/org/scijava/task/TaskServiceTest.java

@@ -30,13 +30,20 @@
 package org.scijava.task;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.ExecutionException;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.scijava.Context;
+import org.scijava.log.LogLevel;
+import org.scijava.log.LogMessage;
+import org.scijava.log.Logger;
 
 /**
  * Tests {@link TaskService}.
@@ -71,4 +78,46 @@ public void testTask() throws InterruptedException, ExecutionException {
 		task.waitFor();
 		assertEquals(100, result[0]);
 	}
+
+	@Test
+	public void testLogger() {
+		final Task task = taskService.createTask("chatty");
+		final Logger logger = task.log();
+		assertSame(logger, task.log());
+		assertEquals("chatty", logger.getSource().name());
+
+		final List<LogMessage> messages = new ArrayList<>();
+		logger.addLogListener(messages::add);
+		logger.debug("detail");
+		logger.warn("careful");
+		assertEquals(2, messages.size());
+		assertEquals("detail", messages.get(0).text());
+		assertEquals(LogLevel.DEBUG, messages.get(0).level());
+		assertEquals(LogLevel.WARN, messages.get(1).level());
+	}
+
+	@Test
+	public void testDefaultLoggerDiscards() {
+		final Task task = new Task() {
+			@Override public void run(final Runnable r) {}
+			@Override public void waitFor() {}
+			@Override public boolean isDone() { return false; }
+			@Override public String getStatusMessage() { return null; }
+			@Override public long getProgressValue() { return 0; }
+			@Override public long getProgressMaximum() { return 0; }
+			@Override public void setStatusMessage(final String status) {}
+			@Override public void setProgressValue(final long step) {}
+			@Override public void setProgressMaximum(final long max) {}
+			@Override public boolean isCanceled() { return false; }
+			@Override public void cancel(final String reason) {}
+			@Override public String getCancelReason() { return null; }
+			@Override public String getName() { return null; }
+			@Override public void setName(final String name) {}
+		};
+		final Logger logger = task.log();
+		final List<LogMessage> messages = new ArrayList<>();
+		logger.addLogListener(messages::add);
+		logger.error("ignored");
+		assertTrue(messages.isEmpty());
+	}
 }