Merge remote-tracking branch 'origin/main' into feat/gapic-centralization-api-core

Author: hebaalazzeh

.github/workflows/import-profiler.yml

@@ -0,0 +1,39 @@
+name: import-profiler
+
+on:
+  pull_request:
+    branches:
+      - main
+      - preview
+  # Trigger workflow on GitHub merge queue events
+  merge_group:
+    types: [checks_requested]
+
+permissions:
+  contents: read
+
+jobs:
+  import-profile:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v6
+      with:
+        fetch-depth: 2
+    - name: Setup Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.15"
+        allow-prereleases: true
+    - name: Upgrade pip, setuptools, and wheel
+      run: |
+        python -m pip install --upgrade setuptools pip wheel
+    - name: Run import profiler
+      env:
+        BUILD_TYPE: presubmit
+        TARGET_BRANCH: ${{ github.base_ref || github.event.merge_group.base_ref }}
+        TEST_TYPE: import_profile
+        PY_VERSION: "3.15"
+      run: |
+        ci/run_conditional_tests.sh

ci/run_single_test.sh

@@ -105,6 +105,61 @@ case ${TEST_TYPE} in
             ;;
         esac
         ;;
+    import_profile)
+        if [ -f setup.py ] || [ -f pyproject.toml ]; then
+            echo "Creating temporary virtualenv for import profile..."
+            python3 -m venv .venv-profiler
+            source .venv-profiler/bin/activate
+            
+            PACKAGE_NAME=$(basename $(pwd))
+            PROFILER_TEMP_DIR=$(mktemp -d)
+            cp ../../scripts/import_profiler/profiler.py "${PROFILER_TEMP_DIR}/profiler.py"
+            PROFILER_SCRIPT="${PROFILER_TEMP_DIR}/profiler.py"
+            BASELINE_CSV="${PROFILER_TEMP_DIR}/baseline_${PACKAGE_NAME}.csv"
+            
+            if [ -n "${TARGET_BRANCH}" ]; then
+                # Try upstream first (for forks), then origin
+                BASELINE_COMMIT=$(git merge-base HEAD "upstream/${TARGET_BRANCH}" 2>/dev/null || \
+                                 git merge-base HEAD "origin/${TARGET_BRANCH}" 2>/dev/null || \
+                                 git merge-base HEAD "${TARGET_BRANCH}" 2>/dev/null || true)
+                if [ -n "${BASELINE_COMMIT}" ]; then
+                    echo "Checking out baseline commit ${BASELINE_COMMIT} in a temporary worktree..."
+                    REPO_PREFIX=$(git rev-parse --show-prefix)
+                    WORKTREE_DIR=$(mktemp -d)
+                    rmdir "${WORKTREE_DIR}"
+                    if git worktree add "${WORKTREE_DIR}" "${BASELINE_COMMIT}" 2>/dev/null; then
+                        (
+                            cd "${WORKTREE_DIR}/${REPO_PREFIX}"
+                            if [ -f setup.py ] || [ -f pyproject.toml ]; then
+                                pip install -e .
+                                python "${PROFILER_SCRIPT}" --package "${PACKAGE_NAME}" --iterations 11 --csv "${BASELINE_CSV}"
+                            fi
+                        )
+                        git worktree remove -f "${WORKTREE_DIR}"
+                    else
+                        echo "Failed to create git worktree for baseline. Skipping baseline generation."
+                    fi
+                else
+                    echo "Could not find baseline commit for ${TARGET_BRANCH:-main}. Skipping baseline generation."
+                fi
+            fi
+            
+            pip install -e .
+            
+            if [ -f "${BASELINE_CSV}" ]; then
+                python ${PROFILER_SCRIPT} --package ${PACKAGE_NAME} --iterations 11 --fail-threshold 5000 --diff-baseline "${BASELINE_CSV}" --diff-threshold 100
+            else
+                python ${PROFILER_SCRIPT} --package ${PACKAGE_NAME} --iterations 11 --fail-threshold 5000
+            fi
+            retval=$?
+            deactivate
+            rm -rf .venv-profiler
+            rm -rf "${PROFILER_TEMP_DIR}"
+        else
+            echo "Skipping import_profile as this does not appear to be a Python package (no setup.py or pyproject.toml)."
+            retval=0
+        fi
+        ;;
     *)
         nox -s ${TEST_TYPE}
         retval=$?

packages/google-cloud-compute/google/cloud/compute_v1/__init__.py

@@ -4365,3 +4365,4 @@ def _get_version(dependency_name):
     "ZoneVmExtensionPoliciesClient",
     "ZonesClient",
 )
+# Trigger CI check

packages/google-cloud-kms/google/cloud/kms_v1/__init__.py

@@ -355,3 +355,4 @@ def _get_version(dependency_name):
     "VerifyConnectivityRequest",
     "VerifyConnectivityResponse",
 )
