diff --git a/src/databricks/sql/client.py b/src/databricks/sql/client.py index 5bb191ca2..5e5b9cedc 100755 --- a/src/databricks/sql/client.py +++ b/src/databricks/sql/client.py @@ -9,6 +9,7 @@ import json import os import decimal +from urllib.parse import urlparse from uuid import UUID from databricks.sql import __version__ @@ -322,6 +323,20 @@ def read(self) -> Optional[OAuthToken]: session_id_hex=self.get_session_id_hex() ) + # Determine proxy usage + use_proxy = self.http_client.using_proxy() + proxy_host_info = None + if ( + use_proxy + and self.http_client.proxy_uri + and isinstance(self.http_client.proxy_uri, str) + ): + parsed = urlparse(self.http_client.proxy_uri) + proxy_host_info = HostDetails( + host_url=parsed.hostname or self.http_client.proxy_uri, + port=parsed.port or 8080, + ) + driver_connection_params = DriverConnectionParameters( http_path=http_path, mode=DatabricksClientType.SEA @@ -331,13 +346,31 @@ def read(self) -> Optional[OAuthToken]: auth_mech=TelemetryHelper.get_auth_mechanism(self.session.auth_provider), auth_flow=TelemetryHelper.get_auth_flow(self.session.auth_provider), socket_timeout=kwargs.get("_socket_timeout", None), + azure_workspace_resource_id=kwargs.get("azure_workspace_resource_id", None), + azure_tenant_id=kwargs.get("azure_tenant_id", None), + use_proxy=use_proxy, + use_system_proxy=use_proxy, + proxy_host_info=proxy_host_info, + use_cf_proxy=False, # CloudFlare proxy not yet supported in Python + cf_proxy_host_info=None, # CloudFlare proxy not yet supported in Python + non_proxy_hosts=None, + allow_self_signed_support=kwargs.get("_tls_no_verify", False), + use_system_trust_store=True, # Python uses system SSL by default + enable_arrow=pyarrow is not None, + enable_direct_results=True, # Always enabled in Python + enable_sea_hybrid_results=kwargs.get("use_hybrid_disposition", False), + http_connection_pool_size=kwargs.get("pool_maxsize", None), + rows_fetched_per_block=DEFAULT_ARRAY_SIZE, + async_poll_interval_millis=2000, # Default polling interval + support_many_parameters=True, # Native parameters supported + enable_complex_datatype_support=_use_arrow_native_complex_types, + allowed_volume_ingestion_paths=self.staging_allowed_local_path, ) self._telemetry_client.export_initial_telemetry_log( driver_connection_params=driver_connection_params, user_agent=self.session.useragent_header, ) - self.staging_allowed_local_path = kwargs.get("staging_allowed_local_path", None) def _set_use_inline_params_with_warning(self, value: Union[bool, str]): """Valid values are True, False, and "silent" diff --git a/src/databricks/sql/common/unified_http_client.py b/src/databricks/sql/common/unified_http_client.py index 7ccd69c54..96fb9cbb9 100644 --- a/src/databricks/sql/common/unified_http_client.py +++ b/src/databricks/sql/common/unified_http_client.py @@ -301,6 +301,11 @@ def using_proxy(self) -> bool: """Check if proxy support is available (not whether it's being used for a specific request).""" return self._proxy_pool_manager is not None + @property + def proxy_uri(self) -> Optional[str]: + """Get the configured proxy URI, if any.""" + return self._proxy_uri + def close(self): """Close the underlying connection pools.""" if self._direct_pool_manager: diff --git a/src/databricks/sql/telemetry/models/event.py b/src/databricks/sql/telemetry/models/event.py index c7f9d9d17..2e6f63a6f 100644 --- a/src/databricks/sql/telemetry/models/event.py +++ b/src/databricks/sql/telemetry/models/event.py @@ -38,6 +38,25 @@ class DriverConnectionParameters(JsonSerializableMixin): auth_mech (AuthMech): The authentication mechanism used auth_flow (AuthFlow): The authentication flow type socket_timeout (int): Connection timeout in milliseconds + azure_workspace_resource_id (str): Azure workspace resource ID + azure_tenant_id (str): Azure tenant ID + use_proxy (bool): Whether proxy is being used + use_system_proxy (bool): Whether system proxy is being used + proxy_host_info (HostDetails): Proxy host details if configured + use_cf_proxy (bool): Whether CloudFlare proxy is being used + cf_proxy_host_info (HostDetails): CloudFlare proxy host details if configured + non_proxy_hosts (list): List of hosts that bypass proxy + allow_self_signed_support (bool): Whether self-signed certificates are allowed + use_system_trust_store (bool): Whether system trust store is used + enable_arrow (bool): Whether Arrow format is enabled + enable_direct_results (bool): Whether direct results are enabled + enable_sea_hybrid_results (bool): Whether SEA hybrid results are enabled + http_connection_pool_size (int): HTTP connection pool size + rows_fetched_per_block (int): Number of rows fetched per block + async_poll_interval_millis (int): Async polling interval in milliseconds + support_many_parameters (bool): Whether many parameters are supported + enable_complex_datatype_support (bool): Whether complex datatypes are supported + allowed_volume_ingestion_paths (str): Allowed paths for volume ingestion """ http_path: str @@ -46,6 +65,25 @@ class DriverConnectionParameters(JsonSerializableMixin): auth_mech: Optional[AuthMech] = None auth_flow: Optional[AuthFlow] = None socket_timeout: Optional[int] = None + azure_workspace_resource_id: Optional[str] = None + azure_tenant_id: Optional[str] = None + use_proxy: Optional[bool] = None + use_system_proxy: Optional[bool] = None + proxy_host_info: Optional[HostDetails] = None + use_cf_proxy: Optional[bool] = None + cf_proxy_host_info: Optional[HostDetails] = None + non_proxy_hosts: Optional[list] = None + allow_self_signed_support: Optional[bool] = None + use_system_trust_store: Optional[bool] = None + enable_arrow: Optional[bool] = None + enable_direct_results: Optional[bool] = None + enable_sea_hybrid_results: Optional[bool] = None + http_connection_pool_size: Optional[int] = None + rows_fetched_per_block: Optional[int] = None + async_poll_interval_millis: Optional[int] = None + support_many_parameters: Optional[bool] = None + enable_complex_datatype_support: Optional[bool] = None + allowed_volume_ingestion_paths: Optional[str] = None @dataclass @@ -111,6 +149,69 @@ class DriverErrorInfo(JsonSerializableMixin): stack_trace: str +@dataclass +class ChunkDetails(JsonSerializableMixin): + """ + Contains detailed metrics about chunk downloads during result fetching. + + These metrics are accumulated across all chunk downloads for a single statement. + + Attributes: + initial_chunk_latency_millis (int): Latency of the first chunk download + slowest_chunk_latency_millis (int): Latency of the slowest chunk download + total_chunks_present (int): Total number of chunks available + total_chunks_iterated (int): Number of chunks actually downloaded + sum_chunks_download_time_millis (int): Total time spent downloading all chunks + """ + + initial_chunk_latency_millis: Optional[int] = None + slowest_chunk_latency_millis: Optional[int] = None + total_chunks_present: Optional[int] = None + total_chunks_iterated: Optional[int] = None + sum_chunks_download_time_millis: Optional[int] = None + + +@dataclass +class ResultLatency(JsonSerializableMixin): + """ + Contains latency metrics for different phases of query execution. + + This tracks two distinct phases: + 1. result_set_ready_latency_millis: Time from query submission until results are available (execute phase) + - Set when execute() completes + 2. result_set_consumption_latency_millis: Time spent iterating/fetching results (fetch phase) + - Measured from first fetch call until no more rows available + - In Java: tracked via markResultSetConsumption(hasNext) method + - Records start time on first fetch, calculates total on last fetch + + Attributes: + result_set_ready_latency_millis (int): Time until query results are ready (execution phase) + result_set_consumption_latency_millis (int): Time spent fetching/consuming results (fetch phase) + + """ + + result_set_ready_latency_millis: Optional[int] = None + result_set_consumption_latency_millis: Optional[int] = None + + +@dataclass +class OperationDetail(JsonSerializableMixin): + """ + Contains detailed information about the operation being performed. + + Attributes: + n_operation_status_calls (int): Number of status polling calls made + operation_status_latency_millis (int): Total latency of all status calls + operation_type (str): Specific operation type (e.g., EXECUTE_STATEMENT, LIST_TABLES, CANCEL_STATEMENT) + is_internal_call (bool): Whether this is an internal driver operation + """ + + n_operation_status_calls: Optional[int] = None + operation_status_latency_millis: Optional[int] = None + operation_type: Optional[str] = None + is_internal_call: Optional[bool] = None + + @dataclass class SqlExecutionEvent(JsonSerializableMixin): """ @@ -122,7 +223,10 @@ class SqlExecutionEvent(JsonSerializableMixin): is_compressed (bool): Whether the result is compressed execution_result (ExecutionResultFormat): Format of the execution result retry_count (int): Number of retry attempts made - chunk_id (int): ID of the chunk if applicable + chunk_id (int): ID of the chunk if applicable (used for error tracking) + chunk_details (ChunkDetails): Aggregated chunk download metrics + result_latency (ResultLatency): Latency breakdown by execution phase + operation_detail (OperationDetail): Detailed operation information """ statement_type: StatementType @@ -130,6 +234,9 @@ class SqlExecutionEvent(JsonSerializableMixin): execution_result: ExecutionResultFormat retry_count: Optional[int] chunk_id: Optional[int] + chunk_details: Optional[ChunkDetails] = None + result_latency: Optional[ResultLatency] = None + operation_detail: Optional[OperationDetail] = None @dataclass diff --git a/src/databricks/sql/telemetry/telemetry_client.py b/src/databricks/sql/telemetry/telemetry_client.py index 71fcc40c6..134757fe5 100644 --- a/src/databricks/sql/telemetry/telemetry_client.py +++ b/src/databricks/sql/telemetry/telemetry_client.py @@ -380,7 +380,7 @@ class TelemetryClientFactory: # Shared flush thread for all clients _flush_thread = None _flush_event = threading.Event() - _flush_interval_seconds = 90 + _flush_interval_seconds = 300 # 5 minutes DEFAULT_BATCH_SIZE = 100 diff --git a/tests/unit/test_telemetry.py b/tests/unit/test_telemetry.py index 2ff82cee5..36141ee2b 100644 --- a/tests/unit/test_telemetry.py +++ b/tests/unit/test_telemetry.py @@ -2,6 +2,7 @@ import pytest from unittest.mock import patch, MagicMock import json +from dataclasses import asdict from databricks.sql.telemetry.telemetry_client import ( TelemetryClient, @@ -9,7 +10,16 @@ TelemetryClientFactory, TelemetryHelper, ) -from databricks.sql.telemetry.models.enums import AuthMech, AuthFlow +from databricks.sql.telemetry.models.enums import AuthMech, AuthFlow, DatabricksClientType +from databricks.sql.telemetry.models.event import ( + TelemetryEvent, + DriverConnectionParameters, + DriverSystemConfiguration, + SqlExecutionEvent, + DriverErrorInfo, + DriverVolumeOperation, + HostDetails, +) from databricks.sql.auth.authenticators import ( AccessTokenAuthProvider, DatabricksOAuthProvider, @@ -446,3 +456,356 @@ def test_telemetry_disabled_when_flag_request_fails( mock_http_request.assert_called_once() client = TelemetryClientFactory.get_telemetry_client("test-session-ff-fail") assert isinstance(client, NoopTelemetryClient) + + +class TestTelemetryEventModels: + """Tests for telemetry event model data structures and JSON serialization.""" + + def test_host_details_serialization(self): + """Test HostDetails model serialization.""" + host = HostDetails(host_url="test-host.com", port=443) + + # Test JSON string generation + json_str = host.to_json() + assert isinstance(json_str, str) + parsed = json.loads(json_str) + assert parsed["host_url"] == "test-host.com" + assert parsed["port"] == 443 + + def test_driver_connection_parameters_all_fields(self): + """Test DriverConnectionParameters with all fields populated.""" + host_info = HostDetails(host_url="workspace.databricks.com", port=443) + proxy_info = HostDetails(host_url="proxy.company.com", port=8080) + cf_proxy_info = HostDetails(host_url="cf-proxy.company.com", port=8080) + + params = DriverConnectionParameters( + http_path="/sql/1.0/warehouses/abc123", + mode=DatabricksClientType.SEA, + host_info=host_info, + auth_mech=AuthMech.OAUTH, + auth_flow=AuthFlow.BROWSER_BASED_AUTHENTICATION, + socket_timeout=30000, + azure_workspace_resource_id="/subscriptions/test/resourceGroups/test", + azure_tenant_id="tenant-123", + use_proxy=True, + use_system_proxy=True, + proxy_host_info=proxy_info, + use_cf_proxy=False, + cf_proxy_host_info=cf_proxy_info, + non_proxy_hosts=["localhost", "127.0.0.1"], + allow_self_signed_support=False, + use_system_trust_store=True, + enable_arrow=True, + enable_direct_results=True, + enable_sea_hybrid_results=True, + http_connection_pool_size=100, + rows_fetched_per_block=100000, + async_poll_interval_millis=2000, + support_many_parameters=True, + enable_complex_datatype_support=True, + allowed_volume_ingestion_paths="/Volumes/catalog/schema/volume", + ) + + # Serialize to JSON and parse back + json_str = params.to_json() + json_dict = json.loads(json_str) + + # Verify all new fields are in JSON + assert json_dict["http_path"] == "/sql/1.0/warehouses/abc123" + assert json_dict["mode"] == "SEA" + assert json_dict["host_info"]["host_url"] == "workspace.databricks.com" + assert json_dict["auth_mech"] == "OAUTH" + assert json_dict["auth_flow"] == "BROWSER_BASED_AUTHENTICATION" + assert json_dict["socket_timeout"] == 30000 + assert json_dict["azure_workspace_resource_id"] == "/subscriptions/test/resourceGroups/test" + assert json_dict["azure_tenant_id"] == "tenant-123" + assert json_dict["use_proxy"] is True + assert json_dict["use_system_proxy"] is True + assert json_dict["proxy_host_info"]["host_url"] == "proxy.company.com" + assert json_dict["use_cf_proxy"] is False + assert json_dict["cf_proxy_host_info"]["host_url"] == "cf-proxy.company.com" + assert json_dict["non_proxy_hosts"] == ["localhost", "127.0.0.1"] + assert json_dict["allow_self_signed_support"] is False + assert json_dict["use_system_trust_store"] is True + assert json_dict["enable_arrow"] is True + assert json_dict["enable_direct_results"] is True + assert json_dict["enable_sea_hybrid_results"] is True + assert json_dict["http_connection_pool_size"] == 100 + assert json_dict["rows_fetched_per_block"] == 100000 + assert json_dict["async_poll_interval_millis"] == 2000 + assert json_dict["support_many_parameters"] is True + assert json_dict["enable_complex_datatype_support"] is True + assert json_dict["allowed_volume_ingestion_paths"] == "/Volumes/catalog/schema/volume" + + def test_driver_connection_parameters_minimal_fields(self): + """Test DriverConnectionParameters with only required fields.""" + host_info = HostDetails(host_url="workspace.databricks.com", port=443) + + params = DriverConnectionParameters( + http_path="/sql/1.0/warehouses/abc123", + mode=DatabricksClientType.THRIFT, + host_info=host_info, + ) + + # Note: to_json() filters out None values, so we need to check asdict for complete structure + json_str = params.to_json() + json_dict = json.loads(json_str) + + # Required fields should be present + assert json_dict["http_path"] == "/sql/1.0/warehouses/abc123" + assert json_dict["mode"] == "THRIFT" + assert json_dict["host_info"]["host_url"] == "workspace.databricks.com" + + # Optional fields with None are filtered out by to_json() + # This is expected behavior - None values are excluded from JSON output + + def test_driver_system_configuration_serialization(self): + """Test DriverSystemConfiguration model serialization.""" + sys_config = DriverSystemConfiguration( + driver_name="Databricks SQL Connector for Python", + driver_version="3.0.0", + runtime_name="CPython", + runtime_version="3.11.0", + runtime_vendor="Python Software Foundation", + os_name="Darwin", + os_version="23.0.0", + os_arch="arm64", + char_set_encoding="utf-8", + locale_name="en_US", + client_app_name="MyApp", + ) + + json_str = sys_config.to_json() + json_dict = json.loads(json_str) + + assert json_dict["driver_name"] == "Databricks SQL Connector for Python" + assert json_dict["driver_version"] == "3.0.0" + assert json_dict["runtime_name"] == "CPython" + assert json_dict["runtime_version"] == "3.11.0" + assert json_dict["runtime_vendor"] == "Python Software Foundation" + assert json_dict["os_name"] == "Darwin" + assert json_dict["os_version"] == "23.0.0" + assert json_dict["os_arch"] == "arm64" + assert json_dict["locale_name"] == "en_US" + assert json_dict["char_set_encoding"] == "utf-8" + assert json_dict["client_app_name"] == "MyApp" + + def test_telemetry_event_complete_serialization(self): + """Test complete TelemetryEvent serialization with all nested objects.""" + host_info = HostDetails(host_url="workspace.databricks.com", port=443) + proxy_info = HostDetails(host_url="proxy.company.com", port=8080) + + connection_params = DriverConnectionParameters( + http_path="/sql/1.0/warehouses/abc123", + mode=DatabricksClientType.SEA, + host_info=host_info, + auth_mech=AuthMech.OAUTH, + use_proxy=True, + proxy_host_info=proxy_info, + enable_arrow=True, + rows_fetched_per_block=100000, + ) + + sys_config = DriverSystemConfiguration( + driver_name="Databricks SQL Connector for Python", + driver_version="3.0.0", + runtime_name="CPython", + runtime_version="3.11.0", + runtime_vendor="Python Software Foundation", + os_name="Darwin", + os_version="23.0.0", + os_arch="arm64", + char_set_encoding="utf-8", + ) + + error_info = DriverErrorInfo( + error_name="ConnectionError", + stack_trace="Traceback...", + ) + + event = TelemetryEvent( + session_id="test-session-123", + sql_statement_id="test-stmt-456", + operation_latency_ms=1500, + auth_type="OAUTH", + system_configuration=sys_config, + driver_connection_params=connection_params, + error_info=error_info, + ) + + # Test JSON serialization + json_str = event.to_json() + assert isinstance(json_str, str) + + # Parse and verify structure + parsed = json.loads(json_str) + assert parsed["session_id"] == "test-session-123" + assert parsed["sql_statement_id"] == "test-stmt-456" + assert parsed["operation_latency_ms"] == 1500 + assert parsed["auth_type"] == "OAUTH" + + # Verify nested objects + assert parsed["system_configuration"]["driver_name"] == "Databricks SQL Connector for Python" + assert parsed["driver_connection_params"]["http_path"] == "/sql/1.0/warehouses/abc123" + assert parsed["driver_connection_params"]["use_proxy"] is True + assert parsed["driver_connection_params"]["proxy_host_info"]["host_url"] == "proxy.company.com" + assert parsed["error_info"]["error_name"] == "ConnectionError" + + def test_json_serialization_excludes_none_values(self): + """Test that JSON serialization properly excludes None values.""" + host_info = HostDetails(host_url="workspace.databricks.com", port=443) + + params = DriverConnectionParameters( + http_path="/sql/1.0/warehouses/abc123", + mode=DatabricksClientType.SEA, + host_info=host_info, + # All optional fields left as None + ) + + json_str = params.to_json() + parsed = json.loads(json_str) + + # Required fields present + assert parsed["http_path"] == "/sql/1.0/warehouses/abc123" + + # None values should be EXCLUDED from JSON (not included as null) + # This is the behavior of JsonSerializableMixin + assert "auth_mech" not in parsed + assert "azure_tenant_id" not in parsed + assert "proxy_host_info" not in parsed + + +@patch("databricks.sql.client.Session") +@patch("databricks.sql.common.unified_http_client.UnifiedHttpClient._setup_pool_managers") +class TestConnectionParameterTelemetry: + """Tests for connection parameter population in telemetry.""" + + def test_connection_with_proxy_populates_telemetry(self, mock_setup_pools, mock_session): + """Test that proxy configuration is captured in telemetry.""" + mock_session_instance = MagicMock() + mock_session_instance.guid_hex = "test-session-proxy" + mock_session_instance.auth_provider = AccessTokenAuthProvider("token") + mock_session_instance.is_open = False + mock_session_instance.use_sea = True + mock_session_instance.port = 443 + mock_session_instance.host = "workspace.databricks.com" + mock_session.return_value = mock_session_instance + + with patch("databricks.sql.telemetry.telemetry_client.TelemetryClient.export_initial_telemetry_log") as mock_export: + conn = sql.connect( + server_hostname="workspace.databricks.com", + http_path="/sql/1.0/warehouses/test", + access_token="test-token", + enable_telemetry=True, + force_enable_telemetry=True, + ) + + # Verify export was called + mock_export.assert_called_once() + call_args = mock_export.call_args + + # Extract driver_connection_params + driver_params = call_args.kwargs.get("driver_connection_params") + assert driver_params is not None + assert isinstance(driver_params, DriverConnectionParameters) + + # Verify fields are populated + assert driver_params.http_path == "/sql/1.0/warehouses/test" + assert driver_params.mode == DatabricksClientType.SEA + assert driver_params.host_info.host_url == "workspace.databricks.com" + assert driver_params.host_info.port == 443 + + def test_connection_with_azure_params_populates_telemetry(self, mock_setup_pools, mock_session): + """Test that Azure-specific parameters are captured in telemetry.""" + mock_session_instance = MagicMock() + mock_session_instance.guid_hex = "test-session-azure" + mock_session_instance.auth_provider = AccessTokenAuthProvider("token") + mock_session_instance.is_open = False + mock_session_instance.use_sea = False + mock_session_instance.port = 443 + mock_session_instance.host = "workspace.azuredatabricks.net" + mock_session.return_value = mock_session_instance + + with patch("databricks.sql.telemetry.telemetry_client.TelemetryClient.export_initial_telemetry_log") as mock_export: + conn = sql.connect( + server_hostname="workspace.azuredatabricks.net", + http_path="/sql/1.0/warehouses/test", + access_token="test-token", + azure_workspace_resource_id="/subscriptions/test/resourceGroups/test", + azure_tenant_id="tenant-123", + enable_telemetry=True, + force_enable_telemetry=True, + ) + + mock_export.assert_called_once() + driver_params = mock_export.call_args.kwargs.get("driver_connection_params") + + # Verify Azure fields + assert driver_params.azure_workspace_resource_id == "/subscriptions/test/resourceGroups/test" + assert driver_params.azure_tenant_id == "tenant-123" + + def test_connection_populates_arrow_and_performance_params(self, mock_setup_pools, mock_session): + """Test that Arrow and performance parameters are captured in telemetry.""" + mock_session_instance = MagicMock() + mock_session_instance.guid_hex = "test-session-perf" + mock_session_instance.auth_provider = AccessTokenAuthProvider("token") + mock_session_instance.is_open = False + mock_session_instance.use_sea = True + mock_session_instance.port = 443 + mock_session_instance.host = "workspace.databricks.com" + mock_session.return_value = mock_session_instance + + with patch("databricks.sql.telemetry.telemetry_client.TelemetryClient.export_initial_telemetry_log") as mock_export: + # Import pyarrow availability check + try: + import pyarrow + arrow_available = True + except ImportError: + arrow_available = False + + conn = sql.connect( + server_hostname="workspace.databricks.com", + http_path="/sql/1.0/warehouses/test", + access_token="test-token", + pool_maxsize=200, + enable_telemetry=True, + force_enable_telemetry=True, + ) + + mock_export.assert_called_once() + driver_params = mock_export.call_args.kwargs.get("driver_connection_params") + + # Verify performance fields + assert driver_params.enable_arrow == arrow_available + assert driver_params.enable_direct_results is True + assert driver_params.http_connection_pool_size == 200 + assert driver_params.rows_fetched_per_block == 100000 # DEFAULT_ARRAY_SIZE + assert driver_params.async_poll_interval_millis == 2000 + assert driver_params.support_many_parameters is True + + def test_cf_proxy_fields_default_to_false_none(self, mock_setup_pools, mock_session): + """Test that CloudFlare proxy fields default to False/None (not yet supported).""" + mock_session_instance = MagicMock() + mock_session_instance.guid_hex = "test-session-cfproxy" + mock_session_instance.auth_provider = AccessTokenAuthProvider("token") + mock_session_instance.is_open = False + mock_session_instance.use_sea = True + mock_session_instance.port = 443 + mock_session_instance.host = "workspace.databricks.com" + mock_session.return_value = mock_session_instance + + with patch("databricks.sql.telemetry.telemetry_client.TelemetryClient.export_initial_telemetry_log") as mock_export: + conn = sql.connect( + server_hostname="workspace.databricks.com", + http_path="/sql/1.0/warehouses/test", + access_token="test-token", + enable_telemetry=True, + force_enable_telemetry=True, + ) + + mock_export.assert_called_once() + driver_params = mock_export.call_args.kwargs.get("driver_connection_params") + + # CF proxy not yet supported - should be False/None + assert driver_params.use_cf_proxy is False + assert driver_params.cf_proxy_host_info is None