amd-node-scraper 0.0.1__py3-none-any.whl

nodescraper/plugins/inband/rocm/rocm_collector.py

@@ -0,0 +1,205 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Optional
+
+from nodescraper.base import InBandDataCollector
+from nodescraper.connection.inband import TextFileArtifact
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus, OSFamily
+from nodescraper.models import TaskResult
+from nodescraper.utils import strip_ansi_codes
+
+from .rocmdata import RocmDataModel
+
+
+class RocmCollector(InBandDataCollector[RocmDataModel, None]):
+    """Collect ROCm version data"""
+
+    SUPPORTED_OS_FAMILY: set[OSFamily] = {OSFamily.LINUX}
+
+    DATA_MODEL = RocmDataModel
+    CMD_VERSION_PATHS = [
+        "/opt/rocm/.info/version-rocm",
+        "/opt/rocm/.info/version",
+    ]
+    CMD_ROCMINFO = "{rocm_path}/bin/rocminfo"
+    CMD_ROCM_LATEST = "ls -v -d /opt/rocm-[3-7]* | tail -1"
+    CMD_ROCM_DIRS = "ls -v -d /opt/rocm*"
+    CMD_LD_CONF = "grep -i -E 'rocm' /etc/ld.so.conf.d/*"
+    CMD_ROCM_LIBS = "ldconfig -p | grep -i -E 'rocm'"
+    CMD_ENV_VARS = "env | grep -Ei 'rocm|hsa|hip|mpi|openmp|ucx|miopen'"
+    CMD_CLINFO = "{rocm_path}/opencl/bin/*/clinfo"
+    CMD_KFD_PROC = "ls /sys/class/kfd/kfd/proc/"
+
+    def collect_data(self, args=None) -> tuple[TaskResult, Optional[RocmDataModel]]:
+        """Collect ROCm version data from the system.
+
+        Returns:
+            tuple[TaskResult, Optional[RocmDataModel]]: tuple containing the task result and ROCm data model if available.
+        """
+        rocm_data = None
+        for path in self.CMD_VERSION_PATHS:
+            res = self._run_sut_cmd(f"grep . {path}")
+            if res.exit_code == 0:
+                try:
+                    rocm_data = RocmDataModel(rocm_version=res.stdout)
+                    self._log_event(
+                        category="ROCM_VERSION_READ",
+                        description="ROCm version data collected",
+                        data=rocm_data.model_dump(include={"rocm_version"}),
+                        priority=EventPriority.INFO,
+                    )
+                    self.result.message = f"ROCm version: {rocm_data.rocm_version}"
+                    self.result.status = ExecutionStatus.OK
+                    break
+                except ValueError as e:
+                    self._log_event(
+                        category=EventCategory.OS,
+                        description=f"Invalid ROCm version format: {res.stdout}",
+                        data={"version": res.stdout, "error": str(e)},
+                        priority=EventPriority.ERROR,
+                        console_log=True,
+                    )
+                    self.result.message = f"Invalid ROCm version format: {res.stdout}"
+                    self.result.status = ExecutionStatus.ERROR
+                    return self.result, None
+        else:
+            self._log_event(
+                category=EventCategory.OS,
+                description=f"Unable to read ROCm version from {self.CMD_VERSION_PATHS}",
+                data={"raw_output": res.stdout},
+                priority=EventPriority.ERROR,
+            )
+
+        # Collect additional ROCm data if version was found
+        if rocm_data:
+            # Collect latest versioned ROCm path (rocm-[3-7]*)
+            versioned_path_res = self._run_sut_cmd(self.CMD_ROCM_LATEST)
+            if versioned_path_res.exit_code == 0:
+                rocm_data.rocm_latest_versioned_path = versioned_path_res.stdout.strip()
+
+            # Collect all ROCm paths as list
+            all_paths_res = self._run_sut_cmd(self.CMD_ROCM_DIRS)
+            if all_paths_res.exit_code == 0:
+                rocm_data.rocm_all_paths = [
+                    path.strip()
+                    for path in all_paths_res.stdout.strip().split("\n")
+                    if path.strip()
+                ]
+
+            # Determine ROCm path for commands that need it
+            rocm_path = rocm_data.rocm_latest_versioned_path or "/opt/rocm"
+
+            # Collect rocminfo output as list of lines with ANSI codes stripped
+            rocminfo_cmd = self.CMD_ROCMINFO.format(rocm_path=rocm_path)
+            rocminfo_res = self._run_sut_cmd(rocminfo_cmd)
+            rocminfo_artifact_content = ""
+            if rocminfo_res.exit_code == 0:
+                # Split into lines and strip ANSI codes from each line
+                rocm_data.rocminfo = [
+                    strip_ansi_codes(line) for line in rocminfo_res.stdout.strip().split("\n")
+                ]
+                rocminfo_artifact_content += "=" * 80 + "\n"
+                rocminfo_artifact_content += "ROCMNFO OUTPUT\n"
+                rocminfo_artifact_content += "=" * 80 + "\n\n"
+                rocminfo_artifact_content += rocminfo_res.stdout
+
+            # Collect ld.so.conf ROCm entries
+            ld_conf_res = self._run_sut_cmd(self.CMD_LD_CONF)
+            if ld_conf_res.exit_code == 0:
+                rocm_data.ld_conf_rocm = [
+                    line.strip() for line in ld_conf_res.stdout.strip().split("\n") if line.strip()
+                ]
+
+            # Collect ROCm libraries from ldconfig
+            rocm_libs_res = self._run_sut_cmd(self.CMD_ROCM_LIBS)
+            if rocm_libs_res.exit_code == 0:
+                rocm_data.rocm_libs = [
+                    line.strip()
+                    for line in rocm_libs_res.stdout.strip().split("\n")
+                    if line.strip()
+                ]
+
+            # Collect ROCm-related environment variables
+            env_vars_res = self._run_sut_cmd(self.CMD_ENV_VARS)
+            if env_vars_res.exit_code == 0:
+                rocm_data.env_vars = [
+                    line.strip() for line in env_vars_res.stdout.strip().split("\n") if line.strip()
+                ]
+
+            # Collect clinfo output
+            clinfo_cmd = self.CMD_CLINFO.format(rocm_path=rocm_path)
+            clinfo_res = self._run_sut_cmd(clinfo_cmd)
+
+            # Always append clinfo section to artifact, even if empty or failed
+            if rocminfo_artifact_content:
+                rocminfo_artifact_content += "\n\n"
+            rocminfo_artifact_content += "=" * 80 + "\n"
+            rocminfo_artifact_content += "CLINFO OUTPUT\n"
+            rocminfo_artifact_content += "=" * 80 + "\n\n"
+
+            if clinfo_res.exit_code == 0:
+                rocm_data.clinfo = [
+                    strip_ansi_codes(line) for line in clinfo_res.stdout.strip().split("\n")
+                ]
+                rocminfo_artifact_content += clinfo_res.stdout
+            else:
+                # Add error information if clinfo failed
+                rocminfo_artifact_content += f"Command: {clinfo_res.command}\n"
+                rocminfo_artifact_content += f"Exit Code: {clinfo_res.exit_code}\n"
+                if clinfo_res.stderr:
+                    rocminfo_artifact_content += f"Error: {clinfo_res.stderr}\n"
+                if clinfo_res.stdout:
+                    rocminfo_artifact_content += f"Output: {clinfo_res.stdout}\n"
+
+            # Add combined rocminfo and clinfo output as a text file artifact
+            if rocminfo_artifact_content:
+                self.result.artifacts.append(
+                    TextFileArtifact(filename="rocminfo.log", contents=rocminfo_artifact_content)
+                )
+
+            # Collect KFD process list
+            kfd_proc_res = self._run_sut_cmd(self.CMD_KFD_PROC)
+            if kfd_proc_res.exit_code == 0:
+                rocm_data.kfd_proc = [
+                    proc.strip() for proc in kfd_proc_res.stdout.strip().split("\n") if proc.strip()
+                ]
+
+        if not rocm_data:
+            self._log_event(
+                category=EventCategory.OS,
+                description="Error checking ROCm version",
+                data={
+                    "command": res.command,
+                    "exit_code": res.exit_code,
+                    "stderr": res.stderr,
+                },
+                priority=EventPriority.ERROR,
+                console_log=True,
+            )
+            self.result.message = "ROCm version not found"
+            self.result.status = ExecutionStatus.ERROR
+
+        return self.result, rocm_data

