Merge branch 'development' into alex_devenum

Author: alexandraBara

docs/node-scraper-external/ext_nodescraper_plugins/sample/sample_collector.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from nodescraper.base import InBandDataCollector
 from nodescraper.enums import ExecutionStatus
 from nodescraper.models import TaskResult
@@ -9,7 +11,7 @@ class SampleCollector(InBandDataCollector[SampleDataModel, None]):
 
     DATA_MODEL = SampleDataModel
 
-    def collect_data(self, args=None) -> tuple[TaskResult, SampleDataModel | None]:
+    def collect_data(self, args=None) -> tuple[TaskResult, Optional[SampleDataModel]]:
         sample_data = SampleDataModel(some_str="example123")
         self.result.message = "Collector ran successfully"
         self.result.status = ExecutionStatus.OK

nodescraper/plugins/inband/journal/collector_args.py

@@ -0,0 +1,33 @@
+###############################################################################
+#
+# 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.models import CollectorArgs
+
+
+class JournalCollectorArgs(CollectorArgs):
+    boot: Optional[int] = None

nodescraper/plugins/inband/journal/journal_collector.py

@@ -25,27 +25,50 @@
 ###############################################################################
 from typing import Optional
 
+from pydantic import ValidationError
+
 from nodescraper.base import InBandDataCollector
 from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus, OSFamily
 from nodescraper.models import TaskResult
+from nodescraper.utils import get_exception_details
 
+from .collector_args import JournalCollectorArgs
 from .journaldata import JournalData
 
 
-class JournalCollector(InBandDataCollector[JournalData, None]):
+class JournalCollector(InBandDataCollector[JournalData, JournalCollectorArgs]):
     """Read journal log via journalctl."""
 
     SUPPORTED_OS_FAMILY = {OSFamily.LINUX}
     DATA_MODEL = JournalData
     CMD = "journalctl --no-pager --system --output=short-iso"
 
-    def _read_with_journalctl(self):
+    def _read_with_journalctl(self, args: Optional[JournalCollectorArgs] = None):
         """Read journal logs using journalctl
 
         Returns:
             str|None: system journal read
         """
