@@ -412,10 +412,12 @@ def parallelize(
     iterable:
         The iterable, who's items are to be passed as singles to the function.
     flush_at_end:
-        If True, what the tasks print is written to stdout in the order of
-        ``iterable`` once the batch has finished. If False, it is discarded.
-        Either way it is captured while the tasks run, so that concurrent
-        printing cannot garble the progress bar.
+        If True, what the tasks print and log is written out in the order of
+        ``iterable`` once the batch has finished. If False, it is discarded,
+        except for log records at WARNING and above. Those report a problem
+        rather than progress, so they are written out either way. Either way
+        the output is captured while the tasks run, so that concurrent writing
+        cannot garble the progress bar.
     progress_bar:
         If True, a progress bar will be displayed.
     return_exceptions:
@@ -502,13 +504,16 @@ async def _capture(task):
         sys.stdout = stdout.stream
         osw_logger.handlers = saved_handlers
         osw_logger.propagate = saved_propagate
-        if flush_at_end:
-            # in the finally block, so a failed batch still reports what its
-            # tasks had to say
-            for output, task_records in zip(outputs, records):
-                if output:
-                    print(output, end="")
-                for record in task_records:
+        # in the finally block, so a failed batch still reports what its
+        # tasks had to say
+        for output, task_records in zip(outputs, records):
+            if flush_at_end and output:
+                print(output, end="")
+            for record in task_records:
+                # A warning reports a problem, not progress, so a batch asked
+                # to stay quiet still passes it on. Discarding it would hide
+                # from the caller that something went wrong in a worker.
+                if flush_at_end or record.levelno >= logging.WARNING:
                     log_handler.replay(record)
 
     return results
 
@@ -289,6 +289,12 @@ def _log_item(item):
     return item
 
 
+def _warn_on_item(item):
+    logging.getLogger(WORKER).info(f"handled {item}")
+    logging.getLogger(WORKER).warning(f"trouble with {item}")
+    return item
+
+
 def test_worker_records_are_replayed_in_input_order(collected):
     """The tasks finish in whatever order they finish, so the replay is what
     puts the messages back in the order of the iterable."""
@@ -303,12 +309,64 @@ def test_worker_records_are_replayed_in_input_order(collected):
 
 
 def test_worker_records_are_dropped_without_flush_at_end(collected):
-    """flush_at_end=False means quiet, which is what debug=False asks for."""
+    """flush_at_end=False means quiet for progress, which is what debug=False
+    asks for."""
     parallelize(_log_item, [1, 2, 3], flush_at_end=False, progress_bar=False)
 
     assert collected.messages(WORKER) == []
 
 
+def test_worker_warnings_survive_a_quiet_batch(collected):
+    """A warning reports a problem rather than progress, so a batch asked to
+    stay quiet still passes it on. These call sites used warnings.warn before,
+    which parallelize never suppressed, so dropping them would lose output a
+    caller has today."""
+    parallelize(_warn_on_item, [1, 2], flush_at_end=False, progress_bar=False)
+
+    assert collected.messages(WORKER) == ["trouble with 1", "trouble with 2"]
+
+
+def test_worker_errors_survive_a_quiet_batch(collected):
+    """Errors are replayed on the same grounds as warnings. OSW.delete_entity
+    logs one from inside a worker it parallelizes, at src/osw/core.py."""
+
+    def _fail_quietly(item):
+        logging.getLogger(WORKER).error(f"could not handle {item}")
+
+    parallelize(_fail_quietly, [1], flush_at_end=False, progress_bar=False)
+
+    assert collected.messages(WORKER) == ["could not handle 1"]
+
+
+def test_worker_warnings_reach_pytests_caplog(caplog, osw_logger):
+    """caplog puts its handler on the root logger, so a replayed record has to
+    travel the same path as any other to be seen. The integration test
+    tests/integration/performance_test.py asserts on a warning from a parallel
+    get_page batch this way, and it needs wiki credentials to run."""
+    caplog.set_level(logging.WARNING, logger="osw")
+
+    parallelize(_warn_on_item, [1], flush_at_end=False, progress_bar=False)
+
+    assert any("trouble with 1" in record.message for record in caplog.records)
+
+
+def test_worker_warnings_are_replayed_in_input_order(collected):
+    """The tasks finish in whatever order they finish, so the warnings are put
+    back in the order of the iterable like everything else."""
+    parallelize(_warn_on_item, [1, 2, 3, 4], flush_at_end=True, progress_bar=False)
+
+    assert collected.messages(WORKER) == [
+        "handled 1",
+        "trouble with 1",
+        "handled 2",
+        "trouble with 2",
+        "handled 3",
+        "trouble with 3",
+        "handled 4",
+        "trouble with 4",
+    ]
+
+
 def test_worker_records_reach_the_application_handler(osw_logger):
     """The capture replays into whatever the handler chain holds, so a batch's
     records land in the application's handlers like any other."""