chore: merge main into opentelemetry workflow update

Author: zhongkechen

.github/scripts/build_lambda_layer.py

@@ -14,25 +14,19 @@
 from pathlib import Path
 
 
-ARCHITECTURE_PLATFORMS = {
-    "x86_64": "manylinux2014_x86_64",
-    "arm64": "manylinux2014_aarch64",
-}
-SUPPORTED_PYTHON_VERSIONS = ("3.11", "3.12", "3.13", "3.14")
+UNIVERSAL_WHEEL_SUFFIX = "-py3-none-any.whl"
 
 
 @dataclass(frozen=True)
 class BuildConfig:
     output: Path
-    target_python: str
-    architecture: str
     sdk_distribution: Path
     otel_distribution: Path
     build_dir: Path | None = None
 
 
 def build_layer(config: BuildConfig) -> Path:
-    """Build a Lambda layer containing the SDK and OpenTelemetry plugin."""
+    """Build a universal Lambda layer containing the SDK and OTel plugin."""
 
     _validate_config(config)
 
@@ -44,42 +38,28 @@ def build_layer(config: BuildConfig) -> Path:
         layer_python_dir = work_dir / "python"
         layer_python_dir.mkdir(parents=True)
 
-        _install_layer_dependencies(config, layer_python_dir)
+        _install_layer_distributions(config, layer_python_dir)
         _write_zip(config.output, work_dir)
 
     return config.output
 
 
 def _validate_config(config: BuildConfig) -> None:
-    if config.architecture not in ARCHITECTURE_PLATFORMS:
-        supported = ", ".join(sorted(ARCHITECTURE_PLATFORMS))
-        raise ValueError(
-            f"Unsupported architecture: {config.architecture}. "
-            f"Supported architectures: {supported}"
-        )
-
-    if config.target_python not in SUPPORTED_PYTHON_VERSIONS:
-        supported = ", ".join(SUPPORTED_PYTHON_VERSIONS)
-        raise ValueError(
-            f"Unsupported Python version: {config.target_python}. "
-            f"Supported versions: {supported}"
-        )
-
     for distribution in (config.sdk_distribution, config.otel_distribution):
         if not distribution.is_file():
             raise FileNotFoundError(distribution)
+        if not distribution.name.endswith(UNIVERSAL_WHEEL_SUFFIX):
+            raise ValueError(
+                f"Layer distributions must be universal wheels: {distribution}"
+            )
 
 
 def _validate_output_location(output: Path, build_dir: Path) -> None:
     if output.resolve().is_relative_to(build_dir.resolve()):
         raise ValueError("Layer output must be outside the build directory")
 
 
-def _install_layer_dependencies(config: BuildConfig, target_dir: Path) -> None:
-    python_version = config.target_python
-    abi = f"cp{python_version.replace('.', '')}"
-    platform = ARCHITECTURE_PLATFORMS[config.architecture]
-
+def _install_layer_distributions(config: BuildConfig, target_dir: Path) -> None:
     command = [
         sys.executable,
         "-m",
@@ -88,17 +68,10 @@ def _install_layer_dependencies(config: BuildConfig, target_dir: Path) -> None:
         "--upgrade",
         "--target",
         str(target_dir),
-        "--platform",
-        platform,
-        "--implementation",
-        "cp",
-        "--python-version",
-        python_version,
-        "--abi",
-        abi,
         "--only-binary",
         ":all:",
         "--no-compile",
+        "--no-deps",
         str(config.sdk_distribution),
         str(config.otel_distribution),
     ]
@@ -119,21 +92,9 @@ def _write_zip(output: Path, layer_root: Path) -> None:
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="build_lambda_layer.py",
-        description="Build the AWS Durable Execution SDK OTel plugin Lambda layer.",
+        description="Build the universal AWS Durable Execution SDK OTel plugin layer.",
     )
     parser.add_argument("--output", type=Path, required=True)
-    parser.add_argument(
-        "--target-python",
-        choices=SUPPORTED_PYTHON_VERSIONS,
-        required=True,
-        help="Lambda Python minor version.",
-    )
-    parser.add_argument(
-        "--architecture",
-        choices=sorted(ARCHITECTURE_PLATFORMS),
-        required=True,
-        help="Lambda instruction set architecture.",
-    )
     parser.add_argument("--sdk-distribution", type=Path, required=True)
     parser.add_argument("--otel-distribution", type=Path, required=True)
     parser.add_argument(
@@ -146,8 +107,6 @@ def main(argv: list[str] | None = None) -> int:
     output = build_layer(
         BuildConfig(
             output=args.output,
-            target_python=args.target_python,
-            architecture=args.architecture,
             sdk_distribution=args.sdk_distribution,
             otel_distribution=args.otel_distribution,
             build_dir=args.build_dir,

.github/scripts/check_otel_wheel_dependencies.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import email
+import zipfile
+from pathlib import Path
+
+from packaging.requirements import Requirement
+from packaging.utils import canonicalize_name
+
+
+EXPECTED_STANDALONE_DEPENDENCIES = {
+    "opentelemetry-api",
+    "opentelemetry-propagator-aws-xray",
+    "opentelemetry-sdk",
+}
+
+
+def check_otel_wheel_dependencies(wheel: Path) -> None:
+    """Validate that OpenTelemetry dependencies are layer-provided by default."""
+    requirements = _read_requirements(wheel)
+    base_otel_dependencies = {
+        canonicalize_name(requirement.name)
+        for requirement in requirements
+        if canonicalize_name(requirement.name).startswith("opentelemetry-")
+        and (requirement.marker is None or requirement.marker.evaluate({"extra": ""}))
+    }
+    if base_otel_dependencies:
+        names = ", ".join(sorted(base_otel_dependencies))
+        raise ValueError(
+            f"{wheel.name} installs OpenTelemetry dependencies by default: {names}"
+        )
+
+    standalone_dependencies = {
+        canonicalize_name(requirement.name)
+        for requirement in requirements
+        if canonicalize_name(requirement.name).startswith("opentelemetry-")
+        and requirement.marker is not None
+        and requirement.marker.evaluate({"extra": "standalone"})
+    }
+    if standalone_dependencies != EXPECTED_STANDALONE_DEPENDENCIES:
+        expected = ", ".join(sorted(EXPECTED_STANDALONE_DEPENDENCIES))
+        actual = ", ".join(sorted(standalone_dependencies)) or "none"
+        raise ValueError(
+            f"{wheel.name} standalone OpenTelemetry dependencies must be "
+            f"{expected}; found {actual}"
+        )
+
+
+def _read_requirements(wheel: Path) -> list[Requirement]:
+    if not wheel.is_file():
+        raise FileNotFoundError(wheel)
+
+    with zipfile.ZipFile(wheel) as archive:
+        metadata_files = [
+            name for name in archive.namelist() if name.endswith(".dist-info/METADATA")
+        ]
+        if len(metadata_files) != 1:
+            raise ValueError(
+                f"{wheel.name} must contain exactly one dist-info/METADATA file"
+            )
+        metadata = email.message_from_bytes(archive.read(metadata_files[0]))
+
+    return [
+        Requirement(value) for value in metadata.get_all("Requires-Dist", failobj=[])
+    ]
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Validate the OTel plugin wheel dependency contract."
+    )
+    parser.add_argument("wheel", type=Path)
+    args = parser.parse_args(argv)
+
+    check_otel_wheel_dependencies(args.wheel)
+    print(args.wheel)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())