Send build and script output to SciJava task logs

Build tool output goes to the build task's logger, and a script's stdout,
stderr, task.update messages and failure traceback go to its run task's
logger, so that the task monitor can show them.

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

Author: ctrueden

GAPS.md

@@ -115,6 +115,17 @@ Because stderr is read separately from stdout, the wrapper writes a unique
 end-marker line to stderr, and the engine waits up to 2 s for it before
 returning, so that late stderr lines are not lost or misattributed.
 
+The same lines, plus `task.update` messages and the traceback of a failed
+run, also go to the run's SciJava task logger (`Task#log()`), and a
+build's tool output goes to the build task's logger. The task monitor's log
+window shows them.
+
+**Tradeoff:** Task loggers retain nothing, so the log window shows only what
+is logged after it is opened. And since the task monitor drops tasks as soon
+as they finish, a build that fails quickly cannot have its log opened at
+all; its error message is the
+only record. If this proves annoying, `DefaultTask` could keep a history.
+
 **Fragile because:** The whole mechanism depends on debug message formats,
 which are not API. Appose core should offer structured stdout/stderr
 callbacks on `Service`, ideally tagged by task (see

pom.xml

@@ -91,6 +91,9 @@
 
 		<appose.version>0.12.0</appose.version>
 		<imglib2-appose.version>0.9.0</imglib2-appose.version>
+
+		<!-- TEMP: for Task#log(); drop once propagated to pom-scijava. -->
+		<scijava-common.version>2.101.0</scijava-common.version>
 	</properties>
 
 	<dependencies>

src/main/java/org/scijava/plugins/scripting/appose/python/ApposePythonScriptEngine.java

@@ -67,6 +67,7 @@
 import org.scijava.app.StatusService;
 import org.scijava.convert.ConvertService;
 import org.scijava.log.LogService;
+import org.scijava.log.Logger;
 import org.scijava.module.ModuleItem;
 import org.scijava.plugin.Parameter;
 import org.scijava.plugins.scripting.appose.python._internal.ResidentWorker;
@@ -254,6 +255,7 @@ private Object runTask(final ResidentWorker worker,
 			});
 			progress = SciJavaTasks.track(taskService, statusService, "Running " +
 				scriptName(info), task, worker::kill);
+			if (progress != null) forwarder.taskLog = progress.log();
 			try {
 				task.waitFor();
 			}
@@ -281,6 +283,7 @@ private Object runTask(final ResidentWorker worker,
 				// which would say the worker crashed if it had to be stopped.
 				throw new ScriptException("Python script canceled");
 			}
