vedro-profiling 0.0.1__tar.gz

vedro_profiling-0.0.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: vedro-profiling
+Version: 0.0.1
+Summary: Vedro plugin for measuring docker resource usage.
+Home-page: https://github.com/lolimpo/vedro-profiling
+Author: Nikita Mikheev
+Author-email: thelol1mpo@gmail.com
+License: Apache-2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: vedro<2.0.0,>=1.13.0
+Requires-Dist: docker<8.0.0,>=7.0.0
+Requires-Dist: matplotlib<4.0.0,>=3.10.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Vedro profiling
+
+Vedro plugin for measuring docker resource usage of tests.

vedro_profiling-0.0.1/README.md

@@ -0,0 +1,3 @@
+# Vedro profiling
+
+Vedro plugin for measuring docker resource usage of tests.

vedro_profiling-0.0.1/setup.cfg

@@ -0,0 +1,18 @@
+[flake8]
+exclude = venv,__pycache__
+max_line_length = 99
+statistics = true
+
+[isort]
+line_length = 99
+multi_line_output = 3
+include_trailing_comma = true
+skip = venv,__pycache__
+
+[mypy]
+ignore_missing_imports = false
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

vedro_profiling-0.0.1/setup.py

@@ -0,0 +1,39 @@
+from setuptools import find_packages, setup
+
+from vedro_profiling import version
+
+
+def find_required():
+    with open("requirements.txt") as f:
+        return f.read().splitlines()
+
+
+def find_dev_required():
+    with open("requirements-dev.txt") as f:
+        return f.read().splitlines()
+
+
+setup(
+    name="vedro-profiling",
+    version=version,
+    description="Vedro plugin for measuring docker resource usage.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Nikita Mikheev",
+    author_email="thelol1mpo@gmail.com",
+    python_requires=">=3.10",
+    url="https://github.com/lolimpo/vedro-profiling",
+    license="Apache-2.0",
+    packages=find_packages(exclude=["tests", "tests.*"]),
+    package_data={"vedro_profiling": ["py.typed"]},
+    install_requires=find_required(),
+    tests_require=find_dev_required(),
+    classifiers=[
+        "License :: OSI Approved :: Apache Software License",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Typing :: Typed"
+    ]
+)

vedro_profiling-0.0.1/vedro_profiling/__init__.py

@@ -0,0 +1,5 @@
+from ._vedro_profiling import VedroProfiling, VedroProfilingPlugin
+
+version = "0.0.1"
+
+__all__ = ("VedroProfiling", "VedroProfilingPlugin", "version",)

vedro_profiling-0.0.1/vedro_profiling/_vedro_profiling.py

