feat(http_fetcher): improve network error handling with exponential backoff

Network errors now use exponential backoff strategy instead of fixed
reloadInterval delay, enabling faster recovery from transient issues.

Changes:
- Add networkErrorCount tracking alongside serverErrorCount
- Network errors retry at: 15s → 30s → 60s → cap at reloadInterval
- Gradual log-level escalation: WARN for first 2 attempts, ERROR after
- Extract retry calculation to static HTTPFetcher.calculateBackoffDelay()
- Apply same backoff strategy to WeatherGov initialization retries
- Reset both counters on successful response

Benefits:
- Faster recovery from transient network glitches (15s vs 10min)
- Less log spam for temporary issues (WARN vs ERROR initially)
- Consistent retry behavior across HTTPFetcher and provider init
- Reusable backoff calculation for future providers

Example: SMHI "fetch failed" now retries after 15s instead of 10min.

Author: KristjanESPERANTO

defaultmodules/weather/providers/weathergov.js

@@ -50,7 +50,7 @@ class WeatherGovProvider {
 			// Retry on temporary errors (DNS, timeout, network)
 			if (errorInfo.isRetryable && this.initRetryCount < 5) {
 				this.initRetryCount++;
-				const delay = Math.min(30000 * Math.pow(2, this.initRetryCount - 1), 5 * 60 * 1000); // 30s, 60s, 120s, 240s, 300s max
+				const delay = HTTPFetcher.calculateBackoffDelay(this.initRetryCount);
 				Log.info(`[weathergov] Will retry initialization in ${Math.round(delay / 1000)}s (attempt ${this.initRetryCount}/5)`);
 				this.initRetryTimer = setTimeout(() => this.initialize(), delay);
 			} else if (this.onErrorCallback) {

js/http_fetcher.js

@@ -42,6 +42,23 @@ const ERROR_TYPE_TO_TRANSLATION = {
  */
 class HTTPFetcher extends EventEmitter {
 
+	/**
+	 * Calculates exponential backoff delay for retries
+	 * @param {number} attempt - Attempt number (1-based)
+	 * @param {object} options - Configuration options
+	 * @param {number} [options.baseDelay] - Initial delay in ms (default: 15s)
+	 * @param {number} [options.maxDelay] - Maximum delay in ms (default: 5min)
+	 * @returns {number} Delay in milliseconds
+	 * @example
+	 * HTTPFetcher.calculateBackoffDelay(1) // 15000 (15s)
+	 * HTTPFetcher.calculateBackoffDelay(2) // 30000 (30s)
+	 * HTTPFetcher.calculateBackoffDelay(3) // 60000 (60s)
+	 * HTTPFetcher.calculateBackoffDelay(6) // 300000 (5min, capped)
+	 */
+	static calculateBackoffDelay (attempt, { baseDelay = 15000, maxDelay = 300000 } = {}) {
+		return Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+	}
+
 	/**
 	 * Creates a new HTTPFetcher instance
 	 * @param {string} url - The URL to fetch
@@ -71,6 +88,7 @@ class HTTPFetcher extends EventEmitter {
 
 		this.reloadTimer = null;
 		this.serverErrorCount = 0;
+		this.networkErrorCount = 0;
 	}
 
 	/**
@@ -226,7 +244,7 @@ class HTTPFetcher extends EventEmitter {
 			errorType,
 			translationKey: ERROR_TYPE_TO_TRANSLATION[errorType] || "MODULE_ERROR_UNSPECIFIED",
 			retryAfter,
-			retryCount: this.serverErrorCount,
+			retryCount: errorType === "NETWORK_ERROR" ? this.networkErrorCount : this.serverErrorCount,
 			url: this.url,
 			originalError
 		};
@@ -255,8 +273,9 @@ class HTTPFetcher extends EventEmitter {
 				nextDelay = delay;
 				this.emit("error", errorInfo);
 			} else {
-				// Reset server error count on success
+				// Reset error counts on success
 				this.serverErrorCount = 0;
+				this.networkErrorCount = 0;
 
 				/**
 				 * Response event - fired when fetch succeeds
@@ -269,6 +288,13 @@ class HTTPFetcher extends EventEmitter {
 			const isTimeout = error.name === "AbortError";
 			const message = isTimeout ? `Request timeout after ${this.timeout}ms` : `Network error: ${error.message}`;
 
+			// Apply exponential backoff for network errors
+			this.networkErrorCount = Math.min(this.networkErrorCount + 1, this.maxRetries);
+			const backoffDelay = HTTPFetcher.calculateBackoffDelay(this.networkErrorCount, {
+				maxDelay: this.reloadInterval
+			});
+			nextDelay = backoffDelay;
+
 			// Truncate URL for cleaner logs
 			let shortUrl = this.url;
 			try {
@@ -277,13 +303,20 @@ class HTTPFetcher extends EventEmitter {
 			} catch (urlError) {
 				// If URL parsing fails, use original URL
 			}
-			Log.error(`${this.logContext}${shortUrl} - ${message}`);
+
+			// Gradual log-level escalation: WARN for first 2 attempts, ERROR after
+			const retryMessage = `Retry #${this.networkErrorCount} in ${Math.round(nextDelay / 1000)}s.`;
+			if (this.networkErrorCount <= 2) {
+				Log.warn(`${this.logContext}${shortUrl} - ${message} ${retryMessage}`);
+			} else {
+				Log.error(`${this.logContext}${shortUrl} - ${message} ${retryMessage}`);
+			}
 
 			const errorInfo = this.#createErrorInfo(
 				message,
 				null,
 				"NETWORK_ERROR",
-				this.reloadInterval,
+				nextDelay,
 				error
 			);