Add git commit and unify flagos log (#102)

Author: cyber-pioneer

.gitignore

@@ -2,6 +2,7 @@
 __pycache__/
 build/
 dist/
+vllm_fl/_version.py
 
 # Coverage
 .coverage

pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vllm-plugin-fl"
-version = "0.1.0"
+dynamic = ["version"]
 description = "A vLLM plugin built on the FlagOS unified multi-chip backend"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
@@ -56,6 +56,40 @@ test = [
     "modelscope>=1.18.1",
 ]
 
+[tool.setuptools_scm]
+# Generate a static `_version.py` at build time so the installed package
+# never needs to run `git` at import time (same pattern as vLLM/PyTorch).
+# The template extracts commit sha and date from the version string and
+# exposes them as `git_version`, `git_date`, and `git_info`.
+write_to = "vllm_fl/_version.py"
+# Keep the public version at the nearest tag without appending `.devN`.
+version_scheme = "only-version"
+write_to_template = '''# This file is generated by setuptools-scm at build time.  Do not edit.
+# At runtime vllm_fl/version.py imports git_version and git_date from here.
+from __future__ import annotations
+import re as _re
+
+__version__: str = "{version}"
+version: str = __version__
+_node_date: str = "{scm_version.node_date}"
+
+_sha_m = _re.search(r"(?:^|[.+-])g(?P<sha>[0-9a-f]{{7,40}})(?:[.+-]|$)", __version__)
+_date_m = _re.search(r"(?:^|[.+-])d(?P<ymd>\d{{8}})(?:[.+-]|$)", __version__)
+
+git_version: str = _sha_m.group("sha") if _sha_m else "Unknown"
+git_date: str = (
+    _node_date if _node_date not in ("", "None")
+    else (
+        _date_m.group("ymd")[0:4] + "-" + _date_m.group("ymd")[4:6] + "-" + _date_m.group("ymd")[6:8]
+        if _date_m else "Unknown"
+    )
+)
+git_info: dict[str, str] = {{"id": git_version, "date": git_date}}
+'''
+# Include commit date in the local version string so the template can parse it.
+local_scheme = "node-and-date"
+fallback_version = "0.0.0"
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["vllm_fl*"]

tests/unit_tests/test_version.py

@@ -0,0 +1,7 @@
+import vllm_fl.version as version
+
+
+def test_public_git_exports_shape():
+    assert isinstance(version.git_version, str)
+    assert isinstance(version.git_info, dict)
+    assert set(version.git_info.keys()) == {"id", "date"}

vllm_fl/__init__.py

@@ -2,8 +2,11 @@
 
 import os
 import logging
+
 from vllm_fl.utils import get_op_config as _get_op_config
 
+from . import version as version  # PyTorch-style: vllm_fl.version.git_version
+
 
 logger = logging.getLogger(__name__)
 

vllm_fl/dispatch/manager.py

@@ -29,6 +29,48 @@
 # Debug printing control
 _DISPATCH_DEBUG = os.getenv("VLLM_FL_DISPATCH_DEBUG", "0") == "1"
 
+# Record which dispatch-level ops are used into the FlagGems oplist file,
+# so users can inspect runtime op usage in one place.
+_FLAGOS_OPLIST_LOCK = threading.Lock()
+_RECORDED_FLAGOS_OPS: Set[Tuple[str, str]] = set()  # (op_name, impl_id)
+
+
+def _record_default_flagos_op(op_name: str, impl: OpImpl) -> None:
+    """Record dispatch-level op usage into the FlagGems oplist file.
+
+    Writes through the FlagGems logger's file handlers directly so that the
+    record goes via the same file descriptor that FlagGems itself uses.  This
+    avoids a file-position race between two independent file descriptors (the
+    old ``open(path, "a+")`` approach vs FlagGems' ``FileHandler(mode="w")``)
+    that caused dispatch entries to be silently overwritten in short-lived
+    processes such as offline inference.
+    """
+    key = (op_name, impl.impl_id)
+    with _FLAGOS_OPLIST_LOCK:
+        if key in _RECORDED_FLAGOS_OPS:
+            return
+        try:
+            fg_logger = logging.getLogger("flag_gems")
+            line = (
+                f"[DEBUG] vllm_fl.dispatch.ops.{op_name}: {impl.impl_id}"
+            )
+            # Write directly through each FlagGems-owned FileHandler so
+            # that the file position stays synchronised with FlagGems'
+            # own writes.  Using ``logger.debug()`` would prepend an
+            # unwanted ``[DEBUG] flag_gems.<funcName>:`` prefix added by
+            # the handler's formatter.
+            for handler in fg_logger.handlers:
+                if (
+                    isinstance(handler, logging.FileHandler)
+                    and getattr(handler, "_flaggems_owned", False)
+                ):
+                    handler.stream.write(line + "\n")
+                    handler.stream.flush()
+            _RECORDED_FLAGOS_OPS.add(key)
+        except Exception:
+            # Never break inference/serving due to diagnostics I/O.
+            return
+
 
 @dataclass
 class _OpManagerState:
@@ -485,6 +527,8 @@ def call(self, op_name: str, *args, **kwargs):
                                         f"Op '{op_name}' switched from '{last_impl_id}' to '{impl_id}' "
                                         f"(kind={impl.kind.value}, vendor={impl.vendor})"
                                     )
