refactor: Move metadata extraction to analyzers (EME-606)

Moves tooling metadata extraction from artifact_processor into the
platform-specific analyzers where app_info is created. This better
encapsulates the metadata extraction logic and makes it more consistent
with other app_info field population.

Also renames sentry_cli_version to cli_version for consistency with
the metadata file format.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: runningcode

src/launchpad/api/update_api_models.py

@@ -63,9 +63,9 @@ class UpdateData(BaseModel):
     apple_app_info: Optional[AppleAppInfo] = None
     android_app_info: Optional[AndroidAppInfo] = None
     dequeued_at: Optional[datetime] = Field(None, description="Timestamp when message was dequeued from Kafka")
-    sentry_cli_version: Optional[str] = Field(None, description="Version of sentry-cli used to upload the artifact")
-    fastlane_version: Optional[str] = Field(None, description="Version of fastlane plugin used")
-    gradle_plugin_version: Optional[str] = Field(None, description="Version of gradle plugin used")
+    cli_version: Optional[str] = Field(None, description="sentry-cli version extracted from .sentry-cli-metadata.txt")
+    fastlane_version: Optional[str] = Field(None, description="Fastlane plugin version extracted from .sentry-cli-metadata.txt")
+    gradle_plugin_version: Optional[str] = Field(None, description="Gradle plugin version extracted from .sentry-cli-metadata.txt")
 
     @field_serializer("dequeued_at")
     def serialize_datetime(self, dt: datetime | None) -> str | None:

src/launchpad/artifact_processor.py

@@ -497,9 +497,9 @@ def _get_artifact_type(artifact: Artifact) -> ArtifactType:
             apple_app_info=apple_app_info,
             android_app_info=android_app_info,
             dequeued_at=dequeued_at,
-            sentry_cli_version=tooling_versions["sentry_cli_version"],
-            fastlane_version=tooling_versions["fastlane_version"],
-            gradle_plugin_version=tooling_versions["gradle_plugin_version"],
+            cli_version=app_info.cli_version,
+            fastlane_version=app_info.fastlane_version,
+            gradle_plugin_version=app_info.gradle_plugin_version,
         )
 
         return update_data.model_dump(exclude_none=True)

src/launchpad/size/analyzers/android.py

@@ -27,6 +27,7 @@
 from launchpad.size.utils.android_bundle_size import calculate_apk_download_size, calculate_apk_install_size
 from launchpad.utils.file_utils import calculate_file_hash
 from launchpad.utils.logging import get_logger
+from launchpad.utils.metadata_extractor import extract_metadata_from_zip
 
 logger = get_logger(__name__)
 
@@ -50,12 +51,18 @@ def preprocess(self, artifact: AndroidArtifact) -> AndroidAppInfo:
         manifest_dict = artifact.get_manifest().model_dump()
         has_proguard_mapping = artifact.get_dex_mapping() is not None
 
+        # Extract tooling metadata from .sentry-cli-metadata.txt if present
+        metadata = extract_metadata_from_zip(artifact.path)
+
         self.app_info = AndroidAppInfo(
             name=manifest_dict["application"]["label"] or "Unknown",
             version=manifest_dict["version_name"] or "Unknown",
             build=manifest_dict["version_code"] or "Unknown",
             app_id=manifest_dict["package_name"],
             has_proguard_mapping=has_proguard_mapping,
+            cli_version=metadata.cli_version,
+            fastlane_version=metadata.fastlane_version,
+            gradle_plugin_version=metadata.gradle_plugin_version,
         )
 
         return self.app_info

src/launchpad/size/analyzers/apple.py

@@ -44,6 +44,7 @@
 from launchpad.utils.apple.code_signature_validator import CodeSignatureValidator
 from launchpad.utils.file_utils import get_file_size, to_nearest_block_size
 from launchpad.utils.logging import get_logger
