profiler-runit 0.1.3.post1.dev1__tar.gz → 0.1.4.post1.dev9__tar.gz

{profiler_runit-0.1.3.post1.dev1 → profiler_runit-0.1.4.post1.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: profiler-runit
-Version: 0.1.3.post1.dev1
+Version: 0.1.4.post1.dev9
 Summary: Execute and profile cli commands
 Author-email: NotesOfCliff <notesofcliff@gmail.com>
 License-Expression: GPL-3.0-only

{profiler_runit-0.1.3.post1.dev1 → profiler_runit-0.1.4.post1.dev9}/profiler_runit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: profiler-runit
-Version: 0.1.3.post1.dev1
+Version: 0.1.4.post1.dev9
 Summary: Execute and profile cli commands
 Author-email: NotesOfCliff <notesofcliff@gmail.com>
 License-Expression: GPL-3.0-only

{profiler_runit-0.1.3.post1.dev1 → profiler_runit-0.1.4.post1.dev9}/runit/cli.py

@@ -28,7 +28,7 @@ def run_cli():
     stats = monitor_process(args.command)
     report = format_report(stats)
     if args.plot:
-        plot_charts(stats)
+        plot_charts(stats, args.plot_width, args.plot_height)
     print(report)
     if args.out_file:
         sys.stdout = orig_stdout
@@ -69,6 +69,18 @@ def create_parser():
         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,

{profiler_runit-0.1.3.post1.dev1 → profiler_runit-0.1.4.post1.dev9}/runit/monitor.py

@@ -1,10 +1,14 @@
-import subprocess
-import psutil
-from datetime import datetime
-import time
-import logging
-
-log = logging.getLogger(__name__)
+import subprocess
+import psutil
+from datetime import datetime
+import time
+import logging
+import threading
+import sys
+
+log = logging.getLogger(__name__)
+_STREAM_CHUNK_SIZE = 4096
+_THREAD_JOIN_TIMEOUT_SECONDS = 5
 
 def _start_proc(command: list):
     log.info("Starting process: %s", command)
@@ -15,7 +19,7 @@ def _start_proc(command: list):
     )
     return proc
 
-def monitor_process(command):
+def monitor_process(command):
     log.info("Monitoring process: %s", command)
     stats = {
         'start_time': datetime.now(),
@@ -26,13 +30,53 @@ def monitor_process(command):
         'children': [],
         'threads': [],
     }
-    proc = _start_proc(command)
-    ps_proc = psutil.Process(proc.pid)
-    log.debug("Subprocess started with PID %s", ps_proc.pid)
-
-    stats['pid'] = ps_proc.pid
-    try:
-        while ps_proc.is_running() and not ps_proc.status() == psutil.STATUS_ZOMBIE:
+    proc = _start_proc(command)
+    ps_proc = psutil.Process(proc.pid)
+    log.debug("Subprocess started with PID %s", ps_proc.pid)
+
+    stdout_chunks = []
+    stderr_chunks = []
+
+    def _safe_close(stream):
+        try:
+            stream.close()
+        except (OSError, ValueError):
+            pass
+
+    def _forward_and_capture(stream, target, chunks):
+        reader = getattr(stream, 'read1', None)
+        if reader is None:
+            # Fallback for file-like streams that do not implement read1().
+            reader = stream.read
+        try:
+            while True:
+                chunk = reader(_STREAM_CHUNK_SIZE)
+                if not chunk:
+                    break
+                chunks.append(chunk)
+                target.buffer.write(chunk)
+                target.flush()
+        except (OSError, ValueError) as e:
+            log.warning("Stream forwarding stopped due to read error: %s", e)
+        finally:
+            _safe_close(stream)
+
+    stdout_thread = threading.Thread(
+        target=_forward_and_capture,
+        args=(proc.stdout, sys.stdout, stdout_chunks),
+        daemon=True,
+    )
+    stderr_thread = threading.Thread(
+        target=_forward_and_capture,
+        args=(proc.stderr, sys.stderr, stderr_chunks),
+        daemon=True,
+    )
+    stdout_thread.start()
+    stderr_thread.start()
+
+    stats['pid'] = ps_proc.pid
+    try:
+        while ps_proc.is_running() and not ps_proc.status() == psutil.STATUS_ZOMBIE:
             try:
                 cpu_percent = ps_proc.cpu_percent(interval=0.1)
                 memory_info = ps_proc.memory_info()
@@ -44,15 +88,25 @@ def monitor_process(command):
                 stats['threads'].append(threads)
                 stats['check_times'].append(datetime.now())
                 log.debug("Sampled stats at %s, CPU: %s%%, Memory: %s bytes, Children: %s, Threads: %s", stats['check_times'][-1], cpu_percent, memory_info.rss, len(children), len(threads))