-        res = self._run_sut_cmd(self.CMD, sudo=True, log_artifact=False, strip=False)
+
+        cmd = "journalctl --no-pager --system --output=short-iso"
+        try:
+            # safe check for args.boot
+            if args is not None and getattr(args, "boot", None):
+                cmd = f"journalctl --no-pager -b {args.boot} --system --output=short-iso"
+
+            res = self._run_sut_cmd(cmd, sudo=True, log_artifact=False, strip=False)
+
+        except ValidationError as val_err:
+            self._log_event(
+                category=EventCategory.OS,
+                description="Exception while running journalctl",
+                data=get_exception_details(val_err),
+                priority=EventPriority.ERROR,
+                console_log=True,
+            )
+            self.result.message = "Could not read journalctl data"
+            self.result.status = ExecutionStatus.ERROR
+            return None
 
         if res.exit_code != 0:
             self._log_event(
@@ -61,16 +84,22 @@ def _read_with_journalctl(self):
 
         return res.stdout
 
-    def collect_data(self, args=None) -> tuple[TaskResult, Optional[JournalData]]:
+    def collect_data(
+        self,
+        args: Optional[JournalCollectorArgs] = None,
+    ) -> tuple[TaskResult, Optional[JournalData]]:
         """Collect journal logs
 
         Args:
             args (_type_, optional): Collection args. Defaults to None.
 
         Returns:
-            tuple[TaskResult, Optional[JournalData, None]]: Tuple of results and data model or none.
+            tuple[TaskResult, Optional[JournalData]]: Tuple of results and data model or none.
         """
-        journal_log = self._read_with_journalctl()
+        if args is None:
+            args = JournalCollectorArgs()
+
+        journal_log = self._read_with_journalctl(args)
         if journal_log:
             data = JournalData(journal_log=journal_log)
             self.result.message = self.result.message or "Journal data collected"

nodescraper/plugins/inband/journal/journal_plugin.py

@@ -25,13 +25,16 @@
 ###############################################################################
 from nodescraper.base import InBandDataPlugin
 
+from .collector_args import JournalCollectorArgs
 from .journal_collector import JournalCollector
 from .journaldata import JournalData
 
 
-class JournalPlugin(InBandDataPlugin[JournalData, None, None]):
+class JournalPlugin(InBandDataPlugin[JournalData, JournalCollectorArgs, None]):
     """Plugin for collection of journal data"""
 
     DATA_MODEL = JournalData
 
     COLLECTOR = JournalCollector
+
+    COLLECTOR_ARGS = JournalCollectorArgs

nodescraper/plugins/inband/kernel/analyzer_args.py

@@ -61,4 +61,4 @@ def build_from_model(cls, datamodel: KernelDataModel) -> "KernelAnalyzerArgs":
         Returns:
             KernelAnalyzerArgs: instance of analyzer args class
         """
-        return cls(exp_kernel=datamodel.kernel_version)
+        return cls(exp_kernel=datamodel.kernel_info)

nodescraper/plugins/inband/kernel/kernel_collector.py

@@ -23,6 +23,7 @@
 # SOFTWARE.
 #
 ###############################################################################
+import re
 from typing import Optional
 
 from nodescraper.base import InBandDataCollector
@@ -37,7 +38,31 @@ class KernelCollector(InBandDataCollector[KernelDataModel, None]):
 
     DATA_MODEL = KernelDataModel
     CMD_WINDOWS = "wmic os get Version /Value"
-    CMD = "sh -c 'uname -r'"
+    CMD = "sh -c 'uname -a'"
+
+    def _parse_kernel_version(self, uname_a: str) -> Optional[str]:
+        """Extract the kernel release from `uname -a` output.
+
+        Args:
+            uname_a (str): The full output string from the `uname -a` command.
+
+        Returns:
+            Optional[str]: The parsed kernel release (e.g., "5.13.0-30-generic")
+            if found, otherwise None.
+        """
+        if not uname_a:
+            return None
+
+        result = uname_a.strip().split()
+        if len(result) >= 3:
+            return result[2]
+
+        # if some change in output look for a version-like string (e.g. 4.18.0-553.el8_10.x86_64)
+        match = re.search(r"\d+\.\d+\.\d+[\w\-\.]*", uname_a)
+        if match:
+            return match.group(0)
+
+        return None
 
     def collect_data(
         self,
@@ -51,16 +76,28 @@ def collect_data(
         """
 
         kernel = None
+        kernel_info = None
+
         if self.system_info.os_family == OSFamily.WINDOWS:
             res = self._run_sut_cmd(self.CMD_WINDOWS)
             if res.exit_code == 0:
+                kernel_info = res.stdout
                 kernel = [line for line in res.stdout.splitlines() if "Version=" in line][0].split(
                     "="
                 )[1]
         else:
             res = self._run_sut_cmd(self.CMD)
             if res.exit_code == 0:
-                kernel = res.stdout
+                kernel_info = res.stdout
+                kernel = self._parse_kernel_version(kernel_info)
+                if not kernel:
+                    self._log_event(
+                        category=EventCategory.OS,
+                        description="Could not extract kernel version from 'uname -a'",
+                        data={"command": res.command, "exit_code": res.exit_code},
+                        priority=EventPriority.ERROR,
+                        console_log=True,
+                    )
 
         if res.exit_code != 0:
             self._log_event(
@@ -71,8 +108,9 @@ def collect_data(
                 console_log=True,
             )
 
-        if kernel:
-            kernel_data = KernelDataModel(kernel_version=kernel)
+        if kernel_info and kernel:
+
+            kernel_data = KernelDataModel(kernel_info=kernel_info, kernel_version=kernel)
             self._log_event(
                 category="KERNEL_READ",
                 description="Kernel version read",
@@ -82,6 +120,10 @@ def collect_data(
         else:
             kernel_data = None
 
-        self.result.message = f"Kernel: {kernel}" if kernel else "Kernel not found"
-        self.result.status = ExecutionStatus.OK if kernel else ExecutionStatus.ERROR
+        self.result.message = (
+            "Kernel not found"
+            if not kernel_info
+            else f"Kernel info: {kernel_info} | Kernel version: {kernel if kernel else 'Kernel version not found'}"
+        )
+        self.result.status = ExecutionStatus.OK if kernel_info else ExecutionStatus.ERROR
         return self.result, kernel_data

nodescraper/plugins/inband/kernel/kerneldata.py

@@ -23,8 +23,10 @@
 # SOFTWARE.
 #
 ###############################################################################
+
 from nodescraper.models import DataModel
 
 
 class KernelDataModel(DataModel):
+    kernel_info: str
     kernel_version: str

test/unit/plugin/test_kernel_analyzer.py

@@ -35,7 +35,10 @@
 
 @pytest.fixture
 def model_obj():
-    return KernelDataModel(kernel_version="5.13.0-30-generic")
+    return KernelDataModel(
+        kernel_info="Linux MockSystem 5.13.0-30-generic #1 XYZ Day Month 10 15:19:13 EDT 2024 x86_64 x86_64 x86_64 GNU/Linux",
+        kernel_version="5.13.0-30-generic",
+    )
 
 
 @pytest.fixture
@@ -118,14 +121,14 @@ def test_invalid_kernel_config(system_info, model_obj, config):
 
 
 def test_match_regex(system_info, model_obj):
-    args = KernelAnalyzerArgs(exp_kernel=[r"5.13.\d-\d+-[\w]+"], regex_match=True)
+    args = KernelAnalyzerArgs(exp_kernel=[r".*5\.13\.\d+-\d+-[\w-]+.*"], regex_match=True)
     analyzer = KernelAnalyzer(system_info)
     result = analyzer.analyze_data(model_obj, args)
     assert result.status == ExecutionStatus.OK
 
 
 def test_mismatch_regex(system_info, model_obj):
-    args = KernelAnalyzerArgs(exp_kernel=[r"4.3.\d-\d+-[\w]+"], regex_match=True)
+    args = KernelAnalyzerArgs(exp_kernel=[r".*4\.13\.\d+-\d+-[\w-]+.*"], regex_match=True)
     analyzer = KernelAnalyzer(system_info)
     result = analyzer.analyze_data(model_obj, args)
 

test/unit/plugin/test_kernel_collector.py

@@ -53,22 +53,27 @@ def test_run_windows(collector, conn_mock):
 
     result, data = collector.collect_data()
 
-    assert data == KernelDataModel(kernel_version="10.0.19041.1237")
+    assert data == KernelDataModel(
+        kernel_info="Version=10.0.19041.1237", kernel_version="10.0.19041.1237"
+    )
     assert result.status == ExecutionStatus.OK
 
 
 def test_run_linux(collector, conn_mock):
     collector.system_info.os_family = OSFamily.LINUX
     conn_mock.run_command.return_value = CommandArtifact(
         exit_code=0,
-        stdout="5.4.0-88-generic",
+        stdout="Linux MockSystem 5.13.0-30-generic #1 XYZ Day Month 10 15:19:13 EDT 2024 x86_64 x86_64 x86_64 GNU/Linux",
         stderr="",
-        command="sh -c 'uname -r'",
+        command="sh -c 'uname -a'",
     )
 
     result, data = collector.collect_data()
 
-    assert data == KernelDataModel(kernel_version="5.4.0-88-generic")
+    assert data == KernelDataModel(
+        kernel_info="Linux MockSystem 5.13.0-30-generic #1 XYZ Day Month 10 15:19:13 EDT 2024 x86_64 x86_64 x86_64 GNU/Linux",
+        kernel_version="5.13.0-30-generic",
+    )
     assert result.status == ExecutionStatus.OK