+                                if impl.kind == BackendImplKind.DEFAULT:
+                                    _record_default_flagos_op(op_name, impl)
                                 break
                         self._called_ops[op_name] = impl_id
 
@@ -526,6 +570,8 @@ def call(self, op_name: str, *args, **kwargs):
                                         f"Op '{op_name}' switched from '{last_impl_id}' to '{impl.impl_id}' "
                                         f"(kind={impl.kind.value}, vendor={impl.vendor})"
                                     )
+                                if impl.kind == BackendImplKind.DEFAULT:
+                                    _record_default_flagos_op(op_name, impl)
                                 self._called_ops[op_name] = impl.impl_id
                 else:
                     # Always log fallback attempts (these are important runtime events)
@@ -540,6 +586,8 @@ def call(self, op_name: str, *args, **kwargs):
                 if idx > 0:
                     with self._lock:
                         self._called_ops[op_name] = impl.impl_id
+                if impl.kind == BackendImplKind.DEFAULT:
+                    _record_default_flagos_op(op_name, impl)
 
                 return result
 

vllm_fl/version.py

@@ -0,0 +1,92 @@
+"""vllm_fl version information (PyTorch-style).
+
+This module is intentionally lightweight and safe to import.
+
+At build time (pip install .), setuptools-scm writes `vllm_fl/_version.py`
+with pre-computed `git_version` and `git_date`.  At runtime we simply import
+that static file, exactly as vLLM does, so no subprocess is needed in the
+happy path.  Subprocess git calls are only used as a last-resort fallback
+(e.g. pip install -e . or running from source without a build step).
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from importlib import metadata
+
+
+def _pkg_version() -> str:
+    # Project name in pyproject.toml is "vllm-plugin-fl".
+    try:
+        return metadata.version("vllm-plugin-fl")
+    except Exception:
+        pass
+    try:
+        from . import _version
+        return _version.__version__
+    except Exception:
+        return "0.0.0+unknown"
+
+
+def _git_head_from_repo() -> str | None:
+    # Only works from a git checkout with `git` available.
+    try:
+        root = os.path.dirname(os.path.dirname(__file__))
+        return subprocess.check_output(
+            ["git", "-C", root, "rev-parse", "HEAD"],
+            stderr=subprocess.DEVNULL,
+            text=True,
+            timeout=0.2,
+        ).strip() or None
+    except Exception:
+        return None
+
+
+def _git_commit_date_from_repo() -> str | None:
+    # Returns YYYY-MM-DD of the HEAD committer date.
+    try:
+        root = os.path.dirname(os.path.dirname(__file__))
+        out = subprocess.check_output(
+            ["git", "-C", root, "show", "-s", "--format=%cI", "HEAD"],
+            stderr=subprocess.DEVNULL,
+            text=True,
+            timeout=0.2,
+        ).strip()
+        return out[:10] if out else None
+    except Exception:
+        return None
+
+
+def _load_scm() -> tuple[str | None, str | None]:
+    """Read (commit_id, commit_date) from the build-time generated _version.py.
+
+    setuptools-scm writes `vllm_fl/_version.py` at `pip install .` time with
+    pre-computed `git_version` (commit sha) and `git_date` (YYYY-MM-DD)
+    derived from the version string.  Importing that static file avoids any
+    runtime git subprocess in the common installed case.
+    """
+    try:
+        from . import _version as _v
+    except Exception:
+        return None, None
+    cid = getattr(_v, "git_version", None)
+    cdate = getattr(_v, "git_date", None)
+    cid = cid if isinstance(cid, str) and cid not in ("", "Unknown") else None
+    cdate = cdate if isinstance(cdate, str) and cdate not in ("", "Unknown") else None
+    return cid, cdate
+
+
+__version__ = _pkg_version()
+
+_scm_id, _scm_date = _load_scm()
+
+# Public: git commit id of the installed package/build (best-effort).
+git_version: str = _scm_id or _git_head_from_repo() or "Unknown"
+
+# Public: git metadata aligned with torch.version.git_info style.
+git_info: dict[str, str] = {
+    "id": git_version,
+    "date": _scm_date or _git_commit_date_from_repo() or "Unknown",
+}
+