+			if (progress != null) progress.log().error(e.getMessage());
 			throw scriptException("Python script failed: " + e.getMessage(), e);
 		}
 		catch (final InterruptedException e) {
@@ -309,7 +312,8 @@ private static String scriptName(final ScriptInfo info) {
 
 	/**
 	 * Forwards the worker process's stdout (other than Appose protocol
-	 * messages) and stderr to the script context's writers.
+	 * messages) and stderr to the script context's writers, and to the run's
+	 * task logger, if any.
 	 * <p>
 	 * Note: This relies on the format of Appose's debug messages: stderr lines
 	 * arrive as {@code [WORKER-n] line} and non-protocol stdout lines as
@@ -326,6 +330,9 @@ private class OutputForwarder implements Consumer<String> {
 			"]";
 		private final CountDownLatch ended = new CountDownLatch(1);
 
+		/** Logger of the run's SciJava task, if any. */
+		private volatile Logger taskLog;
+
 		@Override
 		public void accept(final String message) {
 			final int end = message.indexOf("] ");
@@ -334,13 +341,21 @@ public void accept(final String message) {
 			final String line = message.substring(end + 2);
 			if (prefix.startsWith("[WORKER-")) {
 				if (line.equals(endMarker)) ended.countDown();
-				else writeLine(getContext().getErrorWriter(), line);
+				else output(getContext().getErrorWriter(), line);
 			}
 			else if (prefix.startsWith("[SERVICE-") && line.startsWith("<INVALID> ")) {
-				writeLine(getContext().getWriter(), line.substring(10));
+				output(getContext().getWriter(), line.substring(10));
 			}
 		}
 
+		private void output(final Writer writer, final String line) {
+			writeLine(writer, line);
+			// Note: Info level for stderr too, since Python writes ordinary
+			// output there as well, e.g. via the logging module.
+			final Logger logger = taskLog;
+			if (logger != null) logger.info(line);
+		}
+
 		/** Waits until the wrapper script's stderr output has all arrived. */
 		private void awaitEnd() throws InterruptedException {
 			ended.await(OUTPUT_DRAIN_MILLIS, TimeUnit.MILLISECONDS);

src/main/java/org/scijava/plugins/scripting/appose/python/_internal/SciJavaTasks.java

@@ -60,7 +60,8 @@ private SciJavaTasks() {
 
 	/**
 	 * Creates a {@link BuildListener} that shows each environment build as a
-	 * SciJava task of its own, and logs the build tool's output at debug level.
+	 * SciJava task of its own. The build tool's output goes to the task's
+	 * logger, and to the application log at debug level.
 	 * <p>
 	 * A build gets its own task, rather than borrowing that of the run which
 	 * needs it, because a build can take minutes: a run stuck at 0% for that
@@ -107,21 +108,30 @@ public void buildProgress(final String envName, final String title,
 
 			@Override
 			public void buildOutput(final String envName, final String text) {
-				if (log != null) log.debug(text.trim());
+				output(envName, text);
 			}
 
 			@Override
 			public void buildError(final String envName, final String text) {
-				// Note: Not log.error! Build tools write ordinary status to stderr.
-				if (log != null) log.debug(text.trim());
+				// Note: Not error level! Build tools write ordinary status to stderr.
+				output(envName, text);
+			}
+
+			private void output(final String envName, final String text) {
+				final String line = chomp(text);
+				if (log != null) log.debug(line);
+				final Task task = building.get(envName);
+				if (task != null) task.log().info(line);
 			}
 
 			@Override
 			public void buildFinished(final String envName, final Throwable error) {
 				final Task task = building.remove(envName);
 				if (task != null) {
-					if (error != null) task.setStatusMessage("Failed: " + error
-						.getMessage());
+					if (error != null) {
+						task.setStatusMessage("Failed: " + error.getMessage());
+						task.log().error("Build failed", error);
+					}
 					task.finish();
 				}
 				if (status != null) status.clearStatus();
@@ -163,7 +173,10 @@ public static Task track(final TaskService tasks, final StatusService status,
 			if (event.responseType.isTerminal()) finished.set(true);
 			if (event.responseType != ResponseType.UPDATE) return;
 			if (task != null) {
-				if (event.message != null) task.setStatusMessage(event.message);
+				if (event.message != null) {
+					task.setStatusMessage(event.message);
+					task.log().info(event.message);
+				}
 				task.setProgressValue(event.current);
 				task.setProgressMaximum(event.maximum);
 			}
@@ -194,4 +207,9 @@ public static Task track(final TaskService tasks, final StatusService status,
 		task.start();
 		return task;
 	}
+
+	/** Strips trailing line breaks, keeping any indentation. */
+	private static String chomp(final String text) {
+		return text.replaceAll("[\\r\\n]+$", "");
+	}
 }

src/test/java/org/scijava/plugins/scripting/appose/python/ApposePythonIntegrationTest.java

@@ -43,10 +43,13 @@
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
@@ -63,6 +66,8 @@
 import org.scijava.Context;
 import org.scijava.event.EventHandler;
 import org.scijava.event.EventService;
+import org.scijava.log.LogLevel;
+import org.scijava.log.LogMessage;
 import org.scijava.module.ModuleService;
 import org.scijava.plugins.scripting.appose.python._internal.SciJavaTasks;
 import org.scijava.script.ScriptInfo;
@@ -176,6 +181,11 @@ public void testPrintAndStderr() throws Exception {
 			"print('to stderr', file=sys.stderr)\n", new HashMap<>());
 		assertTrue(out.toString(), out.toString().contains("to stdout"));
 		assertTrue(err.toString(), err.toString().contains("to stderr"));
+
+		// The output also goes to the run's task log.
+		final List<String> lines = tasks.log("Running print.py", LogLevel.INFO);
+		assertTrue(lines.toString(), lines.contains("to stdout"));
+		assertTrue(lines.toString(), lines.contains("to stderr"));
 	}
 
 	@Test
@@ -189,6 +199,10 @@ public void testErrorReportsScriptLine() throws Exception {
 		assertTrue(error, error.contains(new File(scriptDir, "failing.py").getPath()));
 		assertTrue(error, error.contains("line 5"));
 		assertNull(module.getOutput("x"));
+
+		final List<String> errors = tasks.log("Running failing.py", LogLevel.ERROR);
+		assertEquals(1, errors.size());
+		assertTrue(errors.get(0), errors.get(0).contains("ValueError: boom"));
 	}
 
 	@Test
@@ -260,6 +274,8 @@ public void testRunIsSciJavaTask() throws Exception {
 		assertNotNull(task);
 		assertTrue(task.isDone());
 		assertEquals(2, task.getProgressMaximum());
+		assertEquals(Collections.singletonList("halfway"), tasks.log(
+			"Running tracked.py", LogLevel.INFO));
 	}
 
 	@Test
@@ -331,16 +347,33 @@ private ScriptModule module(final String name, final String script)
 	public static class TaskRecorder {
 
 		private final Map<String, Task> tasks = new ConcurrentHashMap<>();
+		private final Map<Task, List<LogMessage>> logs = new ConcurrentHashMap<>();
 
 		@EventHandler
 		public void onEvent(final TaskEvent event) {
-			tasks.put(event.getTask().getName(), event.getTask());
+			final Task task = event.getTask();
+			tasks.put(task.getName(), task);
+			// Note: A task's first event arrives before it produces any output.
+			logs.computeIfAbsent(task, t -> {
+				final List<LogMessage> messages = new CopyOnWriteArrayList<>();
+				t.log().addLogListener(messages::add);
+				return messages;
+			});
 		}
 
 		public Task find(final String name) {
 			return tasks.get(name);
 		}
 
+		/** Gets the lines logged to the named task at the given level. */
+		public List<String> log(final String name, final int level) {
+			final List<String> lines = new ArrayList<>();
+			for (final LogMessage message : logs.get(find(name))) {
+				if (message.level() == level) lines.add(message.text());
+			}
+			return lines;
+		}
+
 		public Task await(final String name) throws InterruptedException {
 			final long deadline = System.currentTimeMillis() + 10000;
 			while (System.currentTimeMillis() < deadline) {

src/test/java/org/scijava/plugins/scripting/appose/python/_internal/SciJavaTasksTest.java

@@ -0,0 +1,104 @@
+/*
+ * #%L
+ * Python scripting language plugin backed by Appose.
+ * %%
+ * Copyright (C) 2026 SciJava developers.
+ * %%
+ * 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.plugins.scripting.appose.python._internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.scijava.Context;
+import org.scijava.event.EventHandler;
+import org.scijava.event.EventService;
+import org.scijava.log.LogLevel;
+import org.scijava.log.LogMessage;
+import org.scijava.task.Task;
+import org.scijava.task.TaskService;
+import org.scijava.task.event.TaskEvent;
+
+/**
+ * Tests {@link SciJavaTasks}.
+ *
+ * @author Curtis Rueden
+ */
+public class SciJavaTasksTest {
+
+	private Context context;
+	private final List<LogMessage> messages = new CopyOnWriteArrayList<>();
+	private Task buildTask;
+
+	@Before
+	public void setUp() {
+		context = new Context();
+		context.service(EventService.class).subscribe(this);
+	}
+
+	@After
+	public void tearDown() {
+		context.dispose();
+	}
+
+	@EventHandler
+	public void onEvent(final TaskEvent event) {
+		if (buildTask != null) return;
+		buildTask = event.getTask();
+		buildTask.log().addLogListener(messages::add);
+	}
+
+	@Test
+	public void testBuildOutputGoesToTaskLog() {
+		final BuildListener listener = SciJavaTasks.buildListener(context.service(
+			TaskService.class), null, null);
+		listener.buildStarted("myenv");
+		assertNotNull(buildTask);
+		listener.buildOutput("myenv", "  resolving\n");
+		listener.buildError("myenv", "installed\r\n");
+		listener.buildProgress("myenv", "Downloading", 1, 2);
+		final RuntimeException failure = new RuntimeException("no space left");
+		listener.buildFinished("myenv", failure);
+
+		assertTrue(buildTask.isDone());
+		assertEquals(3, messages.size());
+		// Note: Build tools write ordinary status to stderr, so it is not an error.
+		assertEquals(LogLevel.INFO, messages.get(0).level());
+		assertEquals("  resolving", messages.get(0).text());
+		assertEquals(LogLevel.INFO, messages.get(1).level());
+		assertEquals("installed", messages.get(1).text());
+		assertEquals(LogLevel.ERROR, messages.get(2).level());
+		assertSame(failure, messages.get(2).throwable());
+	}
+}