next-dev/dist/bin/devTest.js

Tentu, berikut adalah markdown yang telah diperbaiki:

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const autocannon_1 = __importDefault(require("autocannon"));
require("colors");
// Display a progress animation with text
const displayProgress = (url, duration) => {
    let percent = 0;
    const interval = setInterval(() => {
        process.stdout.write(`\rTesting ${url}... ${percent}%`.white);
        percent += 1;
        if (percent > 100) {
            clearInterval(interval);
        }
    }, (duration * 10)); // Adjust interval duration to fit the test duration
    return interval;
};
// Format and print the results in a readable way
const printResults = (result, testOptions) => {
    console.log('\n\nLoad Test Results:'.white);
    console.log('-------------------'.white);
    console.log('Headers:'.white);
    console.log(`  - URL: ${testOptions.url} [URL yang diuji]`.gray);
    console.log(`  - Connections: ${testOptions.connections} [Jumlah koneksi simultan]`.gray);
    console.log(`  - Duration: ${testOptions.duration} seconds [Durasi pengujian dalam detik]`.gray);
    console.log(`  - Pipelining: ${testOptions.pipelining} [Jumlah permintaan yang diproses secara paralel]`.gray);
    console.log(`  - Overall Rate: ${testOptions.overallRate} requests per second [Kecepatan permintaan total per detik]`.gray);
    console.log(`  - Workers: ${testOptions.workers} [Jumlah thread worker yang digunakan]`.gray);
    console.log('-------------------'.white);
    console.log(`Requests per second: ${result.requests.average.toFixed(2)} [Rata-rata permintaan per detik]`.gray);
    console.log('Latency (ms):'.white);
    console.log(`  - p50: ${result.latency.p50.toFixed(2)} [Latensi median (P50)]`.gray);
    console.log(`  - p90: ${result.latency.p90.toFixed(2)} [Latensi 90 persentil (P90)]`.gray);
    console.log(`  - p99: ${result.latency.p99.toFixed(2)} [Latensi 99 persentil (P99)]`.gray);
    console.log('Throughput (bytes/sec):'.white);
    console.log(`  - Mean: ${result.throughput.mean.toFixed(2)} [Rata-rata throughput]`.gray);
    console.log(`  - Standard Deviation: ${result.throughput.stddev.toFixed(2)} [Standar Deviasi throughput]`.gray);
    console.log('Errors:'.white, result.errors);
    // Evaluate the results and provide a conclusion
    const rps = result.requests.average;
    const latencyP99 = result.latency.p99;
    const throughput = result.throughput.mean;
    let conclusion = '\nKondisi situs web dapat dianggap:'.white;
    let score = 0;
    let reason = '';
    let suggestion = '';
    if (rps > 1000 && latencyP99 < 2000 && throughput > 1000000) {
        conclusion += '\n  - Sangat baik. [Situs memiliki performa yang sangat baik]'.green;
        score = 90;
        reason = 'Sangat baik: RPS tinggi, latensi rendah, dan throughput tinggi menunjukkan situs yang sangat responsif dan mampu menangani banyak permintaan.';
        suggestion = 'Lanjutkan pemantauan dan optimasi berkala untuk mempertahankan performa.';
    }
    else if (rps > 500 && latencyP99 < 3000 && throughput > 500000) {
        conclusion += '\n  - Bagus. [Situs memiliki performa yang baik]'.blue;
        score = 75;
        reason = 'Bagus: RPS cukup tinggi, latensi yang masih dapat diterima, dan throughput yang baik menunjukkan performa yang solid.';
        suggestion = 'Pertimbangkan untuk meningkatkan caching dan optimasi query database.';
    }
    else if (rps > 200 && latencyP99 < 4000 && throughput > 200000) {
        conclusion += '\n  - Cukup baik. [Situs memiliki performa yang cukup baik]'.cyan;
        score = 60;
        reason = 'Cukup baik: RPS yang cukup, latensi yang mulai meningkat, dan throughput yang memadai menunjukkan performa yang cukup baik namun perlu perbaikan.';
        suggestion = 'Optimalkan kode backend dan gunakan CDN untuk konten statis.';
    }
    else if (rps > 100 && latencyP99 < 5000 && throughput > 100000) {
        conclusion += '\n  - Kurang memuaskan. [Situs memiliki performa yang kurang memuaskan]'.yellow;
        score = 40;
        reason = 'Kurang memuaskan: RPS rendah, latensi tinggi, dan throughput yang rendah menunjukkan performa yang kurang baik dan perlu perbaikan serius.';
        suggestion = 'Tingkatkan konfigurasi server dan optimasi database.';
    }
    else {
        conclusion += '\n  - Buruk. [Situs memiliki performa yang buruk]'.red;
        score = 20;
        reason = 'Buruk: RPS sangat rendah, latensi sangat tinggi, dan throughput yang sangat rendah menunjukkan performa yang sangat buruk dan membutuhkan perbaikan besar.';
        suggestion = 'Lakukan audit menyeluruh terhadap infrastruktur dan kode aplikasi.';
    }
    conclusion += `\n  - Nilai: ${score}/100 [Nilai performa]`.white;
    conclusion += `\n  - Alasan: ${reason}`.white;
    conclusion += `\n  - Saran: ${suggestion}`.white;
    console.log(conclusion);
};
// Main function to run the load test
async function devTest(argv) {
    try {
        const testUrl = argv.url;
        const duration = argv.duration || 60; // Durasi pengujian 1 menit
        const progressInterval = displayProgress(testUrl, duration);
        const testOptions = {
            url: testUrl,
            connections: argv.connections || 200, // Minimum 200 koneksi simultan
            duration: duration,
            pipelining: argv.pipelining || 10, // Pipelining 10 permintaan
            overallRate: argv.rate || 1000, // Minimum 1000 permintaan per detik
            workers: argv.workers || 4, // Minimum 4 worker threads
        };
        // Display the test description and objectives
        console.log('\nStarting Load Test'.white);
        console.log('-------------------'.white);
        console.log('Deskripsi:'.white);
        console.log('  Pengujian ini dilakukan untuk mengevaluasi performa dan kemampuan situs web dalam menangani beban tinggi.'.gray);
        console.log('  Dengan melakukan tes ini, kita dapat mengetahui tingkat responsivitas, kehandalan, dan kapasitas situs web.'.gray);
        console.log('Tujuan:'.white);
        console.log('  1. Menentukan jumlah permintaan maksimum yang dapat ditangani per detik.'.gray);
        console.log('  2. Mengukur latensi permintaan untuk memastikan waktu respon yang cepat.'.gray);
        console.log('  3. Mengukur throughput data untuk mengetahui kapasitas transfer data yang optimal.'.gray);
        console.log('Jangkauan:'.white);
        console.log('  Hasil tes ini akan memberikan wawasan mengenai area yang memerlukan optimasi dan peningkatan performa.'.gray);
        console.log('-------------------'.white);
        (0, autocannon_1.default)(testOptions, (err, result) => {
            clearInterval(progressInterval); // Stop the progress animation
            if (err) {
                console.error('Error during load testing:'.red, err);
                return;
            }
            if (!result) {
                console.error('No load test results received'.red);
                return;
            }
            printResults(result, testOptions); // Print the results in a human-readable format
        });
    }
    catch (error) {
        console.error('Error during load test:'.red, error);
    }
}
exports.default = devTest;