e6data-python-connector 2.3.10rc3__tar.gz → 2.3.10rc5__tar.gz

{e6data_python_connector-2.3.10rc3/e6data_python_connector.egg-info → e6data_python_connector-2.3.10rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.10rc3
+Version: 2.3.10rc5
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.10,rc3-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.10,rc5-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.10rc3 → e6data_python_connector-2.3.10rc5}/README.md

@@ -1,6 +1,6 @@
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.10,rc3-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.10,rc5-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.10rc3 → e6data_python_connector-2.3.10rc5}/e6data_python_connector/e6data_grpc.py

@@ -10,6 +10,7 @@ import datetime
 import re
 import sys
 import time
+import uuid
 from decimal import Decimal
 from io import BytesIO
 from ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
@@ -80,10 +81,12 @@ def re_auth(func):
                 if current_retry == max_retry:
                     raise e
                 if e.code() == grpc.StatusCode.INTERNAL and 'Access denied' in e.details():
+                    _logger.debug(f'Re-authenticating due to {e}')
                     time.sleep(0.2)
                     self.connection.get_re_authenticate_session_id()
                 elif 'status: 456' in e.details():
                     # Strategy changed, clear cache and retry
+                    _logger.debug(f'Re-authenticating due to status: 456')
                     _clear_strategy_cache()
                     # Force re-authentication which will detect new strategy
                     self.connection.get_re_authenticate_session_id()
@@ -133,10 +136,15 @@ STRATEGY_CACHE_TIMEOUT = 300
 # Global set to track debug-enabled connections
 _debug_connections = set()
 
-def _strategy_debug_log(message):
+def _generate_trace_id():
+    """Generate a unique trace ID for tracking requests across a session."""
+    return str(uuid.uuid4())[:8]  # Use first 8 characters for readability
+
+def _strategy_debug_log(message, trace_id=None):
     """Log strategy debug messages if any connection has debug enabled."""
     if _debug_connections:
-        _logger.debug(f"[E6DATA_STRATEGY_DEBUG] {time.strftime('%Y-%m-%d %H:%M:%S')} - {message}")
+        trace_info = f"[{trace_id}] " if trace_id else ""
+        _logger.debug(f"[E6DATA_STRATEGY_DEBUG] {time.strftime('%Y-%m-%d %H:%M:%S')} - {trace_info}{message}")
 
 
 def _get_shared_strategy():
@@ -302,10 +310,18 @@ def _get_strategy_debug_info():
         }
 
 
-def _get_grpc_header(engine_ip=None, cluster=None, strategy=None):
+def _get_grpc_header(engine_ip=None, cluster=None, strategy=None, session_id=None, request_type=None, trace_id=None):
     """Generate gRPC metadata headers for the request."""
     # Use the strategy module's implementation
-    return _get_strategy_header(engine_ip=engine_ip, cluster=cluster, strategy=strategy)
+    headers = _get_strategy_header(engine_ip=engine_ip, cluster=cluster, strategy=strategy)
+    
+    # Log headers being sent if debug connections exist
+    if _debug_connections:
+        session_info = f", session: {session_id}" if session_id else ""
+        request_info = f" [{request_type}]" if request_type else ""
+        _strategy_debug_log(f"Sending headers{request_info}: strategy={strategy}, cluster={cluster}, engine_ip={engine_ip}{session_info}", trace_id)
+    
+    return headers
 
 
 def connect(*args, **kwargs):
@@ -377,6 +393,7 @@ class Connection(object):
         self.cluster_name = cluster_name
         self._session_id = None
         self._session_strategy = None  # Track which strategy was used for current session
+        self._trace_id = _generate_trace_id()  # Generate trace ID for this connection
         self._host = host
         self._port = port
 
@@ -401,7 +418,7 @@ class Connection(object):
         self._debug = debug
         if self._debug:
             _debug_connections.add(id(self))
-            _strategy_debug_log(f"Debug mode enabled for connection {id(self)}")
+            _strategy_debug_log(f"Debug mode enabled for connection {id(self)}", self._trace_id)
         
         self._create_client()
 
@@ -520,11 +537,11 @@ class Connection(object):
         # Check if session strategy matches current active strategy
         elif self._session_id and self._session_strategy and self._session_strategy != _get_active_strategy():
             # Session was created with different strategy, need to re-authenticate
-            _strategy_debug_log(f"Session strategy mismatch: session {self._session_id} created with {self._session_strategy}, current active is {_get_active_strategy()}")
+            _strategy_debug_log(f"Session strategy mismatch: session {self._session_id} created with {self._session_strategy}, current active is {_get_active_strategy()}", self._trace_id)
             old_session_id = self._session_id
             self._session_id = None
             self._session_strategy = None
-            _strategy_debug_log(f"Invalidating session {old_session_id} due to strategy mismatch")
+            _strategy_debug_log(f"Invalidating session {old_session_id} due to strategy mismatch", self._trace_id)
             self.close()
             self._create_client()
 
@@ -542,18 +559,22 @@ class Connection(object):
 
                 if active_strategy and not pending_strategy:
                     # Use cached strategy only if there's no pending strategy