nodescraper/plugins/inband/rocm/rocm_plugin.py

@@ -0,0 +1,43 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from nodescraper.base import InBandDataPlugin
+
+from .analyzer_args import RocmAnalyzerArgs
+from .rocm_analyzer import RocmAnalyzer
+from .rocm_collector import RocmCollector
+from .rocmdata import RocmDataModel
+
+
+class RocmPlugin(InBandDataPlugin[RocmDataModel, None, RocmAnalyzerArgs]):
+    """Plugin for collection and analysis of rocm version data"""
+
+    DATA_MODEL = RocmDataModel
+
+    COLLECTOR = RocmCollector
+
+    ANALYZER = RocmAnalyzer
+
+    ANALYZER_ARGS = RocmAnalyzerArgs

nodescraper/plugins/inband/rocm/rocmdata.py

@@ -0,0 +1,62 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+import re
+from typing import List
+
+from pydantic import field_validator
+
+from nodescraper.models import DataModel
+
+
+class RocmDataModel(DataModel):
+    rocm_version: str
+    rocminfo: List[str] = []
+    rocm_latest_versioned_path: str = ""
+    rocm_all_paths: List[str] = []
+    ld_conf_rocm: List[str] = []
+    rocm_libs: List[str] = []
+    env_vars: List[str] = []
+    clinfo: List[str] = []
+    kfd_proc: List[str] = []
+
+    @field_validator("rocm_version")
+    @classmethod
+    def validate_rocm_version(cls, rocm_version: str) -> str:
+        """
+        Validate the ROCm version format.
+
+        Args:
+            rocm_version (str): The ROCm version string to validate.
+
+        Raises:
+            ValueError: If the ROCm version does not match the expected format.
+
+        Returns:
+            str: The validated ROCm version string.
+        """
+        if not re.match(r"^\d+(?:\.\d+){0,3}(-\d+)?$", rocm_version):
+            raise ValueError(f"ROCm version has invalid format: {rocm_version}")
+        return rocm_version

