Add logging for domain availability checks and improve error handling

app.py

@@ -1,3 +1,4 @@
+from typing import Callable
 from flask import Flask, request, send_from_directory
 import dns.resolver
 import socket
@@ -28,6 +29,7 @@ def index():
 @app.route('/check/<domain>', methods=['POST'])
 def check_domain(domain: str):
     """Check domain availability"""
+    logs: list[str] = []
     try:
         domain = domain.lower().strip('/').strip()
         if '://' in domain:
@@ -38,53 +40,57 @@ def check_domain(domain: str):
                 return { 
                     'domain': domain, 
                     "available": False, 
-                    "method": f"Unsupported TLD, try at {unsupported_TLD.get('try')}"
+                    "method": f"Unsupported TLD, try at {unsupported_TLD.get('try')}",
+                    "logs": logs
                 }
 
-        result = check_domain_availability(domain)
+        result = check_domain_availability(domain, logs.append)
         if result:
             return { 
                 "domain": domain,
                 "method": f"Checked via {result['method']}",
-                "available": result['available'] 
+                "available": result['available'],
+                "logs": logs
             }
-    except:
-        pass
+    except Exception as e:
+        logs.append(f"{check_domain.__name__}:{str(e)}")
     return { 
         'domain': domain, 
         "available": False, 
-        "method": "Cannot confirm if doimain is available"
+        "method": "Cannot confirm if doimain is available",
+        "logs": logs
     }
 
-def check_domain_availability(domain):
+def check_domain_availability(domain, logs_append: Callable[[str], None]):
     """Check domain availability using multiple methods."""
     # First try DNS resolution
-    is_available, availability_method, _continue = dns_is_available(domain)
+    is_available, availability_method, _continue = dns_is_available(domain, logs_append)
     if not _continue:
         return { "available": is_available, "method": f"DNS:{availability_method}" }
     
     # Try RDAP
-    is_available, availability_method, _continue = rdap_is_available(domain)
+    is_available, availability_method, _continue = rdap_is_available(domain, logs_append)
     if not _continue:
         return { "available": is_available, "method": f"RDAP:{availability_method}" }
 
     # Fall back to WHOIS
-    is_available, availability_method, _continue = whois_is_available(domain)
+    is_available, availability_method, _continue = whois_is_available(domain, logs_append)
     if not _continue:
         return {"available": is_available, "method": f"WHOIS:{availability_method}"}
 
-def dns_is_available(domain):
+def dns_is_available(domain, logs_append: Callable[[str], None]):
     """Check if domain exists in DNS by looking for common record types."""
     # Check NS records first as they're required for valid domains
     for record_type in ['NS', 'A', 'AAAA', 'MX', 'CNAME']:
         try:
             dns.resolver.resolve(domain, record_type)
             return False, record_type, False
-        except:
+        except Exception as e:
+            logs_append(f"{dns_is_available.__name__}:{str(e)}")
             continue
     return True, None, True
 
-def rdap_is_available(domain):
+def rdap_is_available(domain, logs_append: Callable[[str], None]):
     try:
         bootstrap_url = "https://data.iana.org/rdap/dns.json"
         bootstrap_data = requests.get(bootstrap_url, timeout=5).json()
@@ -99,11 +105,11 @@ def rdap_is_available(domain):
                         return True, rdap_base_url, False
                     elif response.status_code == 200:
                         return False, rdap_base_url, False
-    except:
-        pass
+    except Exception as e:
+        logs_append(f"{rdap_is_available.__name__}:{str(e)}")
     return False, None, True
 
-def whois_is_available(domain) -> bool:
+def whois_is_available(domain, logs_append: Callable[[str], None]) -> bool:
     try:
         available_patterns = [
             'no match',
@@ -116,19 +122,19 @@ def whois_is_available(domain) -> bool:
             'domain not found'
         ]
         is_available_callback = lambda output: any(pattern in output for pattern in available_patterns)
-        is_available, availability_method = socket_whois_is_available(domain, is_available_callback)
+        is_available, availability_method = socket_whois_is_available(domain, is_available_callback, logs_append)
         if is_available:
             return True, availability_method, False
-        is_available, availability_method = terminal_whois_is_available(domain, is_available_callback)
+        is_available, availability_method = terminal_whois_is_available(domain, is_available_callback, logs_append)
         if is_available:
             return True, availability_method, False
-    except:
-        pass
+    except Exception as e:
+        logs_append(f"{whois_is_available.__name__}:{str(e)}")
     return False, None, True
 
-def socket_whois_is_available(domain, is_available_callback):
+def socket_whois_is_available(domain, is_available_callback: Callable[[str], bool], logs_append: Callable[[str], None]):
     try:
-        whois_server = get_whois_server(domain)
+        whois_server = get_whois_server(domain, logs_append)
         whois_server = "whois.reg.ly"
 
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -140,11 +146,11 @@ def socket_whois_is_available(domain, is_available_callback):
         
         response_lower = response.lower()
         return is_available_callback(response_lower), whois_server
-    except:
-        pass
+    except Exception as e:
+        logs_append(f"{socket_whois_is_available.__name__}:{str(e)}")
     return False, None
 
-def terminal_whois_is_available(domain, is_available_callback):
+def terminal_whois_is_available(domain, is_available_callback: Callable[[str], bool], logs_append: Callable[[str], None]):
     try:
         # Check if OS is Linux
         if platform.system().lower() == 'linux':
@@ -155,16 +161,18 @@ def terminal_whois_is_available(domain, is_available_callback):
                     stdout=subprocess.PIPE, 
                     stderr=subprocess.PIPE)
                 try:
-                    stdout, _ = process.communicate(timeout=60)
+                    stdout, stderr = process.communicate(timeout=60)
                     output = stdout.decode('utf-8', errors='ignore').lower()
+                    logs_append(f"{terminal_whois_is_available.__name__}:stderr:{str(stderr.decode(encoding='utf-8'))}")
                     return is_available_callback(output), "system whois"
-                except subprocess.TimeoutExpired:
+                except subprocess.TimeoutExpired as timeout_e:
+                    logs_append(f"{terminal_whois_is_available.__name__}:{str(timeout_e)}")
                     process.kill()
-    except:
-        pass
+    except Exception as e:
+        logs_append(f"{terminal_whois_is_available.__name__}:{str(e)}")
     return False, None
 
-def get_whois_server(domain):
+def get_whois_server(domain, logs_append: Callable[[str], None]):
     """Get WHOIS server from IANA root zone database."""
     try:
         response = requests.get(f'https://www.iana.org/whois?q={domain}')
@@ -172,6 +180,6 @@ def get_whois_server(domain):
             for line in response.text.split('\n'):
                 if 'whois:' in line.lower():
                     return line.split(':')[1].strip()
-    except:
-        pass
+    except Exception as e:
+        logs_append(f"{get_whois_server.__name__}:{str(e)}")
     return None