stemtrace 0.3.8__tar.gz → 0.3.9__tar.gz

{stemtrace-0.3.8 → stemtrace-0.3.9}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.3.8"
+current_version = "0.3.9"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 commit = true

{stemtrace-0.3.8 → stemtrace-0.3.9}/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.9] - 2026-10-10
+
+### Added
+- Task output: with `init_worker(app, capture_output=True)`, what each task attempt prints and logs is shown on its task page, one block per attempt (latest first). Off by default because output isn't scrubbed; each attempt keeps the last `max_output_size` bytes (default 16 KB). Works with prefork, thread and gevent pools (thanks @JonatanMartens for the original implementation — #49; requested by @ohadmata — #47).
+
 ## [0.3.8] - 2026-10-10
 
 ### Fixed
@@ -181,7 +186,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **E2E test suite**: Docker API tests + Playwright browser tests
 - **Comprehensive test suite**: 350+ Python tests, 90%+ coverage
 
-[unreleased]: https://github.com/iansokolskyi/stemtrace/compare/v0.3.8...HEAD
+[unreleased]: https://github.com/iansokolskyi/stemtrace/compare/v0.3.9...HEAD
+[0.3.9]: https://github.com/iansokolskyi/stemtrace/compare/v0.3.8...v0.3.9
 [0.3.8]: https://github.com/iansokolskyi/stemtrace/compare/v0.3.7...v0.3.8
 [0.3.7]: https://github.com/iansokolskyi/stemtrace/compare/v0.3.6...v0.3.7
 [0.3.6]: https://github.com/iansokolskyi/stemtrace/compare/v0.3.5...v0.3.6

