fixup! fixup! fixup! fixup! fixup! fixup! fixup! Include the binary in repo

Author: sfc-gh-turbaszek

src/snowflake/connector/_utils.py

@@ -13,6 +13,8 @@
 from threading import Timer
 from uuid import UUID
 
+from snowflake.connector.description import ISA, OPERATING_SYSTEM, OS_VERSION
+
 
 class TempObjectType(Enum):
     TABLE = "TABLE"
@@ -261,3 +263,20 @@ def get_file_name(self) -> str:
 
 
 _core_loader = _CoreLoader()
+
+
+def build_minicore_usage_for_session() -> dict[str, str | None]:
+    return {
+        "ISA": ISA,
+        "CORE_VERSION": _core_loader.get_core_version(),
+        "CORE_FILE_NAME": _core_loader.get_file_name(),
+    }
+
+
+def build_minicore_usage_for_telemetry() -> dict[str, str | None]:
+    return {
+        "OS": OPERATING_SYSTEM,
+        "OS_VERSION": OS_VERSION,
+        "CORE_LOAD_ERROR": _core_loader.get_load_error(),
+        **build_minicore_usage_for_session(),
+    }

src/snowflake/connector/auth/_auth.py

@@ -17,7 +17,7 @@
     load_pem_private_key,
 )
 
-from .._utils import get_application_path
+from .._utils import build_minicore_usage_for_session, get_application_path
 from ..compat import urlencode
 from ..constants import (
     DAY_IN_SECONDS,
@@ -144,6 +144,7 @@ def base_auth_data(
                         platform_detection_timeout_seconds=platform_detection_timeout_seconds,
                         session_manager=session_manager.clone(max_retries=0),
                     ),
+                    **build_minicore_usage_for_session(),
                 },
             },
         }

src/snowflake/connector/connection.py

