Added better support for kubuntu and fixed some issues with telemetry.

ptlinux/telemetry.py

@@ -27,6 +27,7 @@ import uuid
 
 from . import __version__
 from .paths import AppPaths
+from .system_identity import SystemIdentity, detect_system_identity, read_os_release
 from .telemetry_environment import collect_extended_environment
 
 
@@ -267,6 +268,7 @@ class TelemetryService:
 		environment: Mapping[str, str] | None = None,
 		transport: TelemetryTransport | None = None,
 		session_metadata: Mapping[str, object] | None = None,
+		report_launcher_lifecycle: bool | None = None,
 		monotonic: Callable[[], float] = time.monotonic,
 	) -> None:
 		self.paths = paths
@@ -283,10 +285,15 @@ class TelemetryService:
 		self._session_metadata = dict(session_metadata or {})
 		self._monotonic = monotonic
 		self._started_at = monotonic()
-		self._reports_launcher_lifecycle = (
+		process_reports_launcher_lifecycle = (
 			self._environment.get(TELEMETRY_PROCESS_ROLE_VARIABLE, "").strip().casefold()
 			!= TELEMETRY_OPERATION_PROCESS_ROLE
 		)
+		self._reports_launcher_lifecycle = process_reports_launcher_lifecycle and (
+			True
+			if report_launcher_lifecycle is None
+			else bool(report_launcher_lifecycle)
+		)
 		self._enabled = bool(enabled)
 		self._active = False
 		self._accepting = False
@@ -923,6 +930,7 @@ class TelemetryService:
 
 	def _collect_common_payload(self, first_seen: str) -> dict[str, object]:
 		environment = self._environment
+		system_identity = detect_system_identity()
 		payload: dict[str, object] = {
 			"launcher_version": __version__,
 			"launcher_build": environment.get("PTLINUX_BUILD", __version__)[:32],
@@ -934,10 +942,13 @@ class TelemetryService:
 				"install_is_external": _install_is_external(self.paths, environment),
 				"configuration_schema_version": _settings_schema_version(),
 			},
-			"os": _operating_system_info(),
+			"os": _operating_system_info(system_identity),
 			"display": _display_info(environment),
 			"filesystem": _filesystem_info(self.paths.data),
 		}
+		execution_environment = _execution_environment_info(system_identity)
+		if execution_environment is not None:
+			payload["execution_environment"] = execution_environment
 		commit = environment.get("PTLINUX_COMMIT")
 		if commit and re.fullmatch(r"[0-9a-fA-F]{7,40}", commit):
 			payload["launcher_commit"] = commit[:12].lower()
@@ -1097,6 +1108,7 @@ def initialize_shared_telemetry(
 	paths: AppPaths,
 	*,
 	session_metadata: Mapping[str, object] | None = None,
+	report_launcher_lifecycle: bool | None = None,
 ) -> tuple[TelemetryService, bool]:
 	"""Return the process-wide service and whether this caller owns its shutdown."""
 
@@ -1108,6 +1120,7 @@ def initialize_shared_telemetry(
 			paths,
 			enabled=_telemetry_enabled_from_settings(paths),
 			session_metadata=session_metadata,
+			report_launcher_lifecycle=report_launcher_lifecycle,
 		)
 		_shared_service = service
 	service.initialize()
@@ -1230,8 +1243,11 @@ def _fsync_directory(path: Path) -> None:
 		os.close(descriptor)
 
 
-def _operating_system_info() -> dict[str, object]:
-	release = _read_os_release()
+def _operating_system_info(
+	identity: SystemIdentity | None = None,
+) -> dict[str, object]:
+	identity = detect_system_identity() if identity is None else identity
+	release = identity.operating_system_release
 	return {
 		"name": release.get("NAME", platform.system() or "unknown"),
 		"id": release.get("ID", "unknown"),
@@ -1241,27 +1257,38 @@ def _operating_system_info() -> dict[str, object]:
 		"architecture": platform.machine() or "unknown",
 		"machine_architecture": platform.machine() or "unknown",
 		"glibc_version": platform.libc_ver()[1] or None,
+		"identity_source": (
+			"container_host_os_release"
+			if identity.host_release is not None
+			else "execution_os_release"
+		),
 	}
 
 
 def _read_os_release(path: Path = Path("/etc/os-release")) -> dict[str, str]:
-	try:
-		lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
-	except OSError:
-		return {}
-	result: dict[str, str] = {}
-	for line in lines:
-		if not line or line.startswith("#") or "=" not in line:
-			continue
-		key, raw = line.split("=", 1)
-		if not re.fullmatch(r"[A-Z][A-Z0-9_]*", key):
-			continue
-		value = raw.strip()
-		if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
-			value = value[1:-1]
-		value = value.replace(r"\n", " ").replace(r"\"", '"').replace(r"\\", "\\")
-		result[key] = value[:255]
-	return result
+	return read_os_release(path)
+
+
+def _execution_environment_info(
+	identity: SystemIdentity,
+) -> dict[str, object] | None:
+	if not identity.running_inside_steam_runtime:
+		return None
+	release = identity.execution_release
+	return {
+		"containerized": True,
+		"kind": "steam_runtime",
+		"id": release.get("ID", "steamrt"),
+		"name": release.get("NAME", "Steam Runtime"),
+		"version": release.get(
+			"PRETTY_NAME",
+			release.get("VERSION", "unknown"),
+		),
+		"version_id": release.get("VERSION_ID", "unknown"),
+		"host_os_release_available": identity.host_release is not None,
+		"launcher_inside_game_runtime": True,
+		"glibc_version": platform.libc_ver()[1] or None,
+	}
 
 
 def _display_info(environment: Mapping[str, str]) -> dict[str, object]: