Merge branch 'development' into alex_amdsmi

Author: alexandraBara

docs/PLUGIN_DOC.md

@@ -36,7 +36,7 @@
 import pkgutil
 import sys
 from pathlib import Path
-from typing import Any, Iterable, List, Type
+from typing import Any, Iterable, List, Optional, Type
 
 LINK_BASE_DEFAULT = "https://github.com/amd/node-scraper/blob/HEAD/"
 REL_ROOT_DEFAULT = "nodescraper/plugins/inband"
@@ -50,7 +50,7 @@ def get_attr(obj: Any, name: str, default: Any = None) -> Any:
         return default
 
 
-def _slice_from_rel_root(p: Path, rel_root: str | None) -> str | None:
+def _slice_from_rel_root(p: Path, rel_root: Optional[str]) -> Optional[str]:
     if not rel_root:
         return None
     parts = list(p.parts)
@@ -63,7 +63,7 @@ def _slice_from_rel_root(p: Path, rel_root: str | None) -> str | None:
     return None
 
 
-def setup_link(class_data, link_base: str, rel_root: str | None) -> str:
+def setup_link(class_data, link_base: str, rel_root: Optional[str]) -> str:
     try:
         file_location = Path(inspect.getfile(class_data)).resolve()
     except Exception:
@@ -80,7 +80,7 @@ def setup_link(class_data, link_base: str, rel_root: str | None) -> str:
     return base + rel_path
 
 
-def get_own_doc(cls: type) -> str | None:
+def get_own_doc(cls: type) -> Optional[str]:
     """
     Return only the __doc__ defined in the class itself, ignore inheritance.
     """
@@ -224,6 +224,57 @@ def add_cmd(s: Any):
     return cmds
 
 
+def extract_regexes_and_args_from_analyzer(
+    analyzer_cls: type, args_cls: Optional[type]
+) -> List[str]:
+    """Extract regex patterns and analyzer args from analyzer class"""
+    if not inspect.isclass(analyzer_cls):
+        return []
+
+    output: List[str] = []
+
+    # Check for ERROR_REGEX class variable (used by RegexAnalyzer subclasses like DmesgAnalyzer)
+    error_regex = get_attr(analyzer_cls, "ERROR_REGEX", None)
+    if error_regex and isinstance(error_regex, list):
+        output.append("**Built-in Regexes:**")
+        for item in error_regex:
+            # ErrorRegex objects have regex, message, event_category attributes
+            if hasattr(item, "regex"):
+                pattern = getattr(item.regex, "pattern", None)
+                message = getattr(item, "message", "")
+                if pattern:
+                    # Truncate long patterns
+                    pattern_str = pattern if len(pattern) < 50 else pattern[:47] + "..."
+                    output.append(f"- {message}: `{pattern_str}`")
+            elif hasattr(item, "pattern"):
+                pattern_str = item.pattern if len(item.pattern) < 50 else item.pattern[:47] + "..."
+                output.append(f"- `{pattern_str}`")
+
+    # Check for other regex-related attributes
+    for attr in dir(analyzer_cls):
+        if "REGEX" in attr.upper() and not attr.startswith("_"):
+            val = get_attr(analyzer_cls, attr, default=None)
+            if val is None or attr == "ERROR_REGEX":
+                continue
+
+            if hasattr(val, "pattern"):
+                output.append(f"**{attr}**: `{val.pattern}`")
+            elif isinstance(val, str):
+                output.append(f"**{attr}**: `{val}`")
+
+    # Extract analyzer args if provided
+    if inspect.isclass(args_cls):
+        anns = get_attr(args_cls, "__annotations__", {}) or {}
+        if anns:
+            output.append("**Analyzer Args:**")
+            for key, value in anns.items():
+                # Format the type annotation
+                type_str = str(value).replace("typing.", "")
+                output.append(f"- `{key}`: {type_str}")
+
+    return output
+
+
 def md_header(text: str, level: int = 2) -> str:
     return f"{'#' * level} {text}\n\n"
 
@@ -257,7 +308,20 @@ def class_vars_dump(cls: type, exclude: set) -> List[str]:
             continue
         if callable(val) or isinstance(val, (staticmethod, classmethod, property)):
             continue
-        out.append(f"**{name}**: `{val}`")
+
+        # Format list values with each item on a new line
+        if isinstance(val, list) and len(val) > 0:
+            val_str = str(val)
+            if len(val_str) > 200:
+                formatted_items = []
+                for item in val:
+                    formatted_items.append(f"  {item}")
+                formatted_list = "[\n" + ",\n".join(formatted_items) + "\n]"
+                out.append(f"**{name}**: `{formatted_list}`")
+            else:
+                out.append(f"**{name}**: `{val}`")
+        else:
+            out.append(f"**{name}**: `{val}`")
     return out
 
 
