[FEATURE] - Improve logging and error visibility;

Description

Logging is minimal throughout the codebase. Many catch blocks are empty, and there's a lack of informative log messages at key stages (request sending, response receiving, errors). This makes debugging and production troubleshooting difficult.

Location

Files: All files using Logger, including:

• lib/src/tracker/http_tracker.dart
• lib/src/tracker/udp_tracker.dart
• lib/src/tracker/http_tracker_base.dart
• lib/src/tracker/udp_tracker_base.dart

Current Issues

1. Empty catch blocks without logging:

try {
  var peers = CompactAddress.parseIPv4Addresses(value);
  // ...
} catch (e) {
  // ❌ Empty catch - no logging, no error visibility
}

2. Minimal logging at key stages:

   • No logging when requests are sent
   • No logging when responses are received
   • Limited error context

3. Silent failures:

   • Errors are caught but not logged
   • No way to diagnose issues in production

Expected Behavior

Add comprehensive logging at appropriate levels:

1. Fine/Debug level:

   • Request parameters (without sensitive data)
   • Response metadata
   • Flow tracking

2. Info level:

   • Successful operations
   • Connection establishment
   • Important state changes

3. Warning level:

   • Recoverable errors
   • Timeout events
   • Invalid but handled responses

4. Severe/Error level:

   • Critical errors
   • Network failures
   • Protocol violations

Proposed Implementation

Replace Empty Catch Blocks

// Before
try {
  var peers = CompactAddress.parseIPv4Addresses(value);
  // ...
} catch (e) {
  //
}

// After
try {
  var peers = CompactAddress.parseIPv4Addresses(value);
  // ...
} catch (e) {
  _log.warning('Failed to parse IPv4 peer addresses', e);
}

Add Request/Response Logging

Future<T?> httpGet<T>(Map<String, dynamic> options) async {
  if (isClosed) {
    _log.fine('HTTP client is closed, skipping request');
    return null;
  }
  
  try {
    var url = _createAccessURL(options);
    _log.fine('Sending HTTP request to: ${url.replaceAll(RegExp(r'peer_id=[^&]*'), 'peer_id=***')}');
    
    var uri = Uri.parse(url);
    _httpClient?.close();
    _httpClient = HttpClient();
    _request?.abort();
    _request = await _httpClient?.getUrl(uri);
    var response = await _request?.close();

    _log.fine('Received HTTP response: ${response?.statusCode}');
    
    var datas = await _receiveResponseData(response);
    _log.fine('Received ${datas.length} bytes of response data');
    
    await _clear();
    return processResponseData(Uint8List.fromList(datas));
  } catch (e, stackTrace) {
    _log.severe('HTTP request failed', e, stackTrace);
    await _clear();
    rethrow;
  }
}

Add UDP Logging

void _sendMessage(Uint8List message, List<CompactAddress> addresses) {
  if (isClosed) return;
  _log.fine('Sending UDP message (${message.length} bytes) to ${addresses.length} address(es)');
  
  var success = false;
  for (var element in addresses) {
    var bytes = _socket?.send(message, element.address, element.port);
    if (bytes != 0) success = true;
    _log.fine('Sent ${bytes} bytes to ${element.address}:${element.port}');
  }
  
  if (!success) {
    _log.warning('Failed to send UDP message to any address, retrying...');
    Timer.run(() => _sendMessage(message, addresses));
  }
}

Add Error Context

@override
PeerEvent processResponseData(Uint8List data) {
  try {
    var result = decode(data) as Map;
    
    if (result['failure reason'] != null) {
      var errorMsg = String.fromCharCodes(result['failure reason']);
      _log.warning('Tracker returned failure reason: $errorMsg');
      throw errorMsg;
    }
    
    _log.fine('Successfully parsed tracker response: interval=${result['interval']}, '
        'peers=${result['peers']?.length ?? 0}');
    
    // ... rest of processing ...
  } catch (e, stackTrace) {
    _log.severe('Failed to process tracker response (${data.length} bytes)', e, stackTrace);
    rethrow;
  }
}

Impact

• Severity: Medium (Quality Improvement)
• Affected: All tracker operations
• Benefits:
  • Better debugging capabilities
  • Production diagnostics
  • Troubleshooting network issues
  • Monitoring and observability

Additional Context

Logging should:

• Not include sensitive data (peer_id, IPs can be masked)
• Use appropriate log levels
• Include context (URLs, data sizes, error details)
• Follow Dart logging best practices
• Allow developers to control verbosity

Related Standards

• Dart logging package best practices
• Production-ready error handling