chore(telemetry): added fallbacks for machine id

Author: adi-wan-askui

pdm.lock

@@ -53,6 +53,7 @@ test = [
     "isort>=6.0.0",
     "black>=25.1.0",
     "ruff>=0.9.5",
+    "pytest-mock>=3.14.0",
 ]
 chat = [
     "streamlit>=1.42.0",

pyproject.toml

@@ -0,0 +1,62 @@
+import os
+import uuid
+import machineid
+from pathlib import Path
+
+from askui.logger import logger
+from askui.telemetry.utils import map_guid_to_uuid4
+
+_HASH_KEY = "askui"
+_MACHINE_ID_FILE_PATH = Path.home() / ".askui" / "machine_id"
+
+_machine_id: str | None = None
+
+
+def _read_machine_id_from_file() -> str | None:
+    """Read machine ID from file if it exists."""
+    try:
+        if os.path.exists(_MACHINE_ID_FILE_PATH):
+            with open(_MACHINE_ID_FILE_PATH, "r") as f:
+                return f.read().strip()
+        return None
+    except Exception as e:
+        logger.warning(f"Failed to read machine ID from file: {str(e)}")
+        return None
+
+
+def _write_machine_id_to_file(machine_id: str) -> bool:
+    """Write machine ID to file, creating directories if needed."""
+    try:
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(_MACHINE_ID_FILE_PATH), exist_ok=True)
+        with open(_MACHINE_ID_FILE_PATH, "w") as f:
+            f.write(machine_id)
+        return True
+    except Exception as e:
+        logger.warning(f"Failed to write machine ID to file: {str(e)}")
+        return False
+    
+
+def _is_valid_uuid4(uuid_str: str) -> bool:
+    """Check if a string is a valid UUID version 4."""
+    try:
+        return str(uuid.UUID(uuid_str, version=4)) == uuid_str
+    except Exception:
+        return False
+
+
+def get_machine_id() -> str:
+    """Get the machine ID of the host machine, with file persistence."""
+    global _machine_id
+    
+    if _machine_id is None:
+        _machine_id = _read_machine_id_from_file()
+        if _machine_id is None or not _is_valid_uuid4(_machine_id):
+            try:
+                _machine_id = map_guid_to_uuid4(machineid.hashed_id(app_id=_HASH_KEY)).lower()
+                _write_machine_id_to_file(_machine_id)
+            except machineid.MachineIdNotFound:
+                logger.warning("Failed to get machine ID, generating a random UUID version 4.")
+                _machine_id = str(uuid.uuid4()).lower()
+                _write_machine_id_to_file(_machine_id)
+    return _machine_id.lower()

src/askui/telemetry/machineid.py

@@ -6,7 +6,6 @@
 from typing import Any, Callable
 import uuid
 
-import machineid
 from pydantic import BaseModel, Field
 
 from askui.logger import logger
@@ -18,13 +17,13 @@
     OSContext,
     PlatformContext,
 )
+from askui.telemetry.machineid import get_machine_id
 from askui.telemetry.pkg_version import get_pkg_version
 from askui.telemetry.processors import SegmentSettings, TelemetryProcessor
 from askui.telemetry.user_identification import (
     UserIdentification,
     UserIdentificationSettings,
 )
-from askui.telemetry.utils import map_guid_to_uuid4
 
 
 class TelemetrySettings(BaseModel):
