profiler-runit 0.1.4.post1.dev9__tar.gz → 0.2.0.post1.dev5__tar.gz

profiler_runit-0.2.0.post1.dev5/CHANGES.md

@@ -0,0 +1,10 @@
+# Changes
+
+## 0.2.0 (unreleased)
+
+- Fixed: `--out-file` no longer crashes the output thread or kills the command with a broken pipe. All output of the command is shown and captured.
+- Fixed: output larger than the pipe buffer (about 64 KB) no longer makes runit hang. This was fixed on main by streaming stdout and stderr (PR #1). The 0.1.4 release still has the hang.
+- Changed (new in 0.2.0): runit exits with the exit code of the command (128 + N for signal N, 127 when the command is not found, 126 when it cannot be executed, also for a script without a `#!` line). Before, it exited with 0; use `runit ... || true` if a script relies on that. The report's `Exit Code` shows the same value, with the signal name for a signal (for example `143 (signal 15, SIGTERM)`).
+- Fixed: an `--out-file` that cannot be written, or a full stdout, now gives one error line instead of a traceback. For a full stdout, runit keeps the command's exit code. For an unwritable `--out-file`, a non-zero exit code of the command wins; otherwise runit exits 1. `--out-file` is written before the report goes to the terminal. When the stdout reader goes away (`runit yes | head`), runit stops quietly.
+- Changed: the plotext dependency is pinned to `plotext>=5.3,<6`. plotext 6 replaced the API that `--plot` uses, so charts were silently skipped, and plotext 5.2 draws empty charts. runit now logs a clear warning if an unsupported plotext is installed.
+- Tests: added regression tests that run the installed `runit` command for these cases.

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/PKG-INFO

@@ -1,14 +1,17 @@
 Metadata-Version: 2.4
 Name: profiler-runit
-Version: 0.1.4.post1.dev9
+Version: 0.2.0.post1.dev5
 Summary: Execute and profile cli commands
 Author-email: NotesOfCliff <notesofcliff@gmail.com>
 License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/McIndi/runit
+Project-URL: Repository, https://github.com/McIndi/runit
+Project-URL: Issues, https://github.com/McIndi/runit/issues
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: psutil
-Requires-Dist: plotext
+Requires-Dist: plotext<6,>=5.3
 Dynamic: license-file
 
 # runit
@@ -39,14 +42,14 @@ See `runit` in action:
 ## Requirements
 * Python 3.9+
 * psutil
-* plotext
+* plotext 5.x (`plotext>=5.3,<6`). plotext 6 replaced the plotting API that runit uses, so it is not supported yet.
 
 ## Installation
 
 Clone this repository and install with pip:
 
 ```sh
-git clone https://github.com/notesofcliff/runit.git
+git clone https://github.com/McIndi/runit.git
 cd runit
 python -m venv .venv
 source .venv/bin/activate  # Or (for Windows) .venv/Scripts/activate
@@ -59,7 +62,7 @@ python test.py
 Or, install directly from GitHub:
 
 ```sh
-pip install git+https://github.com/notesofcliff/runit.git
+pip install git+https://github.com/McIndi/runit.git
 ```
 
 After installation, use `runit` to run and analyze any command:
@@ -91,6 +94,7 @@ PID: 12345
 Start Time: 2025-07-31 12:00:00.000000
 End Time: 2025-07-31 12:00:01.000000
 Duration: 0:00:01
+Exit Code: 0
 Max RSS (bytes): 12345678
 Max Threads: 4
 Max Children: 0
@@ -110,12 +114,15 @@ runit python benchmark.py
 ## CLI Options
 
 - `--log-level LEVEL`: Set the logging level (default: INFO)
-- `--out-file FILE`: Write the report and charts to a file (output is also shown in the terminal)
+- `--out-file FILE`: Also write the report and charts to a file (they are still shown in the terminal)
 - `--strip-ansi`: Remove ANSI escape codes from output file (for plain text files)
 - `--plot`: If specified, attempt to plot CPU and memory usage
+- `--plot-width N`, `--plot-height N`: Set the chart size (default: 80 x 20)
 - `command`: The command to run and monitor
 
-When using `--out-file`, the output is both displayed in the terminal and written to the file. For plain text (no colors or terminal formatting), simply add `--strip-ansi`.
+The output of the command goes to the terminal while it runs (stdout to stdout, stderr to stderr), with or without `--out-file`. When the command ends, runit shows the report, which also contains the captured stdout and stderr.
+
+When using `--out-file`, the report and charts are both displayed in the terminal and written to the file. For plain text (no colors or terminal formatting), simply add `--strip-ansi`.
 
 ```sh
 runit --out-file out.txt --strip-ansi python benchmark.py
@@ -123,6 +130,20 @@ runit --out-file out.txt --strip-ansi python benchmark.py
 
 You'll see the report and charts in your terminal, and a plain text version in `out.txt`.
 
+## Exit Status
+
+runit exits with the exit code of the command, so you can use it in scripts and CI:
+
+- The exit code of the command (for example, `runit false` exits with 1).
+- 128 + N when the command is stopped by signal N (for example, 143 for SIGTERM).
+- 127 when the command is not found, and 126 when it cannot be executed (for example, no permission, or a script without a `#!` line).
+
+The `Exit Code:` line of the report shows the same value that runit exits with. For a signal, it also shows the signal, for example `Exit Code: 143 (signal 15, SIGTERM)`.
+
+If runit cannot write the `--out-file` file, it logs one error line. If the command failed, runit exits with the exit code of the command; if the command exited with 0, runit exits with 1. If runit cannot write the report to stdout (for example, a full disk), it logs one error line and exits with the exit code of the command. If the reader of stdout goes away (for example, `runit yes | head`), runit stops quietly. The `--out-file` file is written before the report goes to the terminal.
+
+This behavior is new in 0.2.0. Releases up to 0.1.4 always exited with 0. If a script relies on that, use `runit ... || true`.
+
 ## Development & Extending
 
 ### Project Structure

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/README.md

@@ -26,14 +26,14 @@ See `runit` in action:
 ## Requirements
 * Python 3.9+
 * psutil
-* plotext
+* plotext 5.x (`plotext>=5.3,<6`). plotext 6 replaced the plotting API that runit uses, so it is not supported yet.
 
 ## Installation
 
 Clone this repository and install with pip:
 
 ```sh
-git clone https://github.com/notesofcliff/runit.git
+git clone https://github.com/McIndi/runit.git
 cd runit
 python -m venv .venv
 source .venv/bin/activate  # Or (for Windows) .venv/Scripts/activate
@@ -46,7 +46,7 @@ python test.py
 Or, install directly from GitHub:
 
 ```sh
-pip install git+https://github.com/notesofcliff/runit.git
+pip install git+https://github.com/McIndi/runit.git
 ```
 
 After installation, use `runit` to run and analyze any command:
@@ -78,6 +78,7 @@ PID: 12345
 Start Time: 2025-07-31 12:00:00.000000
 End Time: 2025-07-31 12:00:01.000000
 Duration: 0:00:01
+Exit Code: 0
 Max RSS (bytes): 12345678
 Max Threads: 4
 Max Children: 0
@@ -97,12 +98,15 @@ runit python benchmark.py
 ## CLI Options
 
 - `--log-level LEVEL`: Set the logging level (default: INFO)
-- `--out-file FILE`: Write the report and charts to a file (output is also shown in the terminal)
+- `--out-file FILE`: Also write the report and charts to a file (they are still shown in the terminal)
 - `--strip-ansi`: Remove ANSI escape codes from output file (for plain text files)
 - `--plot`: If specified, attempt to plot CPU and memory usage
+- `--plot-width N`, `--plot-height N`: Set the chart size (default: 80 x 20)
 - `command`: The command to run and monitor
 
-When using `--out-file`, the output is both displayed in the terminal and written to the file. For plain text (no colors or terminal formatting), simply add `--strip-ansi`.
+The output of the command goes to the terminal while it runs (stdout to stdout, stderr to stderr), with or without `--out-file`. When the command ends, runit shows the report, which also contains the captured stdout and stderr.
+
+When using `--out-file`, the report and charts are both displayed in the terminal and written to the file. For plain text (no colors or terminal formatting), simply add `--strip-ansi`.
 
 ```sh
 runit --out-file out.txt --strip-ansi python benchmark.py
@@ -110,6 +114,20 @@ runit --out-file out.txt --strip-ansi python benchmark.py
 
 You'll see the report and charts in your terminal, and a plain text version in `out.txt`.
 
+## Exit Status
+
+runit exits with the exit code of the command, so you can use it in scripts and CI:
+
+- The exit code of the command (for example, `runit false` exits with 1).
+- 128 + N when the command is stopped by signal N (for example, 143 for SIGTERM).
+- 127 when the command is not found, and 126 when it cannot be executed (for example, no permission, or a script without a `#!` line).
+
+The `Exit Code:` line of the report shows the same value that runit exits with. For a signal, it also shows the signal, for example `Exit Code: 143 (signal 15, SIGTERM)`.
+
+If runit cannot write the `--out-file` file, it logs one error line. If the command failed, runit exits with the exit code of the command; if the command exited with 0, runit exits with 1. If runit cannot write the report to stdout (for example, a full disk), it logs one error line and exits with the exit code of the command. If the reader of stdout goes away (for example, `runit yes | head`), runit stops quietly. The `--out-file` file is written before the report goes to the terminal.
+
+This behavior is new in 0.2.0. Releases up to 0.1.4 always exited with 0. If a script relies on that, use `runit ... || true`.
+
 ## Development & Extending
 
 ### Project Structure

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/profiler_runit.egg-info/PKG-INFO

@@ -1,14 +1,17 @@
 Metadata-Version: 2.4
 Name: profiler-runit
-Version: 0.1.4.post1.dev9
+Version: 0.2.0.post1.dev5
 Summary: Execute and profile cli commands
 Author-email: NotesOfCliff <notesofcliff@gmail.com>
 License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/McIndi/runit
+Project-URL: Repository, https://github.com/McIndi/runit
+Project-URL: Issues, https://github.com/McIndi/runit/issues
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: psutil
-Requires-Dist: plotext
+Requires-Dist: plotext<6,>=5.3
 Dynamic: license-file
 
 # runit
@@ -39,14 +42,14 @@ See `runit` in action:
 ## Requirements
 * Python 3.9+
 * psutil
-* plotext
+* plotext 5.x (`plotext>=5.3,<6`). plotext 6 replaced the plotting API that runit uses, so it is not supported yet.
 
 ## Installation
 
 Clone this repository and install with pip:
 
 ```sh
-git clone https://github.com/notesofcliff/runit.git
+git clone https://github.com/McIndi/runit.git
 cd runit
 python -m venv .venv
 source .venv/bin/activate  # Or (for Windows) .venv/Scripts/activate
@@ -59,7 +62,7 @@ python test.py
 Or, install directly from GitHub:
 
 ```sh
-pip install git+https://github.com/notesofcliff/runit.git
+pip install git+https://github.com/McIndi/runit.git
 ```
 
 After installation, use `runit` to run and analyze any command:
@@ -91,6 +94,7 @@ PID: 12345
 Start Time: 2025-07-31 12:00:00.000000
 End Time: 2025-07-31 12:00:01.000000
 Duration: 0:00:01
+Exit Code: 0
 Max RSS (bytes): 12345678
 Max Threads: 4
 Max Children: 0
@@ -110,12 +114,15 @@ runit python benchmark.py
 ## CLI Options
 
 - `--log-level LEVEL`: Set the logging level (default: INFO)
-- `--out-file FILE`: Write the report and charts to a file (output is also shown in the terminal)
+- `--out-file FILE`: Also write the report and charts to a file (they are still shown in the terminal)
 - `--strip-ansi`: Remove ANSI escape codes from output file (for plain text files)
 - `--plot`: If specified, attempt to plot CPU and memory usage
+- `--plot-width N`, `--plot-height N`: Set the chart size (default: 80 x 20)
 - `command`: The command to run and monitor
 
-When using `--out-file`, the output is both displayed in the terminal and written to the file. For plain text (no colors or terminal formatting), simply add `--strip-ansi`.
+The output of the command goes to the terminal while it runs (stdout to stdout, stderr to stderr), with or without `--out-file`. When the command ends, runit shows the report, which also contains the captured stdout and stderr.
+
+When using `--out-file`, the report and charts are both displayed in the terminal and written to the file. For plain text (no colors or terminal formatting), simply add `--strip-ansi`.
 
 ```sh
 runit --out-file out.txt --strip-ansi python benchmark.py
@@ -123,6 +130,20 @@ runit --out-file out.txt --strip-ansi python benchmark.py
 
 You'll see the report and charts in your terminal, and a plain text version in `out.txt`.
 
+## Exit Status
+
+runit exits with the exit code of the command, so you can use it in scripts and CI:
+
+- The exit code of the command (for example, `runit false` exits with 1).
+- 128 + N when the command is stopped by signal N (for example, 143 for SIGTERM).
+- 127 when the command is not found, and 126 when it cannot be executed (for example, no permission, or a script without a `#!` line).
+
+The `Exit Code:` line of the report shows the same value that runit exits with. For a signal, it also shows the signal, for example `Exit Code: 143 (signal 15, SIGTERM)`.
+
+If runit cannot write the `--out-file` file, it logs one error line. If the command failed, runit exits with the exit code of the command; if the command exited with 0, runit exits with 1. If runit cannot write the report to stdout (for example, a full disk), it logs one error line and exits with the exit code of the command. If the reader of stdout goes away (for example, `runit yes | head`), runit stops quietly. The `--out-file` file is written before the report goes to the terminal.
+
+This behavior is new in 0.2.0. Releases up to 0.1.4 always exited with 0. If a script relies on that, use `runit ... || true`.
+
 ## Development & Extending
 
 ### Project Structure

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/profiler_runit.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 .gitignore
+CHANGES.md
 LICENSE
 README.md
 benchmark.py
@@ -14,6 +15,8 @@ profiler_runit.egg-info/SOURCES.txt
 profiler_runit.egg-info/dependency_links.txt
 profiler_runit.egg-info/entry_points.txt
 profiler_runit.egg-info/requires.txt
+profiler_runit.egg-info/scm_file_list.json
+profiler_runit.egg-info/scm_version.json
 profiler_runit.egg-info/top_level.txt
 runit/__init__.py
 runit/cli.py

profiler_runit-0.2.0.post1.dev5/profiler_runit.egg-info/requires.txt

@@ -0,0 +1,2 @@
+psutil
+plotext<6,>=5.3

profiler_runit-0.2.0.post1.dev5/profiler_runit.egg-info/scm_file_list.json

@@ -0,0 +1,23 @@
+{
+  "files": [
+    ".github/workflows/ci.yml",
+    ".github/workflows/release.yml",
+    ".github/workflows/testpypi.yml",
+    ".gitignore",
+    "CHANGES.md",
+    "LICENSE",
+    "README.md",
+    "assets/runit-demo.gif",
+    "benchmark.py",
+    "pyproject.toml",
+    "requirements.txt",
+    "runit/__init__.py",
+    "runit/cli.py",
+    "runit/logging_config.py",
+    "runit/monitor.py",
+    "runit/plotting.py",
+    "runit/report.py",
+    "runit/utils.py",
+    "test.py"
+  ]
+}

profiler_runit-0.2.0.post1.dev5/profiler_runit.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.2.0",
+  "distance": 5,
+  "node": "g30d2fa7621d9ddbc2c773cbf2796d6d9a60ddb44",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-11-11"
+}

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/pyproject.toml