@@ -279,14 +343,20 @@ def generate_plugin_table_rows(plugins: List[type]) -> List[List[str]]:
                     seen.add(key)
                     uniq.append(c)
             cmds = uniq
+
+        # Extract regexes and args from analyzer
+        regex_and_args = []
+        if inspect.isclass(an):
+            regex_and_args = extract_regexes_and_args_from_analyzer(an, args)
+
         rows.append(
             [
-                f"{p.__module__}.{p.__name__}",
+                p.__name__,
+                "<br>".join(cmds).replace("|", "\\|") if cmds else "-",
+                "<br>".join(regex_and_args).replace("|", "\\|") if regex_and_args else "-",
                 link_anchor(dm, "model") if inspect.isclass(dm) else "-",
                 link_anchor(col, "collector") if inspect.isclass(col) else "-",
                 link_anchor(an, "analyzer") if inspect.isclass(an) else "-",
-                link_anchor(args, "args") if inspect.isclass(args) else "-",
-                "<br>".join(cmds) if cmds else "-",
             ]
         )
     return rows
@@ -302,7 +372,7 @@ def render_table(headers: List[str], rows: List[List[str]]) -> str:
     return "".join(out)
 
 
-def render_collector_section(col: type, link_base: str, rel_root: str | None) -> str:
+def render_collector_section(col: type, link_base: str, rel_root: Optional[str]) -> str:
     hdr = md_header(f"Collector Class {col.__name__}", 2)
     desc = sanitize_doc(get_own_doc(col) or "")
     s = hdr
@@ -335,7 +405,7 @@ def render_collector_section(col: type, link_base: str, rel_root: str | None) ->
     return s
 
 
-def render_analyzer_section(an: type, link_base: str, rel_root: str | None) -> str:
+def render_analyzer_section(an: type, link_base: str, rel_root: Optional[str]) -> str:
     hdr = md_header(f"Data Analyzer Class {an.__name__}", 2)
     desc = sanitize_doc(get_own_doc(an) or "")
     s = hdr
@@ -350,10 +420,18 @@ def render_analyzer_section(an: type, link_base: str, rel_root: str | None) -> s
     if cv:
         s += md_header("Class Variables", 3) + md_list(cv)
 
+    # Add regex patterns if present (pass None for args_cls since we don't have context here)
+    regex_info = extract_regexes_and_args_from_analyzer(an, None)
+    if regex_info:
+        s += md_header("Regex Patterns", 3)
+        if len(regex_info) > 10:
+            s += f"*{len(regex_info)} items defined*\n\n"
+        s += md_list(regex_info)
+
     return s
 
 
-def render_model_section(model: type, link_base: str, rel_root: str | None) -> str:
+def render_model_section(model: type, link_base: str, rel_root: Optional[str]) -> str:
     hdr = md_header(f"{model.__name__} Model", 2)
     desc = sanitize_doc(get_own_doc(model) or "")
     s = hdr
@@ -368,7 +446,7 @@ def render_model_section(model: type, link_base: str, rel_root: str | None) -> s
     return s
 
 
-def render_analyzer_args_section(args_cls: type, link_base: str, rel_root: str | None) -> str:
+def render_analyzer_args_section(args_cls: type, link_base: str, rel_root: Optional[str]) -> str:
     hdr = md_header(f"Analyzer Args Class {args_cls.__name__}", 2)
     desc = sanitize_doc(get_own_doc(args_cls) or "")
     s = hdr
@@ -418,7 +496,14 @@ def all_subclasses(cls: Type) -> set[type]:
     plugins.sort(key=lambda c: f"{c.__module__}.{c.__name__}".lower())
 
     rows = generate_plugin_table_rows(plugins)
-    headers = ["Plugin", "DataModel", "Collector", "Analyzer", "AnalyzerArgs", "Cmd(s)"]
+    headers = [
+        "Plugin",
+        "Collection",
+        "Analysis",
+        "DataModel",
+        "Collector",
+        "Analyzer",
+    ]
 
     collectors, analyzers, models, args_classes = [], [], [], []
     seen_c, seen_a, seen_m, seen_args = set(), set(), set(), set()

docs/generate_plugin_doc_bundle.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

docs/node-scraper-external/ext_nodescraper_plugins/sample/sample_collector.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/collector_args.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_collector.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/journal/journal_plugin.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)