Add release workflows

Cirilla-zmh · Cirilla-zmh · commit 79f1cab8f4cd · 2026-02-24T09:43:31.000+08:00
Change-Id: Ib0d4aa36a776339f0e97c6c25ea6101396b23b81
Co-developed-by: Cursor &lt;noreply@cursor.com&gt;
diff --git a/.github/workflows/loongsuite-release.yml b/.github/workflows/loongsuite-release.yml
@@ -0,0 +1,91 @@
+# LoongSuite Release - Build tar.gz and publish to GitHub Release (Scheme 1)
+#
+# This workflow builds the loongsuite Python Agent package with:
+# - util built as loongsuite-util-genai (avoids conflict with upstream opentelemetry-util-genai)
+# - Instrumentation packages (genai, loongsuite) depending on loongsuite-util-genai
+#
+# The tar.gz is published to GitHub Release for loongsuite-bootstrap -a install.
+name: LoongSuite Release
+
+run-name: "LoongSuite Release ${{ github.event.inputs.version || github.ref_name }}"
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Release version (e.g. 1.0.0)'
+        required: true
+      release_notes:
+        description: 'Release notes (optional, uses CHANGELOG-loongsuite.md Unreleased if empty)'
+        required: false
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  release:
+    permissions:
+      contents: write  # required for creating releases
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set version from tag or input
+        id: version
+        run: |
+          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref_type }}" == "tag" ]]; then
+            # Remove 'refs/tags/' prefix, then optional 'v' (e.g. v1.0.0 -> 1.0.0)
+            tag="${GITHUB_REF#refs/tags/}"
+            version="${tag#v}"
+          else
+            version="${{ github.event.inputs.version }}"
+          fi
+          if [[ -z "$version" ]]; then
+            echo "Version is required"
+            exit 1
+          fi
+          echo "version=$version" >> $GITHUB_OUTPUT
+          echo "VERSION=$version" >> $GITHUB_ENV
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip build
+
+      - name: Build loongsuite package (Scheme 1)
+        run: |
+          python scripts/build_loongsuite_package.py \
+            --loongsuite-release \
+            --version ${{ steps.version.outputs.version }}
+
+      - name: Generate release notes
+        id: release_notes
+        run: |
+          if [[ -n "${{ github.event.inputs.release_notes }}" ]]; then
+            echo "${{ github.event.inputs.release_notes }}" > /tmp/release-notes.txt
+          elif [[ -f CHANGELOG-loongsuite.md ]]; then
+            # Extract Unreleased section from CHANGELOG-loongsuite.md
+            sed -n '/^## Unreleased$/,/^## /p' CHANGELOG-loongsuite.md | sed '/^## /d' > /tmp/release-notes.txt
+            if [[ ! -s /tmp/release-notes.txt ]]; then
+              echo "LoongSuite Python Agent ${{ steps.version.outputs.version }}" > /tmp/release-notes.txt
+              echo "" >> /tmp/release-notes.txt
+              echo "See CHANGELOG-loongsuite.md for details." >> /tmp/release-notes.txt
+            fi
+          else
+            echo "LoongSuite Python Agent ${{ steps.version.outputs.version }}" > /tmp/release-notes.txt
+          fi
+
+      - name: Create GitHub release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "v${{ steps.version.outputs.version }}" \
+            --title "LoongSuite Python Agent v${{ steps.version.outputs.version }}" \
+            --notes-file /tmp/release-notes.txt \
+            dist/loongsuite-python-agent-${{ steps.version.outputs.version }}.tar.gz
diff --git a/loongsuite-distro/src/loongsuite/distro/bootstrap.py b/loongsuite-distro/src/loongsuite/distro/bootstrap.py
@@ -42,11 +42,13 @@
 logger = logging.getLogger(__name__)
 
 # Base dependency packages (must be installed)
+# Use loongsuite-util-genai for Scheme 1 release (tar.gz from GitHub) to avoid
+# conflict with upstream opentelemetry-util-genai on user's system
 BASE_DEPENDENCIES = {
     "opentelemetry-api",
     "opentelemetry-sdk",
     "opentelemetry-instrumentation",
-    "opentelemetry-util-genai",
+    "loongsuite-util-genai",
     "opentelemetry-semantic-conventions",
 }
 
diff --git a/scripts/build_loongsuite_package.py b/scripts/build_loongsuite_package.py
@@ -11,21 +11,39 @@
 6. Skip duplicate packages according to config file
 7. Package all whl files into tar.gz
 
