snowflake-connector-python 3.12.0__tar.gz → 3.12.2__tar.gz

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/DESCRIPTION.md

@@ -8,6 +8,21 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.12.2(September 11,2024)
+  - Improved error handling for asynchronous queries, providing more detailed and informative error messages when an async query fails.
+  - Improved inference of top-level domains for accounts specifying a region in China, now defaulting to snowflakecomputing.cn.
+  - Improved implementation of the `snowflake.connector.util_text.random_string` to reduce the likelihood of collisions.
+  - Updated the log level for OCSP fail-open warning messages from ERROR to WARNING.
+
+- v3.12.1(August 20,2024)
+  - Fixed a bug that logged the session token when renewing a session.
+  - Fixed a bug where disabling client telemetry did not work.
+  - Fixed a bug where passing `login_timeout` as a string raised a `TypeError` during the login retry step.
+  - Use `pathlib` instead of `os` for default config file location resolution.
+  - Removed upper `cryptogaphy` version pin.
+  - Removed reference to script `snowflake-export-certs` (its backing module was already removed long ago)
+  - Enhanced retry mechanism for handling transient network failures during query result polling when no server response is received.
+
 - v3.12.0(July 24,2024)
   - Set default connection timeout of 10 seconds and socket read timeout of 10 minutes for HTTP calls in file transfer.
   - Optimized `to_pandas()` performance by fully parallel downloading logic.

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-connector-python
-Version: 3.12.0
+Version: 3.12.2
 Summary: Snowflake Connector for Python
 Home-page: https://www.snowflake.com/
 Author: Snowflake, Inc
@@ -40,7 +40,7 @@ License-File: LICENSE.txt
 License-File: NOTICE
 Requires-Dist: asn1crypto<2.0.0,>0.24.0
 Requires-Dist: cffi<2.0.0,>=1.9
-Requires-Dist: cryptography<43.0.0,>=3.1.0
+Requires-Dist: cryptography>=3.1.0
 Requires-Dist: pyOpenSSL<25.0.0,>=16.2.0
 Requires-Dist: pyjwt<3.0.0
 Requires-Dist: pytz
@@ -85,6 +85,21 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 
 # Release Notes
 
+- v3.12.2(September 11,2024)
+  - Improved error handling for asynchronous queries, providing more detailed and informative error messages when an async query fails.
+  - Improved inference of top-level domains for accounts specifying a region in China, now defaulting to snowflakecomputing.cn.
+  - Improved implementation of the `snowflake.connector.util_text.random_string` to reduce the likelihood of collisions.
+  - Updated the log level for OCSP fail-open warning messages from ERROR to WARNING.
+
+- v3.12.1(August 20,2024)
+  - Fixed a bug that logged the session token when renewing a session.
+  - Fixed a bug where disabling client telemetry did not work.
+  - Fixed a bug where passing `login_timeout` as a string raised a `TypeError` during the login retry step.
+  - Use `pathlib` instead of `os` for default config file location resolution.
+  - Removed upper `cryptogaphy` version pin.
+  - Removed reference to script `snowflake-export-certs` (its backing module was already removed long ago)
+  - Enhanced retry mechanism for handling transient network failures during query result polling when no server response is received.
+
 - v3.12.0(July 24,2024)
   - Set default connection timeout of 10 seconds and socket read timeout of 10 minutes for HTTP calls in file transfer.
   - Optimized `to_pandas()` performance by fully parallel downloading logic.

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/README.md

@@ -52,3 +52,32 @@ These tools are integrated into `tox` to allow us to easily set them up universa
 * **coverage**: Runs `coverage.py` to combine generated coverage data files. Useful when multiple categories were run
   and we would like to have an overall coverage data file created for them.
 * **flake8**: (Deprecated) Similar to `fix_lint`, but only runs `flake8` checks.
+
+## Disable telemetry
+
+By default, the Snowflake Connector for Python collects telemetry data to improve the product.
+You can disable the telemetry data collection by setting the session parameter `CLIENT_TELEMETRY_ENABLED` to `False`
+when connecting to Snowflake:
+```python
+import snowflake.connector
+conn = snowflake.connector.connect(
+    user='XXXX',
+    password='XXXX',
+    account='XXXX',
+    session_parameters={
+      "CLIENT_TELEMETRY_ENABLED": False,
+    }
+)
+```
+
+Alternatively, you can disable the telemetry data collection
+by setting the `telemetry_enabled` property to `False` on the `SnowflakeConnection` object:
+```python
+import snowflake.connector
+conn = snowflake.connector.connect(
+    user='XXXX',
+    password='XXXX',
+    account='XXXX',
+)
+conn.telemetry_enabled = False
+```

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/setup.cfg

