js.compare-report.js Maven / Gradle / Ivy

Go to download
function reportComparison(runRecs) {
    let IDs = runRecs.map(rec => rec.ID);
    loadCommonOps(IDs, commonOps => reportCommonOps(runRecs, commonOps))
}

function loadCommonOps(IDs, fun) {
    $(".btn").prop('disabled', true);
    startSpinner("#op-spin");
    let url = getCommonOperationsForRunsURL(IDs);
    $.getJSON(url, fun);
}

function reportCommonOps(runRecs, commonOps) {
    if (commonOps.length > 0) {
        let runIDs = runRecs.map(runRec => runRec.ID);
        $.each(commonOps, (i, op) => {
            addTabs(op);
            getComparativeHdrData(runIDs, op, comparison => {
                let hdrMap = new Map(Object.entries(comparison.runs));
                for (rec of runRecs) {
                    let runID = rec.ID;
                    let hdrData = hdrMap.get(runID.toString());
                    let date = getDate(rec.date);
                    reportPlots(hdrData, op, date, runID);
                }
                let pvalues = new Map(Object.entries(comparison.pvalues));
                reportPvalues(op, pvalues, runRecs);
            });
        });
    } else {
        warn("No common operations: nothing to compare!");
    }
}

function addTabs(op) {
    addTab(op, "tps");
    addTab(op, "response-time");
    ['MEDIAN', '_99', '_99_99', 'MAX']
        .forEach(p => addTab(op, p));
    addPercentilesTab(op);
    startSpinner(`.${op}-spin`);
}

function reportPlots(hdrData, op, date, runID) {
    graphTps(hdrData, op, false, date);
    graphResponseTime(hdrData, op, false, date);
    graphTimedPercentiles(hdrData, op, false, date);
    graphPercentiles(hdrData, op, date, runID);
}

function graphTimedPercentiles(hdrData, op, realTimes, name) {
    ['MEDIAN', '_99', '_99_99', 'MAX']
        .forEach(p => graphTimedPercentile(hdrData, op, p, name));
}

function graphTimedPercentile(hdrData, op, percentile, name) {
    let divId = addTab(op, percentile);

    var layout = {
        title: op,
        xaxis: xaxis(false),
        yaxis: {title: 'Response time ' + percentileLabel(percentile) + ' (ms)'}
    };

    var traces = {
        x: xtimes(hdrData.startTimes, false),
        y: hdrData.timedPercentiles[percentile],
        name: name,
        type: 'scatter',
        mode: 'lines',
        line: {width: '1'}
    };

    var data = [traces];

    Plotly.plot(divId, data, layout, {showLink: false});
    stopSpinner(`#${op}-${percentile}-spin`);
}

function percentileLabel(percentile) {
    switch(percentile) {
        case 'MEDIAN': return 'medians';
        case '_99': return '99th percentiles';
        case '_99_99': return '99.99th percentiles';
        case 'MAX': return 'maximums';
    }
}

function graphPercentiles(hdrData, op, name, runID) {
    let divId = addPercentilesTab(op);

    var traces = {
        x: hdrData.percentilePoints,
        y: hdrData.percentileValues,
        name: name,
        type: 'scatter',
        line: {width: '1'}
    };

    addRoundedPercentiles(divId, hdrData, name, runID);

    var data = [traces];

    var layout = {
        title: op,
        xaxis: xaxis(false),
        yaxis: {title: 'Response Time percentiles distribution (ms)'}
    };

    Plotly.plot(divId + "_graph", data, layout, {showLink: false});
    stopSpinner(`#${op}-percentiles-spin`);
}

function addPercentilesTab(op) {
    type = 'percentiles';
    let divId = op + type;
    if (!exists(divId)) {
        $('#percentiles-ul').append(`${op}  ${tabSpinner(op, type)}`);

        let tabs = $("#percentiles-tabs");
        tabs.append(``);

        let div = $(`#${divId}`);

        let graphId = divId + "_graph";
        div.append(``);

        let footerId = divId + "_footer";
        div.append(``);

        $(`#${footerId}`).append('
Percentiles per run:
');

        let tableId = divId + "_table";
        let table = ``;
        table += ['MEDIAN', '_99', '_99_99', 'MAX']
            .map(percentileName)
            .map(p => ``)
            .reduce((acc, cur) => acc + cur);
        table += 'Run date ${p}';
        $(`#${footerId}`).append(table);

        tabs.tabs("refresh");
        tabs.tabs( "option", "active", 0 );
    }
    return divId;
}

function addRoundedPercentiles(divId, hdrData, name, runID) {
    let row = `${name}`;
    row += ['MEDIAN', '_99', '_99_99', 'MAX']
            .map(percentile => hdrData.roundedPercentiles[percentile] / 1000)
            .map(val => `${val}`)
            .reduce((acc, cur) => acc + cur);
    row += '';

    let tableId = "#" + divId + "_table";
    $(tableId).append(row);
}

function reportPvalues(op, pvalues, runRecs) {
    let divId = addPercentilesTab(op);
    let div = $("#" + divId + "_footer");

    div.append('
');
    div.append('
Kolmogorov-Smirnov test p-values for percentile distributions in pairs of runs:');

    let table = '';
    table += '';
    pvalues.forEach((pvalue, spair) => {
        let pair = $.parseJSON(spair);
        let date1 = getDateByID(runRecs, pair[0]);
        let date2 = getDateByID(runRecs, pair[1]);
        table += ``;
    });
    table += " Run 1  Run 2  P-value  
 ${date1}  ${date2}  ${pvalue}  ";

    div.append(table);
}

function getDateByID(runRecs, ID) {
    let rec = runRecs.filter(rec => rec.ID === ID)[0];
    return getDate(rec.date)
}