@@ -0,0 +1,136 @@
+import json
+import threading
+import time
+from collections import defaultdict
+from typing import Any, DefaultDict, Optional, Type
+
+import docker
+from matplotlib import pyplot as plt
+from vedro.core import Dispatcher, Plugin, PluginConfig
+from vedro.events import ArgParsedEvent, ArgParseEvent, CleanupEvent, StartupEvent
+
+
+class VedroProfilingPlugin(Plugin):
+    """
+    Adds docker profiling support to the Vedro framework.
+    """
+
+    def __init__(self, config: Type["VedroProfiling"]):
+        super().__init__(config)
+        self._poll_time: float = config.poll_time
+        self._enable_profiling: bool = config.enable_profiling
+        self._draw_plots: bool = config.draw_plots
+        self._stats: DefaultDict[str, Any] = defaultdict(lambda: {"CPU": [], "MEM": []})
+
+        self._client = docker.from_env()
+        self._running: bool = False
+        self._thread: Optional[threading.Thread] = None
+
+    def subscribe(self, dispatcher: Dispatcher) -> None:
+        dispatcher.listen(ArgParseEvent, self.on_arg_parse) \
+                  .listen(ArgParsedEvent, self.on_arg_parsed) \
+                  .listen(StartupEvent, self.on_startup) \
+                  .listen(CleanupEvent, self.on_cleanup)
+
+    def on_arg_parse(self, event: ArgParseEvent) -> None:
+        group = event.arg_parser.add_argument_group("VedroProfiling")
+        group.add_argument(
+            "--enable-profiling",
+            action="store_true",
+            default=self._enable_profiling,
+            help="Enable recording of containers stats during scenario execution"
+        )
+        group.add_argument(
+            "--draw-plots",
+            action="store_true",
+            default=self._draw_plots,
+            help="Draw CPU/MEM plots after test run"
+        )
+
+    def on_arg_parsed(self, event: ArgParsedEvent) -> None:
+        self._enable_profiling = event.args.enable_profiling
+        self._draw_plots = event.args.draw_plots
+
+    def _collect_stats(self) -> None:
+        containers = self._client.containers.list()
+        while self._running:
+            for container in containers:
+                stats = container.stats(decode=None, stream=False)
+
+                cpu_delta = (stats["cpu_stats"]["cpu_usage"]["total_usage"] -
+                             stats["precpu_stats"]["cpu_usage"]["total_usage"])
+                system_delta = (stats["cpu_stats"]["system_cpu_usage"] -
+                                stats["precpu_stats"]["system_cpu_usage"])
+
+                if system_delta > 0 and stats["cpu_stats"].get("online_cpus"):
+                    cpu_percent = ((cpu_delta / system_delta) *
+                                   stats["cpu_stats"]["online_cpus"] * 100)
+                    self._stats[container.name]["CPU"].append(cpu_percent)
+
+                mem = stats["memory_stats"]["usage"]
+                self._stats[container.name]["MEM"].append(mem / 1e6)  # in MB
+            time.sleep(self._poll_time)
+
+    def on_startup(self, event: StartupEvent) -> None:
+        if not self._enable_profiling:
+            return
+
+        if not self._client.containers.list():
+            raise RuntimeError("No running containers found for profiling.")
+
+        self._running = True
+        self._thread = threading.Thread(target=self._collect_stats, daemon=True)
+        self._thread.start()
+
+    def _generate_plots(self) -> None:
+        for name, metrics in self._stats.items():
+            ticks = list(range(len(metrics["CPU"])))
+
+            # CPU plot
+            plt.figure()
+            plt.plot(ticks, metrics["CPU"], label="CPU (%)")
+            plt.xlabel("Tick")
+            plt.ylabel("CPU Usage (%)")
+            plt.title(f"{name} - CPU Usage")
+            plt.legend()
+            plt.tight_layout()
+            plt.savefig(f"{name}_cpu.png")
+            plt.close()
+
+            # Memory plot
+            plt.figure()
+            plt.plot(ticks, metrics["MEM"], label="Memory (MB)")
+            plt.xlabel("Tick")
+            plt.ylabel("Memory Usage (MB)")
+            plt.title(f"{name} - Memory Usage")
+            plt.legend()
+            plt.tight_layout()
+            plt.savefig(f"{name}_mem.png")
+            plt.close()
+
+    def on_cleanup(self, event: CleanupEvent) -> None:
+        if not self._enable_profiling:
+            return
+
+        self._running = False
+        if self._thread and self._thread.is_alive():
+            self._thread.join()
+
+        with open("./profiling.log", "w") as profiling_log:
+            json.dump(dict(self._stats), profiling_log, indent=2)
+
+        if self._draw_plots:
+            self._generate_plots()
+
+
+class VedroProfiling(PluginConfig):
+    plugin = VedroProfilingPlugin
+
+    # Enable stats collection
+    enable_profiling: bool = False
+
+    # Enable plots drawing for given profile snapshot
+    draw_plots: bool = False
+
+    # Poll time for stats in seconds
+    poll_time: float = 1.0

vedro_profiling-0.0.1/vedro_profiling.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: vedro-profiling
+Version: 0.0.1
+Summary: Vedro plugin for measuring docker resource usage.
+Home-page: https://github.com/lolimpo/vedro-profiling
+Author: Nikita Mikheev
+Author-email: thelol1mpo@gmail.com
+License: Apache-2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: vedro<2.0.0,>=1.13.0
+Requires-Dist: docker<8.0.0,>=7.0.0
+Requires-Dist: matplotlib<4.0.0,>=3.10.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Vedro profiling
+
+Vedro plugin for measuring docker resource usage of tests.

vedro_profiling-0.0.1/vedro_profiling.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.cfg
+setup.py
+vedro_profiling/__init__.py
+vedro_profiling/_vedro_profiling.py
+vedro_profiling/py.typed
+vedro_profiling.egg-info/PKG-INFO
+vedro_profiling.egg-info/SOURCES.txt
+vedro_profiling.egg-info/dependency_links.txt
+vedro_profiling.egg-info/requires.txt
+vedro_profiling.egg-info/top_level.txt

vedro_profiling-0.0.1/vedro_profiling.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vedro_profiling-0.0.1/vedro_profiling.egg-info/requires.txt

@@ -0,0 +1,3 @@
+vedro<2.0.0,>=1.13.0
+docker<8.0.0,>=7.0.0
+matplotlib<4.0.0,>=3.10.0

vedro_profiling-0.0.1/vedro_profiling.egg-info/top_level.txt

@@ -0,0 +1 @@
+vedro_profiling