{stemtrace-0.3.8 → stemtrace-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stemtrace
-Version: 0.3.8
+Version: 0.3.9
 Summary: A lightweight Celery task flow visualizer
 Project-URL: Homepage, https://github.com/iansokolskyi/stemtrace
 Project-URL: Documentation, https://github.com/iansokolskyi/stemtrace#readme
@@ -59,7 +59,7 @@ Description-Content-Type: text/markdown
 
 **Zero-infrastructure Celery task flow visualizer**
 
-[![PyPI version](https://img.shields.io/badge/pypi-v0.3.8-darklime)](https://pypi.org/project/stemtrace)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.3.9-darklime)](https://pypi.org/project/stemtrace)
 [![Python](https://img.shields.io/pypi/pyversions/stemtrace.svg)](https://pypi.org/project/stemtrace/)
 [![CI](https://github.com/iansokolskyi/stemtrace/actions/workflows/ci.yml/badge.svg)](https://github.com/iansokolskyi/stemtrace/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/iansokolskyi/stemtrace/graph/badge.svg)](https://codecov.io/gh/iansokolskyi/stemtrace)
@@ -83,6 +83,7 @@ Stemtrace captures your task executions as a graph — visualize parent→child
 - **Task Flow Graphs** — Visualize chains, groups, and chords as interactive DAGs
 - **Execution Timeline** — Track queued → started → retried → finished states
 - **Arguments & Results** — Inspect inputs, outputs, and exceptions
+- **Task Output** — See what each attempt printed and logged, next to the task (opt-in)
 - **Retry Chains** — Understand exactly when and why retries happened
 
 **Canvas Support**
@@ -253,6 +254,10 @@ stemtrace.init_worker(
     scrub_sensitive_data=True,                 # Scrub passwords, API keys, etc.
     additional_sensitive_keys=frozenset({"my_secret"}),  # Add custom keys
     safe_keys=frozenset({"public_key"}),       # Never scrub these keys
+
+    # Task output (disabled by default, see "Task Output" below)
+    capture_output=False,                      # Capture what each attempt prints/logs
+    max_output_size=16384,                     # Max bytes kept per attempt (the end is kept)
 )
 
 # Introspection (after init)
@@ -271,6 +276,75 @@ By default, stemtrace scrubs common sensitive keys from task arguments:
 
 Scrubbed values appear as `[Filtered]` in the UI.
 
+#### Task Output (print and logging)
+
+Turn on `capture_output` on the worker to see what each task attempt printed and
+logged on its task page, instead of searching interleaved worker logs:
+
+```python
+stemtrace.init_worker(app, capture_output=True)
+```
+
+```python
+from celery.utils.log import get_task_logger
+import logging
+
+task_logger = get_task_logger(__name__)
+log = logging.getLogger("myapp.billing")
+
+@app.task(bind=True, max_retries=3)
+def charge(self, order_id):
+    print(f"charging {order_id}")           # -> charging 42
+    task_logger.info("calling gateway")     # -> INFO myapp.tasks: calling gateway
+    log.warning("gateway slow")             # -> WARNING myapp.billing: gateway slow
+    ...
+```
+
+The task page shows an **Output** section with one block per attempt (latest
+first): the output of a retried attempt is on its `RETRY` event, the final one on
+`SUCCESS`/`FAILURE`.
+
+- **What's captured**: `print()` to stdout and stderr, exactly as printed
+  (whether or not Celery redirects stdout to its log), and log records
+  (`logging.getLogger(...)`, `get_task_logger(...)`) emitted while the task
+  runs, in one chronological stream. Records are captured when they reach the
+  root logger or `celery.task`, or when a handler writes them to stdout/stderr
+  after stemtrace is set up. A logger with `propagate=False` whose handlers were
+  set up at worker startup (writing to the real stream or a file) isn't
+  captured. Log levels still apply to log records: one your logging config
+  filters out (e.g. `DEBUG` under `--loglevel=INFO`) isn't captured.
+  stemtrace's own logs and Celery/kombu internals are left out.
+  What the worker prints to its console or log file is unchanged (when no
+  logging handlers are configured, warnings still print as Python's
+  `logging.lastResort` would). One side effect: from the first task on, the root
+  logger has stemtrace's handler, so `logging.getLogger().hasHandlers()` is
+  `True` and a later `logging.basicConfig()` call without `force=True` does
+  nothing. Configure logging at startup (or pass `force=True`). Logging
+  handlers added while a task runs, ones that override `handle()`, or ones
+  that write to stdout/stderr in unusual ways may show a record twice or show
+  Celery/kombu lines in that task's output; handlers set up at worker startup
+  don't.
+- **Size**: at most `max_output_size` bytes (UTF-8) per attempt. Longer output
+  keeps its end, where failures usually are, after a `[… N bytes truncated]` line.
+  Output travels with the task's terminal event, so it is stored wherever events
+  are: by the server (up to `max_nodes` tasks) and, with the Redis transport, in
+  the stemtrace stream on your broker, which keeps the last `max(ttl, 10000)`
+  events (86,400 with the default `ttl`). At 16 KB per attempt that can add up to
+  more than a GB of Redis memory on busy workers, so consider a lower
+  `max_output_size` or `ttl` there. It isn't sent over the UI's WebSocket; the
+  task page fetches it.
+- **Pools**: each task's output is collected in a `ContextVar` (per thread, and
+  per greenlet under gevent/eventlet), so concurrent tasks never mix output.
+  Output from threads a task starts itself isn't captured.
+- **Not captured**: anything after the task ends, and output of a task whose
+  worker process was killed (hard time limit, OOM), since no terminal event is
+  sent from that process. Capture of a failed or retried attempt stops when
+  Celery reports the failure/retry, so `on_failure`/`on_retry` output is included
+  but `after_return` output is included only on success.
+- **Not scrubbed**: output is free text, so the key-based scrubbing above can't
+  apply. That's why it's off by default: only enable it if your tasks don't print
+  or log secrets.
+
 ### Canvas Graph Visualization
 
 `stemtrace` automatically detects and visualizes Celery canvas constructs:
@@ -631,6 +705,7 @@ What is detected depends on the transport:
 - ✅ **Full lifecycle tracking** — PENDING → RECEIVED → STARTED → SUCCESS/FAILURE
 - ✅ **Canvas awareness** — Automatic GROUP/CHORD node visualization
 - ✅ **Arguments & results** — View inputs, outputs, and exceptions
+- ✅ **Task output** — What each attempt printed and logged (opt-in)
 - ✅ **Sensitive data scrubbing** — Passwords and API keys filtered automatically
 - ✅ **Real-time updates** — WebSocket-powered live dashboard
 - ✅ **FastAPI integration** — Mount into your existing app

{stemtrace-0.3.8 → stemtrace-0.3.9}/README.md

@@ -4,7 +4,7 @@
 
 **Zero-infrastructure Celery task flow visualizer**
 
-[![PyPI version](https://img.shields.io/badge/pypi-v0.3.8-darklime)](https://pypi.org/project/stemtrace)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.3.9-darklime)](https://pypi.org/project/stemtrace)
 [![Python](https://img.shields.io/pypi/pyversions/stemtrace.svg)](https://pypi.org/project/stemtrace/)
 [![CI](https://github.com/iansokolskyi/stemtrace/actions/workflows/ci.yml/badge.svg)](https://github.com/iansokolskyi/stemtrace/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/iansokolskyi/stemtrace/graph/badge.svg)](https://codecov.io/gh/iansokolskyi/stemtrace)
@@ -28,6 +28,7 @@ Stemtrace captures your task executions as a graph — visualize parent→child
 - **Task Flow Graphs** — Visualize chains, groups, and chords as interactive DAGs
 - **Execution Timeline** — Track queued → started → retried → finished states
 - **Arguments & Results** — Inspect inputs, outputs, and exceptions
+- **Task Output** — See what each attempt printed and logged, next to the task (opt-in)
 - **Retry Chains** — Understand exactly when and why retries happened
 
 **Canvas Support**
@@ -198,6 +199,10 @@ stemtrace.init_worker(
     scrub_sensitive_data=True,                 # Scrub passwords, API keys, etc.
     additional_sensitive_keys=frozenset({"my_secret"}),  # Add custom keys
     safe_keys=frozenset({"public_key"}),       # Never scrub these keys
+
+    # Task output (disabled by default, see "Task Output" below)
+    capture_output=False,                      # Capture what each attempt prints/logs
+    max_output_size=16384,                     # Max bytes kept per attempt (the end is kept)
 )
 
 # Introspection (after init)
@@ -216,6 +221,75 @@ By default, stemtrace scrubs common sensitive keys from task arguments:
 
 Scrubbed values appear as `[Filtered]` in the UI.
 
+#### Task Output (print and logging)
+
+Turn on `capture_output` on the worker to see what each task attempt printed and
+logged on its task page, instead of searching interleaved worker logs:
+
+```python
+stemtrace.init_worker(app, capture_output=True)
+```
+
+```python
+from celery.utils.log import get_task_logger
+import logging
+
+task_logger = get_task_logger(__name__)
+log = logging.getLogger("myapp.billing")
+
+@app.task(bind=True, max_retries=3)
+def charge(self, order_id):
+    print(f"charging {order_id}")           # -> charging 42
+    task_logger.info("calling gateway")     # -> INFO myapp.tasks: calling gateway
+    log.warning("gateway slow")             # -> WARNING myapp.billing: gateway slow
+    ...
+```
+
+The task page shows an **Output** section with one block per attempt (latest
+first): the output of a retried attempt is on its `RETRY` event, the final one on
+`SUCCESS`/`FAILURE`.
+
+- **What's captured**: `print()` to stdout and stderr, exactly as printed
+  (whether or not Celery redirects stdout to its log), and log records
+  (`logging.getLogger(...)`, `get_task_logger(...)`) emitted while the task
+  runs, in one chronological stream. Records are captured when they reach the
+  root logger or `celery.task`, or when a handler writes them to stdout/stderr
+  after stemtrace is set up. A logger with `propagate=False` whose handlers were
+  set up at worker startup (writing to the real stream or a file) isn't
+  captured. Log levels still apply to log records: one your logging config
+  filters out (e.g. `DEBUG` under `--loglevel=INFO`) isn't captured.
+  stemtrace's own logs and Celery/kombu internals are left out.
+  What the worker prints to its console or log file is unchanged (when no
+  logging handlers are configured, warnings still print as Python's
+  `logging.lastResort` would). One side effect: from the first task on, the root
+  logger has stemtrace's handler, so `logging.getLogger().hasHandlers()` is
+  `True` and a later `logging.basicConfig()` call without `force=True` does
+  nothing. Configure logging at startup (or pass `force=True`). Logging
+  handlers added while a task runs, ones that override `handle()`, or ones
+  that write to stdout/stderr in unusual ways may show a record twice or show
+  Celery/kombu lines in that task's output; handlers set up at worker startup
+  don't.
+- **Size**: at most `max_output_size` bytes (UTF-8) per attempt. Longer output
+  keeps its end, where failures usually are, after a `[… N bytes truncated]` line.
+  Output travels with the task's terminal event, so it is stored wherever events
+  are: by the server (up to `max_nodes` tasks) and, with the Redis transport, in
+  the stemtrace stream on your broker, which keeps the last `max(ttl, 10000)`
+  events (86,400 with the default `ttl`). At 16 KB per attempt that can add up to
+  more than a GB of Redis memory on busy workers, so consider a lower
+  `max_output_size` or `ttl` there. It isn't sent over the UI's WebSocket; the
+  task page fetches it.
+- **Pools**: each task's output is collected in a `ContextVar` (per thread, and
+  per greenlet under gevent/eventlet), so concurrent tasks never mix output.
+  Output from threads a task starts itself isn't captured.
+- **Not captured**: anything after the task ends, and output of a task whose
+  worker process was killed (hard time limit, OOM), since no terminal event is
+  sent from that process. Capture of a failed or retried attempt stops when
+  Celery reports the failure/retry, so `on_failure`/`on_retry` output is included
+  but `after_return` output is included only on success.
+- **Not scrubbed**: output is free text, so the key-based scrubbing above can't
+  apply. That's why it's off by default: only enable it if your tasks don't print
+  or log secrets.
+
 ### Canvas Graph Visualization
 
 `stemtrace` automatically detects and visualizes Celery canvas constructs:
@@ -576,6 +650,7 @@ What is detected depends on the transport:
 - ✅ **Full lifecycle tracking** — PENDING → RECEIVED → STARTED → SUCCESS/FAILURE
 - ✅ **Canvas awareness** — Automatic GROUP/CHORD node visualization
 - ✅ **Arguments & results** — View inputs, outputs, and exceptions
+- ✅ **Task output** — What each attempt printed and logged (opt-in)
 - ✅ **Sensitive data scrubbing** — Passwords and API keys filtered automatically
 - ✅ **Real-time updates** — WebSocket-powered live dashboard
 - ✅ **FastAPI integration** — Mount into your existing app

{stemtrace-0.3.8 → stemtrace-0.3.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stemtrace"
-version = "0.3.8"
+version = "0.3.9"
 description = "A lightweight Celery task flow visualizer"
 readme = "README.md"
 license = { text = "MIT" }

{stemtrace-0.3.8 → stemtrace-0.3.9}/src/stemtrace/__init__.py

@@ -43,7 +43,7 @@ if TYPE_CHECKING:
     from celery import Celery
     from fastapi import FastAPI
 
-__version__ = "0.3.8"
+__version__ = "0.3.9"
 __all__ = [
     "ConfigurationError",
     "StemtraceConfig",
@@ -106,6 +106,8 @@ def init_worker(
     safe_keys: frozenset[str] | None = None,
     max_data_size: int = 10240,
     node_alias_from_arguments: str | None = None,
+    capture_output: bool = False,
+    max_output_size: int = 16384,
 ) -> None:
     """Initialize stemtrace for Celery worker instrumentation.
 
@@ -127,9 +129,14 @@ def init_worker(
             A non-None value emits a ``DeprecationWarning`` (and a one-time
             log warning, since Celery workers hide deprecation warnings); the
             parameter will be removed in a future major release.
+        capture_output: Capture what each task attempt prints and logs and show
+            it in the UI (default: False). Output is not scrubbed.
+        max_output_size: Maximum UTF-8 bytes of output kept per attempt; the
+            end is kept (default: 16KB).
 
     Raises:
-        ConfigurationError: If no broker URL can be determined.
+        ConfigurationError: If no broker URL can be determined, or
+            max_output_size isn't positive.
     """
     global _transport, _node_alias_deprecation_logged
 
@@ -147,6 +154,10 @@ def init_worker(
             "No broker URL available. Either pass transport_url or configure "
             "Celery's broker_url."
         )
+    if max_output_size <= 0:
+        raise ConfigurationError(
+            f"max_output_size must be a positive number of bytes, got {max_output_size}."
+        )
 
     config = StemtraceConfig(
         transport_url=url,
@@ -159,6 +170,8 @@ def init_worker(
         safe_keys=safe_keys or frozenset(),
         max_data_size=max_data_size,
         node_alias_from_arguments=node_alias_from_arguments,
+        capture_output=capture_output,
+        max_output_size=max_output_size,
     )
     set_config(config)
 

{stemtrace-0.3.8 → stemtrace-0.3.9}/src/stemtrace/core/events.py

@@ -74,6 +74,8 @@ class TaskEvent(BaseModel):
         result: Return value of the task (SUCCESS state only).
         exception: Exception message (FAILURE/RETRY states).
         traceback: Full traceback string (FAILURE/RETRY states).
+        output: What the attempt printed and logged, in order (SUCCESS,
+            FAILURE and RETRY events, when output capture is enabled).
     """
 
     model_config = ConfigDict(frozen=True)
@@ -96,6 +98,7 @@ class TaskEvent(BaseModel):
     result: Any | None = None
     exception: str | None = None
     traceback: str | None = None
+    output: str | None = None
 
 
 class WorkerEvent(BaseModel):

{stemtrace-0.3.8 → stemtrace-0.3.9}/src/stemtrace/library/config.py

@@ -20,6 +20,10 @@ class StemtraceConfig(BaseModel):
             backward compatibility only; node aliases are resolved by the
             server (``init_app()`` / ``stemtrace server
             --node-alias-from-arguments``).
+        capture_output: Whether to capture what each task attempt prints and
+            logs and attach it to the attempt's terminal event.
+        max_output_size: Maximum UTF-8 bytes of output kept per attempt (the
+            end of the output is kept).
     """
 
     model_config = ConfigDict(frozen=True)
@@ -41,6 +45,10 @@ class StemtraceConfig(BaseModel):
     # Deprecated: unused on the worker side (resolved by the server)
     node_alias_from_arguments: str | None = None
 
+    # Output capture options (disabled by default)
+    capture_output: bool = False
+    max_output_size: int = Field(default=16384, gt=0)  # 16 KB
+
 
 _config: StemtraceConfig | None = None