@@ -12,9 +12,14 @@ authors = [{ name = "NotesOfCliff", email = "notesofcliff@gmail.com" }]
 license = "GPL-3.0-only"
 dependencies = [
   "psutil",
-  "plotext",
+  "plotext>=5.3,<6",
 ]
 
+[project.urls]
+Homepage = "https://github.com/McIndi/runit"
+Repository = "https://github.com/McIndi/runit"
+Issues = "https://github.com/McIndi/runit/issues"
+
 [tool.setuptools_scm]
 version_scheme = "no-guess-dev"
 local_scheme = "no-local-version"

profiler_runit-0.2.0.post1.dev5/requirements.txt

@@ -0,0 +1,2 @@
+psutil
+plotext>=5.3,<6

profiler_runit-0.2.0.post1.dev5/runit/cli.py

@@ -0,0 +1,132 @@
+import sys
+from .monitor import monitor_process
+from .report import format_report
+from .plotting import plot_charts
+from .utils import strip_ansi, exit_status
+from .logging_config import setup_logging
+import argparse
+import logging
+import os
+from contextlib import redirect_stdout
+from io import StringIO
+
+
+def _write_stdout(text, log):
+    """Write the report to stdout. Return False if stdout is closed or broken.
+
+    When the reader has gone away (for example `runit cmd | head`), stay quiet
+    like other command line tools. For other errors (for example a full disk),
+    log one line. In both cases stdout is pointed at os.devnull, so that the
+    flush at interpreter exit does not raise again.
+    """
+    try:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+        return True
+    except (OSError, ValueError) as e:
+        if isinstance(e, BrokenPipeError):
+            log.info("Output reader closed the pipe; report not shown.")
+        else:
+            log.error("Cannot write the report to stdout: %s", e)
+        try:
+            devnull = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(devnull, sys.stdout.fileno())
+            os.close(devnull)
+        except (OSError, ValueError):
+            pass
+        return False
+
+
+def run_cli():
+    parser = create_parser()
+    args = parser.parse_args()
+    setup_logging(args.log_level)
+    log = logging.getLogger(__name__)
+    log.info("Starting runit CLI")
+    if not args.command:
+        parser.print_help()
+        log.info("No command provided. Exiting.")
+        return 0
+    try:
+        # The program's stdout and stderr go to the terminal as it runs.
+        stats = monitor_process(args.command)
+    except FileNotFoundError as e:
+        log.error("Command not found: %s (%s)", args.command[0], e)
+        return 127
+    except OSError as e:
+        # For example EACCES, or ENOEXEC for a script without a shebang.
+        log.error("Command cannot be executed: %s (%s)", args.command[0], e)
+        return 126
+    status = exit_status(stats.get('returncode'))
+    report = format_report(stats)
+    # Capture the report and charts, write --out-file first, then the terminal.
+    buf = StringIO()
+    with redirect_stdout(buf):
+        if args.plot:
+            plot_charts(stats, args.plot_width, args.plot_height)
+        print(report)
+    output = buf.getvalue()
+    if args.out_file:
+        file_output = output
+        if getattr(args, 'strip_ansi', False):
+            log.info("Stripping ANSI codes for output file.")
+            file_output = strip_ansi(output)
+        try:
+            with open(args.out_file, 'w', encoding='utf-8') as f:
+                f.write(file_output)
+            log.info("Wrote output to file: %s", args.out_file)
+        except OSError as e:
+            # runit's own job failed: report it in one line. A non-zero
+            # exit code of the command wins; otherwise runit exits 1.
+            log.error("Cannot write --out-file %s: %s", args.out_file, e)
+            if status == 0:
+                status = 1
+    _write_stdout(output, log)
+    log.info("runit CLI finished.")
+    return status
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        description="Run a command and report on its execution (time, resources, etc)."
+    )
+    parser.add_argument(
+        '--log-level',
+        default='INFO',
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
+        help='Set the logging level (default: INFO)'
+    )
+    parser.add_argument(
+        '--out-file',
+        type=str,
+        default=None,
+        help='Also write the report (and charts) to this file. '
+             'The program output and the report are still shown in the terminal.'
+    )
+    parser.add_argument(
+        '--strip-ansi',
+        action='store_true',
+        help='Remove ANSI escape codes from output (for plain text files).'
+    )
+    parser.add_argument(
+        '--plot',
+        action='store_true',
+        help='Show resource usage charts (requires plotext).'
+    )
+    parser.add_argument(
+        '--plot-width',
+        type=int,
+        default=80,
+        help='Set the plot width (default: 80)'
+    )
+    parser.add_argument(
+        '--plot-height',
+        type=int,
+        default=20,
+        help='Set the plot height (default: 20)'
+    )
+    parser.add_argument(
+        'command',
+        nargs=argparse.REMAINDER,
+        help='The command and arguments to run.'
+    )
+    return parser

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/runit/monitor.py