+When --loongsuite-release is used (Scheme 1):
+- util is built FIRST as loongsuite-util-genai
+- Instrumentation packages depending on opentelemetry-util-genai get dependency
+  replaced to loongsuite-util-genai
+- Avoids conflict with upstream opentelemetry-util-genai on user's system
+
 Note: loongsuite-distro is not included as it is published separately to PyPI.
 """
 
 import argparse
 import json
 import logging
+import os
 import subprocess
 import sys
 import tarfile
+from contextlib import contextmanager
 from pathlib import Path
 from typing import List, Set
 
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 logger = logging.getLogger(__name__)
 
+# Instrumentation packages that depend on opentelemetry-util-genai (need replacement in loongsuite-release)
+LOONGSUITE_UTIL_GENAI_DEPENDENTS = [
+    "instrumentation-genai/opentelemetry-instrumentation-google-genai",
+    "instrumentation-genai/opentelemetry-instrumentation-vertexai",
+    "instrumentation-genai/opentelemetry-instrumentation-openai-agents-v2",
+    "instrumentation-loongsuite/loongsuite-instrumentation-mem0",
+    "instrumentation-loongsuite/loongsuite-instrumentation-dashscope",
+    "instrumentation-loongsuite/loongsuite-instrumentation-agentscope",
+]
+
 
 def load_skip_config(config_path: Path) -> Set[str]:
     """Load package names to skip from config file"""
@@ -73,8 +91,25 @@ def get_package_name_from_whl(whl_path: Path) -> str:
     return name
 
 
+@contextmanager
+def _patch_pyproject(pyproject_path: Path, replacements: List[tuple]):
+    """Temporarily patch pyproject.toml, restore on exit."""
+    content = pyproject_path.read_text(encoding="utf-8")
+    try:
+        patched = content
+        for old, new in replacements:
+            patched = patched.replace(old, new)
+        pyproject_path.write_text(patched, encoding="utf-8")
+        yield
+    finally:
+        pyproject_path.write_text(content, encoding="utf-8")
+
+
 def build_package(
-    package_dir: Path, dist_dir: Path, existing_whl_files: Set[Path]
+    package_dir: Path,
+    dist_dir: Path,
+    existing_whl_files: Set[Path],
+    env_extra: dict | None = None,
 ) -> List[Path]:
     """Build whl file for a single package"""
     pyproject_toml = package_dir / "pyproject.toml"
@@ -87,6 +122,10 @@ def build_package(
         # Record whl files before build
         before_whl_files = set(dist_dir.glob("*.whl"))
 
+        build_env = dict(os.environ)
+        if env_extra:
+            build_env.update(env_extra)
+
         result = subprocess.run(
             [
                 sys.executable,
@@ -100,6 +139,7 @@ def build_package(
             check=True,
             capture_output=True,
             text=True,
+            env=build_env,
         )
 
         # Find newly generated whl files (exist after build but not before)
@@ -207,7 +247,121 @@ def collect_packages(
         all_whl_files.extend(whl_files)
         existing_whl_files.update(whl_files)
 
-    # 6. Filter out packages that need to be skipped
+    return _filter_and_dedupe_whl_files(all_whl_files, skip_packages)
+
+
+def collect_packages_loongsuite_release(
+    base_dir: Path,
+    dist_dir: Path,
+    skip_packages: Set[str],
+) -> List[Path]:
+    """
+    Build for Scheme 1 (loongsuite release): util first as loongsuite-util-genai,
+    then instrumentation with dependency replacement.
+    """
+    all_whl_files = []
+    existing_whl_files = set(dist_dir.glob("*.whl"))
+
+    util_genai_dir = base_dir / "util" / "opentelemetry-util-genai"
+    if not (
+        util_genai_dir.exists()
+        and (util_genai_dir / "pyproject.toml").exists()
+    ):
+        raise FileNotFoundError(
+            f"util/opentelemetry-util-genai not found at {util_genai_dir}"
+    )
+
+    # 1. Build util FIRST as loongsuite-util-genai
+    logger.info("Building util as loongsuite-util-genai (Scheme 1)...")
+    with _patch_pyproject(
+        util_genai_dir / "pyproject.toml",
+        [('name = "opentelemetry-util-genai"', 'name = "loongsuite-util-genai"')],
+    ):
+        whl_files = build_package(
+            util_genai_dir, dist_dir, existing_whl_files
+        )
+        all_whl_files.extend(whl_files)
+        existing_whl_files.update(whl_files)
+
+    def _build_with_patch_if_needed(rel_path: str, package_dir: Path) -> List[Path]:
+        """Build package, patching opentelemetry-util-genai -> loongsuite-util-genai if needed."""
+        if rel_path in LOONGSUITE_UTIL_GENAI_DEPENDENTS:
+            pyproject = package_dir / "pyproject.toml"
+            with _patch_pyproject(
+                pyproject,
+                [("opentelemetry-util-genai", "loongsuite-util-genai")],
+            ):
+                return build_package(
+                    package_dir, dist_dir, existing_whl_files
+                )
+        return build_package(package_dir, dist_dir, existing_whl_files)
+
+    # 2. Build instrumentation/ (no util dependency)
+    instrumentation_dir = base_dir / "instrumentation"
+    if instrumentation_dir.exists():
+        logger.info("Building packages under instrumentation/...")
+        for package_dir in sorted(instrumentation_dir.iterdir()):
+            if (
+                package_dir.is_dir()
+                and (package_dir / "pyproject.toml").exists()
+            ):
+                whl_files = build_package(
+                    package_dir, dist_dir, existing_whl_files
+                )
+                all_whl_files.extend(whl_files)
+                existing_whl_files.update(whl_files)
+
+    # 3. Build instrumentation-genai/ (with dependency patch)
+    instrumentation_genai_dir = base_dir / "instrumentation-genai"
+    if instrumentation_genai_dir.exists():
+        logger.info("Building packages under instrumentation-genai/...")
+        for package_dir in sorted(instrumentation_genai_dir.iterdir()):
+            if (
+                package_dir.is_dir()
+                and (package_dir / "pyproject.toml").exists()
+            ):
+                rel_path = str(package_dir.relative_to(base_dir))
+                whl_files = _build_with_patch_if_needed(rel_path, package_dir)
+                all_whl_files.extend(whl_files)
+                existing_whl_files.update(whl_files)
+
+    # 4. Build instrumentation-loongsuite/ (with dependency patch)
+    instrumentation_loongsuite_dir = base_dir / "instrumentation-loongsuite"
+    if instrumentation_loongsuite_dir.exists():
+        logger.info("Building packages under instrumentation-loongsuite/...")
+        for package_dir in sorted(instrumentation_loongsuite_dir.iterdir()):
+            if (
+                package_dir.is_dir()
+                and (package_dir / "pyproject.toml").exists()
+            ):
+                rel_path = str(package_dir.relative_to(base_dir))
+                whl_files = _build_with_patch_if_needed(rel_path, package_dir)
+                all_whl_files.extend(whl_files)
+                existing_whl_files.update(whl_files)
+
+    # 5. Build processor/loongsuite-processor-baggage/
+    processor_baggage_dir = (
+        base_dir / "processor" / "loongsuite-processor-baggage"
+    )
+    if (
+        processor_baggage_dir.exists()
+        and (processor_baggage_dir / "pyproject.toml").exists()
+    ):
+        logger.info("Building processor/loongsuite-processor-baggage/...")
+        whl_files = build_package(
+            processor_baggage_dir, dist_dir, existing_whl_files
+        )
+        all_whl_files.extend(whl_files)
+        existing_whl_files.update(whl_files)
+
+    return _filter_and_dedupe_whl_files(all_whl_files, skip_packages)
+
+
+def _filter_and_dedupe_whl_files(
+    all_whl_files: List[Path],
+    skip_packages: Set[str],
+) -> List[Path]:
+    """Filter skip list and deduplicate whl files."""
     filtered_whl_files = []
     skipped_count = 0
     seen_packages = {}  # Used to detect duplicate packages
@@ -302,6 +456,12 @@ def main():
         default="dev",
         help="Version number (for output filename)",
     )
+    parser.add_argument(
+        "--loongsuite-release",
+        action="store_true",
+        help="Build for Scheme 1: util as loongsuite-util-genai, "
+        "instrumentation deps replaced (for GitHub Release tar.gz)",
+    )
 
     args = parser.parse_args()
 
@@ -318,7 +478,12 @@ def main():
     skip_packages = load_skip_config(args.config)
 
     # Collect and build all packages
-    whl_files = collect_packages(base_dir, dist_dir, skip_packages)
+    if args.loongsuite_release:
+        whl_files = collect_packages_loongsuite_release(
+            base_dir, dist_dir, skip_packages
+        )
+    else:
+        whl_files = collect_packages(base_dir, dist_dir, skip_packages)
 
     if not whl_files:
         logger.error("No whl files found, build failed")
