processes 3.0.1__tar.gz → 3.1.1__tar.gz

{processes-3.0.1 → processes-3.1.1}/.github/workflows/docs.yml

@@ -20,8 +20,8 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@v5
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v6
       - name: Install dependencies
         run: uv sync --all-groups
       - name: Build and Deploy

{processes-3.0.1 → processes-3.1.1}/.github/workflows/lint.yml

@@ -14,10 +14,10 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true # Speeds up future runs
 

{processes-3.0.1 → processes-3.1.1}/.github/workflows/mypy.yml

@@ -14,10 +14,10 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true # Speeds up future runs
 

{processes-3.0.1 → processes-3.1.1}/.github/workflows/publish.yml

@@ -8,9 +8,9 @@ jobs:
   quality-gate:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: Install dependencies
         run: uv sync --all-extras --dev
@@ -33,9 +33,9 @@ jobs:
       contents: read
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: Build package
         run: uv build

{processes-3.0.1 → processes-3.1.1}/.github/workflows/tags.yml

@@ -15,10 +15,10 @@ jobs:
 
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 

{processes-3.0.1 → processes-3.1.1}/.github/workflows/tests.yml

@@ -16,10 +16,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           version: "latest"
           enable-cache: true

{processes-3.0.1 → processes-3.1.1}/CHANGELOG.md

@@ -1,3 +1,21 @@
+## v3.1.1 (2026-06-13)
+
+### Refactor
+
+- rename _log_formatting to _logfile_formatting and _TaskLogFormatter to _TaskLogfileFormatter
+
+## v3.1.0 (2026-06-13)
+
+### Feat
+
+- **logging**: include failure context in task logfiles
+
+### Refactor
+
+- extract typed _ErrorData from task_context via shared base formatter
+- inline single-use _task_context_lines helper
+- move task logfile formatting out of _email_internals
+
 ## v3.0.1 (2026-06-13)
 
 ### Refactor