@@ -45,7 +45,7 @@ packages = find_namespace:
 install_requires = 
 	asn1crypto>0.24.0,<2.0.0
 	cffi>=1.9,<2.0.0
-	cryptography>=3.1.0,<43.0.0
+	cryptography>=3.1.0
 	pyOpenSSL>=16.2.0,<25.0.0
 	pyjwt<3.0.0
 	pytz
@@ -76,7 +76,6 @@ console_scripts =
 	snowflake-dump-ocsp-response = snowflake.connector.tool.dump_ocsp_response:main
 	snowflake-dump-ocsp-response-cache = snowflake.connector.tool.dump_ocsp_response_cache:main
 	snowflake-dump-certs = snowflake.connector.tool.dump_certs:main
-	snowflake-export-certs = snowflake.connector.tool.export_certs:main
 
 [options.extras_require]
 development = 

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/auth/_auth.py

@@ -198,7 +198,7 @@ class Auth:
             self._rest._connection._internal_application_name,
             self._rest._connection._internal_application_version,
             self._rest._connection._ocsp_mode(),
-            self._rest._connection._login_timeout,
+            self._rest._connection.login_timeout,
             self._rest._connection._network_timeout,
             self._rest._connection._socket_timeout,
         )

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/auth/okta.py

@@ -170,7 +170,7 @@ class AuthByOkta(AuthByPlugin):
             conn._internal_application_name,
             conn._internal_application_version,
             conn._ocsp_mode(),
-            conn._login_timeout,
+            conn.login_timeout,
             conn._network_timeout,
         )
 

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/auth/webbrowser.py

@@ -462,7 +462,7 @@ You can close this window now and go back where you started from.
             conn._rest._connection._internal_application_name,
             conn._rest._connection._internal_application_version,
             conn._rest._connection._ocsp_mode(),
-            conn._rest._connection._login_timeout,
+            conn._rest._connection.login_timeout,
             conn._rest._connection._network_timeout,
         )
 

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/connection.py