@@ -9,6 +9,24 @@ import sys
 log = logging.getLogger(__name__)
 _STREAM_CHUNK_SIZE = 4096
 _THREAD_JOIN_TIMEOUT_SECONDS = 5
+
+def _binary_writer(target):
+    """Return a function that writes bytes to ``target`` and flushes it.
+
+    ``target`` is normally ``sys.stdout`` or ``sys.stderr``. A text stream
+    without a binary ``buffer`` (for example ``io.StringIO``) gets the bytes
+    decoded, so that forwarding never fails because of the stream type.
+    """
+    buffer = getattr(target, 'buffer', None)
+    if buffer is not None:
+        def write(chunk):
+            buffer.write(chunk)
+            buffer.flush()
+    else:
+        def write(chunk):
+            target.write(chunk.decode(errors='backslashreplace'))
+            target.flush()
+    return write
 
 def _start_proc(command: list):
     log.info("Starting process: %s", command)
@@ -29,6 +47,9 @@ def monitor_process(command):
         'memory_info': [],
         'children': [],
         'threads': [],
+        'stdout': '',
+        'stderr': '',
+        'returncode': None,
     }
     proc = _start_proc(command)
     ps_proc = psutil.Process(proc.pid)
@@ -48,14 +69,32 @@ def monitor_process(command):
         if reader is None:
             # Fallback for file-like streams that do not implement read1().
             reader = stream.read