+# Trigger CI check

scripts/import_profiler/profiler.py

@@ -154,7 +154,7 @@ def _format_stats(title, data, p50, p90, p99, fmt):
 {_format_stats("Physical RSS RAM (MB)", rss_memories, p50_rss, p90_rss, p99_rss, ".4f")}"""
     print(final_output.strip())
 
-def run_master(iterations, target_module, cpu=0, csv_path=None, clear_cache=True):
+def run_master(iterations, target_module, cpu=0, csv_path=None, clear_cache=True, fail_threshold=None, diff_baseline=None, diff_threshold=None):
     """Orchestrates the benchmark."""
     if iterations < 1:
         raise ValueError("Number of iterations must be at least 1.")
@@ -191,6 +191,7 @@ def run_master(iterations, target_module, cpu=0, csv_path=None, clear_cache=True
             times.append(data["time_ms"])
             memories.append(data["peak_ram_mb"])
             rss_memories.append(data["rss_ram_mb"])
+            print(f"Iteration {i+1}/{iterations} completed in {data['time_ms']:.2f} ms")
             if i > 0 and loaded_modules_val != data["loaded_modules"]:
                 print(f"WARNING: Non-deterministic import behavior! Iteration {i+1} loaded {data['loaded_modules']} modules (expected {loaded_modules_val}).", file=sys.stderr)
             if i > 0 and loaded_lines_val != data["loaded_lines"]:
@@ -207,6 +208,13 @@ def run_master(iterations, target_module, cpu=0, csv_path=None, clear_cache=True
             print(f"Error in worker process:\n{e.stderr}", file=sys.stderr)
             raise e
 
+    if iterations > 1:
+        times = times[1:]
+        memories = memories[1:]
+        rss_memories = rss_memories[1:]
+        iterations -= 1
+        print("Discarded the first iteration as a cache burn-in run.")
+
     # Write CSV if requested
     if csv_path:
         with open(csv_path, "w", newline="", encoding="utf-8") as f:
@@ -229,6 +237,68 @@ def run_master(iterations, target_module, cpu=0, csv_path=None, clear_cache=True
         rss_memories, p50_rss, p90_rss, p99_rss
     )
 
+    exit_code = 0
+    final_messages = []
+
+    baseline_p50 = None
+    if diff_baseline:
+        if os.path.exists(diff_baseline):
+            baseline_times = []
+            with open(diff_baseline, "r", encoding="utf-8") as f:
+                reader = csv.reader(f)
+                next(reader) # skip header
+                for row in reader:
+                    baseline_times.append(float(row[1]))
+            if baseline_times:
+                baseline_p50, _, _ = _calculate_percentiles(baseline_times)
+            
+            if baseline_p50 is not None:
+                diff = p50_time - baseline_p50
+                
+                diff_msg = (
+                    f"--- Diff vs Baseline ---\n"
+                    f"Baseline Median: {baseline_p50:.2f} ms\n"
+                    f"Current Median:  {p50_time:.2f} ms\n"
+                    f"Difference:      {diff:+.2f} ms"
+                )
+                final_messages.append(diff_msg)
+                
+                relative_diff_threshold = 0.15 * baseline_p50
+                if diff > diff_threshold and diff > relative_diff_threshold:
+                    final_messages.append(
+                        f"FAILURE: Import time regression of {diff:.2f} ms exceeds both the absolute threshold ({diff_threshold} ms) "
+                        f"and the relative threshold ({relative_diff_threshold:.2f} ms, 15% of baseline Median)."
+                    )
+                    exit_code = 1
+                else:
+                    if diff > diff_threshold:
+                        final_messages.append(f"SUCCESS: Import time regression of {diff:.2f} ms exceeds absolute threshold ({diff_threshold} ms) but is within relative threshold ({relative_diff_threshold:.2f} ms, 15%).")
+                    else:
+                        final_messages.append("SUCCESS: Import time diff is within acceptable thresholds.")
+        else:
+            final_messages.append(f"WARNING: Baseline CSV {diff_baseline} not found. Skipping diff check.")
+
+    if fail_threshold is not None:
+        if p50_time > fail_threshold:
+            if baseline_p50 is not None and baseline_p50 > fail_threshold:
+                final_messages.append(f"WARNING: Median import time ({p50_time:.2f} ms) exceeds the absolute failure threshold ({fail_threshold} ms), but the baseline ({baseline_p50:.2f} ms) also exceeded it. Bypassing absolute backstop failure.")
+            else:
+                final_messages.append(f"FAILURE: Median import time ({p50_time:.2f} ms) exceeds the failure threshold ({fail_threshold} ms).")
+                exit_code = 1
+        else:
+            final_messages.append(f"SUCCESS: Median import time ({p50_time:.2f} ms) is within the failure threshold ({fail_threshold} ms).")
+
+    if final_messages:
+        print("\n" + "\n".join(final_messages))
+        
+    if exit_code == 0:
+        print("\nSession import_profiler was successful.")
+        sys.exit(0)
+    else:
+        print("\nSession import_profiler failed.")
+        sys.exit(1)
+
+
 def run_trace(target_module):
     """Generates importtime trace log and writes it to a file."""
     trace_file = f"import_trace_{target_module.replace('.', '_')}.log"
@@ -307,8 +377,59 @@ def validate_module_name(module_name):
             raise argparse.ArgumentTypeError(f"'{module_name}' is not a valid Python module identifier.")
         return module_name
 
+    def find_module_from_package(pkg):
+        import importlib.metadata
+        import importlib.util
+
+        # 1. Try to use importlib.metadata.files (works for standard installations from PyPI/wheels)
+        try:
+            files = importlib.metadata.files(pkg)
+            if files:
+                init_files = [str(f) for f in files if str(f).endswith('__init__.py') and '__pycache__' not in str(f) and not str(f).startswith('tests/')]
+                if init_files:
+                    from pathlib import Path
+                    shortest_init = min(init_files, key=lambda p: len(Path(p).parts))
+                    parts = Path(shortest_init).parent.parts
+                    mod = '.'.join(parts)
+                    if importlib.util.find_spec(mod):
+                        return mod
+        except Exception:
+            pass
+
+        # 2. Try setuptools.find_namespace_packages() in current directory (works for editable installs in source trees)
+        try:
+            import setuptools
+            import os
+            if os.path.exists('setup.py') or os.path.exists('pyproject.toml'):
+                pkgs = setuptools.find_namespace_packages(where='.')
+                for p in sorted(pkgs, key=len):
+                    if p in ("google", "google.cloud") or p.startswith("tests"):
+                        continue
+                    path = p.replace('.', os.sep)
+                    if os.path.isfile(os.path.join(path, '__init__.py')):
+                        if importlib.util.find_spec(p):
+                            return p
+        except Exception:
+            pass
+
+        # 3. Fallback to basic string manipulation heuristics
+        candidates = [
+            pkg.replace('-', '.'),
+            '.'.join(pkg.split('-')[:-1]) + '_' + pkg.split('-')[-1] if '-' in pkg else pkg,
+            pkg.replace('-', '_')
+        ]
+        for mod in candidates:
+            try:
+                if importlib.util.find_spec(mod):
+                    return mod
+            except Exception:
+                pass
+        return candidates[0]
+
     parser = argparse.ArgumentParser(description="Python SDK Import Profiler")
-    parser.add_argument("--module", type=validate_module_name, default="google.cloud.compute_v1", help="Target module to profile")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--module", type=validate_module_name, help="Target module to profile")
+    group.add_argument("--package", help="Target package name to profile (auto-detects module)")
     parser.add_argument("--iterations", type=int, default=50, help="Number of iterations")
     default_cpu = 0 if sys.platform.startswith("linux") else NO_CPU_PINNING
     parser.add_argument("--cpu", type=int, default=default_cpu, help="CPU core to pin to (or -1 for no pinning)")
@@ -317,20 +438,27 @@ def validate_module_name(module_name):
     parser.add_argument("--cprofile", action="store_true", help="Run cProfile")
     parser.add_argument("--mprofile", action="store_true", help="Run tracemalloc memory snapshot")
     parser.add_argument("--keep-pycache", action="store_true", help="Preserve __pycache__ and allow bytecode execution (Default: False, script automatically sweeps __pycache__ for true cold-starts)")
+    parser.add_argument("--fail-threshold", type=float, help="Fail the profiling if the Median time exceeds this threshold (in ms).")
+    parser.add_argument("--diff-baseline", help="Path to a baseline CSV file to compare against.")
+    parser.add_argument("--diff-threshold", type=float, default=100.0, help="Fail if Median time exceeds baseline Median by this many ms.")
     parser.add_argument("--worker", action="store_true", help=argparse.SUPPRESS)
 
     args = parser.parse_args()
 
+    target_module = args.module
+    if args.package:
+        target_module = find_module_from_package(args.package)
+    
     if args.worker:
-        run_worker(args.module)
+        run_worker(target_module)
     elif args.trace:
         if not args.keep_pycache: clean_bytecode()
-        run_trace(args.module)
+        run_trace(target_module)
     elif args.cprofile:
         if not args.keep_pycache: clean_bytecode()
-        run_cprofile(args.module)
+        run_cprofile(target_module)
     elif args.mprofile:
         if not args.keep_pycache: clean_bytecode()
-        run_mprofile(args.module)
+        run_mprofile(target_module)
     else:
-        run_master(args.iterations, args.module, args.cpu, args.csv, not args.keep_pycache)
+        run_master(args.iterations, target_module, args.cpu, args.csv, not args.keep_pycache, args.fail_threshold, args.diff_baseline, args.diff_threshold)