-                    _strategy_debug_log(f"Authenticating with cached strategy: {active_strategy} (session: {self._session_id})")
+                    _strategy_debug_log(f"Authenticating with cached strategy: {active_strategy} (session: {self._session_id})", self._trace_id)
                     try:
                         authenticate_response = self._client.authenticate(
                             authenticate_request,
-                            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=active_strategy)
+                            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=active_strategy, 
+                                                    session_id=self._session_id, request_type="authenticate", trace_id=self._trace_id)
                         )
                         self._session_id = authenticate_response.sessionId
                         if not self._session_id:
                             raise ValueError("Invalid credentials.")
                         # Track which strategy was used for this session
                         self._session_strategy = active_strategy
-                        _strategy_debug_log(f"Authentication successful with strategy: {active_strategy}, session: {self._session_id}")
+                        # Generate new trace ID for this authenticated session
+                        old_trace_id = self._trace_id
+                        self._trace_id = _generate_trace_id()
+                        _strategy_debug_log(f"Authentication successful with strategy: {active_strategy}, session: {self._session_id}, new trace: {self._trace_id} (was: {old_trace_id})", self._trace_id)
                         # Check for new strategy in authenticate response
                         if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                             new_strategy = authenticate_response.new_strategy.lower()
@@ -593,19 +614,23 @@ class Connection(object):
                         _strategy_debug_log(f"No cached strategy, will try strategies in order: {strategies}")
                     last_error = None
                     for strategy in strategies:
-                        _strategy_debug_log(f"Attempting authentication with strategy: {strategy} (no session yet)")
+                        _strategy_debug_log(f"Attempting authentication with strategy: {strategy} (no session yet)", self._trace_id)
                         try:
                             authenticate_response = self._client.authenticate(
                                 authenticate_request,
-                                metadata=_get_grpc_header(cluster=self.cluster_name, strategy=strategy)
+                                metadata=_get_grpc_header(cluster=self.cluster_name, strategy=strategy, 
+                                                        session_id=None, request_type="authenticate", trace_id=self._trace_id)
                             )
                             self._session_id = authenticate_response.sessionId
                             if self._session_id:
                                 # Success! Cache this strategy
-                                _strategy_debug_log(f"Authentication successful with strategy: {strategy}, session: {self._session_id}")
                                 _set_active_strategy(strategy)
                                 # Track which strategy was used for this session
                                 self._session_strategy = strategy
+                                # Generate new trace ID for this authenticated session
+                                old_trace_id = self._trace_id
+                                self._trace_id = _generate_trace_id()
+                                _strategy_debug_log(f"Authentication successful with strategy: {strategy}, session: {self._session_id}, new trace: {self._trace_id} (was: {old_trace_id})", self._trace_id)
 
                                 # Check for new strategy in authenticate response
                                 if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
@@ -694,6 +719,7 @@ class Connection(object):
         This method ensures that the gRPC channel is properly closed and the session ID is reset to None.
         """
         old_session = self._session_id
+        old_trace_id = self._trace_id
         if self._channel is not None:
             self._channel.close()
             self._channel = None
@@ -704,7 +730,10 @@ class Connection(object):
         if self._debug:
             _debug_connections.discard(id(self))
             session_info = f", session was: {old_session}" if old_session else ""
-            _strategy_debug_log(f"Debug mode disabled for connection {id(self)}{session_info}")
+            _strategy_debug_log(f"Debug mode disabled for connection {id(self)}{session_info}, trace: {old_trace_id}", old_trace_id)
+        
+        # Reset trace ID to None after connection close
+        self._trace_id = None
 
     def check_connection(self):
         """
@@ -767,7 +796,8 @@ class Connection(object):
         )
         clear_response = self._client.clear(
             clear_request,
-            metadata=_get_grpc_header(engine_ip=engine_ip, cluster=self.cluster_name, strategy=_get_active_strategy())
+            metadata=_get_grpc_header(engine_ip=engine_ip, cluster=self.cluster_name, strategy=_get_active_strategy(),
+                                    session_id=self.connection.get_session_id, request_type="clear", trace_id=self.connection._trace_id)
         )
 
         # Check for new strategy in clear response
@@ -798,7 +828,8 @@ class Connection(object):
         )
         cancel_response = self._client.cancelQuery(
             cancel_query_request,
-            metadata=_get_grpc_header(engine_ip=engine_ip, cluster=self.cluster_name, strategy=_get_active_strategy())
+            metadata=_get_grpc_header(engine_ip=engine_ip, cluster=self.cluster_name, strategy=_get_active_strategy(),
+                                    session_id=self._session_id, request_type="query_cancel", trace_id=self._trace_id)
         )
 
         # Check for new strategy in cancel response
@@ -822,7 +853,8 @@ class Connection(object):
         )
         dry_run_response = self._client.dryRun(
             dry_run_request,
-            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy())
+            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy(),
+                                    session_id=self.get_session_id, request_type="dry_run", trace_id=self._trace_id)
         )
         return dry_run_response.dryrunValue
 