+        write = _binary_writer(target)
         try:
             while True:
                 chunk = reader(_STREAM_CHUNK_SIZE)
                 if not chunk:
                     break
                 chunks.append(chunk)
-                target.buffer.write(chunk)
-                target.flush()
+                if write is None:
+                    continue
+                try:
+                    write(chunk)
+                except (OSError, ValueError) as e:
+                    # The destination is closed or full (for example EPIPE
+                    # from `runit cmd | head`). Stop and close the pipe so
+                    # the program sees a closed pipe, as without runit.
+                    if isinstance(e, BrokenPipeError):
+                        log.info("Output reader closed the pipe; stopped forwarding.")
+                    else:
+                        log.warning("Stream forwarding stopped due to write error: %s", e)
+                    break
+                except Exception as e:
+                    # Any other failure must not stop the reader: a program
+                    # that cannot write blocks on a full pipe or is killed by
+                    # a closed one. Keep capturing and stop forwarding.
+                    log.warning("Stream forwarding stopped due to write error: %s", e)
+                    write = None
         except (OSError, ValueError) as e:
             log.warning("Stream forwarding stopped due to read error: %s", e)
         finally:
@@ -92,7 +131,7 @@ def monitor_process(command):
                 log.warning("Process ended or became inaccessible during monitoring.")
                 break
             time.sleep(0.1)
