refactor(logging): remove unused logger instances and enhance error logging in webhook steps

services/advoware.py

@@ -72,6 +72,11 @@ class AdvowareAPI:
 
         self._session: Optional[aiohttp.ClientSession] = None
 
+    def _log(self, message: str, level: str = 'info') -> None:
+        """Internal logging helper"""
+        log_func = getattr(self.logger, level, self.logger.info)
+        log_func(message)
+
     async def _get_session(self) -> aiohttp.ClientSession:
         if self._session is None or self._session.closed:
             self._session = aiohttp.ClientSession()
@@ -98,8 +103,8 @@ class AdvowareAPI:
         signature = hmac.new(api_key_bytes, message, hashlib.sha512)
         return base64.b64encode(signature.digest()).decode('utf-8')
 
-    def _fetch_new_access_token(self) -> str:
-        """Fetch new access token from Advoware Auth API"""
+    async def _fetch_new_access_token(self) -> str:
+        """Fetch new access token from Advoware Auth API (async)"""
         self.logger.info("Fetching new access token from Advoware")
         
         nonce = str(uuid.uuid4())
@@ -122,40 +127,41 @@ class AdvowareAPI:
         
         self.logger.debug(f"Token request: AppID={self.app_id}, User={self.user}")
         
-        # Using synchronous requests for token fetch (called from sync context)
-        # TODO: Convert to async in future version
-        import requests
+        # Async token fetch using aiohttp
+        session = await self._get_session()
         
         try:
-            response = requests.post(
+            async with session.post(
                 ADVOWARE_CONFIG.auth_url,
                 json=data,
                 headers=headers,
-                timeout=self.api_timeout_seconds
-            )
-            
-            self.logger.debug(f"Token response status: {response.status_code}")
-            
-            if response.status_code == 401:
-                raise AdvowareAuthError(
-                    "Authentication failed - check credentials",
-                    status_code=401
-                )
-            
-            response.raise_for_status()
-            
-        except requests.Timeout:
+                timeout=aiohttp.ClientTimeout(total=self.api_timeout_seconds)
+            ) as response:
+                self.logger.debug(f"Token response status: {response.status}")
+                
+                if response.status == 401:
+                    raise AdvowareAuthError(
+                        "Authentication failed - check credentials",
+                        status_code=401
+                    )
+                
+                if response.status >= 400:
+                    error_text = await response.text()
+                    raise AdvowareAPIError(
+                        f"Token request failed ({response.status}): {error_text}",
+                        status_code=response.status
+                    )
+                
+                result = await response.json()
+        
+        except asyncio.TimeoutError:
             raise AdvowareTimeoutError(
                 "Token request timed out",
                 status_code=408
             )
-        except requests.RequestException as e:
-            raise AdvowareAPIError(
-                f"Token request failed: {str(e)}",
-                status_code=getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
-            )
+        except aiohttp.ClientError as e:
+            raise AdvowareAPIError(f"Token request failed: {str(e)}")
         
-        result = response.json()
         access_token = result.get("access_token")
         
         if not access_token:
@@ -173,7 +179,7 @@ class AdvowareAPI:
         
         return access_token
 
-    def get_access_token(self, force_refresh: bool = False) -> str:
+    async def get_access_token(self, force_refresh: bool = False) -> str:
         """
         Get valid access token (from cache or fetch new).
         
@@ -187,11 +193,11 @@ class AdvowareAPI:
         
         if not self.redis_client:
             self.logger.info("No Redis available, fetching new token")
-            return self._fetch_new_access_token()
+            return await self._fetch_new_access_token()
         
         if force_refresh:
             self.logger.info("Force refresh requested, fetching new token")
-            return self._fetch_new_access_token()
+            return await self._fetch_new_access_token()
         
         # Check cache
         cached_token = self.redis_client.get(ADVOWARE_CONFIG.token_cache_key)
@@ -210,7 +216,7 @@ class AdvowareAPI:
                 self.logger.debug(f"Error reading cached token: {e}")
         
         self.logger.info("Cached token expired or invalid, fetching new")
-        return self._fetch_new_access_token()
+        return await self._fetch_new_access_token()
 
     async def api_call(
         self,
@@ -254,7 +260,7 @@ class AdvowareAPI:
         
         # Get auth token
         try:
-            token = self.get_access_token()
+            token = await self.get_access_token()
         except AdvowareAuthError:
             raise
         except Exception as e:
@@ -282,7 +288,7 @@ class AdvowareAPI:
                     # Handle 401 - retry with fresh token
                     if response.status == 401:
                         self.logger.warning("401 Unauthorized, refreshing token")
-                        token = self.get_access_token(force_refresh=True)
+                        token = await self.get_access_token(force_refresh=True)
                         effective_headers['Authorization'] = f'Bearer {token}'
 
                         async with session.request(