@@ -61,7 +61,6 @@ from .constants import (
     PARAMETER_CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY,
     PARAMETER_CLIENT_STORE_TEMPORARY_CREDENTIAL,
     PARAMETER_CLIENT_TELEMETRY_ENABLED,
-    PARAMETER_CLIENT_TELEMETRY_OOB_ENABLED,
     PARAMETER_CLIENT_VALIDATE_DEFAULT_PARAMETERS,
     PARAMETER_ENABLE_STAGE_S3_PRIVATELINK_FOR_US_EAST_1,
     PARAMETER_QUERY_CONTEXT_CACHE_SIZE,
@@ -106,7 +105,6 @@ from .network import (
 )
 from .sqlstate import SQLSTATE_CONNECTION_NOT_EXISTS, SQLSTATE_FEATURE_NOT_SUPPORTED
 from .telemetry import TelemetryClient, TelemetryData, TelemetryField
-from .telemetry_oob import TelemetryService
 from .time_util import HeartBeatTimer, get_time_millis
 from .url_util import extract_top_level_domain_from_hostname
 from .util_text import construct_hostname, parse_account, split_statements
@@ -409,7 +407,8 @@ class SnowflakeConnection:
         self.messages = []
         self._async_sfqids: dict[str, None] = {}
         self._done_async_sfqids: dict[str, None] = {}
-        self.telemetry_enabled = False
+        self._client_param_telemetry_enabled = True
+        self._server_param_telemetry_enabled = False
         self._session_parameters: dict[str, str | int | bool] = {}
         logger.info(
             "Snowflake Connector for Python Version: %s, "
@@ -626,11 +625,22 @@ class SnowflakeConnection:
 
     @property
     def telemetry_enabled(self) -> bool:
-        return self._telemetry_enabled
+        return bool(
+            self._client_param_telemetry_enabled
+            and self._server_param_telemetry_enabled
+        )
 
     @telemetry_enabled.setter
     def telemetry_enabled(self, value) -> None:
-        self._telemetry_enabled = True if value else False
+        self._client_param_telemetry_enabled = True if value else False
+        if (
+            self._client_param_telemetry_enabled
+            and not self._server_param_telemetry_enabled
+        ):
+            logger.info(
+                "Telemetry has been disabled by the session parameter CLIENT_TELEMETRY_ENABLED."
+                " Set session parameter CLIENT_TELEMETRY_ENABLED to true to enable telemetry."
+            )
 
     @property
     def service_name(self) -> str | None:
@@ -720,7 +730,6 @@ class SnowflakeConnection:
         logger.debug("connect")
         if len(kwargs) > 0:
             self.__config(**kwargs)
-            TelemetryService.get_instance().update_context(kwargs)
 
         if self.enable_connection_diag:
             exceptions_dict = {}
@@ -777,7 +786,7 @@ class SnowflakeConnection:
 
             # close telemetry first, since it needs rest to send remaining data
             logger.info("closed")
-            self._telemetry.close(send_on_close=retry)
+            self._telemetry.close(send_on_close=bool(retry and self.telemetry_enabled))
             if (
                 self._all_async_queries_finished()
                 and not self._server_session_keep_alive
@@ -1009,7 +1018,7 @@ class SnowflakeConnection:
             elif self._authenticator == DEFAULT_AUTHENTICATOR:
                 self.auth_class = AuthByDefault(
                     password=self._password,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             elif self._authenticator == EXTERNAL_BROWSER_AUTHENTICATOR:
@@ -1029,7 +1038,7 @@ class SnowflakeConnection:
                         protocol=self._protocol,
                         host=self.host,
                         port=self.port,
-                        timeout=self._login_timeout,
+                        timeout=self.login_timeout,
                         backoff_generator=self._backoff_generator,
                     )
                 else:
@@ -1039,7 +1048,7 @@ class SnowflakeConnection:
                         protocol=self._protocol,
                         host=self.host,
                         port=self.port,
-                        timeout=self._login_timeout,
+                        timeout=self.login_timeout,
                         backoff_generator=self._backoff_generator,
                     )
 
@@ -1054,13 +1063,13 @@ class SnowflakeConnection:
 
                 self.auth_class = AuthByKeyPair(
                     private_key=private_key,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             elif self._authenticator == OAUTH_AUTHENTICATOR:
                 self.auth_class = AuthByOAuth(
                     oauth_token=self._token,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             elif self._authenticator == USR_PWD_MFA_AUTHENTICATOR:
@@ -1076,14 +1085,14 @@ class SnowflakeConnection:
                 self.auth_class = AuthByUsrPwdMfa(
                     password=self._password,
                     mfa_token=self.rest.mfa_token,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
             else:
                 # okta URL, e.g., https://<account>.okta.com/
                 self.auth_class = AuthByOkta(
                     application=self.application,
-                    timeout=self._login_timeout,
+                    timeout=self.login_timeout,
                     backoff_generator=self._backoff_generator,
                 )
 
@@ -1717,12 +1726,7 @@ class SnowflakeConnection:
         for name, value in parameters.items():
             self._session_parameters[name] = value
             if PARAMETER_CLIENT_TELEMETRY_ENABLED == name:
-                self.telemetry_enabled = value
-            elif PARAMETER_CLIENT_TELEMETRY_OOB_ENABLED == name:
-                if value:
-                    TelemetryService.get_instance().enable()
-                else:
-                    TelemetryService.get_instance().disable()
+                self._server_param_telemetry_enabled = value
             elif PARAMETER_CLIENT_SESSION_KEEP_ALIVE == name:
                 # Only set if the local config is None.
                 # Always give preference to user config.
@@ -1813,6 +1817,39 @@ class SnowflakeConnection:
         with suppress(Exception):
             self.close(retry=False)
 
+    def _process_error_query_status(
+        self,
+        sf_qid: str,
+        status_resp: dict,
+        error_message: str = "",
+        error_cls: type[Exception] = ProgrammingError,
+    ) -> None:
+        status_resp = status_resp or {}
+        data = status_resp.get("data", {})
+        queries = data.get("queries")
+
+        if sf_qid in self._async_sfqids:
+            self._async_sfqids.pop(sf_qid, None)
+        message = status_resp.get("message")
+        if message is None:
+            message = ""
+        code = queries[0].get("errorCode", -1) if queries else -1
+        sql_state = None
+        if "data" in status_resp:
+            message += queries[0].get("errorMessage", "") if queries else ""
+            sql_state = data.get("sqlState")
+        Error.errorhandler_wrapper(
+            self,
+            None,
+            error_cls,
+            {
+                "msg": message or error_message,
+                "errno": int(code),
+                "sqlstate": sql_state,
+                "sfqid": sf_qid,
+            },
+        )
+
     def get_query_status(self, sf_qid: str) -> QueryStatus:
         """Retrieves the status of query with sf_qid.
 
@@ -1841,31 +1878,8 @@ class SnowflakeConnection:
         """
         status, status_resp = self._get_query_status(sf_qid)
         self._cache_query_status(sf_qid, status)
-        queries = status_resp["data"]["queries"]
         if self.is_an_error(status):
-            if sf_qid in self._async_sfqids:
-                self._async_sfqids.pop(sf_qid, None)
-            message = status_resp.get("message")
-            if message is None:
-                message = ""
-            code = queries[0].get("errorCode", -1)
-            sql_state = None
-            if "data" in status_resp:
-                message += (
-                    queries[0].get("errorMessage", "") if len(queries) > 0 else ""
-                )
-                sql_state = status_resp["data"].get("sqlState")
-            Error.errorhandler_wrapper(
-                self,
-                None,
-                ProgrammingError,
-                {
-                    "msg": message,
-                    "errno": int(code),
-                    "sqlstate": sql_state,
-                    "sfqid": sf_qid,
-                },
-            )
+            self._process_error_query_status(sf_qid, status_resp)
         return status
 
     def initialize_query_context_cache(self) -> None:

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/cursor.py

@@ -1638,7 +1638,8 @@ class SnowflakeCursor:
             no_data_counter = 0
             retry_pattern_pos = 0
             while True:
-                status = self.connection.get_query_status(sfqid)
+                status, status_resp = self.connection._get_query_status(sfqid)
+                self.connection._cache_query_status(sfqid, status)
                 if not self.connection.is_still_running(status):
                     break
                 if status == QueryStatus.NO_DATA:  # pragma: no cover
@@ -1655,10 +1656,12 @@ class SnowflakeCursor:
                 if retry_pattern_pos < (len(ASYNC_RETRY_PATTERN) - 1):
                     retry_pattern_pos += 1
             if status != QueryStatus.SUCCESS:
-                raise DatabaseError(
-                    "Status of query '{}' is {}, results are unavailable".format(
-                        sfqid, status.name
-                    )
+                logger.info(f"Status of query '{sfqid}' is {status.name}")
+                self.connection._process_error_query_status(
+                    sfqid,
+                    status_resp,
+                    error_message=f"Status of query '{sfqid}' is {status.name}, results are unavailable",
+                    error_cls=DatabaseError,
                 )
             self._inner_cursor.execute(f"select * from table(result_scan('{sfqid}'))")
             self._result = self._inner_cursor._result

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/errors.py

@@ -15,7 +15,6 @@ from typing import TYPE_CHECKING, Any
 from .compat import BASE_EXCEPTION_CLASS
 from .secret_detector import SecretDetector
 from .telemetry import TelemetryData, TelemetryField
-from .telemetry_oob import TelemetryService
 from .time_util import get_time_millis
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -167,11 +166,6 @@ class Error(BASE_EXCEPTION_CLASS):
                 )
             except AttributeError:
                 logger.debug("Cursor failed to log to telemetry.", exc_info=True)
-        elif connection is None:
-            # Send with out-of-band telemetry
-
-            telemetry_oob = TelemetryService.get_instance()
-            telemetry_oob.log_general_exception(self.__class__.__name__, telemetry_data)
 
     def exception_telemetry(
         self,

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/network.py

@@ -13,7 +13,6 @@ import json
 import logging
 import re
 import time
-import traceback
 import uuid
 from collections import OrderedDict
 from threading import Lock
@@ -92,9 +91,7 @@ from .sqlstate import (
     SQLSTATE_CONNECTION_NOT_EXISTS,
     SQLSTATE_CONNECTION_REJECTED,
     SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED,
-    SQLSTATE_IO_ERROR,
 )
-from .telemetry_oob import TelemetryService
 from .time_util import (
     DEFAULT_MASTER_VALIDITY_IN_SECONDS,
     TimeoutBackoffCtx,
@@ -230,14 +227,6 @@ def raise_failed_request_error(
     method: str,
     response: Response,
 ) -> None:
-    TelemetryService.get_instance().log_http_request_error(
-        f"HttpError{response.status_code}",
-        url,
-        method,
-        SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED,
-        ER_FAILED_TO_REQUEST,
-        response=response,
-    )
     Error.errorhandler_wrapper(
         connection,
         None,
@@ -568,7 +557,7 @@ class SnowflakeRestful:
             token=header_token,
         )
         if ret.get("success") and ret.get("data", {}).get("sessionToken"):
-            logger.debug("success: %s", ret)
+            logger.debug("success: %s", SecretDetector.mask_secrets(str(ret)))
             self.update_tokens(
                 ret["data"]["sessionToken"],
                 ret["data"].get("masterToken"),
@@ -577,7 +566,7 @@ class SnowflakeRestful:
             logger.debug("updating session completed")
             return ret
         else:
-            logger.debug("failed: %s", ret)
+            logger.debug("failed: %s", SecretDetector.mask_secrets(str(ret)))
             err = ret.get("message")
             if err is not None and ret.get("data"):
                 err += ret["data"].get("errorMessage", "")
@@ -690,6 +679,7 @@ class SnowflakeRestful:
         headers: dict[str, str],
         token: str = None,
         timeout: int | None = None,
+        is_fetch_query_status: bool = False,
     ) -> dict[str, Any]:
         if "Content-Encoding" in headers:
             del headers["Content-Encoding"]
@@ -703,6 +693,7 @@ class SnowflakeRestful:
             headers,
             timeout=timeout,
             token=token,
+            is_fetch_query_status=is_fetch_query_status,
         )
         if ret.get("code") == SESSION_EXPIRED_GS_CODE:
             try:
@@ -717,7 +708,12 @@ class SnowflakeRestful:
                 )
             )
             if ret.get("success"):
-                return self._get_request(url, headers, token=self.token)
+                return self._get_request(
+                    url,
+                    headers,
+                    token=self.token,
+                    is_fetch_query_status=is_fetch_query_status,
+                )
 
         return ret
 
@@ -790,7 +786,13 @@ class SnowflakeRestful:
             result_url = ret["data"]["getResultUrl"]
             logger.debug("ping pong starting...")
             ret = self._get_request(
-                result_url, headers, token=self.token, timeout=timeout
+                result_url,
+                headers,
+                token=self.token,
+                timeout=timeout,
+                is_fetch_query_status=bool(
+                    re.match(r"^/queries/.+/result$", result_url)
+                ),
             )
             logger.debug("ret[code] = %s", ret.get("code", "N/A"))
             logger.debug("ping pong done")
@@ -889,6 +891,15 @@ class SnowflakeRestful:
 
         full_url = retry_ctx.add_retry_params(full_url)
         full_url = SnowflakeRestful.add_request_guid(full_url)
+        is_fetch_query_status = kwargs.pop("is_fetch_query_status", False)
+        # raise_raw_http_failure is not a public parameter and may change in the future
+        # it enables raising raw http errors that are not handled by
+        # connector, connector handles the following http error:
+        #  1. FORBIDDEN error when trying to login
+        #  2. retryable http code defined in method is_retryable_http_code
+        #  3. UNAUTHORIZED error when using okta authentication
+        # raise_raw_http_failure doesn't work for the 3 mentioned cases.
+        raise_raw_http_failure = kwargs.pop("raise_raw_http_failure", False)
         try:
             return_object = self._request_exec(
                 session=session,
@@ -897,37 +908,18 @@ class SnowflakeRestful:
                 headers=headers,
                 data=data,
                 token=token,
+                raise_raw_http_failure=raise_raw_http_failure,
                 **kwargs,
             )
             if return_object is not None:
                 return return_object
+            if is_fetch_query_status:
+                err_msg = "fetch query status failed and http request returned None, this is usually caused by transient network failures, retrying..."
+                logger.info(err_msg)
+                raise RetryRequest(err_msg)
             self._handle_unknown_error(method, full_url, headers, data, conn)
-            TelemetryService.get_instance().log_http_request_error(
-                "HttpRequestUnknownError",
-                full_url,
-                method,
-                SQLSTATE_IO_ERROR,
-                ER_FAILED_TO_REQUEST,
-                retry_timeout=retry_ctx.timeout,
-                retry_count=retry_ctx.current_retry_count,
-            )
             return {}
         except RetryRequest as e:
-            if (
-                retry_ctx.current_retry_count
-                == TelemetryService.get_instance().num_of_retry_to_trigger_telemetry
-            ):
-                TelemetryService.get_instance().log_http_request_error(
-                    "HttpRequestRetry%dTimes" % retry_ctx.current_retry_count,
-                    full_url,
-                    method,
-                    SQLSTATE_IO_ERROR,
-                    ER_FAILED_TO_REQUEST,
-                    retry_timeout=retry_ctx.timeout,
-                    retry_count=retry_ctx.current_retry_count,
-                    exception=str(e),
-                    stack_trace=traceback.format_exc(),
-                )
             cause = e.args[0]
             if no_retry:
                 self.log_and_handle_http_error_with_cause(
@@ -984,7 +976,9 @@ class SnowflakeRestful:
                     )
             return None  # retry
         except Exception as e:
-            if not no_retry:
+            if (
+                raise_raw_http_failure and isinstance(e, requests.exceptions.HTTPError)
+            ) or not no_retry:
                 raise e
             logger.debug("Ignored error", exc_info=True)
             return {}
@@ -1001,17 +995,6 @@ class SnowflakeRestful:
     ) -> None:
         cause = e.args[0]
         logger.error(cause, exc_info=True)
-        TelemetryService.get_instance().log_http_request_error(
-            "HttpRequestRetryTimeout" if timed_out else f"HttpRequestError: {cause}",
-            full_url,
-            method,
-            SQLSTATE_IO_ERROR,
-            ER_FAILED_TO_REQUEST,
-            retry_timeout=retry_timeout,
-            retry_count=retry_count,
-            exception=str(e),
-            stack_trace=traceback.format_exc(),
-        )
         if isinstance(cause, Error):
             Error.errorhandler_wrapper_from_cause(conn, cause)
         else:
@@ -1064,6 +1047,7 @@ class SnowflakeRestful:
         binary_data_handler=None,
         socket_timeout: int | None = None,
         is_okta_authentication: bool = False,
+        raise_raw_http_failure: bool = False,
     ):
         if socket_timeout is None:
             if self._connection.socket_timeout is not None:
@@ -1141,6 +1125,8 @@ class SnowflakeRestful:
                     raise_okta_unauthorized_error(self._connection, raw_ret)
                     return None  # required for tests
                 else:
+                    if raise_raw_http_failure:
+                        raw_ret.raise_for_status()
                     raise_failed_request_error(
                         self._connection, full_url, method, raw_ret
                     )
@@ -1149,15 +1135,6 @@ class SnowflakeRestful:
                 raw_ret.close()  # ensure response is closed
         except SSLError as se:
             logger.debug("Hit non-retryable SSL error, %s", str(se))
-            TelemetryService.get_instance().log_http_request_error(
-                "CertificateException%s" % str(se),
-                full_url,
-                method,
-                SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED,
-                ER_FAILED_TO_REQUEST,
-                exception=se,
-                stack_trace=traceback.format_exc(),
-            )
 
         except (
             BadStatusLine,
@@ -1190,15 +1167,6 @@ class SnowflakeRestful:
                 )
                 raise RetryRequest(err)
         except Exception as err:
-            TelemetryService.get_instance().log_http_request_error(
-                "HttpException%s" % str(err),
-                full_url,
-                method,
-                SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED,
-                ER_FAILED_TO_REQUEST,
-                exception=err,
-                stack_trace=traceback.format_exc(),
-            )
             raise err
 
     def make_requests_session(self) -> Session:

{snowflake_connector_python-3.12.0 → snowflake_connector_python-3.12.2}/src/snowflake/connector/ocsp_snowflake.py

@@ -13,7 +13,6 @@ import re
 import sys
 import tempfile
 import time
-import traceback
 from base64 import b64decode, b64encode
 from datetime import datetime, timezone
 from logging import getLogger
@@ -56,7 +55,6 @@ from snowflake.connector.errorcode import (
 )
 from snowflake.connector.errors import RevocationCheckError
 from snowflake.connector.network import PYTHON_CONNECTOR_USER_AGENT
-from snowflake.connector.telemetry_oob import TelemetryService
 
 from . import constants
 from .backoff_policies import exponential_backoff
@@ -250,15 +248,6 @@ class OCSPTelemetryData:
             is_oob_telemetry=True,
         )
 
-        telemetry_client = TelemetryService.get_instance()
-        telemetry_client.log_ocsp_exception(
-            event_type,
-            telemetry_data,
-            exception=str(exception),
-            stack_trace=traceback.format_exc(),
-            urgent=urgent,
-        )
-
         return telemetry_data
         # To be updated once Python Driver has out of band telemetry.
         # telemetry_client = TelemetryClient()
@@ -1087,7 +1076,7 @@ class SnowflakeOCSP:
             "responder. Details:"
         )
         ocsp_warning = f"{static_warning} \n {ocsp_log}"
-        logger.error(ocsp_warning)
+        logger.warning(ocsp_warning)
 
     def validate_by_direct_connection(
         self,