@@ -44,7 +43,7 @@ class TelemetrySettings(BaseModel):
         ),
     )
     device_id: str = Field(
-        default_factory=lambda: map_guid_to_uuid4(machineid.hashed_id("askui")),
+        default_factory=get_machine_id,
         description=(
             "The device ID of the host machine. "
             "This is used to identify the device and the user (if anynomous) across AskUI components. "

src/askui/telemetry/telemetry.py

@@ -0,0 +1,120 @@
+import os
+import uuid
+import pytest
+
+import machineid
+from askui.telemetry.machineid import (
+    get_machine_id,
+    _read_machine_id_from_file,
+    _write_machine_id_to_file,
+    _is_valid_uuid4,
+    _MACHINE_ID_FILE_PATH,
+)
+
+
+@pytest.fixture(autouse=True)
+def reset_machine_id():
+    """Reset cached machine ID before each test."""
+    import askui.telemetry.machineid
+    askui.telemetry.machineid._machine_id = None
+    yield
+    askui.telemetry.machineid._machine_id = None
+
+
+def test_read_machine_id_from_file(mocker):
+    mocker.patch("os.path.exists", return_value=True)
+    mock_file = mocker.mock_open(read_data="test-uuid-1234\n")
+    mocker.patch("builtins.open", mock_file)
+    
+    result = _read_machine_id_from_file()
+    assert result == "test-uuid-1234"
+    mock_file.assert_called_once_with(_MACHINE_ID_FILE_PATH, "r")
+
+
+def test_read_machine_id_from_nonexistent_file(mocker):
+    mocker.patch("os.path.exists", return_value=False)
+    result = _read_machine_id_from_file()
+    assert result is None
+
+
+def test_read_machine_id_file_error(mocker):
+    mocker.patch("os.path.exists", return_value=True)
+    mocker.patch("builtins.open", side_effect=IOError("Test IO Error"))
+    result = _read_machine_id_from_file()
+    assert result is None
+
+
+def test_write_machine_id_to_file(mocker):
+    mocker.patch("os.makedirs")
+    mock_file = mocker.mock_open()
+    mocker.patch("builtins.open", mock_file)
+    
+    result = _write_machine_id_to_file("test-uuid-5678")
+    assert result is True
+    os.makedirs.assert_called_once_with(os.path.dirname(_MACHINE_ID_FILE_PATH), exist_ok=True)
+    mock_file.assert_called_once_with(_MACHINE_ID_FILE_PATH, "w")
+    mock_file().write.assert_called_once_with("test-uuid-5678")
+
+
+def test_write_machine_id_file_error(mocker):
+    mocker.patch("os.makedirs", side_effect=OSError("Test OS Error"))
+    result = _write_machine_id_to_file("test-uuid-5678")
+    assert result is False
+
+
+def test_is_valid_uuid4():
+    # Valid UUID4
+    valid_uuid = str(uuid.uuid4())
+    assert _is_valid_uuid4(valid_uuid) is True
+    
+    # Invalid UUIDs
+    assert _is_valid_uuid4("not-a-uuid") is False
+    assert _is_valid_uuid4("12345678-1234-1234-1234-123456789012") is False  # Valid format but not v4
+    assert _is_valid_uuid4("") is False
+
+
+def test_get_machine_id_from_file(mocker):
+    valid_uuid = str(uuid.uuid4()).lower()
+    mocker.patch("askui.telemetry.machineid._read_machine_id_from_file", return_value=valid_uuid)
+    mock_write = mocker.patch("askui.telemetry.machineid._write_machine_id_to_file")
+    mock_hashed_id = mocker.patch("machineid.hashed_id")
+    
+    result = get_machine_id()
+    
+    assert result == valid_uuid
+    mock_hashed_id.assert_not_called()
+    mock_write.assert_not_called()
+
+
+def test_get_machine_id_from_system(mocker):
+    mocker.patch("askui.telemetry.machineid._read_machine_id_from_file", return_value=None)
+    mock_write = mocker.patch("askui.telemetry.machineid._write_machine_id_to_file")
+    mock_hashed_id = mocker.patch("machineid.hashed_id")
+    mock_hashed_id.return_value = "system-machine-id"
+    result = get_machine_id()
+    mock_hashed_id.assert_called_once_with(app_id="askui")
+    mock_write.assert_called_once()
+    assert _is_valid_uuid4(result)
+
+
+def test_get_machine_id_fallback_to_random(mocker):
+    mocker.patch("askui.telemetry.machineid._read_machine_id_from_file", return_value=None)
+    mock_write = mocker.patch("askui.telemetry.machineid._write_machine_id_to_file")
+    mock_hashed_id = mocker.patch("machineid.hashed_id")
+    mock_hashed_id.side_effect = machineid.MachineIdNotFound()
+    random_uuid = uuid.uuid4()
+    mocker.patch("uuid.uuid4", return_value=random_uuid)
+    result = get_machine_id()
+    assert result == str(random_uuid).lower()
+    mock_write.assert_called_once_with(str(random_uuid).lower())
+
+
+def test_get_machine_id_caching(mocker):
+    valid_uuid = str(uuid.uuid4()).lower()
+    mock_read = mocker.patch("askui.telemetry.machineid._read_machine_id_from_file", return_value=valid_uuid)
+    result1 = get_machine_id()
+    assert result1 == valid_uuid
+    mock_read.reset_mock()
+    result2 = get_machine_id()
+    assert result2 == valid_uuid
+    mock_read.assert_not_called()