fixup! Add option to disable core loading

Author: sfc-gh-turbaszek

src/snowflake/connector/_utils.py

@@ -107,9 +107,10 @@ class _CoreLoader:
     def __init__(self):
         self._version: bytes | None = None
         self._error: Exception | None = None
+        self._path: str | None = None
 
     @staticmethod
-    def _get_core_path():
+    def _get_core_path() -> Path:
         # Define the file name for each platform
         if sys.platform.startswith("win"):
             lib_name = "libsf_mini_core.dll"
@@ -147,6 +148,7 @@ def _load(self) -> None:
             self._register_functions(core)
             self._version = core.sf_core_full_version()
             self._error = None
+            self._path = str(path)
         except Exception as err:
             self._error = err
 
@@ -170,5 +172,8 @@ def get_core_version(self) -> str | None:
                 pass
         return None
 
+    def get_file_name(self) -> str:
+        return self._path
+
 
 _core_loader = _CoreLoader()

src/snowflake/connector/connection.py

@@ -94,6 +94,9 @@
 from .description import (
     CLIENT_NAME,
     CLIENT_VERSION,
+    ISA,
+    OPERATING_SYSTEM,
+    OS_VERSION,
     PLATFORM,
     PYTHON_VERSION,
     SNOWFLAKE_CONNECTOR_VERSION,
@@ -2509,14 +2512,27 @@ def async_query_check_helper(
         return not found_unfinished_query
 
     def _log_minicore_import(self):
+        """
+                OS - meaningful value like Windows, Linux, Darwin/MacOS etc.
+        OS_VERSION - meaningful version like kernel version for Linux/Darwin, etc. that your language provides
+        ISA - instruction set architecture, like amd64/arm64.
+        CORE_VERSION - result of sf_core_full_version call, if finished successfully.
+        CORE_FILE_NAME - a string representing binary name that driver tried to load
+        CORE_LOAD_ERROR - flag or error type included if there are any errors (can’t write a library to disk, can’t load it, can’t find symbols, etc).
+                :return:
+        """
         ts = get_time_millis()
         self._log_telemetry(
             TelemetryData.from_telemetry_data_dict(
                 from_dict={
                     TelemetryField.KEY_TYPE.value: TelemetryField.CORE_IMPORT.value,
                     TelemetryField.KEY_VALUE: {
-                        "CORE_LOAD_ERROR": _core_loader.get_load_error(),
+                        "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(),
                     },
                 },
                 timestamp=ts,

src/snowflake/connector/description.py

@@ -12,6 +12,8 @@
 PYTHON_VERSION = ".".join(str(v) for v in sys.version_info[:3])
 OPERATING_SYSTEM = platform.system()
 PLATFORM = platform.platform()
+OS_VERSION = platform.version()
+ISA = platform.machine()
 IMPLEMENTATION = platform.python_implementation()
 COMPILER = platform.python_compiler()
 

test/integ/test_connection.py

@@ -19,12 +19,18 @@
 
 import snowflake.connector
 from snowflake.connector import DatabaseError, OperationalError, ProgrammingError
+from snowflake.connector._utils import _core_loader
 from snowflake.connector.compat import IS_WINDOWS
 from snowflake.connector.connection import (
     DEFAULT_CLIENT_PREFETCH_THREADS,
     SnowflakeConnection,
 )
-from snowflake.connector.description import CLIENT_NAME
+from snowflake.connector.description import (
+    CLIENT_NAME,
+    ISA,
+    OPERATING_SYSTEM,
+    OS_VERSION,
+)
 from snowflake.connector.errorcode import (
     ER_CONNECTION_IS_CLOSED,
     ER_FAILED_PROCESSING_PYFORMAT,
@@ -1232,7 +1238,7 @@ def check_packages(message: str, expected_packages: list[str]) -> bool:
 
 @pytest.mark.skipolddriver
 def test_minicore_import_telemetry(conn_cnx, capture_sf_telemetry):
-    """Test that minicore import telemetry (CORE_LOAD_ERROR and CORE_VERSION) is logged."""
+    """Test that minicore import telemetry is logged with all required fields and correct values."""
     with (
         conn_cnx() as conn,
         capture_sf_telemetry.patch_connection(conn, False) as telemetry_test,
@@ -1248,12 +1254,14 @@ def test_minicore_import_telemetry(conn_cnx, capture_sf_telemetry):
                 and TelemetryField.KEY_VALUE.value in t.message
             ):
                 found_minicore_telemetry = True
-                # Verify that the value contains CORE_LOAD_ERROR and CORE_VERSION
+                # Verify that the value contains all required fields with correct values
                 value = t.message[TelemetryField.KEY_VALUE.value]
-                assert (
-                    "CORE_LOAD_ERROR" in value
-                ), "CORE_LOAD_ERROR not in telemetry value"
-                assert "CORE_VERSION" in value, "CORE_VERSION not in telemetry value"
+                assert value["OS"] == OPERATING_SYSTEM
+                assert value["OS_VERSION"] == OS_VERSION
+                assert value["ISA"] == ISA
+                assert value["CORE_VERSION"] == _core_loader.get_core_version()
+                assert value["CORE_FILE_NAME"] == _core_loader.get_file_name()
+                assert value["CORE_LOAD_ERROR"] == _core_loader.get_load_error()
                 break
         assert (
             found_minicore_telemetry

test/unit/test_util.py

@@ -40,6 +40,7 @@ def test_core_loader_initialization(self):
         loader = _CoreLoader()
         assert loader._version is None
         assert loader._error is None
+        assert loader._path is None
 
     def test_get_core_path_windows(self):
         """Test _get_core_path returns correct path for Windows."""
@@ -129,7 +130,7 @@ def test_is_core_disabled_returns_false_when_not_set(self):
         loader = _CoreLoader()
         with mock.patch.dict(os.environ, {}, clear=True):
             # Ensure the env var is not set
-            os.environ.pop("SNOWFLAKE_DISABLE_CORE", None)
+            os.environ.pop("SNOWFLAKE_DISABLE_MINICORE", None)
             assert loader._is_core_disabled() is False
 
     def test_load_skips_loading_when_core_disabled(self):
@@ -171,6 +172,7 @@ def test_load_success(self):
                         mock_register.assert_called_once_with(mock_core)
                         assert loader._version == mock_version
                         assert loader._error is None
+                        assert loader._path == str(mock_path)
 
     def test_load_failure(self):
         """Test that load captures exceptions."""
@@ -186,6 +188,7 @@ def test_load_failure(self):
                 mock_get_path.assert_called_once()
                 assert loader._version is None
                 assert loader._error == test_error
+                assert loader._path is None
 
     def test_get_load_error_with_error(self):
         """Test get_load_error returns error message when error exists."""
@@ -222,6 +225,23 @@ def test_get_core_version_no_version(self):
 
         assert result is None
 
+    def test_get_file_name_with_path(self):
+        """Test get_file_name returns the path string after successful load."""
+        loader = _CoreLoader()
+        loader._path = "/path/to/libsf_mini_core.so"
+
+        result = loader.get_file_name()
+
+        assert result == "/path/to/libsf_mini_core.so"
+
+    def test_get_file_name_no_path(self):
+        """Test get_file_name returns None when no path exists."""
+        loader = _CoreLoader()
+
+        result = loader.get_file_name()
+
+        assert result is None
+
 
 def test_importing_snowflake_connector_triggers_core_loader_load():
     """Test that importing snowflake.connector triggers core_loader.load()."""