mongo-x-ray-gmd 2.0.0__tar.gz

mongo_x_ray_gmd-2.0.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: mongo-x-ray-gmd
+Version: 2.0.0
+Summary: getMongoData analysis plugin for x-ray
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mongo-x-ray>=2.0.0
+Requires-Dist: mongo-x-ray-hc>=2.0.0
+Requires-Dist: pymongo>=4.0
+Requires-Dist: python-dateutil>=2.9.0
+
+# mongo-x-ray-gmd
+
+[![CI](https://github.com/zhangyaoxing/mongo-x-ray-gmd/actions/workflows/ci.yml/badge.svg)](https://github.com/zhangyaoxing/mongo-x-ray-gmd/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/mongo-x-ray-gmd.svg)](https://pypi.org/project/mongo-x-ray-gmd/)
+
+getMongoData analysis plugin for [x-ray](https://github.com/mongodb-ps/ce-mongo-x-ray).
+
+## Install
+
+```bash
+pip install mongo-x-ray mongo-x-ray-hc mongo-x-ray-gmd
+```
+
+## Usage
+
+```bash
+x-ray gmd /path/to/getMongoData-output.json
+x-ray gmd /path/to/getMongoData-output.json -f html -o /path/to/output/
+```
+
+## Compatibility
+
+Supports MongoDB 5.0 and above on all topologies:
+
+| Replica Set | Sharded Cluster | Standalone |
+| :---------: | :-------------: | :--------: |
+| ✅ | ✅ | ✅ |
+
+## Parameters
+
+```bash
+x-ray gmd [-h] [-s CHECKSET] [-o OUTPUT] [-f {markdown,html,pdf}] [--no-browser]
+          gmd_file
+```
+
+| Argument | Description | Default |
+| --- | --- | --- |
+| `gmd_file` | Path to the getMongoData output JSON file. | required |
+| `-s, --checkset` | Checkset to run. | `default` |
+| `-o, --output` | Output folder path. | `output/` |
+| `-f, --format` | Output format: `markdown`, `html` or `pdf` (PDF also keeps Markdown and HTML). | `html` |
+| `--no-browser` | Do not open the generated report in the browser. | `false` |
+
+## Analysis Items
+
+| Item | Purpose |
+| --- | --- |
+| `SummaryItem` | Overall summary of the getMongoData output. |
+| `BuildInfoItem` | Build information (reuses the healthcheck build info parser and version EOL rule). |
+| `CollInfoItem` | Collection statistics: sizes and fragmentation. |
+| `DBItem` | Database-level information. |
+| `HostInfoItem` | Host filesystem type, NUMA settings and host properties. |
+| `IndexInfoItem` | Index information. |
+| `RSInfoItem` | Replica set topology, oplog window and status. |
+| `SecurityItem` | Security posture. |
+| `ServerStatusItem` | Cache, connections and query targeting status. |
+| `SHInfoItem` | Sharding architecture and shard details. |
+
+## Development
+
+Requires Python 3.10+, MongoDB 5.0 or later, the [mongo-x-ray](https://github.com/mongodb-ps/ce-mongo-x-ray) core and the
+[mongo-x-ray-hc](https://github.com/zhangyaoxing/mongo-x-ray-hc) plugin (gmd reuses its parsers and rules).
+
+```bash
+make unit-test   # run the unit tests
+make lint        # ruff check + ruff format --check
+make minify      # minify templates
+```

mongo_x_ray_gmd-2.0.0/README.md

@@ -0,0 +1,68 @@
+# mongo-x-ray-gmd
+
+[![CI](https://github.com/zhangyaoxing/mongo-x-ray-gmd/actions/workflows/ci.yml/badge.svg)](https://github.com/zhangyaoxing/mongo-x-ray-gmd/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/mongo-x-ray-gmd.svg)](https://pypi.org/project/mongo-x-ray-gmd/)
+
+getMongoData analysis plugin for [x-ray](https://github.com/mongodb-ps/ce-mongo-x-ray).
+
+## Install
+
+```bash
+pip install mongo-x-ray mongo-x-ray-hc mongo-x-ray-gmd
+```
+
+## Usage
+
+```bash
+x-ray gmd /path/to/getMongoData-output.json
+x-ray gmd /path/to/getMongoData-output.json -f html -o /path/to/output/
+```
+
+## Compatibility
+
+Supports MongoDB 5.0 and above on all topologies:
+
+| Replica Set | Sharded Cluster | Standalone |
+| :---------: | :-------------: | :--------: |
+| ✅ | ✅ | ✅ |
+
+## Parameters
+
+```bash
+x-ray gmd [-h] [-s CHECKSET] [-o OUTPUT] [-f {markdown,html,pdf}] [--no-browser]
+          gmd_file
+```
+
+| Argument | Description | Default |
+| --- | --- | --- |
+| `gmd_file` | Path to the getMongoData output JSON file. | required |
+| `-s, --checkset` | Checkset to run. | `default` |
+| `-o, --output` | Output folder path. | `output/` |
+| `-f, --format` | Output format: `markdown`, `html` or `pdf` (PDF also keeps Markdown and HTML). | `html` |
+| `--no-browser` | Do not open the generated report in the browser. | `false` |
+
+## Analysis Items
+
+| Item | Purpose |
+| --- | --- |
+| `SummaryItem` | Overall summary of the getMongoData output. |
+| `BuildInfoItem` | Build information (reuses the healthcheck build info parser and version EOL rule). |
+| `CollInfoItem` | Collection statistics: sizes and fragmentation. |
+| `DBItem` | Database-level information. |
+| `HostInfoItem` | Host filesystem type, NUMA settings and host properties. |
+| `IndexInfoItem` | Index information. |
+| `RSInfoItem` | Replica set topology, oplog window and status. |
+| `SecurityItem` | Security posture. |
+| `ServerStatusItem` | Cache, connections and query targeting status. |
+| `SHInfoItem` | Sharding architecture and shard details. |
+
+## Development
+
+Requires Python 3.10+, MongoDB 5.0 or later, the [mongo-x-ray](https://github.com/mongodb-ps/ce-mongo-x-ray) core and the
+[mongo-x-ray-hc](https://github.com/zhangyaoxing/mongo-x-ray-hc) plugin (gmd reuses its parsers and rules).
+
+```bash
+make unit-test   # run the unit tests
+make lint        # ruff check + ruff format --check
+make minify      # minify templates
+```

mongo_x_ray_gmd-2.0.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools==83.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mongo-x-ray-gmd"
+version = "2.0.0"
+description = "getMongoData analysis plugin for x-ray"
+readme = "README.md"
+requires-python = ">=3.10,<4"
+dependencies = [
+  "mongo-x-ray>=2.0.0",
+  "mongo-x-ray-hc>=2.0.0",
+  "pymongo>=4.0",
+  "python-dateutil>=2.9.0",
+]
+
+[project.entry-points."mongo_x_ray.plugins"]
+gmd = "mongo_x_ray_gmd.plugin:GmdPlugin"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["mongo_x_ray_gmd*"]
+
+[tool.setuptools.package-data]
+"mongo_x_ray_gmd" = ["templates/**/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+markers = [
+  "slow: marks tests as slow",
+  "integration: marks tests as integration tests",
+  "unit: marks tests as unit tests",
+]
+
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+exclude = [".venv", "build", "dist"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = ["E501"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["mongo_x_ray", "mongo_x_ray_ftdc", "mongo_x_ray_gmd", "mongo_x_ray_hc", "mongo_x_ray_log", "mongo_x_ray_risk"]
+
+
+[tool.pyright]
+pythonVersion = "3.10"
+venvPath = "../ce-mongo-x-ray"
+venv = ".venv"
+typeCheckingMode = "basic"
+extraPaths = [
+  "src",
+  "../ce-mongo-x-ray/src",
+  "../mongo-x-ray-hc/src",
+]

mongo_x_ray_gmd-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mongo_x_ray_gmd-2.0.0/src/mongo_x_ray_gmd/__init__.py

@@ -0,0 +1,11 @@
+"""
+Copyright (c) 2026 MongoDB Inc.
+
+DISCLAIMER: THESE CODE SAMPLES ARE PROVIDED FOR EDUCATIONAL AND ILLUSTRATIVE PURPOSES ONLY,
+TO DEMONSTRATE THE FUNCTIONALITY OF SPECIFIC MONGODB FEATURES.
+THEY ARE NOT PRODUCTION-READY AND MAY LACK THE SECURITY HARDENING, ERROR HANDLING, AND TESTING REQUIRED FOR A LIVE ENVIRONMENT.
+YOU ARE RESPONSIBLE FOR TESTING, VALIDATING, AND SECURING THIS CODE WITHIN YOUR OWN ENVIRONMENT BEFORE IMPLEMENTATION.
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OR LIABILITY.
+
+MongoDB getMongoData analysis package.
+"""

mongo_x_ray_gmd-2.0.0/src/mongo_x_ray_gmd/framework.py

@@ -0,0 +1,137 @@
+"""
+Copyright (c) 2026 MongoDB Inc.
+
+DISCLAIMER: THESE CODE SAMPLES ARE PROVIDED FOR EDUCATIONAL AND ILLUSTRATIVE PURPOSES ONLY,
+TO DEMONSTRATE THE FUNCTIONALITY OF SPECIFIC MONGODB FEATURES.
+THEY ARE NOT PRODUCTION-READY AND MAY LACK THE SECURITY HARDENING, ERROR HANDLING, AND TESTING REQUIRED FOR A LIVE ENVIRONMENT.
+YOU ARE RESPONSIBLE FOR TESTING, VALIDATING, AND SECURING THIS CODE WITHIN YOUR OWN ENVIRONMENT BEFORE IMPLEMENTATION.
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OR LIABILITY.
+"""
+
+from datetime import datetime, timezone
+from typing import TextIO
+
+from mongo_x_ray.framework import BaseFramework
+from mongo_x_ray.shared import str_to_md_id, to_json
+from mongo_x_ray.utils import bold, cyan, env, green, load_classes, red, yellow
+from mongo_x_ray_gmd.gmd_items.summary_item import SummaryItem
+from mongo_x_ray_gmd.shared import load_json
+
+GMD_CLASSES = load_classes("mongo_x_ray_gmd.gmd_items")
+
+
+class Framework(BaseFramework):
+    template_module = "gmd"
+    template_package = "mongo_x_ray_gmd"
+
+    def __init__(self, file_path: str, config: dict):
+        super().__init__(config)
+        self._file_path = file_path
+        self._logger.debug(to_json(self._config))
+        self._log_start = None
+        self._log_end = None
+        if env == "development":
+            self._logger.info(yellow("Running in development mode."))
+
+    def run_gmd_analysis(self, gmd_set_name: str, *_args, **kwargs):
+        self._set_name = gmd_set_name
+        # Create output folder if it doesn't exist
+        output_folder = kwargs.get("output_folder", "output/")
+        batch_folder = self._get_output_folder(output_folder)
+        # Dynamically load the gmd checkset based on the name
+        gmdsets = self._config.get("gmdsets", {})
+        if gmd_set_name not in gmdsets:
+            self._logger.warning(yellow(f"GMD checkset '{gmd_set_name}' not found in configuration. Using default."))
+            gmd_set_name = "default"
+        gmdset = gmdsets[gmd_set_name]
+        self._logger.info("Running GMD checkset: %s", bold(cyan(gmd_set_name)))
+
+        self._items = []
+        for item_name in gmdset.get("items", []):
+            item_cls = GMD_CLASSES.get(item_name)
+            if not item_cls:
+                self._logger.warning(yellow(f"GMD item '{item_name}' not found. Skipping."))
+                continue
+            # The config for the item can be specified in the `item_config` section, under the item class name.
+            item_config = self._config.get("item_config", {}).get(item_name, {})
+            item = item_cls(str(batch_folder), item_config)
+            self._items.append(item)
+            self._logger.info("GMD analyze item loaded: %s", bold(cyan(item_name)))
+        gmd_output = self._file_path
+
+        # Read the getMongoData output and parse the whole content.
+        with open(gmd_output, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+            try:
+                objects = load_json(content)
+            except Exception as ex:
+                self._logger.error(red(f"Failed to parse the getMongoData output as JSON: {ex}"))
+                return
+
+            self._logger.info("Ingesting %s objects from getMongoData output...", green(str(len(objects))))
+
+            for i, obj in enumerate(objects):
+                if (i + 1) % 10000 == 0:
+                    self._logger.info("%s objects ingested...", green(str(i + 1)))
+                for item in self._items:
+                    try:
+                        item.test(obj)
+                    except Exception as e:
+                        self._logger.warning(yellow(f"GMD analysis item '{item.name}' failed: {e}"))
+                        continue
+
+            for item in self._items:
+                try:
+                    item.finalize_analysis()
+                except Exception as e:
+                    self._logger.warning(yellow(f"GMD analysis item '{item.name}' finalization failed: {e}"))
+                    continue
+
+    def _render_markdown(self, output: TextIO) -> None:
+        output.write("# getMongoData Analysis Report\n")
+        output.write(f"Generated at: `{str(datetime.now(tz=timezone.utc))} UTC`\n\n")
+        output.write(f"File path: `{self._file_path}`\n\n")
+        output.write("## 1 Review Test Results\n\n")
+        output.write("### Overview\n\n")
+        # Enrich all test results with matched risks before building summary
+        risk_available = False
+        try:
+            from mongo_x_ray_risk import enrich_test_results, has_risks
+
+            risk_available = has_risks()
+            for item in self._items:
+                enrich_test_results(item._test_result)
+        except Exception:
+            self._logger.debug("Risk register matching not available", exc_info=True)
+        summary_item = SummaryItem(risk_available=risk_available)
+        summary_item.summarize(self._items)
+        summary_item.overview(output)
+        for i, item in enumerate(self._items):
+            if item._in_complete_flag:
+                self._logger.warning(
+                    yellow(f"GMD item '{item.name}' is incomplete because of too many databases/collections.")
+                )
+            try:
+                title = f"1.{i + 1} {item.name}"
+                review_title = f"2.{i + 1} Review {item.name}"
+                review_title_id = str_to_md_id(review_title)
+                output.write(f"### {title}\n\n")
+                output.write(f"{item.description}\n\n")
+                output.write(f"[Review Raw Results →](#{review_title_id})\n\n")
+                item.test_result_markdown(output)
+            except Exception as e:
+                self._logger.warning(yellow(f"Failed to generate markdown for GMD item '{item.name}': {e}"))
+                continue
+
+        output.write("## 2 Review Raw Results\n\n")
+        for i, item in enumerate(self._items):
+            try:
+                title = f"1.{i + 1} {item.name}"
+                title_id = str_to_md_id(title)
+                review_title = f"2.{i + 1} Review {item.name}"
+                output.write(f"### {review_title}\n\n")
+                output.write(f"[← Review Test Results](#{title_id})\n\n")
+                item.review_results_markdown(output)
+            except Exception as e:
+                self._logger.warning(yellow(f"Failed to generate review markdown for GMD item '{item.name}': {e}"))
+                continue

mongo_x_ray_gmd-2.0.0/src/mongo_x_ray_gmd/gmd_items/__init__.py

@@ -0,0 +1,11 @@
+"""
+Copyright (c) 2026 MongoDB Inc.
+
+DISCLAIMER: THESE CODE SAMPLES ARE PROVIDED FOR EDUCATIONAL AND ILLUSTRATIVE PURPOSES ONLY,
+TO DEMONSTRATE THE FUNCTIONALITY OF SPECIFIC MONGODB FEATURES.
+THEY ARE NOT PRODUCTION-READY AND MAY LACK THE SECURITY HARDENING, ERROR HANDLING, AND TESTING REQUIRED FOR A LIVE ENVIRONMENT.
+YOU ARE RESPONSIBLE FOR TESTING, VALIDATING, AND SECURING THIS CODE WITHIN YOUR OWN ENVIRONMENT BEFORE IMPLEMENTATION.
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OR LIABILITY.
+
+Package for GMD analysis items.
+"""

mongo_x_ray_gmd-2.0.0/src/mongo_x_ray_gmd/gmd_items/base_item.py

@@ -0,0 +1,218 @@
+"""
+Copyright (c) 2026 MongoDB Inc.
+
+DISCLAIMER: THESE CODE SAMPLES ARE PROVIDED FOR EDUCATIONAL AND ILLUSTRATIVE PURPOSES ONLY,
+TO DEMONSTRATE THE FUNCTIONALITY OF SPECIFIC MONGODB FEATURES.
+THEY ARE NOT PRODUCTION-READY AND MAY LACK THE SECURITY HARDENING, ERROR HANDLING, AND TESTING REQUIRED FOR A LIVE ENVIRONMENT.
+YOU ARE RESPONSIBLE FOR TESTING, VALIDATING, AND SECURING THIS CODE WITHIN YOUR OWN ENVIRONMENT BEFORE IMPLEMENTATION.
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OR LIABILITY.
+"""
+
+import html as html_mod
+import logging
+import os
+from abc import abstractmethod
+from typing import Callable, Optional
+
+from bson import json_util
+
+from mongo_x_ray.shared import SEVERITY
+from mongo_x_ray.utils import bold, to_ejson, yellow
+from mongo_x_ray.version import Version
+from mongo_x_ray_gmd.shared import GmdEvents
+from mongo_x_ray_hc.check_items.base_item import colorize_severity
+from mongo_x_ray_hc.rules.base_rule import BaseRule
+
+
+class BaseItem:
+    def __init__(self, output_folder: str, config, **_kwargs) -> None:
+        self.config: dict = config
+        self._output_file = os.path.join(output_folder, f"{self.__class__.__name__}.json")
+        self._logger = logging.getLogger(__name__)
+        self._server_version: Optional[Version] = None
+        self._hostname: Optional[str] = None
+        self._set_name: Optional[str] = None
+        self._cluster_type: Optional[str] = None
+        self._test_result: list = []
+        self._rules: dict[str, BaseRule] = {}
+        if os.path.isfile(self._output_file):
+            os.remove(self._output_file)
+
+        self._in_complete_flag = False
+        # Subscribe some common events that most items care about
+        self._cache = None
+        self._watched_events: dict[GmdEvents, list[Callable]] = {}
+        self._watched_all_events: list[tuple[set[GmdEvents], Callable]] = []
+        self._fired_events: set[GmdEvents] = set()
+
+        def get_version(block):
+            self._server_version = Version.parse(block.get("output", {}).get("version", ""))
+
+        def get_host(block):
+            if self._hostname is None:
+                self._hostname = block.get("output", {}).get("system", {}).get("hostname", "unknown")
+
+        def get_cluster_type(block):
+            output = block.get("output", {})
+            set_name = output.get("setName", None)
+            msg = output.get("msg", "")
+            if set_name is not None:
+                self._cluster_type = "RS"
+                self._set_name = set_name
+            elif msg == "isdbgrid":
+                self._cluster_type = "SH"
+                self._set_name = "mongos"
+            else:
+                self._cluster_type = "STANDALONE"
+
+            # Use hostname in ismaster whenever possible
+            if "me" in output:
+                self._hostname = output["me"]
+
+        self.watch_one(GmdEvents.SERVER_BUILD_INFO, get_version)
+        self.watch_one(GmdEvents.HOST_INFO, get_host)
+        self.watch_one(GmdEvents.ISMASTER, get_cluster_type)
+
+    def test(self, block) -> None:
+        sub_sec = block.get("subsection", "")
+        sub_sec = sub_sec.replace("INCOMPLETE_", "")
+        try:
+            current_event = GmdEvents(sub_sec)
+        except ValueError:
+            current_event = GmdEvents.UNKNOWN
+        # Fire subscribed single events
+        for event, funcs in self._watched_events.items():
+            if current_event == event:
+                if block.get("subsection", "").startswith("INCOMPLETE_"):
+                    self._in_complete_flag = True
+                for func in funcs:
+                    try:
+                        func(block)
+                    except Exception as e:
+                        self._logger.warning(yellow("Error in subscribed function for event %s: %s"), event.value, e)
+                self._fired_events.add(event)
+
+        # Fire subscribed all events
+        for events, func in self._watched_all_events:
+            if events.issubset(self._fired_events) and current_event in events:
+                try:
+                    func()
+                except Exception as e:
+                    self._logger.warning("Error in subscribed all-events function for events %s: %s", events, e)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
+    @property
+    def description(self) -> str:
+        desc: str = ""
+        for rule in self._rules.values():
+            desc += rule.description_md + "\n"
+        return desc
+
+    @property
+    def test_result(self) -> list:
+        return self._test_result
+
+    @property
+    def captured_sample(self) -> Optional[dict]:
+        try:
+            with open(self._output_file, "r", encoding="utf-8") as f:
+                return json_util.loads(f.read())
+        except FileNotFoundError:
+            self._logger.warning(
+                "Captured sample file not found: %s. This is probably because the getMongoData output is incomplete.",
+                bold(self._output_file),
+            )
+            return None
+
+    @captured_sample.setter
+    def captured_sample(self, data: Optional[dict]) -> None:
+        with open(self._output_file, "w", encoding="utf-8") as f:
+            f.write(to_ejson(data, indent=None))
+
+    def test_result_markdown(self, output) -> None:
+        if len(self._test_result) == 0:
+            output.write("<b style='color: green;'>Pass.</b>\n\n")
+            return
+
+        output.write(
+            '| <span data-sortable="false">\\#</span>{60px}'
+            ' | <span data-sortable="true">Host</span>{180px}'
+            ' | <span data-sortable="true">Severity</span>{120px}'
+            ' | <span data-sortable="true">Category</span>{200px}'
+            ' | <span data-sortable="false">Message</span>{*} |\n'
+        )
+        output.write("|:----------:|:----------:|:----------:|---------|---------|\n")
+        for idx, item in enumerate(self._test_result):
+            severity = item["severity"]
+            severity_cell = (
+                f'<span data-sort-value="{severity.value}">'
+                f"<b style='color: {colorize_severity(severity)}'>"
+                f" {severity.name} </b></span>"
+            )
+            category_cell = item["title"]
+            risk = item.get("matched_risk")
+            if risk:
+                risk_id = html_mod.escape(str(risk.get("id", "")))
+                risk_name = html_mod.escape(str(risk.get("name", ""))).replace("\r\n", "<br>").replace("\n", "<br>")
+                risk_desc = (
+                    html_mod.escape(str(risk.get("description", ""))).replace("\r\n", "<br>").replace("\n", "<br>")
+                )
+                category_cell += (
+                    f' <span class="risk-badge">RISK-{risk_id}'
+                    f'<span class="risk-tooltip">'
+                    f'<span class="risk-name">{risk_name}</span>'
+                    f"{risk_desc}"
+                    f"</span></span>"
+                )
+            output.write(
+                f"| **{idx + 1}** | `{item['host']}` | {severity_cell} | {category_cell} | {item['message']} |\n"
+            )
+        output.write("\n")
+
+    def finalize_analysis(self) -> None:
+        """
+        This function will be called after all GMD data is ingested and before generating the report.
+        You can do some final analysis here that requires all data to be available.
+        """
+
+    @abstractmethod
+    def review_results_markdown(self, output) -> None:
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    def append_test_result(self, host: str, severity: SEVERITY, title: str, message: str) -> None:
+        self._test_result.append({"host": host, "severity": severity, "title": title, "message": message})
+
+    def append_test_results(self, items: list) -> None:
+        for item in items:
+            self.append_test_result(item["host"], item["severity"], item["title"], item["description"])
+
+    def watch_one(self, event: GmdEvents, func) -> None:
+        """
+        Fires when the specified event occurs.
+        The order of `watch_one` depends on the order of events in the GMD log, not the order of `watch_one` calls.
+        """
+        if event not in self._watched_events:
+            self._watched_events[event] = []
+        self._watched_events[event].append(func)
+
+    def watch_all(self, events: set[GmdEvents], func) -> None:
+        """
+        Fires when all the specified events occured.
+        `watch_all` fires after the last `watch_one` fires.
+        """
+        self._watched_all_events.append((events, func))
+
+    @property
+    def all_events_fired(self) -> bool:
+        """
+        Check if all watched events have been fired.
+        If not all events are fired, some data may be missing in the GMD.
+        """
+        return all(event in self._fired_events for event in self._watched_events)

mongo_x_ray_gmd-2.0.0/src/mongo_x_ray_gmd/gmd_items/build_info_item.py

@@ -0,0 +1,43 @@
+"""
+Copyright (c) 2026 MongoDB Inc.
+
+DISCLAIMER: THESE CODE SAMPLES ARE PROVIDED FOR EDUCATIONAL AND ILLUSTRATIVE PURPOSES ONLY,
+TO DEMONSTRATE THE FUNCTIONALITY OF SPECIFIC MONGODB FEATURES.
+THEY ARE NOT PRODUCTION-READY AND MAY LACK THE SECURITY HARDENING, ERROR HANDLING, AND TESTING REQUIRED FOR A LIVE ENVIRONMENT.
+YOU ARE RESPONSIBLE FOR TESTING, VALIDATING, AND SECURING THIS CODE WITHIN YOUR OWN ENVIRONMENT BEFORE IMPLEMENTATION.
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OR LIABILITY.
+"""
+
+from typing import Any
+
+from mongo_x_ray.parsers.base_parser import BaseParser
+from mongo_x_ray_gmd.gmd_items.base_item import BaseItem
+from mongo_x_ray_gmd.shared import GmdEvents
+from mongo_x_ray_hc.parsers.build_info_parser import BuildInfoParser
+from mongo_x_ray_hc.rules.version_eol_rule import VersionEOLRule
+
+
+class BuildInfoItem(BaseItem):
+    def __init__(self, output_folder: str, config, **kwargs):
+        super().__init__(output_folder, config, **kwargs)
+        self.name: str = "Build Information"
+        self._build_info: dict[str, Any] = {}
+        self._rules["version_eol"] = VersionEOLRule(config)
+
+        def get_build_info(block):
+            self._build_info = block.get("output", {})
+
+        def process_build_info():
+            test_result, _ = self._rules["version_eol"].apply(self._build_info, extra_info={"host": self._hostname})
+            self.append_test_results(test_result)
+            # self.captured_sample = self._build_info
+
+        self.watch_one(GmdEvents.SERVER_BUILD_INFO, get_build_info)
+        self.watch_all({GmdEvents.SERVER_BUILD_INFO, GmdEvents.HOST_INFO}, process_build_info)
+
+    def review_results_markdown(self, output) -> None:
+        data = self._build_info
+        assert data is not None, f"GMD subsection {GmdEvents.SERVER_BUILD_INFO.value} should be available for review."
+        parser: BaseParser = BuildInfoParser()
+        parsed_output = parser.markdown([(self._set_name, self._hostname, data)], caller=self.__class__.__name__)
+        output.write(parsed_output)