network-performance-monitor/dist/src/websiteTest.js

A comprehensive network performance monitoring tool that continuously tests and tracks your network's performance over time

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WebsiteTest = void 0;
const axios_1 = __importDefault(require("axios"));
const config_1 = require("./config");
const logger_1 = require("./logger");
class WebsiteTest {
    db;
    constructor(db) {
        this.db = db;
    }
    async testWebsite(url, networkName) {
        const result = {
            url,
            latency: null,
            statusCode: null,
            error: null,
            success: false
        };
        const startTime = Date.now();
        try {
            const response = await axios_1.default.get(url, {
                timeout: 30000, // 30 second timeout
                validateStatus: () => true, // Don't throw on any status code
                maxRedirects: 5
            });
            result.latency = Date.now() - startTime;
            result.statusCode = response.status;
            result.success = response.status >= 200 && response.status < 400;
            if (!result.success) {
                result.error = `HTTP ${response.status} ${response.statusText}`;
            }
        }
        catch (error) {
            result.latency = Date.now() - startTime;
            if (axios_1.default.isAxiosError(error)) {
                if (error.code === 'ECONNABORTED') {
                    result.error = 'Request timeout';
                }
                else if (error.code === 'ENOTFOUND') {
                    result.error = 'DNS lookup failed';
                }
                else if (error.code === 'ECONNREFUSED') {
                    result.error = 'Connection refused';
                }
                else {
                    result.error = error.message;
                }
            }
            else {
                result.error = error instanceof Error ? error.message : 'Unknown error';
            }
        }
        // Log the result
        (0, logger_1.logTestResult)('WEBSITE', url, result.success, result.latency || undefined, result.error || undefined);
        // Store in database
        await this.db.insertWebsiteTest(url, result.latency, result.statusCode, result.error, networkName);
        // Update baseline if successful
        if (result.success && result.latency !== null) {
            await this.db.updateBaseline('website', url, result.latency);
        }
        return result;
    }
    async testAllWebsites(networkName) {
        const results = [];
        for (const url of config_1.config.websites) {
            const result = await this.testWebsite(url, networkName);
            results.push(result);
        }
        return results;
    }
    async checkForAnomalies(results) {
        let anomalyDetected = false;
        for (const result of results) {
            if (!result.success || result.latency === null) {
                // Any failure is an anomaly
                anomalyDetected = true;
                continue;
            }
            const baseline = await this.db.getBaseline('website', result.url);
            if (baseline !== null && result.latency > baseline * config_1.config.thresholds.latencyMultiplier) {
                anomalyDetected = true;
                (0, logger_1.logTestResult)('WEBSITE_ANOMALY', result.url, false, result.latency, `Latency ${result.latency}ms exceeds threshold (baseline: ${baseline}ms)`);
            }
        }
        return anomalyDetected;
    }
}
exports.WebsiteTest = WebsiteTest;
//# sourceMappingURL=websiteTest.js.map