remove unused logs

Signed-off-by: Nikhil Suri <[email protected]>

Author: nikhilsuri-db

src/databricks/sql/client.py

@@ -320,9 +320,7 @@ def read(self) -> Optional[OAuthToken]:
         )
 
         self.force_enable_telemetry = kwargs.get("force_enable_telemetry", False)
-        self.enable_telemetry = kwargs.get(
-            "enable_telemetry", True
-        )  # Default to True for telemetry
+        self.enable_telemetry = kwargs.get("enable_telemetry", False)
         self.telemetry_enabled = TelemetryHelper.is_telemetry_enabled(self)
 
         TelemetryClientFactory.initialize_telemetry_client(

src/databricks/sql/common/feature_flag.py

@@ -106,48 +106,28 @@ def get_flag_value(self, name: str, default_value: Any) -> Any:
 
     def _refresh_flags(self):
         """Performs a synchronous network request to fetch and update flags."""
-        import logging
-
-        logger = logging.getLogger(__name__)
-
         headers = {}
         try:
             # Authenticate the request
             self._connection.session.auth_provider.add_headers(headers)
             headers["User-Agent"] = self._connection.session.useragent_header
 
-            logger.info(
-                f"Feature Flags: Sending GET request to endpoint: {self._feature_flag_endpoint}"
-            )
             response = self._http_client.request(
                 HttpMethod.GET, self._feature_flag_endpoint, headers=headers, timeout=30
             )
 
-            logger.info(f"Feature Flags: HTTP Response status code: {response.status}")
-
             if response.status == 200:
                 # Parse JSON response from urllib3 response data
                 response_data = json.loads(response.data.decode())
-                logger.info(
-                    f"Feature Flags: ✓ SUCCESS - Received {len(response_data.get('flags', []))} flags from server"
-                )
-                logger.info(f"Feature Flags: Response data: {response_data}")
                 ff_response = FeatureFlagsResponse.from_dict(response_data)
                 self._update_cache_from_response(ff_response)
-                logger.info(f"Feature Flags: Loaded into cache: {self._flags}")
             else:
                 # On failure, initialize with an empty dictionary to prevent re-blocking.
-                logger.info(
-                    f"Feature Flags: ✗ FAILED - Non-200 status code {response.status}, using empty flags"
-                )
                 if self._flags is None:
                     self._flags = {}
 
         except Exception as e:
             # On exception, initialize with an empty dictionary to prevent re-blocking.
-            logger.info(
-                f"Feature Flags: ✗ EXCEPTION - {type(e).__name__}: {e}, using empty flags"
-            )
             if self._flags is None:
                 self._flags = {}
 

src/databricks/sql/telemetry/telemetry_client.py

@@ -110,48 +110,15 @@ def get_auth_flow(auth_provider):
     @staticmethod
     def is_telemetry_enabled(connection: "Connection") -> bool:
         if connection.force_enable_telemetry:
-            logger.info("Telemetry: force_enable_telemetry=True, telemetry ENABLED")
             return True
 
         if connection.enable_telemetry:
-            from databricks.sql import __version__
-
-            endpoint = f"https://{connection.session.host}/api/2.0/connector-service/feature-flags/PYTHON/{__version__}"
-            logger.info(
-                f"Telemetry: enable_telemetry=True, checking server-side feature flag"
-            )
-            logger.info(f"Telemetry: Feature flag endpoint: {endpoint}")
-            logger.info(
-                f"Telemetry: Looking for flag: {TelemetryHelper.TELEMETRY_FEATURE_FLAG_NAME}"
+            context = FeatureFlagsContextFactory.get_instance(connection)
+            flag_value = context.get_flag_value(
+                TelemetryHelper.TELEMETRY_FEATURE_FLAG_NAME, default_value=False
             )
-
-            try:
-                context = FeatureFlagsContextFactory.get_instance(connection)
-                flag_value = context.get_flag_value(
-                    TelemetryHelper.TELEMETRY_FEATURE_FLAG_NAME, default_value=False
-                )
-                logger.info(
-                    f"Telemetry: Feature flag fetch SUCCESS - received value: '{flag_value}'"
-                )
-
-                enabled = str(flag_value).lower() == "true"
-                if enabled:
-                    logger.info(
-                        f"Telemetry: ✓ Server flag is 'true', telemetry ENABLED"
-                    )
-                else:
-                    logger.info(
-                        f"Telemetry: ✗ Server flag is '{flag_value}' (not 'true'), telemetry DISABLED"
-                    )
-                return enabled
-            except Exception as e:
-                logger.info(
-                    f"Telemetry: Feature flag fetch FAILED with exception: {type(e).__name__}: {e}"
-                )
-                logger.info("Telemetry: Defaulting to DISABLED due to fetch failure")
-                return False
+            return str(flag_value).lower() == "true"
         else:
-            logger.info("Telemetry: enable_telemetry=False, telemetry DISABLED")
             return False
 
 
@@ -224,14 +191,13 @@ def __init__(
 
     def _export_event(self, event):
         """Add an event to the batch queue and flush if batch is full"""
-        logger.info(f"Exporting telemetry event for connection {self._session_id_hex}")
+        logger.debug("Exporting event for connection %s", self._session_id_hex)
         with self._lock:
             self._events_batch.append(event)
-        logger.info(
-            f"Event added to batch, batch size now: {len(self._events_batch)}/{self._batch_size}"
-        )
         if len(self._events_batch) >= self._batch_size:
-            logger.info(f"Batch size reached ({self._batch_size}), flushing events")
+            logger.debug(
+                "Batch size limit reached (%s), flushing events", self._batch_size
+            )
             self._flush()
 
     def _flush(self):
@@ -499,8 +465,9 @@ def initialize_telemetry_client(
                 TelemetryClientFactory._initialize()
 
                 if session_id_hex not in TelemetryClientFactory._clients:
-                    logger.info(
-                        f"Creating telemetry client for connection {session_id_hex}, telemetry_enabled={telemetry_enabled}"
+                    logger.debug(
+                        "Creating new TelemetryClient for connection %s",
+                        session_id_hex,
                     )
                     if telemetry_enabled:
                         TelemetryClientFactory._clients[
@@ -514,25 +481,14 @@ def initialize_telemetry_client(
                             batch_size=batch_size,
                             client_context=client_context,
                         )
-                        logger.info(
-                            f"Created TelemetryClient for connection {session_id_hex}"
-                        )
                     else:
                         TelemetryClientFactory._clients[
                             session_id_hex
                         ] = NoopTelemetryClient()
-                        logger.info(
-                            f"Created NoopTelemetryClient for connection {session_id_hex}"
-                        )
         except Exception as e:
-            logger.info(
-                f"Failed to initialize telemetry client: {type(e).__name__}: {e}"
-            )
+            logger.debug("Failed to initialize telemetry client: %s", e)
             # Fallback to NoopTelemetryClient to ensure connection doesn't fail
             TelemetryClientFactory._clients[session_id_hex] = NoopTelemetryClient()
-            logger.info(
-                f"Fallback to NoopTelemetryClient for connection {session_id_hex}"
-            )
 
     @staticmethod
     def get_telemetry_client(session_id_hex):