-        proc.wait()
+        stats['returncode'] = proc.wait()
         stdout_thread.join(timeout=_THREAD_JOIN_TIMEOUT_SECONDS)
         stderr_thread.join(timeout=_THREAD_JOIN_TIMEOUT_SECONDS)
         if stdout_thread.is_alive() or stderr_thread.is_alive():
@@ -107,6 +146,8 @@ def monitor_process(command):
 
     except Exception as e:
         log.warning("Exception during stat collection: %s", e)
+    if stats['returncode'] is None:
+        stats['returncode'] = proc.wait()
     stats['end_time'] = datetime.now()
     stats['duration'] = stats['end_time'] - stats['start_time']
     log.info("Process monitoring complete. Duration: %s", stats['duration'])

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/runit/plotting.py

@@ -10,6 +10,13 @@ def plot_charts(stats, width=80, height=20):
     if plt is None:
         log.warning("plotext is not installed. Skipping plotting.")
         return
+    if not hasattr(plt, 'plot_size'):
+        # plotext 6 replaced the module-level API that runit uses.
+        log.warning(
+            "plotext %s is not supported (runit needs plotext>=5.3,<6). Skipping plotting.",
+            getattr(plt, '__version__', 'unknown'),
+        )
+        return
     if stats['check_times'] and stats['cpu_percent']:
         try:
             log.info("Plotting charts.")

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/runit/report.py