@@ -844,7 +876,8 @@ class Connection(object):
         )
         get_table_response = self._client.getTablesV2(
             get_table_request,
-            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy())
+            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy(),
+                                    session_id=self.get_session_id, request_type="get_tables", trace_id=self._trace_id)
         )
 
         # Check for new strategy in get tables response
@@ -872,7 +905,8 @@ class Connection(object):
         )
         get_columns_response = self._client.getColumnsV2(
             get_columns_request,
-            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy())
+            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy(),
+                                    session_id=self.get_session_id, request_type="get_columns", trace_id=self._trace_id)
         )
 
         # Check for new strategy in get columns response
@@ -896,7 +930,8 @@ class Connection(object):
         )
         get_schema_response = self._client.getSchemaNamesV2(
             get_schema_request,
-            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy())
+            metadata=_get_grpc_header(cluster=self.cluster_name, strategy=_get_active_strategy(),
+                                    session_id=self.get_session_id, request_type="get_schema", trace_id=self._trace_id)
         )
 
         # Check for new strategy in get schema names response
@@ -983,10 +1018,12 @@ class Cursor(DBAPICursor):
         """Reset state about the previous query in preparation for running another query"""
         pass
 
-    @property
-    def metadata(self):
+    def _get_metadata(self, request_type="query_operation"):
         """
-        Get the gRPC metadata for the current query.
+        Get the gRPC metadata for the current query with specific request type.
+
+        Args:
+            request_type (str): The type of request being made
 
         Returns:
             list: A list of tuples containing gRPC metadata.
@@ -999,7 +1036,18 @@ class Cursor(DBAPICursor):
             strategy = self.connection._session_strategy
         else:
             strategy = _get_active_strategy()
-        return _get_grpc_header(engine_ip=self._engine_ip, cluster=self.connection.cluster_name, strategy=strategy)
+        return _get_grpc_header(engine_ip=self._engine_ip, cluster=self.connection.cluster_name, strategy=strategy,
+                               session_id=self.connection.get_session_id, request_type=request_type, trace_id=self.connection._trace_id)
+
+    @property
+    def metadata(self):
+        """
+        Get the gRPC metadata for the current query.
+
+        Returns:
+            list: A list of tuples containing gRPC metadata.
+        """
+        return self._get_metadata("query_operation")
 
     @property
     def arraysize(self):
@@ -1141,7 +1189,7 @@ class Cursor(DBAPICursor):
         )
         # Get fresh client after session access (may have been invalidated)
         client = self.connection.client
-        clear_response = client.clearOrCancelQuery(clear_request, metadata=self.metadata)
+        clear_response = client.clearOrCancelQuery(clear_request, metadata=self._get_metadata("clear_or_cancel"))
 
         # Check for new strategy in clear response
         if hasattr(clear_response, 'new_strategy') and clear_response.new_strategy:
@@ -1199,7 +1247,7 @@ class Cursor(DBAPICursor):
             queryId=query_id,
             engineIP=self._engine_ip
         )
-        status_response = self.connection.client.status(status_request, metadata=self.metadata)
+        status_response = self.connection.client.status(status_request, metadata=self._get_metadata("status"))
 
         # Check for new strategy in status response
         if hasattr(status_response, 'new_strategy') and status_response.new_strategy:
@@ -1240,7 +1288,7 @@ class Cursor(DBAPICursor):
             client = self.connection.client
             prepare_statement_response = client.prepareStatement(
                 prepare_statement_request,
-                metadata=self.metadata
+                metadata=self._get_metadata("prepare_statement")
             )
 
             self._query_id = prepare_statement_response.queryId
@@ -1266,7 +1314,7 @@ class Cursor(DBAPICursor):
             client = self.connection.client
             execute_response = client.executeStatement(
                 execute_statement_request,
-                metadata=self.metadata
+                metadata=self._get_metadata("execute_statement")
             )
 
             # Check for new strategy in execute response
@@ -1285,7 +1333,7 @@ class Cursor(DBAPICursor):
             client = self.connection.client
             prepare_statement_response = client.prepareStatementV2(
                 prepare_statement_request,
-                metadata=self.metadata,
+                metadata=self._get_metadata("prepare_statement_v2"),
                 timeout=self.connection.grpc_prepare_timeout
             )
 
@@ -1313,7 +1361,7 @@ class Cursor(DBAPICursor):
             client = self.connection.client
             execute_response = client.executeStatementV2(
                 execute_statement_request,
-                metadata=self.metadata
+                metadata=self._get_metadata("execute_statement_v2")
             )
 
             # Check for new strategy in execute response

{e6data_python_connector-2.3.10rc3 → e6data_python_connector-2.3.10rc5/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.3.10rc3
+Version: 2.3.10rc5
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.3.10,rc3-blue.svg)
+![version](https://img.shields.io/badge/version-2.3.10,rc5-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.3.10rc3 → e6data_python_connector-2.3.10rc5}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (2, 3, 10, 'rc3')
+VERSION = (2, 3, 10, 'rc5')
 
 
 def get_long_desc():