-            except (psutil.NoSuchProcess, psutil.ZombieProcess, psutil.AccessDenied):
-                log.warning("Process ended or became inaccessible during monitoring.")
-                break
-            time.sleep(0.1)
-        stats['stdout'] = proc.stdout.read().decode()
-        stats['stderr'] = proc.stderr.read().decode()
-
-    except Exception as e:
-        log.warning("Exception during stat collection: %s", e)
+            except (psutil.NoSuchProcess, psutil.ZombieProcess, psutil.AccessDenied):
+                log.warning("Process ended or became inaccessible during monitoring.")
+                break
+            time.sleep(0.1)
+        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():
+            log.warning("Timed out waiting for stream forwarding threads to finish.")
+            for stream in (proc.stdout, proc.stderr):
+                _safe_close(stream)
+            stdout_thread.join(timeout=1)
+            stderr_thread.join(timeout=1)
+        # Preserve undecodable bytes in a visible form without dropping content.
+        stats['stdout'] = b''.join(stdout_chunks).decode(errors='backslashreplace')
+        stats['stderr'] = b''.join(stderr_chunks).decode(errors='backslashreplace')
+
+    except Exception as e:
+        log.warning("Exception during stat collection: %s", e)
     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.3.post1.dev1 → profiler_runit-0.1.4.post1.dev9}/runit/plotting.py

@@ -6,7 +6,7 @@ try:
 except ImportError:
     plt = None
 
-def plot_charts(stats):
+def plot_charts(stats, width=80, height=20):
     if plt is None:
         log.warning("plotext is not installed. Skipping plotting.")
         return
@@ -19,6 +19,7 @@ def plot_charts(stats):
             from .utils import extract_memory_rss
             rss = extract_memory_rss(stats['memory_info'])
             plt.clear_figure()
+            plt.plot_size(width=width, height=height)
             plt.subplots(2, 1)
             plt.subplot(1)
             plt.title("CPU % over time")

{profiler_runit-0.1.3.post1.dev1 → profiler_runit-0.1.4.post1.dev9}/test.py

@@ -1,11 +1,12 @@
 import subprocess
 import unittest
-import tempfile
-import os
-import re
-
-class TestRunitCLI(unittest.TestCase):
-    """Integration tests for the runit CLI command."""
+import tempfile
+import os
+import re
+import time
+
+class TestRunitCLI(unittest.TestCase):
+    """Integration tests for the runit CLI command."""
 
     def test_nonexistent_command(self):
         """Fails gracefully when a nonexistent command is run."""
@@ -54,9 +55,9 @@ class TestRunitCLI(unittest.TestCase):
         self.assertEqual(result.returncode, 0)
         self.assertTrue('usage:' in result.stdout.lower() or 'usage:' in result.stderr.lower())
 
-    def test_command_runs_and_reports(self):
-        """Runs a command and checks for key report fields."""
-        result = subprocess.run(['runit', 'python', '-c', 'print(123)'], capture_output=True, text=True)
+    def test_command_runs_and_reports(self):
+        """Runs a command and checks for key report fields."""
+        result = subprocess.run(['runit', 'python', '-c', 'print(123)'], capture_output=True, text=True)
         out = result.stdout
         self.assertEqual(result.returncode, 0)
         self.assertIn('Command:', out)
@@ -64,8 +65,35 @@ class TestRunitCLI(unittest.TestCase):
         self.assertIn('End Time:', out)
         self.assertIn('Max RSS (bytes):', out)
         self.assertIn('Max Threads:', out)
-        self.assertIn('Max Children:', out)
-        self.assertIn('Samples:', out)
+        self.assertIn('Max Children:', out)
+        self.assertIn('Samples:', out)
+
+    def test_streams_output_in_real_time(self):
+        """Streams child output before command completion."""
+        max_first_output_delay_seconds = 1.5
+        code = 'import time; print("stream-now", flush=True); time.sleep(2); print("done", flush=True)'
+        proc = subprocess.Popen(
+            ['runit', 'python', '-c', code],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        try:
+            start = time.monotonic()
+            first_line = proc.stdout.readline().strip()
+            elapsed = time.monotonic() - start
+
+            self.assertEqual(first_line, 'stream-now')
+            self.assertLess(elapsed, max_first_output_delay_seconds)
+
+            stdout, stderr = proc.communicate(timeout=10)
+            self.assertEqual(proc.returncode, 0, msg=stderr)
+            self.assertIn('Command:', stdout)
+            self.assertIn('End Time:', stdout)
+        finally:
+            if proc.poll() is None:
+                proc.terminate()
+                proc.wait(timeout=5)
 
     def test_out_file_and_strip_ansi(self):
         """Checks --out-file and --strip-ansi produce plain text output."""