+from launchpad.utils.metadata_extractor import extract_metadata_from_zip
 
 from ..models.apple import (
     AppleAnalysisResults,
@@ -333,6 +334,9 @@ def _extract_app_info(self, xcarchive: ZippedXCArchive) -> AppleAppInfo:
         binaries = xcarchive.get_all_binary_paths()
         missing_dsym_binaries = [b.name for b in binaries if b.dsym_path is None]
 
+        # Extract tooling metadata from .sentry-cli-metadata.txt if present
+        metadata = extract_metadata_from_zip(xcarchive.path)
+
         return AppleAppInfo(
             name=app_name,
             app_id=plist.get("CFBundleIdentifier", "unknown.bundle.id"),
@@ -354,6 +358,9 @@ def _extract_app_info(self, xcarchive: ZippedXCArchive) -> AppleAppInfo:
             primary_icon_name=primary_icon_name,
             alternate_icon_names=alternate_icon_names,
             missing_dsym_binaries=missing_dsym_binaries,
+            cli_version=metadata.cli_version,
+            fastlane_version=metadata.fastlane_version,
+            gradle_plugin_version=metadata.gradle_plugin_version,
         )
 
     def _get_profile_type(self, profile_data: dict[str, Any]) -> Tuple[str, str]:

src/launchpad/size/models/common.py

@@ -28,6 +28,9 @@ class BaseAppInfo(BaseModel):
     version: str = Field(..., description="App version")
     build: str = Field(..., description="Build number")
     app_id: str = Field(..., description="App ID (bundle id on iOS, package name on Android)")
+    cli_version: str | None = Field(None, description="sentry-cli version extracted from .sentry-cli-metadata.txt")
+    fastlane_version: str | None = Field(None, description="Fastlane plugin version extracted from .sentry-cli-metadata.txt")
+    gradle_plugin_version: str | None = Field(None, description="Gradle plugin version extracted from .sentry-cli-metadata.txt")
 
 
 class FileAnalysis(BaseModel):

src/launchpad/utils/metadata_extractor.py

@@ -0,0 +1,94 @@
+"""Utility for extracting metadata from .sentry-cli-metadata.txt files in artifacts."""
+
+import zipfile
+
+from pathlib import Path
+from typing import Dict, Optional
+
+from launchpad.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+METADATA_FILENAME = ".sentry-cli-metadata.txt"
+
+
+class ToolingMetadata:
+    """Container for tooling version metadata extracted from artifacts."""
+
+    def __init__(
+        self,
+        cli_version: Optional[str] = None,
+        fastlane_version: Optional[str] = None,
+        gradle_plugin_version: Optional[str] = None,
+    ):
+        self.cli_version = cli_version
+        self.fastlane_version = fastlane_version
+        self.gradle_plugin_version = gradle_plugin_version
+
+    def __repr__(self) -> str:
+        return f"ToolingMetadata(cli_version={self.cli_version}, fastlane_version={self.fastlane_version}, gradle_plugin_version={self.gradle_plugin_version})"
+
+
+def extract_metadata_from_zip(zip_path: Path) -> ToolingMetadata:
+    """Extract tooling metadata from a .sentry-cli-metadata.txt file inside a zip.
+
+    Args:
+        zip_path: Path to the zip file to search
+
+    Returns:
+        ToolingMetadata object with extracted version information
+    """
+    try:
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            # Look for .sentry-cli-metadata.txt anywhere in the zip
+            metadata_files = [name for name in zf.namelist() if name.endswith(METADATA_FILENAME)]
+
+            if not metadata_files:
+                logger.debug(f"No {METADATA_FILENAME} found in {zip_path}")
+                return ToolingMetadata()
+
+            # Use the first metadata file found
+            metadata_file = metadata_files[0]
+            logger.debug(f"Found metadata file: {metadata_file}")
+
+            with zf.open(metadata_file) as f:
+                content = f.read().decode("utf-8")
+                return _parse_metadata_content(content)
+
+    except Exception as e:
+        logger.warning(f"Failed to extract metadata from {zip_path}: {e}")
+        return ToolingMetadata()
+
+
+def _parse_metadata_content(content: str) -> ToolingMetadata:
+    """Parse the content of .sentry-cli-metadata.txt file.
+
+    Expected format:
+        sentry-cli-version: 2.58.2
+        fastlane-plugin: 1.2.3
+        gradle-plugin: 4.12.0
+
+    Args:
+        content: The text content of the metadata file
+
+    Returns:
+        ToolingMetadata object with parsed version information
+    """
+    metadata: Dict[str, str] = {}
+
+    for line in content.strip().split("\n"):
+        line = line.strip()
+        if not line or ":" not in line:
+            continue
+
+        key, value = line.split(":", 1)
+        key = key.strip()
+        value = value.strip()
+
+        metadata[key] = value
+
+    return ToolingMetadata(
+        cli_version=metadata.get("sentry-cli-version"),
+        fastlane_version=metadata.get("fastlane-plugin"),
+        gradle_plugin_version=metadata.get("gradle-plugin"),
+    )

tests/unit/utils/test_metadata_extractor.py

@@ -0,0 +1,190 @@
+"""Tests for metadata extraction from .sentry-cli-metadata.txt files."""
+
+import tempfile
+import zipfile
+
+from pathlib import Path
+
+from launchpad.utils.metadata_extractor import (
+    ToolingMetadata,
+    _parse_metadata_content,
+    extract_metadata_from_zip,
+)
+
+
+class TestParseMetadataContent:
+    """Tests for parsing .sentry-cli-metadata.txt content."""
+
+    def test_parse_all_fields(self):
+        content = """sentry-cli-version: 2.58.2
+fastlane-plugin: 1.2.3
+gradle-plugin: 4.12.0"""
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version == "1.2.3"
+        assert metadata.gradle_plugin_version == "4.12.0"
+
+    def test_parse_partial_fields(self):
+        content = """sentry-cli-version: 2.58.2
+fastlane-plugin: 1.2.3"""
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version == "1.2.3"
+        assert metadata.gradle_plugin_version is None
+
+    def test_parse_only_cli_version(self):
+        content = "sentry-cli-version: 2.58.2"
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version is None
+        assert metadata.gradle_plugin_version is None
+
+    def test_parse_empty_content(self):
+        content = ""
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version is None
+        assert metadata.fastlane_version is None
+        assert metadata.gradle_plugin_version is None
+
+    def test_parse_with_extra_whitespace(self):
+        content = """  sentry-cli-version:  2.58.2
+  fastlane-plugin:  1.2.3
+  gradle-plugin:  4.12.0  """
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version == "1.2.3"
+        assert metadata.gradle_plugin_version == "4.12.0"
+
+    def test_parse_with_extra_lines(self):
+        content = """
+sentry-cli-version: 2.58.2
+
+fastlane-plugin: 1.2.3
+
+gradle-plugin: 4.12.0
+"""
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version == "1.2.3"
+        assert metadata.gradle_plugin_version == "4.12.0"
+
+    def test_parse_with_unknown_fields(self):
+        content = """sentry-cli-version: 2.58.2
+unknown-field: some-value
+fastlane-plugin: 1.2.3"""
+        metadata = _parse_metadata_content(content)
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version == "1.2.3"
+        assert metadata.gradle_plugin_version is None
+
+
+class TestExtractMetadataFromZip:
+    """Tests for extracting metadata from zip files."""
+
+    def test_extract_from_zip_root(self):
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tf:
+            try:
+                with zipfile.ZipFile(tf.name, "w") as zf:
+                    zf.writestr(
+                        ".sentry-cli-metadata.txt",
+                        "sentry-cli-version: 2.58.2\nfastlane-plugin: 1.2.3\ngradle-plugin: 4.12.0",
+                    )
+                    zf.writestr("some-file.txt", "content")
+
+                metadata = extract_metadata_from_zip(Path(tf.name))
+                assert metadata.cli_version == "2.58.2"
+                assert metadata.fastlane_version == "1.2.3"
+                assert metadata.gradle_plugin_version == "4.12.0"
+            finally:
+                Path(tf.name).unlink()
+
+    def test_extract_from_nested_path(self):
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tf:
+            try:
+                with zipfile.ZipFile(tf.name, "w") as zf:
+                    zf.writestr(
+                        "some/nested/path/.sentry-cli-metadata.txt",
+                        "sentry-cli-version: 3.0.0",
+                    )
+                    zf.writestr("other-file.txt", "content")
+
+                metadata = extract_metadata_from_zip(Path(tf.name))
+                assert metadata.cli_version == "3.0.0"
+                assert metadata.fastlane_version is None
+                assert metadata.gradle_plugin_version is None
+            finally:
+                Path(tf.name).unlink()
+
+    def test_extract_when_missing(self):
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tf:
+            try:
+                with zipfile.ZipFile(tf.name, "w") as zf:
+                    zf.writestr("some-file.txt", "content")
+                    zf.writestr("other-file.txt", "content")
+
+                metadata = extract_metadata_from_zip(Path(tf.name))
+                assert metadata.cli_version is None
+                assert metadata.fastlane_version is None
+                assert metadata.gradle_plugin_version is None
+            finally:
+                Path(tf.name).unlink()
+
+    def test_extract_multiple_metadata_files(self):
+        # Should use the first one found
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tf:
+            try:
+                with zipfile.ZipFile(tf.name, "w") as zf:
+                    zf.writestr(
+                        "first/.sentry-cli-metadata.txt",
+                        "sentry-cli-version: 1.0.0",
+                    )
+                    zf.writestr(
+                        "second/.sentry-cli-metadata.txt",
+                        "sentry-cli-version: 2.0.0",
+                    )
+
+                metadata = extract_metadata_from_zip(Path(tf.name))
+                # Should get one of them (order not guaranteed in zip namelist)
+                assert metadata.cli_version in ["1.0.0", "2.0.0"]
+            finally:
+                Path(tf.name).unlink()
+
+    def test_extract_from_invalid_zip(self):
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tf:
+            try:
+                tf.write(b"not a valid zip file")
+                tf.flush()
+
+                metadata = extract_metadata_from_zip(Path(tf.name))
+                # Should return empty metadata on error
+                assert metadata.cli_version is None
+                assert metadata.fastlane_version is None
+                assert metadata.gradle_plugin_version is None
+            finally:
+                Path(tf.name).unlink()
+
+
+class TestToolingMetadata:
+    """Tests for ToolingMetadata container class."""
+
+    def test_create_with_all_fields(self):
+        metadata = ToolingMetadata(
+            cli_version="2.58.2",
+            fastlane_version="1.2.3",
+            gradle_plugin_version="4.12.0",
+        )
+        assert metadata.cli_version == "2.58.2"
+        assert metadata.fastlane_version == "1.2.3"
+        assert metadata.gradle_plugin_version == "4.12.0"
+
+    def test_create_with_defaults(self):
+        metadata = ToolingMetadata()
+        assert metadata.cli_version is None
+        assert metadata.fastlane_version is None
+        assert metadata.gradle_plugin_version is None
+
+    def test_repr(self):
+        metadata = ToolingMetadata(cli_version="2.58.2")
+        repr_str = repr(metadata)
+        assert "ToolingMetadata" in repr_str
+        assert "cli_version=2.58.2" in repr_str