feat: Extract and send tooling versions to Sentry (EME-606)

Extract sentry-cli, fastlane, and gradle plugin versions from artifact
metadata files and send them to Sentry's preprod artifact update API.

Changes:
- Add sentry_cli_version, fastlane_version, and gradle_plugin_version
  fields to UpdateData model
- Add _extract_tooling_versions method to parse .sentry-cli-metadata.txt
- Update _prepare_update_data to extract and include version information
- Add comprehensive tests for version extraction

Refs: EME-606

Author: runningcode

src/launchpad/api/update_api_models.py

@@ -63,6 +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")
 
     @field_serializer("dequeued_at")
     def serialize_datetime(self, dt: datetime | None) -> str | None:

src/launchpad/artifact_processor.py

@@ -411,6 +411,41 @@ def _update_size_error(
         except SentryClientError:
             logger.exception(f"Failed to update artifact with error {message}")
 
+    def _extract_tooling_versions(self, artifact: Artifact) -> Dict[str, str | None]:
+        """Extract tooling version information from the artifact zip file.
+
+        Looks for metadata files like .sentry-cli-metadata.txt in the zip
+        and extracts version information.
+
+        Returns:
+            Dict with keys: sentry_cli_version, fastlane_version, gradle_plugin_version
+        """
+        import zipfile
+
+        versions = {
+            "sentry_cli_version": None,
+            "fastlane_version": None,
+            "gradle_plugin_version": None,
+        }
+
+        try:
+            with zipfile.ZipFile(artifact.path, "r") as zf:
+                # Look for .sentry-cli-metadata.txt in the root of the zip
+                if ".sentry-cli-metadata.txt" in zf.namelist():
+                    with zf.open(".sentry-cli-metadata.txt") as f:
+                        content = f.read().decode("utf-8")
+                        # Parse format: sentry-cli-version: {version}
+                        for line in content.strip().split("\n"):
+                            if line.startswith("sentry-cli-version:"):
+                                version = line.split(":", 1)[1].strip()
+                                versions["sentry_cli_version"] = version
+                                logger.debug(f"Extracted sentry-cli version: {version}")
+                                break
+        except Exception as e:
+            logger.debug(f"Could not extract tooling versions: {e}")
+
+        return versions
+
     def _prepare_update_data(
         self,
         app_info: AppleAppInfo | BaseAppInfo,
@@ -450,6 +485,9 @@ def _get_artifact_type(artifact: Artifact) -> ArtifactType:
                 has_proguard_mapping=app_info.has_proguard_mapping,
             )
 
+        # Extract tooling versions from the artifact metadata
+        tooling_versions = self._extract_tooling_versions(artifact)
+
         update_data = UpdateData(
             app_name=app_info.name,
             app_id=app_info.app_id,
@@ -459,6 +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"],
         )
 
         return update_data.model_dump(exclude_none=True)

tests/unit/artifacts/test_artifact_processor.py

@@ -291,3 +291,104 @@ def test_process_message_project_not_skipped(self, mock_process, mock_sentry_cli
         calls = fake_statsd.calls
         assert ("increment", {"metric": "artifact.processing.started", "value": 1, "tags": None}) in calls
         assert ("increment", {"metric": "artifact.processing.completed", "value": 1, "tags": None}) in calls
+
+
+class TestToolingVersionExtraction:
+    """Test extraction of tooling version information from artifacts."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        mock_sentry_client = Mock(spec=SentryClient)
+        mock_statsd = Mock()
+        self.processor = ArtifactProcessor(mock_sentry_client, mock_statsd)
+
+    def test_extract_tooling_versions_with_sentry_cli_version(self, tmp_path):
+        """Test extracting sentry-cli version from artifact zip."""
+        import zipfile
+
+        from launchpad.artifacts.artifact import Artifact
+
+        # Create a test zip file with .sentry-cli-metadata.txt
+        zip_path = tmp_path / "test_artifact.zip"
+        with zipfile.ZipFile(zip_path, "w") as zf:
+            zf.writestr(".sentry-cli-metadata.txt", "sentry-cli-version: 2.39.1\n")
+
+        # Create an artifact pointing to the zip
+        artifact = Artifact(path=zip_path)
+
+        # Extract versions
+        versions = self.processor._extract_tooling_versions(artifact)
+
+        # Verify sentry-cli version was extracted
+        assert versions["sentry_cli_version"] == "2.39.1"
+        assert versions["fastlane_version"] is None
+        assert versions["gradle_plugin_version"] is None
+
+    def test_extract_tooling_versions_no_metadata_file(self, tmp_path):
+        """Test extracting versions when no metadata file exists."""
+        import zipfile
+
+        from launchpad.artifacts.artifact import Artifact
+
+        # Create a test zip file without metadata
+        zip_path = tmp_path / "test_artifact.zip"
+        with zipfile.ZipFile(zip_path, "w") as zf:
+            zf.writestr("some_file.txt", "content")
+
+        artifact = Artifact(path=zip_path)
+        versions = self.processor._extract_tooling_versions(artifact)
+
+        # All versions should be None
+        assert versions["sentry_cli_version"] is None
+        assert versions["fastlane_version"] is None
+        assert versions["gradle_plugin_version"] is None
+
+    def test_extract_tooling_versions_multiline_metadata(self, tmp_path):
+        """Test extracting version from metadata file with multiple lines."""
+        import zipfile
+
+        from launchpad.artifacts.artifact import Artifact
+
+        zip_path = tmp_path / "test_artifact.zip"
+        with zipfile.ZipFile(zip_path, "w") as zf:
+            metadata_content = """# Sentry CLI Metadata
+sentry-cli-version: 2.40.0
+upload-date: 2025-11-10
+"""
+            zf.writestr(".sentry-cli-metadata.txt", metadata_content)
+
+        artifact = Artifact(path=zip_path)
+        versions = self.processor._extract_tooling_versions(artifact)
+
+        assert versions["sentry_cli_version"] == "2.40.0"
+
+    def test_extract_tooling_versions_with_spaces(self, tmp_path):
+        """Test extracting version with extra whitespace."""
+        import zipfile
+
+        from launchpad.artifacts.artifact import Artifact
+
+        zip_path = tmp_path / "test_artifact.zip"
+        with zipfile.ZipFile(zip_path, "w") as zf:
+            zf.writestr(".sentry-cli-metadata.txt", "sentry-cli-version:   2.39.1   \n")
+
+        artifact = Artifact(path=zip_path)
+        versions = self.processor._extract_tooling_versions(artifact)
+
+        assert versions["sentry_cli_version"] == "2.39.1"
+
+    def test_extract_tooling_versions_invalid_zip(self, tmp_path):
+        """Test graceful handling of invalid/corrupted zip file."""
+        from launchpad.artifacts.artifact import Artifact
+
+        # Create a non-zip file
+        invalid_zip = tmp_path / "invalid.zip"
+        invalid_zip.write_text("not a zip file")
+
+        artifact = Artifact(path=invalid_zip)
+        versions = self.processor._extract_tooling_versions(artifact)
+
+        # Should return all None values without crashing
+        assert versions["sentry_cli_version"] is None
+        assert versions["fastlane_version"] is None
+        assert versions["gradle_plugin_version"] is None