{processes-3.0.1 → processes-3.1.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: processes
-Version: 3.0.1
-Summary: A Python library for managing and executing dependent tasks in parallel or sequential order with automatic dependency resolution and topological sorting
+Version: 3.1.1
+Summary: Orchestrate graphs of callables in Python with automatic dependency resolution, parallel execution, retries, timeouts, and HTML email alerts on failure — zero dependencies
 Project-URL: Homepage, https://github.com/oliverm91/processes
 Project-URL: Documentation, https://oliverm91.github.io/processes/
 Project-URL: Repository, https://github.com/oliverm91/processes
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
@@ -335,6 +336,20 @@ HTMLEmailStyle(
 
 All fields are optional — omit `HTMLEmailStyle` entirely to use the defaults.
 
+#### Traced Variables
+
+On failure, the email body includes the local variables of the **outermost
+user frame in the traceback** — i.e. the last frame that is not inside
+`site-packages` or your virtualenv. A `file:line` reference next to the
+section shows exactly where those values were captured.
+
+`traced_vars_frame_filter` lets you point this at a different frame: set it
+to a path substring (e.g. one of your own package or module names) to
+capture locals from the outermost frame whose filename contains that
+substring instead. This is useful for deep-debugging code that runs through
+several layers of internal libraries or wrappers, where the default
+outermost-user-frame would land too high up the call stack.
+
 </details>
 
 <details>

{processes-3.0.1 → processes-3.1.1}/README.md

@@ -311,6 +311,20 @@ HTMLEmailStyle(
 
 All fields are optional — omit `HTMLEmailStyle` entirely to use the defaults.
 
+#### Traced Variables
+
+On failure, the email body includes the local variables of the **outermost
+user frame in the traceback** — i.e. the last frame that is not inside
+`site-packages` or your virtualenv. A `file:line` reference next to the
+section shows exactly where those values were captured.
+
+`traced_vars_frame_filter` lets you point this at a different frame: set it
+to a path substring (e.g. one of your own package or module names) to
+capture locals from the outermost frame whose filename contains that
+substring instead. This is useful for deep-debugging code that runs through
+several layers of internal libraries or wrappers, where the default
+outermost-user-frame would land too high up the call stack.
+
 </details>
 
 <details>

{processes-3.0.1 → processes-3.1.1}/docs/examples/advanced.md

@@ -217,4 +217,41 @@ style = HTMLEmailStyle(
 )
 
 t = Task("task_name", "logfile", func_to_run, smtp_config=smtp, email_style=style)
-```
+```
+
+## ⏱️ Retries & Timeouts
+
+Two `Task` constructor arguments make individual steps more resilient to
+transient failures, without any extra wiring:
+
+- **`timeout`** — seconds allowed for a single attempt. If `func` doesn't
+  return in time, a `TimeoutError` is raised for that attempt. `None`
+  (the default) means no limit. When a timeout fires, the underlying
+  thread is detached rather than killed — a Python threading limitation.
+- **`retries`** — additional attempts after the first failure. `0` or
+  `None` (the default) means a single attempt with no retry.
+- **`retry_on`** — tuple of exception types that trigger a retry. Only
+  evaluated when `retries >= 1`. When `None`, defaults at call time to
+  `(ConnectionError, TimeoutError)`.
+
+```python
+from processes import Task
+
+def call_flaky_api() -> dict:
+    """May raise ConnectionError on a bad network blip."""
+    ...
+
+t_fetch = Task(
+    "fetch_remote_data",
+    "logs/fetch.log",
+    call_flaky_api,
+    timeout=5,                              # give up an attempt after 5s
+    retries=3,                              # up to 3 extra attempts (4 total)
+    retry_on=(ConnectionError, TimeoutError),  # retry on these exceptions only
+)
+```
+
+If every attempt fails, the task is marked failed with the **last**
+exception raised — `retries` only controls how many times `func` is
+retried, not whether the failure is eventually reported. Combine with
+`smtp_config` to be paged only once all attempts are exhausted.

{processes-3.0.1 → processes-3.1.1}/docs/index.md

@@ -71,16 +71,20 @@ Define your tasks and their dependencies. **Processes** will handle the executio
 ```python
 from datetime import date
 
-from processes import Process, Task, TaskDependency, HTMLSMTPHandler
+from processes import Process, Task, TaskDependency, SMTPConfig, HTMLEmailStyle
 
 # 1. Setup Email Alerts (Optional)
-smtp_handler = HTMLSMTPHandler(
-    ('smtp_server', 587), 'sender@example.com', ['admin@example.com', 'user@example.com'],
+smtp_config = SMTPConfig(
+    mailhost=('smtp_server', 587),
+    fromaddr='sender@example.com',
+    toaddrs=['admin@example.com', 'user@example.com'],
     credentials=('user', 'pass'),
     secure=(),                       # () = STARTTLS; omit for no encryption
-    email_style='modern',            # classic | modern | compact
-    color_palette='neutral',         # neutral | catppuccin | neobones | slate
-    email_language='en',             # en | es | pt | fr | de | it
+)
+email_style = HTMLEmailStyle(
+    style='modern',                  # classic | modern | compact
+    palette='neutral',                # neutral | catppuccin | neobones | slate
+    language='en',                    # en | es | pt | fr | de | it
 )
 
 # 2. If necessary, create wrappers for your Tasks.
@@ -96,7 +100,7 @@ def sum_data_from_csv_and_x(x, a=1, b=2):
 # 3. Create the Task Graph (order is irrelevant, that is handled by Process)
 tasks = [
     Task("t-1", "etl.log", get_previous_working_day),
-    Task("intependent", "indep.log", indep_task, html_mail_handler=smtp_handler),  # This task will send email on failure
+    Task("intependent", "indep.log", indep_task, smtp_config=smtp_config, email_style=email_style),  # This task will send email on failure
     Task("sum_csv", "etl.log", search_and_sum_csv,
             dependencies= [
                 TaskDependency("t-1",
@@ -123,36 +127,48 @@ with Process(tasks) as process: # Context Manager ensures correct disposal of lo
 
 ## 📧 Customizing the HTML email
 
-When a task with an `HTMLSMTPHandler` raises, the alert is a **styled HTML
+When a task with an `smtp_config` raises, the alert is a **styled HTML
 email** built from a bundled template. The body includes the exception,
 the traceback (with the user-frame highlighted), the task context, the
 list of downstream tasks that were skipped because of the failure, and
 the local variables at the failing frame (see [Traced Variables](#traced-variables) below).
 
-Four keyword-only arguments on `HTMLSMTPHandler` control the look, the language, and which frame's locals appear in the email body:
+Email delivery and presentation are configured with two separate dataclasses:
+
+- **`SMTPConfig`** — transport settings (host, credentials, sender/recipients, TLS).
+- **`HTMLEmailStyle`** — presentation settings, all optional:
 
-| Argument | Values | Default |
+| Field | Values | Default |
 |---|---|---|
-| `email_style` | `classic`, `modern`, `compact` | `modern` |
-| `color_palette` | `neutral`, `catppuccin`, `neobones`, `slate` | `neutral` |
-| `email_language` | `en`, `es`, `pt`, `fr`, `de`, `it` | `en` |
-| `last_path_traced_vars` | any path substring, or `None` | `None` (outermost user frame) |
+| `style` | `classic`, `modern`, `compact` | `modern` |
+| `palette` | `neutral`, `catppuccin`, `neobones`, `slate` | `neutral` |
+| `language` | `en`, `es`, `pt`, `fr`, `de`, `it` | `en` |
+| `traced_vars_frame_filter` | any path substring, or `None` | `None` (outermost user frame) |
 
 ```python
-from processes import HTMLSMTPHandler
+from processes import SMTPConfig, HTMLEmailStyle, Task
 
-smtp = HTMLSMTPHandler(
+smtp = SMTPConfig(
     mailhost=("smtp.example.com", 587),
     fromaddr="alerts@example.com",
     toaddrs=["oncall@example.com"],
     credentials=("user", "pass"),
     secure=(),                          # () = STARTTLS; omit for no encryption
-    email_style="compact",              # classic | modern | compact
-    color_palette="catppuccin",         # neutral | catppuccin | neobones | slate
-    email_language="es",                # en | es | pt | fr | de | it
 )
+
+style = HTMLEmailStyle(
+    style="compact",                    # classic | modern | compact
+    palette="catppuccin",               # neutral | catppuccin | neobones | slate
+    language="es",                      # en | es | pt | fr | de | it
+)
+
+t = Task("task_name", "logfile", func_to_run, smtp_config=smtp, email_style=style)
 ```
 
+If `smtp_config` is set and `email_style` is omitted, `HTMLEmailStyle()` defaults
+(modern, neutral, English) are used. If `smtp_config` is `None`, `email_style` is ignored
+and no email handler is attached.
+
 All assets ship inside the wheel — the styles are Jinja-style HTML
 templates at `src/processes/themes/styles/` and the palettes are CSS
 fragments at `src/processes/themes/palettes/`. No template engine or
@@ -168,6 +184,13 @@ in the source the listed values were captured, which is usually the
 fastest way to figure out *why* a complex task broke deep inside a
 wrapper.
 
+This default can be overridden with `HTMLEmailStyle.traced_vars_frame_filter`.
+Set it to a path substring (e.g. the name of one of your own packages or
+modules) to capture locals from the outermost frame whose filename contains
+that substring instead — useful for deep-debugging code that runs through
+several layers of internal libraries or wrappers, where the default
+outermost-user-frame would land too high up the call stack.
+
 ---
 
 ## 🛡️ Fault Tolerance & Logs

{processes-3.0.1 → processes-3.1.1}/mkdocs.yml

@@ -46,6 +46,16 @@ plugins:
       handlers:
         python:
           paths: [src]
+          options:
+            docstring_style: numpy
+            show_source: true
+            show_root_heading: true
+            show_root_full_path: false
+            heading_level: 2
+            members_order: source
+            separate_signature: true
+            show_signature_annotations: true
+            merge_init_into_class: true
   - social:
       cards_layout: default/variant
       cards_layout_options:

{processes-3.0.1 → processes-3.1.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "processes"
 dynamic = ["version"]
-description = "A Python library for managing and executing dependent tasks in parallel or sequential order with automatic dependency resolution and topological sorting"
+description = "Orchestrate graphs of callables in Python with automatic dependency resolution, parallel execution, retries, timeouts, and HTML email alerts on failure — zero dependencies"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
@@ -22,6 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
 ]
 
 dependencies = []
@@ -45,10 +46,9 @@ packages = ["src/processes"]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version_provider = "scm" 
+version_provider = "scm"
 tag_format = "v$version"
 update_map_description = true
-version_files = ["pyproject.toml:version"]
 update_changelog_on_bump = true
 
 [tool.mypy]

{processes-3.0.1 → processes-3.1.1}/src/processes/_email_internals.py

@@ -10,6 +10,7 @@ from email.mime.text import MIMEText
 from email.utils import formatdate
 from typing import cast
 
+from ._error_data import _ErrorContextFormatter
 from .email_config import HTMLEmailStyle, SMTPConfig
 
 _THEMES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "themes")
@@ -21,13 +22,24 @@ _PALETTE_MARKER = "{{__palette_css__}}"
 
 
 def _load_language_strings(language: str) -> dict[str, str]:
-    """Load translatable strings for the given ISO 639-1 language code."""
+    """Load translatable strings for the given ISO 639-1 language code.
+
+    Parameters
+    ----------
+    language : str
+        ISO 639-1 language code, e.g. ``"en"``.
+
+    Returns
+    -------
+    dict[str, str]
+        Mapping of translation keys to localized strings.
+    """
     path = os.path.join(_LANGUAGES_DIR, f"{language}.json")
     with open(path, encoding="utf-8") as fh:
         return cast(dict[str, str], json.load(fh))
 
 
-class _HTMLEmailFormatter(logging.Formatter):
+class _HTMLEmailFormatter(_ErrorContextFormatter):
     """Pure renderer: reads all error context from ``record.task_context`` and
     fills the HTML template.  No exception-info parsing or frame walking here.
     """
@@ -56,9 +68,20 @@ class _HTMLEmailFormatter(logging.Formatter):
     def _split_traceback_at_target(self, tb_str: str, location: str) -> tuple[str, str, str]:
         """Split *tb_str* around the frame line matching *location*.
 
-        Returns ``(before, highlight, after)`` where ``highlight`` is the
-        ``File "<filename>", line <lineno>, in <func>`` line for that frame.
-        Returns ``("", "", tb_str)`` if no match is found.
+        Parameters
+        ----------
+        tb_str : str
+            Full formatted traceback to split.
+        location : str
+            ``"filename:lineno"`` of the frame to highlight, as produced by
+            ``_build_traced_vars_location``.
+
+        Returns
+        -------
+        tuple[str, str, str]
+            ``(before, highlight, after)`` where ``highlight`` is the
+            ``File "<filename>", line <lineno>, in <func>`` line for that
+            frame. Returns ``("", "", tb_str)`` if no match is found.
         """
         if not tb_str or not location:
             return ("", "", tb_str)
@@ -82,38 +105,43 @@ class _HTMLEmailFormatter(logging.Formatter):
         return rendered
 
     def format(self, record: logging.LogRecord) -> str:
-        """Render a log record as a complete HTML email body."""
-        ctx = getattr(record, "task_context", None) or {}
+        """Render a log record as a complete HTML email body.
 
-        exception = ctx.get("exception", record.getMessage())
-        tb_str = ctx.get("traceback_str", "")
-        traced_vars = ctx.get("traced_vars", "")
-        traced_vars_location = ctx.get("traced_vars_location", "")
+        Parameters
+        ----------
+        record : logging.LogRecord
+            The record being formatted.
+
+        Returns
+        -------
+        str
+            The fully rendered HTML email body.
+        """
+        error = self._error_data(record)
 
         tb_before, tb_highlight, tb_after = self._split_traceback_at_target(
-            tb_str, traced_vars_location
+            error.traceback_str, error.traced_vars_location
         )
 
-        downstream = ctx.get("downstream_impact", []) or []
         downstream_items = "".join(
-            f"<li>{html.escape(str(name), quote=True)}</li>" for name in downstream
+            f"<li>{html.escape(str(name), quote=True)}</li>" for name in error.downstream_impact
         )
 
         substitutions = dict(_load_language_strings(self._email_language))
         substitutions["lang_traced_vars_blurb"] = substitutions.get(
             "lang_traced_vars_blurb", ""
-        ).replace("{location}", traced_vars_location)
+        ).replace("{location}", error.traced_vars_location)
         substitutions.update(
             {
-                "task_name": html.escape(str(ctx.get("task_name", "?")), quote=True),
-                "function": html.escape(str(ctx.get("function", "?")), quote=True),
-                "args": html.escape(repr(ctx.get("args", ())), quote=True),
-                "kwargs": html.escape(repr(ctx.get("kwargs", {})), quote=True),
-                "exception": html.escape(exception, quote=True),
+                "task_name": html.escape(error.task_name, quote=True),
+                "function": html.escape(error.function, quote=True),
+                "args": html.escape(repr(error.args), quote=True),
+                "kwargs": html.escape(repr(error.kwargs), quote=True),
+                "exception": html.escape(error.exception, quote=True),
                 "traceback_before": html.escape(tb_before, quote=True),
                 "traceback_highlight": html.escape(tb_highlight, quote=True),
                 "traceback_after": html.escape(tb_after, quote=True),
-                "traced_vars": traced_vars,
+                "traced_vars": error.traced_vars,
                 "downstream_items": downstream_items,
             }
         )
@@ -164,7 +192,23 @@ def _build_task_email_handler(
     style: HTMLEmailStyle,
     task_name: str,
 ) -> _HTMLEmailHandler:
-    """Create a fully configured email handler bound to one task."""
+    """Create a fully configured email handler bound to one task.
+
+    Parameters
+    ----------
+    smtp_config : SMTPConfig
+        SMTP transport configuration for the handler.
+    style : HTMLEmailStyle
+        HTML presentation settings used by the handler's formatter.
+    task_name : str
+        Name of the task the handler is bound to, used in the email subject.
+
+    Returns
+    -------
+    _HTMLEmailHandler
+        A handler at ``logging.ERROR`` level, with its formatter and
+        localized subject configured.
+    """
     handler = _HTMLEmailHandler(smtp_config)
     handler.setFormatter(_HTMLEmailFormatter(style))
     handler.setLevel(logging.ERROR)

processes-3.1.1/src/processes/_error_data.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class _ErrorData:
+    """Typed view of a task failure, extracted from ``record.task_context``.
+
+    Attributes
+    ----------
+    task_name : str
+        Name of the task that failed. Defaults to ``"?"``.
+    function : str
+        Name of the function that was executing. Defaults to ``"?"``.
+    args : tuple[Any, ...]
+        Positional arguments the function was called with. Defaults to ``()``.
+    kwargs : dict[str, Any]
+        Keyword arguments the function was called with. Defaults to ``{}``.
+    downstream_impact : list[str]
+        Names of tasks skipped as a result of this failure. Defaults to ``[]``.
+    exception : str
+        String representation of the raised exception. Defaults to ``""``.
+    traceback_str : str
+        Full formatted traceback. Defaults to ``""``.
+    traced_vars : str
+        Rendered local variables of the traced frame. Defaults to ``""``.
+    traced_vars_location : str
+        ``"filename:lineno"`` of the traced frame. Defaults to ``""``.
+    """
+
+    task_name: str = "?"
+    function: str = "?"
+    args: tuple[Any, ...] = ()
+    kwargs: dict[str, Any] = field(default_factory=dict)
+    downstream_impact: list[str] = field(default_factory=list)
+    exception: str = ""
+    traceback_str: str = ""
+    traced_vars: str = ""
+    traced_vars_location: str = ""
+
+
+class _ErrorContextFormatter(logging.Formatter):
+    """Base formatter providing typed access to a record's failure context."""
+
+    def _error_data(self, record: logging.LogRecord) -> _ErrorData:
+        """Extract the failure context from a log record.
+
+        Parameters
+        ----------
+        record : logging.LogRecord
+            The record being formatted. May or may not carry a
+            ``task_context`` attribute.
+
+        Returns
+        -------
+        _ErrorData
+            Typed view of ``record.task_context``, with defaults filled in
+            for any missing fields.
+        """
+        ctx = getattr(record, "task_context", None) or {}
+        return _ErrorData(
+            task_name=str(ctx.get("task_name", "?")),
+            function=str(ctx.get("function", "?")),
+            args=ctx.get("args", ()),
+            kwargs=ctx.get("kwargs", {}),
+            downstream_impact=ctx.get("downstream_impact", []) or [],
+            exception=ctx.get("exception", record.getMessage()),
+            traceback_str=ctx.get("traceback_str", ""),
+            traced_vars=ctx.get("traced_vars", ""),
+            traced_vars_location=ctx.get("traced_vars_location", ""),
+        )

processes-3.1.1/src/processes/_logfile_formatting.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import logging
+
+from ._error_data import _ErrorContextFormatter
+
+_LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+
+class _TaskLogfileFormatter(_ErrorContextFormatter):
+    """Plain-text formatter for task logfiles.
+
+    On failure, appends the same failure context shown in the HTML email
+    (function, args, kwargs, downstream impact, traced-vars location,
+    traceback) as readable text.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(_LOG_FORMAT)
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Render a log record as plain text, appending failure context if present.
+
+        Parameters
+        ----------
+        record : logging.LogRecord
+            The record being formatted.
+
+        Returns
+        -------
+        str
+            The formatted log line, with the failure context appended if
+            ``record.task_context`` is set.
+        """
+        if not getattr(record, "task_context", None):
+            return super().format(record)
+
+        exc_info, record.exc_info = record.exc_info, None
+        try:
+            base = super().format(record)
+        finally:
+            record.exc_info = exc_info
+
+        error = self._error_data(record)
+        lines = [
+            base,
+            "",
+            f"Function: {error.function}",
+            f"Args: {error.args!r}",
+            f"Kwargs: {error.kwargs!r}",
+            f"Downstream impact: {', '.join(error.downstream_impact) or '-'}",
+            f"Traced vars location: {error.traced_vars_location or '-'}",
+        ]
+        if error.traceback_str:
+            lines.append("")
+            lines.append(error.traceback_str.rstrip("\n"))
+        return "\n".join(lines)