nodescraper/plugins/inband/storage/__init__.py

@@ -0,0 +1,25 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################

nodescraper/plugins/inband/storage/analyzer_args.py

@@ -0,0 +1,38 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Optional
+
+from pydantic import Field
+
+from nodescraper.models.analyzerargs import AnalyzerArgs
+
+
+class StorageAnalyzerArgs(AnalyzerArgs):
+    min_required_free_space_abs: Optional[str] = None
+    min_required_free_space_prct: Optional[int] = None
+    ignore_devices: Optional[list[str]] = Field(default_factory=list)
+    check_devices: Optional[list[str]] = Field(default_factory=list)
+    regex_match: bool = False

nodescraper/plugins/inband/storage/collector_args.py

@@ -0,0 +1,31 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+
+from nodescraper.models import CollectorArgs
+
+
+class StorageCollectorArgs(CollectorArgs):
+    skip_sudo: bool = False

nodescraper/plugins/inband/storage/storage_analyzer.py

@@ -0,0 +1,152 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+import re
+from typing import Optional
+
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus
+from nodescraper.interfaces import DataAnalyzer
+from nodescraper.models import TaskResult
+from nodescraper.utils import bytes_to_human_readable, convert_to_bytes
+
+from .analyzer_args import StorageAnalyzerArgs
+from .storagedata import StorageDataModel
+
+
+class StorageAnalyzer(DataAnalyzer[StorageDataModel, StorageAnalyzerArgs]):
+    """Check storage usage"""
+
+    DATA_MODEL = StorageDataModel
+
+    def _matches_device_filter(
+        self, device_name: str, exp_devices: list[str], regex_match: bool
+    ) -> bool:
+        """Check if the device name matches any of the expected devices""
+
+        Args:
+            device_name (str): device name to check
+            exp_devices (list[str]): list of expected devices to match against
+            regex_match (bool): if True, use regex matching; otherwise, use exact match
+
+        Returns:
+            bool: True if the device name matches any of the expected devices, False otherwise
+        """
+        for exp_device in exp_devices:
+            if regex_match:
+                try:
+                    device_regex = re.compile(exp_device)
+                except re.error:
+                    self._log_event(
+                        category=EventCategory.STORAGE,
+                        description=f"Invalid regex pattern: {exp_device}",
+                        priority=EventPriority.ERROR,
+                    )
+                    continue
+                if device_regex.match(device_name):
+                    return True
+            elif device_name == exp_device:
+                return True
+        return False
+
+    def analyze_data(
+        self, data: StorageDataModel, args: Optional[StorageAnalyzerArgs] = None
+    ) -> TaskResult:
+        """Analyze the storage data to check if there is enough free space
+
+        Args:
+            data (StorageDataModel): storage data to analyze
+            args (Optional[StorageAnalyzerArgs], optional): storage analysis arguments. Defaults to None.
+
+        Returns:
+            TaskResult: Result of the storage analysis containing the status and message.
+        """
+        if args is None:
+            args = StorageAnalyzerArgs(min_required_free_space_prct=10)
+        elif args.min_required_free_space_abs is None and args.min_required_free_space_prct is None:
+            args.min_required_free_space_prct = 10
+            self.logger.warning(
+                "No thresholds provided for storage analyzer arguments; defaulting to 10% free"
+            )
+
+        if not data.storage_data:
+            self.result.message = "No storage data available"
+            self.result.status = ExecutionStatus.NOT_RAN
+            return self.result
+
+        self.result.status = ExecutionStatus.OK
+        passing_devices = []
+        failing_devices = []
+        for device_name, device_data in data.storage_data.items():
+            if args.check_devices:
+                if not self._matches_device_filter(
+                    device_name, args.check_devices, args.regex_match
+                ):
+                    continue
+            elif args.ignore_devices:
+                if self._matches_device_filter(device_name, args.ignore_devices, args.regex_match):
+                    continue
+
+            condition = False
+            if args.min_required_free_space_abs:
+                min_free_abs = convert_to_bytes(args.min_required_free_space_abs)
+                free_abs = convert_to_bytes(str(device_data.free))
+                if free_abs and free_abs > min_free_abs:
+                    condition = True
+            else:
+                condition = True
+
+            if args.min_required_free_space_prct:
+                free_prct = 100 - device_data.percent
+                condition = condition and (free_prct > args.min_required_free_space_prct)
+
+            if condition:
+                passing_devices.append(device_name)
+            else:
+                device = convert_to_bytes(str(device_data.total))
+                prct = device_data.percent
+                failing_devices.append(device_name)
+                event_data = {
+                    "offending_device": {
+                        "device": device_name,
+                        "total": device_data.total,
+                        "free": device_data.free,
+                        "percent": device_data.percent,
+                    },
+                }
+                self._log_event(
+                    category=EventCategory.STORAGE,
+                    description=f"Insufficient disk space: {bytes_to_human_readable(device)} and {prct}%,  used on {device_name}",
+                    data=event_data,
+                    priority=EventPriority.CRITICAL,
+                    console_log=True,
+                )
+        if failing_devices:
+            self.result.message = f"Insufficient disk space on " f"[{', '.join(failing_devices)}]"
+            self.result.status = ExecutionStatus.ERROR
+        else:
+            self.result.message = (
+                f"Sufficient disk space available on " f"[{', '.join(passing_devices)}]"
+            )
+        return self.result