@@ -1,4 +1,4 @@
-from .utils import extract_memory_rss, extract_num_threads, extract_num_children
+from .utils import extract_memory_rss, extract_num_threads, extract_num_children, describe_exit
 import logging
 
 log = logging.getLogger(__name__)
@@ -14,6 +14,7 @@ def format_report(stats):
         "Start Time: {}".format(stats['start_time']),
         "End Time: {}".format(stats['end_time']),
         "Duration: {}".format(stats['duration']),
+        "Exit Code: {}".format(describe_exit(stats.get('returncode'))),
         "Max RSS (bytes): {}".format(max(rss_values) if rss_values else 'N/A'),
         "Max Threads: {}".format(max(num_threads) if num_threads else 'N/A'),
         "Max Children: {}".format(max(num_children) if num_children else 'N/A'),

{profiler_runit-0.1.4.post1.dev9 → profiler_runit-0.2.0.post1.dev5}/runit/utils.py

@@ -1,5 +1,6 @@
 import re
 import logging
+import signal
 from ast import literal_eval
 
 log = logging.getLogger(__name__)
@@ -9,6 +10,29 @@ def strip_ansi(text):
     ansi_escape = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
     return ansi_escape.sub('', text)
 
+def exit_status(returncode):
+    """Map a subprocess return code to the exit status runit uses.
+
+    A program killed by signal N has a negative return code; shells report
+    that as 128 + N, so runit does the same.
+    """
+    if returncode is None:
+        return 1
+    if returncode < 0:
+        return 128 - returncode
+    return returncode
+
+def describe_exit(returncode):
+    """Text for the report: runit's exit status, plus the signal if there was one."""
+    status = exit_status(returncode)
+    if returncode is None or returncode >= 0:
+        return str(status)
+    try:
+        name = signal.Signals(-returncode).name
+    except ValueError:
+        return "{} (signal {})".format(status, -returncode)
+    return "{} (signal {}, {})".format(status, -returncode, name)
+
 def extract_memory_rss(memory_info_list):
     log.debug("Extracting memory RSS values.")
     rss_values = []