@@ -42,7 +42,7 @@
 from ._utils import (
     _DEFAULT_VALUE_SERVER_DOP_CAP_FOR_FILE_TRANSFER,
     _VARIABLE_NAME_SERVER_DOP_CAP_FOR_FILE_TRANSFER,
-    _core_loader,
+    build_minicore_usage_for_telemetry,
 )
 from .auth import (
     FIRST_PARTY_AUTHENTICATORS,
@@ -94,9 +94,6 @@
 from .description import (
     CLIENT_NAME,
     CLIENT_VERSION,
-    ISA,
-    OPERATING_SYSTEM,
-    OS_VERSION,
     PLATFORM,
     PYTHON_VERSION,
     SNOWFLAKE_CONNECTOR_VERSION,
@@ -2526,14 +2523,7 @@ def _log_minicore_import(self):
             TelemetryData.from_telemetry_data_dict(
                 from_dict={
                     TelemetryField.KEY_TYPE.value: TelemetryField.CORE_IMPORT.value,
-                    TelemetryField.KEY_VALUE.value: {
-                        "OS": OPERATING_SYSTEM,
-                        "OS_VERSION": OS_VERSION,
-                        "ISA": ISA,
-                        "CORE_VERSION": _core_loader.get_core_version(),
-                        "CORE_FILE_NAME": _core_loader.get_file_name(),
-                        "CORE_LOAD_ERROR": _core_loader.get_load_error(),
-                    },
+                    TelemetryField.KEY_VALUE.value: build_minicore_usage_for_telemetry(),
                 },
                 timestamp=ts,
                 connection=self,

test/unit/test_util.py

@@ -6,10 +6,12 @@
 
 import pytest
 
-try:
-    from snowflake.connector._utils import _CoreLoader, _TrackedQueryCancellationTimer
-except ImportError:
-    pass
+from snowflake.connector._utils import (
+    _CoreLoader,
+    _TrackedQueryCancellationTimer,
+    build_minicore_usage_for_session,
+    build_minicore_usage_for_telemetry,
+)
 
 pytestmark = pytest.mark.skipolddriver
 
@@ -476,3 +478,169 @@ def test_core_loader_fails_gracefully_on_incompatible_library():
                 assert loader._error is not None
                 assert loader._version is None
                 assert "incompatible library version" in loader.get_load_error()
+
+
+class TestBuildMinicoreUsage:
+    """Tests for build_minicore_usage_for_session and build_minicore_usage_for_telemetry functions."""
+
+    def test_build_minicore_usage_for_session_returns_expected_keys(self):
+        """Test that build_minicore_usage_for_session returns dict with expected keys."""
+        result = build_minicore_usage_for_session()
+
+        assert isinstance(result, dict)
+        assert "ISA" in result
+        assert "CORE_VERSION" in result
+        assert "CORE_FILE_NAME" in result
+
+    def test_build_minicore_usage_for_session_isa_matches_platform(self):
+        """Test that ISA value matches platform.machine()."""
+        import platform
+
+        result = build_minicore_usage_for_session()
+
+        assert result["ISA"] == platform.machine()
+
+    def test_build_minicore_usage_for_session_with_mocked_core_loader(self):
+        """Test build_minicore_usage_for_session with mocked core loader values."""
+        with mock.patch(
+            "snowflake.connector._utils._core_loader.get_core_version",
+            return_value="1.2.3",
+        ):
+            with mock.patch(
+                "snowflake.connector._utils._core_loader.get_file_name",
+                return_value="/path/to/lib.so",
+            ):
+                result = build_minicore_usage_for_session()
+
+                assert result["CORE_VERSION"] == "1.2.3"
+                assert result["CORE_FILE_NAME"] == "/path/to/lib.so"
+
+    def test_build_minicore_usage_for_session_with_failed_load(self):
+        """Test build_minicore_usage_for_session when core loading has failed."""
+        with mock.patch(
+            "snowflake.connector._utils._core_loader.get_core_version",
+            return_value=None,
+        ):
+            with mock.patch(
+                "snowflake.connector._utils._core_loader.get_file_name",
+                return_value=None,
+            ):
+                result = build_minicore_usage_for_session()
+
+                assert result["CORE_VERSION"] is None
+                assert result["CORE_FILE_NAME"] is None
+
+    def test_build_minicore_usage_for_telemetry_returns_expected_keys(self):
+        """Test that build_minicore_usage_for_telemetry returns dict with expected keys."""
+        result = build_minicore_usage_for_telemetry()
+
+        assert isinstance(result, dict)
+        # Telemetry-specific keys
+        assert "OS" in result
+        assert "OS_VERSION" in result
+        assert "CORE_LOAD_ERROR" in result
+        # Session keys (inherited)
+        assert "ISA" in result
+        assert "CORE_VERSION" in result
+        assert "CORE_FILE_NAME" in result
+
+    def test_build_minicore_usage_for_telemetry_os_matches_platform(self):
+        """Test that OS value matches platform.system()."""
+        import platform
+
+        result = build_minicore_usage_for_telemetry()
+
+        assert result["OS"] == platform.system()
+
+    def test_build_minicore_usage_for_telemetry_os_version_matches_platform(self):
+        """Test that OS_VERSION value matches platform.version()."""
+        import platform
+
+        result = build_minicore_usage_for_telemetry()
+
+        assert result["OS_VERSION"] == platform.version()
+
+    def test_build_minicore_usage_for_telemetry_includes_session_data(self):
+        """Test that build_minicore_usage_for_telemetry includes all session data."""
+        with mock.patch(
+            "snowflake.connector._utils._core_loader.get_core_version",
+            return_value="2.0.0",
+        ):
+            with mock.patch(
+                "snowflake.connector._utils._core_loader.get_file_name",
+                return_value="/custom/path/lib.dylib",
+            ):
+                with mock.patch(
+                    "snowflake.connector._utils._core_loader.get_load_error",
+                    return_value="None",
+                ):
+                    session_result = build_minicore_usage_for_session()
+                    telemetry_result = build_minicore_usage_for_telemetry()
+
+                    # All session keys should be present in telemetry result
+                    for key in session_result:
+                        assert key in telemetry_result
+                        assert telemetry_result[key] == session_result[key]
+
+    def test_build_minicore_usage_for_telemetry_with_mocked_values(self):
+        """Test build_minicore_usage_for_telemetry with mocked core loader values."""
+        with mock.patch(
+            "snowflake.connector._utils._core_loader.get_core_version",
+            return_value="3.0.0",
+        ):
+            with mock.patch(
+                "snowflake.connector._utils._core_loader.get_file_name",
+                return_value="/path/to/lib.dylib",
+            ):
+                with mock.patch(
+                    "snowflake.connector._utils._core_loader.get_load_error",
+                    return_value="None",
+                ):
+                    result = build_minicore_usage_for_telemetry()
+
+                    assert result["CORE_VERSION"] == "3.0.0"
+                    assert result["CORE_FILE_NAME"] == "/path/to/lib.dylib"
+                    assert result["CORE_LOAD_ERROR"] == "None"
+
+    def test_build_minicore_usage_for_telemetry_with_disabled_core(self):
+        """Test build_minicore_usage_for_telemetry when core is disabled."""
+        with mock.patch(
+            "snowflake.connector._utils._core_loader.get_core_version",
+            return_value=None,
+        ):
+            with mock.patch(
+                "snowflake.connector._utils._core_loader.get_file_name",
+                return_value=None,
+            ):
+                with mock.patch(
+                    "snowflake.connector._utils._core_loader.get_load_error",
+                    return_value="mini-core-disabled",
+                ):
+                    result = build_minicore_usage_for_telemetry()
+
+                    assert result["CORE_VERSION"] is None
+                    assert result["CORE_FILE_NAME"] is None
+                    assert result["CORE_LOAD_ERROR"] == "mini-core-disabled"
+                    # OS info should still be present
+                    assert result["OS"] is not None
+                    assert result["OS_VERSION"] is not None
+
+    def test_build_minicore_usage_for_telemetry_with_load_error(self):
+        """Test build_minicore_usage_for_telemetry when core loading has failed."""
+        with mock.patch(
+            "snowflake.connector._utils._core_loader.get_core_version",
+            return_value=None,
+        ):
+            with mock.patch(
+                "snowflake.connector._utils._core_loader.get_file_name",
+                return_value=None,
+            ):
+                with mock.patch(
+                    "snowflake.connector._utils._core_loader.get_load_error",
+                    return_value="Library not found",
+                ):
+                    result = build_minicore_usage_for_telemetry()
+
+                    assert result["CORE_VERSION"] is None
+                    assert result["CORE_FILE_NAME"] is None
+                    assert result["CORE_LOAD_ERROR"] == "Library not found"