nodescraper/plugins/inband/storage/storage_collector.py

@@ -0,0 +1,110 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+import re
+from typing import Optional
+
+from nodescraper.base import InBandDataCollector
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus, OSFamily
+from nodescraper.models import TaskResult
+
+from .collector_args import StorageCollectorArgs
+from .storagedata import DeviceStorageData, StorageDataModel
+
+
+class StorageCollector(InBandDataCollector[StorageDataModel, None]):
+    """Collect disk usage details"""
+
+    DATA_MODEL = StorageDataModel
+    CMD_WINDOWS = """wmic LogicalDisk Where DriveType="3" Get DeviceId,Size,FreeSpace"""
+    CMD = """sh -c 'df -lH -B1 | grep -v 'boot''"""
+
+    def collect_data(
+        self, args: Optional[StorageCollectorArgs] = None
+    ) -> tuple[TaskResult, Optional[StorageDataModel]]:
+        """read storage usage data"""
+        if args is None:
+            args = StorageCollectorArgs()
+
+        storage_data = {}
+        if self.system_info.os_family == OSFamily.WINDOWS:
+            res = self._run_sut_cmd(self.CMD_WINDOWS)
+            if res.exit_code == 0:
+                for line in res.stdout.splitlines()[1:]:
+                    if line:
+                        device_id, free_space, size = line.split()
+                        storage_data[device_id] = DeviceStorageData(
+                            total=int(size),
+                            free=int(free_space),
+                            used=int(size) - int(free_space),
+                            percent=round((int(size) - int(free_space)) / int(size) * 100, 2),
+                        )
+        else:
+            if args.skip_sudo:
+                self.result.message = "Skipping sudo plugin"
+                self.result.status = ExecutionStatus.NOT_RAN
+                return self.result, None
+            res = self._run_sut_cmd(self.CMD, sudo=True)
+            if res.exit_code == 0:
+                for line in res.stdout.splitlines()[1:]:
+                    if line:
+                        device_id, size, used, available, percent = line.strip().split()[:5]
+                        if device_id not in ["tmpfs", "overlay"]:
+                            storage_data[device_id] = DeviceStorageData(
+                                total=int(size),
+                                free=int(available),
+                                used=int(used),
+                                percent=float(re.sub(r"%", "", percent)),
+                            )
+
+        if res.exit_code != 0:
+            self._log_event(
+                category=EventCategory.OS,
+                description="Error checking available storage",
+                data={
+                    "command": res.command,
+                    "exit_code": res.exit_code,
+                    "stderr": res.stderr,
+                },
+                priority=EventPriority.ERROR,
+                console_log=True,
+            )
+
+        if storage_data:
+            storage_data = dict(sorted(storage_data.items(), key=lambda x: x[1].total))
+            storage_model = StorageDataModel(storage_data=storage_data)
+            self._log_event(
+                category="STORAGE_READ",
+                description="Available storage read",
+                data=storage_model.model_dump(),
+                priority=EventPriority.INFO,
+            )
+            self.result.message = f"{len(storage_model.storage_data)} storage devices collected"
+            self.result.status = ExecutionStatus.OK
+        else:
+            storage_model = None
+            self.result.message = "Storage info not found"
+            self.result.status = ExecutionStatus.ERROR
+        return self.result, storage_model