phantomas.on('report', function() {
var domainsStats = [],
Stats = require('fast-stats').Stats,
domainsRequests = new Stats();
// TODO: implement phantomas.collection
Object.keys(domains).forEach(function(domain) {
var cnt = domains[domain].requests.length;
domainsStats.push({
name: domain,
cnt: cnt
});
domainsRequests.push(cnt);
});
domainsStats.sort(function(a, b) {
return (a.cnt > b.cnt) ? -1 : 1;
});
if (domainsStats.length > 0) {
phantomas.setMetric('domains', domainsStats.length);
phantomas.setMetric('maxRequestsPerDomain', domainsRequests.range()[1]);
phantomas.setMetric('medianRequestsPerDomain', domainsRequests.median());
}
domainsStats.forEach(function(domain) {
phantomas.addOffender('domains', domain.name + ': ' + domain.cnt + ' request(s)');
});
});
db.rivers.find({}, function(e, rivers) {
var statsSinuosity = new Stats(),
statsRealLength = new Stats();
for (var i=0; i<rivers.length; i++) {
rivers[i] = new River(rivers[i]);
statsSinuosity.push(rivers[i].sinuosity);
statsRealLength.push(rivers[i].realLength);
}
riverUpdateErrors = req.session.riverUpdateErrors;
riverUpdateData = req.session.riverUpdateData;
req.session.riverUpdateErrors = null;
req.session.riverUpdateData = null;
res.render('river/show.jade', {
river: river,
riverUpdateErrors: riverUpdateErrors,
riverUpdateData: riverUpdateData,
statsSinuosity: statsSinuosity,
statsRealLength: statsRealLength
});
});
var nextSecond = function() {
// First process the telemetry for the current second
var currentSecond = requestsPerSecond[requestsPerSecond.length - 1];
if (currentSecond) {
var avgLatency = new Stats();
for (var f in currentSecond.feed) {
var feedObject = {};
// Calculate total per feed
feedObject.total = currentSecond.feed[f].length;
// Calculate average latency per feed, as well as 10th and 95th percentile
var s = new Stats();
for (var j = 0; j < currentSecond.feed[f].length; j++) {
s.push(currentSecond.feed[f][j]);
avgLatency.push(currentSecond.feed[f][j]);
}
feedObject.avg = s.amean();
feedObject.avg10 = s.percentile(10);
feedObject.avg95 = s.percentile(95);
// Replace the full telemetry
currentSecond.feed[f] = feedObject;
}
currentSecond.avg = avgLatency.amean();
currentSecond.avg10 = avgLatency.percentile(10);
currentSecond.avg95 = avgLatency.percentile(95);
}
// Prepare the next second
requestsPerSecond.push({
'total': 0,
'feed': {}
});
};
phantomas.on('report', function() {
var entries = Object.keys(stack).length;
if (entries === 0) {
phantomas.log('requestsStats: no requests data gathered!');
return;
}
// set metrics and provide offenders with URLs
[
'smallestResponse',
'biggestResponse',
'fastestResponse',
'slowestResponse',
'smallestLatency',
'biggestLatency'
].forEach(function(metric) {
var entry = getFromStack(metric),
details = '';
switch (metric) {
case 'smallestResponse':
case 'biggestResponse':
phantomas.setMetric(metric, entry.bodySize);
details = (entry.bodySize/1024).toFixed(2) + ' kB';
break;
case 'fastestResponse':
case 'slowestResponse':
phantomas.setMetric(metric, entry.timeToLastByte);
details = entry.timeToLastByte + ' ms';
break;
case 'smallestLatency':
case 'biggestLatency':
phantomas.setMetric(metric, entry.timeToFirstByte);
details = entry.timeToFirstByte + ' ms';
break;
}
phantomas.addOffender(metric, entry.url + ' (' + details + ')');
});
phantomas.setMetric('medianResponse', responseTimes.median());
phantomas.setMetric('medianLatency', latencyTimes.median());
});
end() {
this.totalDuration = process.hrtime(this.startHrTime);
// Feed the stats object
this.stats.push(this.timings.map(function(x) {
return (x[0] * 1e9 + x[1]) / (1000);
}));
}
// calculate stats for each metric
function getMetricStats(metricName) {
var i,
res = [],
values = new Stats();
for (i=0; i<runs; i++) {
values.push(results[i].getMetric(metricName));
}
res.push(metricName);
// apply stats functions
Object.keys(fields).forEach(function(fnName) {
res.push(fields[fnName](values));
});
return res;
}
Object.keys(domains).forEach(function(domain) {
var cnt = domains[domain].requests.length;
domainsStats.push({
name: domain,
cnt: cnt
});
domainsRequests.push(cnt);
});
function benchmark(error, micros) {
if (error) {
console.error("got error while benchmarking: %s", error.message);
badRequests++;
}
else {
timings.push(micros);
}
return micros;
}
phantomas.on('recv', function(entry, res) {
// ignore anything different than HTTP 200
if (entry.status !== 200) {
return;
}
// size
pushToStack('smallestResponse', entry, function(stack, entry) {
return stack.bodySize > entry.bodySize;
});
pushToStack('biggestResponse', entry, function(stack, entry) {
return stack.bodySize < entry.bodySize;
});
// time (from sent to last byte)
pushToStack('fastestResponse', entry, function(stack, entry) {
return stack.timeToLastByte > entry.timeToLastByte;
});
pushToStack('slowestResponse', entry, function(stack, entry) {
return stack.timeToLastByte < entry.timeToLastByte;
});
// latency
pushToStack('smallestLatency', entry, function(stack, entry) {
return stack.timeToFirstByte > entry.timeToFirstByte;
});
pushToStack('biggestLatency', entry, function(stack, entry) {
return stack.timeToFirstByte < entry.timeToFirstByte;
});
// stats
responseTimes.push(entry.timeToLastByte);
latencyTimes.push(entry.timeToFirstByte);
});
/**
* Precompute indicator fields using time series OHLCV data.
* <br><br>
* This is invoked before draw().
* @param {timeseries.TimeSeriesData} data
*/
precompute(data) {
var data_arr = data.getRawData();
var field_map = data.getFieldMap();
var input_field = field_map[this.input];
var upper_band_field = this.upperBandOutput;
var mid_field = this.midOutput;
var lower_band_field = this.lowerBandOutput;
var period = this.period;
var mean = new Stats();
var sd = new Stats();
for(var i = 0; i < data_arr.length; i++)
{
var dat = data_arr[i];
mean.push(dat[input_field]);
sd.push(dat[input_field]);
if(sd.length === period)
{
var ma = mean.amean();
var std_dev = sd.stddev();
dat[upper_band_field] = ma + 2 * std_dev;
dat[mid_field] = ma;
dat[lower_band_field] = ma - 2 * std_dev;
if(isNaN(dat[upper_band_field]))
{
dat[upper_band_field] = 0.0;
}
if(isNaN(dat[lower_band_field]))
{
dat[lower_band_field] = 0.0;
}
sd.shift();
mean.shift();
}
}
}
db.rivers.find({}).sort({ realLength: -1 }).exec(function(e, rivers) {
lengthVsSinuosityChartData = [{
key: 'Rivers',
values: [],
slope: 0,
intercept: Math.PI
}];
distributionChartData = {}
for (var b=0.0; b<9.6; b+=0.1) {
distributionChartData[b.toFixed(1)] = 0;
}
averagedData = {};
var statsSinuosity = new Stats(),
statsRealLength = new Stats(),
statsCrowLength = new Stats();
for (var i=0; i<rivers.length; i++) {
rivers[i] = new River(rivers[i]);
statsSinuosity.push(rivers[i].sinuosity);
statsRealLength.push(rivers[i].realLength);
statsCrowLength.push(rivers[i].crowLength);
lengthVsSinuosityChartData[0].values.push({
x: rivers[i].realLength,
y: rivers[i].sinuosity
});
distributionChartData[rivers[i].sinuosity.toFixed(1)]++;
}
distributionChartDataValues = [];
for (var key in distributionChartData) {
distributionChartDataValues.push({
label: key,
value: distributionChartData[key]
});
}
distributionChartData = [{
key: 'Rivers',
values: distributionChartDataValues
}];
riverCreateErrors = req.session.riverCreateErrors;
riverCreateData = req.session.riverCreateData;
req.session.riverCreateErrors = null;
req.session.riverCreateData = null;
res.render('index.jade', {
rivers: rivers,
riverCreateErrors: riverCreateErrors,
riverCreateData: riverCreateData,
statsSinuosity: statsSinuosity,
statsRealLength: statsRealLength,
statsCrowLength: statsCrowLength,
lengthVsSinuosityChartData: JSON.stringify(lengthVsSinuosityChartData),
distributionChartData: JSON.stringify(distributionChartData)
});
});
var assert = require('assert');
var Stats = require('fast-stats').Stats;
Array = require('gauss').Vector;
var a = [], b = new Stats();
for(var i=0; i<100001; i++) {
var n = Math.round(Math.random()*10000);
a.push(n);
b.push(n);
}
var amn, bmn;
console.time("gauss-mean");
amn = a.mean();
console.timeEnd("gauss-mean");
console.time("fast-mean");
bmn = b.amean();
console.timeEnd("fast-mean");
assert.equal(amn.toFixed(2), bmn.toFixed(2));
console.time("gauss-median");
amn = a.median();
console.timeEnd("gauss-median");
console.time("fast-median");
bmn = b.median();
console.timeEnd("fast-median");
assert.equal(amn.toFixed(2), bmn.toFixed(2));
gstdDev() {
return this.stats.gstddev();
}
stdDev() {
return this.stats.σ();
}
median() {
return this.stats.median();
}
amean() {
return this.stats.amean();
}
percentile(v) {
return this.stats.percentile(v);
}
push(entries) {
this.stats.push(entries);
}
moe() {
return this.stats.moe();
}
exports.module = function(phantomas) {
var stack = {};
// adds given entry under the "type" if given check function returns true
function pushToStack(type, entry, check) {
// no entry of given type
if (typeof stack[type] === 'undefined') {
stack[type] = entry;
}
// apply check function
else if (check(stack[type], entry) === true) {
stack[type] = entry;
}
}
function getFromStack(type) {
return stack[type];
}
var Stats = require('fast-stats').Stats,
responseTimes = new Stats(),
latencyTimes = new Stats();
phantomas.on('recv', function(entry, res) {
// ignore anything different than HTTP 200
if (entry.status !== 200) {
return;
}
// size
pushToStack('smallestResponse', entry, function(stack, entry) {
return stack.bodySize > entry.bodySize;
});
pushToStack('biggestResponse', entry, function(stack, entry) {
return stack.bodySize < entry.bodySize;
});
// time (from sent to last byte)
pushToStack('fastestResponse', entry, function(stack, entry) {
return stack.timeToLastByte > entry.timeToLastByte;
});
pushToStack('slowestResponse', entry, function(stack, entry) {
return stack.timeToLastByte < entry.timeToLastByte;
});
// latency
pushToStack('smallestLatency', entry, function(stack, entry) {
return stack.timeToFirstByte > entry.timeToFirstByte;
});
pushToStack('biggestLatency', entry, function(stack, entry) {
return stack.timeToFirstByte < entry.timeToFirstByte;
});
// stats
responseTimes.push(entry.timeToLastByte);
latencyTimes.push(entry.timeToFirstByte);
});
phantomas.on('report', function() {
var entries = Object.keys(stack).length;
if (entries === 0) {
phantomas.log('requestsStats: no requests data gathered!');
return;
}
// set metrics and provide offenders with URLs
[
'smallestResponse',
'biggestResponse',
'fastestResponse',
'slowestResponse',
'smallestLatency',
'biggestLatency'
].forEach(function(metric) {
var entry = getFromStack(metric),
details = '';
switch (metric) {
case 'smallestResponse':
case 'biggestResponse':
phantomas.setMetric(metric, entry.bodySize);
details = (entry.bodySize/1024).toFixed(2) + ' kB';
break;
case 'fastestResponse':
case 'slowestResponse':
phantomas.setMetric(metric, entry.timeToLastByte);
details = entry.timeToLastByte + ' ms';
break;
case 'smallestLatency':
case 'biggestLatency':
phantomas.setMetric(metric, entry.timeToFirstByte);
details = entry.timeToFirstByte + ' ms';
break;
}
phantomas.addOffender(metric, entry.url + ' (' + details + ')');
});
phantomas.setMetric('medianResponse', responseTimes.median());
phantomas.setMetric('medianLatency', latencyTimes.median());
});
};
range() {
return this.stats.range();
}
label.diff =diff/3600000;
labelsArr.push(label);
}
}
issuesArr.push({
"number": issue,
"labels": labelsArr
});
// console.log(labelled);
// console.log(closed);
}
var s = new Stats();
var mean, stddev ;
for(var k = 0; k < issuesArr.length; k++) {
var labelsArr = issuesArr[k].labels;
for(var j = 0; j < labelsArr.length; j++) {
s.push(labelsArr[j].diff);
}
}
mean = s.amean();
stddev = s.stddev();
console.log("Mean: %d Standard Deviation: %d", s.amean().toFixed(2), s.stddev().toFixed(2));
for(var k = 0; k < issuesArr.length; k++) {
var labelsArr = issuesArr[k].labels;