mirror of https://gitee.com/bigwinds/arangodb
860 lines
24 KiB
JavaScript
860 lines
24 KiB
JavaScript
/*jslint indent: 2, nomen: true, maxlen: 100, white: true, plusplus: true, unparam: true */
|
|
/*global require, applicationContext*/
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief A Foxx.Controller to handle the statistics
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2014 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Dr. Frank Celler
|
|
/// @author Copyright 2014, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
"use strict";
|
|
|
|
var FoxxController = require("org/arangodb/foxx").Controller;
|
|
var controller = new FoxxController(applicationContext);
|
|
var db = require("org/arangodb").db;
|
|
var internal = require("internal");
|
|
var STATISTICS_INTERVALL = 10;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- private functions
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief avgPerSlice
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function avgPerSlice (now, last) {
|
|
var d = now.count - last.count;
|
|
|
|
if (d === 0) {
|
|
return 0;
|
|
}
|
|
|
|
return (now.sum - last.sum) / d;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief avgPerTimeSlice
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function avgPerTimeSlice (duration, now, last) {
|
|
if (duration === 0) {
|
|
return 0;
|
|
}
|
|
|
|
return (now.sum - last.sum) / duration;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief perTimeSlice
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function perTimeSlice (duration, now, last) {
|
|
if (duration === 0) {
|
|
return 0;
|
|
}
|
|
|
|
return (now - last) / duration;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief avgDistributon
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function avgPercentDistributon (now, last, cuts) {
|
|
var n = cuts.length + 1;
|
|
var result = new Array(n);
|
|
var count = 0;
|
|
var i;
|
|
|
|
if (last === null) {
|
|
count = now.count;
|
|
}
|
|
else {
|
|
count = now.count - last.count;
|
|
}
|
|
|
|
if (count === 0) {
|
|
for (i = 0; i < n; ++i) {
|
|
result[i] = 0;
|
|
}
|
|
}
|
|
|
|
else if (last === null) {
|
|
for (i = 0; i < n; ++i) {
|
|
result[i] = now.counts[i] / count;
|
|
}
|
|
}
|
|
|
|
else {
|
|
for (i = 0; i < n; ++i) {
|
|
result[i] = (now.counts[i] - last.counts[i]) / count;
|
|
}
|
|
}
|
|
|
|
return { values: result, cuts: cuts };
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief computeStatisticsRaw
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function computeStatisticsRaw (start) {
|
|
var values;
|
|
|
|
if (start === null || start === undefined) {
|
|
values = db._query(
|
|
"FOR s IN _statistics "
|
|
+ " SORT s.time "
|
|
+ " return s");
|
|
}
|
|
else {
|
|
values = db._query(
|
|
"FOR s IN _statistics "
|
|
+ " FILTER s.time >= @start "
|
|
+ " SORT s.time "
|
|
+ " return s",
|
|
{ start: start });
|
|
}
|
|
|
|
var times = [];
|
|
var series = [];
|
|
|
|
var lastTime = null;
|
|
var lastRaw = null;
|
|
var lastLastRaw = null;
|
|
|
|
while (values.hasNext()) {
|
|
var raw = values.next();
|
|
var t = raw.time;
|
|
|
|
if (lastTime === null) {
|
|
lastTime = t;
|
|
lastLastRaw = null;
|
|
lastRaw = raw;
|
|
}
|
|
else if (lastTime + STATISTICS_INTERVALL * 1.5 < t
|
|
|| raw.server.uptime < lastRaw.server.uptime) {
|
|
while (lastTime + STATISTICS_INTERVALL * 1.1 < t) {
|
|
lastTime += STATISTICS_INTERVALL;
|
|
|
|
times.push(lastTime);
|
|
|
|
series.push({
|
|
totalTime: null,
|
|
requestTime: null,
|
|
queueTime: null,
|
|
ioTime: null,
|
|
bytesSent: null,
|
|
bytesReceived: null,
|
|
optionsPerSecond: null,
|
|
putsPerSecond: null,
|
|
headsPerSecond: null,
|
|
postsPerSecond: null,
|
|
getsPerSecond: null,
|
|
deletesPerSecond: null,
|
|
othersPerSecond: null,
|
|
patchesPerSecond: null,
|
|
asyncPerSecond: null,
|
|
virtualSize: null,
|
|
residentSize: null,
|
|
residentSizePercent: null,
|
|
majorPageFaultsPerSecond: null,
|
|
minorPageFaultsPerSecond: null,
|
|
userTime: null,
|
|
systemTime: null,
|
|
numberOfThreads: null,
|
|
clientConnections: null
|
|
});
|
|
}
|
|
|
|
lastTime = t;
|
|
lastLastRaw = null;
|
|
lastRaw = raw;
|
|
}
|
|
else {
|
|
var d = t - lastTime;
|
|
|
|
// x (aka time) axis
|
|
times.push(t);
|
|
|
|
// y axis
|
|
var data = {};
|
|
series.push(data);
|
|
|
|
// time figures
|
|
data.totalTime = avgPerSlice(
|
|
raw.client.totalTime,
|
|
lastRaw.client.totalTime);
|
|
|
|
data.requestTime = avgPerSlice(
|
|
raw.client.requestTime,
|
|
lastRaw.client.requestTime);
|
|
|
|
data.queueTime = avgPerSlice(
|
|
raw.client.queueTime,
|
|
lastRaw.client.queueTime);
|
|
|
|
// there is a chance that the request and queue do not fit perfectly
|
|
// if io time get negative, simple ignore it
|
|
|
|
data.ioTime = data.totalTime - data.requestTime - data.queueTime;
|
|
|
|
if (data.ioTime < 0.0) {
|
|
data.ioTime = 0;
|
|
}
|
|
|
|
// data transfer figures
|
|
data.bytesSent = avgPerTimeSlice(
|
|
d,
|
|
raw.client.bytesSent,
|
|
lastRaw.client.bytesSent);
|
|
|
|
data.bytesReceived = avgPerTimeSlice(
|
|
d,
|
|
raw.client.bytesReceived,
|
|
lastRaw.client.bytesReceived);
|
|
|
|
// requests
|
|
data.optionsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsOptions,
|
|
lastRaw.http.requestsOptions);
|
|
|
|
data.putsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsPut,
|
|
lastRaw.http.requestsPut);
|
|
|
|
data.headsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsHead,
|
|
lastRaw.http.requestsHead);
|
|
|
|
data.postsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsPost,
|
|
lastRaw.http.requestsPost);
|
|
|
|
data.getsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsGet,
|
|
lastRaw.http.requestsGet);
|
|
|
|
data.deletesPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsDelete,
|
|
lastRaw.http.requestsDelete);
|
|
|
|
data.othersPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsOther,
|
|
lastRaw.http.requestsOther);
|
|
|
|
data.patchesPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsPatch,
|
|
lastRaw.http.requestsPatch);
|
|
|
|
data.asyncPerSecond = perTimeSlice(
|
|
d,
|
|
raw.http.requestsAsync,
|
|
lastRaw.http.requestsAsync);
|
|
|
|
// memory size
|
|
data.virtualSize = raw.system.virtualSize;
|
|
data.residentSize = raw.system.residentSize;
|
|
data.residentSizePercent = raw.system.residentSizePercent;
|
|
|
|
data.numberOfThreads = raw.system.numberOfThreads;
|
|
data.clientConnections = raw.client.httpConnections;
|
|
|
|
// page faults
|
|
data.majorPageFaultsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.system.majorPageFaults,
|
|
lastRaw.system.majorPageFaults);
|
|
|
|
data.minorPageFaultsPerSecond = perTimeSlice(
|
|
d,
|
|
raw.system.minorPageFaults,
|
|
lastRaw.system.minorPageFaults);
|
|
|
|
// cpu time
|
|
data.userTime = raw.system.userTime;
|
|
data.systemTime = raw.system.systemTime;
|
|
|
|
// update last
|
|
lastTime = t;
|
|
lastLastRaw = lastRaw;
|
|
lastRaw = raw;
|
|
}
|
|
}
|
|
|
|
var distribution;
|
|
var server;
|
|
var current;
|
|
|
|
if (lastRaw === null) {
|
|
distribution = {
|
|
bytesSentPercent: null,
|
|
bytesReceivedPercent: null,
|
|
totalTimePercent: null,
|
|
requestTimePercent: null,
|
|
queueTimePercent: null
|
|
};
|
|
|
|
server = {
|
|
physicalMemory: 0,
|
|
uptime: 0
|
|
};
|
|
|
|
current = {
|
|
asyncRequests: 0,
|
|
asyncRequestsPercentChange: 0,
|
|
clientConnections: 0,
|
|
clientConnectionsPercentChange: 0,
|
|
numberOfThreads: 0,
|
|
numberOfThreadsPercentChange: 0,
|
|
virtualSize: 0,
|
|
virtualSizePercentChange: 0
|
|
};
|
|
}
|
|
else {
|
|
server = {
|
|
physicalMemory: lastRaw.server.physicalMemory,
|
|
uptime: lastRaw.server.uptime
|
|
};
|
|
|
|
if (lastLastRaw === null) {
|
|
current = {
|
|
asyncRequests: lastRaw.http.requestsAsync,
|
|
asyncRequestsPercentChange: 0,
|
|
clientConnections: lastRaw.client.httpConnections,
|
|
clientConnectionsPercentChange: 0,
|
|
numberOfThreads: lastRaw.system.numberOfThreads,
|
|
numberOfThreadsPercentChange: 0,
|
|
virtualSize: lastRaw.system.virtualSize,
|
|
virtualSizePercentChange: 0
|
|
};
|
|
|
|
distribution = {
|
|
bytesSentPercent: avgPercentDistributon(
|
|
lastRaw.client.bytesSent,
|
|
null,
|
|
internal.bytesSentDistribution),
|
|
|
|
bytesReceivedPercent: avgPercentDistributon(
|
|
lastRaw.client.bytesReceived,
|
|
null,
|
|
internal.bytesReceivedDistribution),
|
|
|
|
totalTimePercent: avgPercentDistributon(
|
|
lastRaw.client.totalTime,
|
|
null,
|
|
internal.requestTimeDistribution),
|
|
|
|
requestTimePercent: avgPercentDistributon(
|
|
lastRaw.client.requestTime,
|
|
null,
|
|
internal.requestTimeDistribution),
|
|
|
|
queueTimePercent: avgPercentDistributon(
|
|
lastRaw.client.queueTime,
|
|
null,
|
|
internal.requestTimeDistribution)
|
|
};
|
|
}
|
|
else {
|
|
var n1 = lastRaw.http.requestsAsync;
|
|
var m1 = lastLastRaw.http.requestsAsync;
|
|
var d1 = 0;
|
|
|
|
if (m1 !== 0) {
|
|
d1 = (n1 - m1) / m1;
|
|
}
|
|
|
|
var n2 = lastRaw.client.httpConnections;
|
|
var m2 = lastLastRaw.client.httpConnections;
|
|
var d2 = 0;
|
|
|
|
if (m2 !== 0) {
|
|
d2 = (n2 - m2) / n2;
|
|
}
|
|
|
|
var n3 = lastRaw.system.numberOfThreads;
|
|
var m3 = lastLastRaw.system.numberOfThreads;
|
|
var d3 = 0;
|
|
|
|
if (m3 !== 0) {
|
|
d3 = (n3 - m3) / n3;
|
|
}
|
|
|
|
var n4 = lastRaw.system.virtualSize;
|
|
var m4 = lastLastRaw.system.virtualSize;
|
|
var d4 = 0;
|
|
|
|
if (m4 !== 0) {
|
|
d4 = (n4 - m4) / n4;
|
|
}
|
|
|
|
current = {
|
|
asyncRequests: n1 - m1,
|
|
asyncRequestsPercentChange: d1,
|
|
clientConnections: n2,
|
|
clientConnectionsPercentChange: d2,
|
|
numberOfThreads: n3,
|
|
numberOfThreadsPercentChange: d3,
|
|
virtualSize: n4,
|
|
virtualSizePercentChange: d4
|
|
};
|
|
|
|
distribution = {
|
|
bytesSentPercent: avgPercentDistributon(
|
|
lastRaw.client.bytesSent,
|
|
lastLastRaw.client.bytesSent,
|
|
internal.bytesSentDistribution),
|
|
|
|
bytesReceivedPercent: avgPercentDistributon(
|
|
lastRaw.client.bytesReceived,
|
|
lastLastRaw.client.bytesReceived,
|
|
internal.bytesReceivedDistribution),
|
|
|
|
totalTimePercent: avgPercentDistributon(
|
|
lastRaw.client.totalTime,
|
|
lastLastRaw.client.totalTime,
|
|
internal.requestTimeDistribution),
|
|
|
|
requestTimePercent: avgPercentDistributon(
|
|
lastRaw.client.requestTime,
|
|
lastLastRaw.client.requestTime,
|
|
internal.requestTimeDistribution),
|
|
|
|
queueTimePercent: avgPercentDistributon(
|
|
lastRaw.client.queueTime,
|
|
lastLastRaw.client.queueTime,
|
|
internal.requestTimeDistribution)
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
next: lastTime,
|
|
times: times,
|
|
series: series,
|
|
distribution: distribution,
|
|
current: current,
|
|
server: server
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief computeStatisticsRaw15M
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function computeStatisticsRaw15M (start) {
|
|
var values = db._query(
|
|
"FOR s IN _statistics "
|
|
+ " FILTER s.time >= @m15 "
|
|
+ " SORT s.time "
|
|
+ " return { time: s.time, "
|
|
+ " requestsAsync: s.http.requestsAsync, "
|
|
+ " clientConnections: s.client.httpConnections, "
|
|
+ " numberOfThreads: s.system.numberOfThreads, "
|
|
+ " virtualSize: s.system.virtualSize }",
|
|
{ m15: start - 15 * 60 });
|
|
|
|
var lastRaw = null;
|
|
var count = 0;
|
|
var sumAsync = 0;
|
|
var sumConnections = 0;
|
|
var sumThreads = 0;
|
|
var sumVirtualSize = 0;
|
|
|
|
var firstAsync = null;
|
|
var firstConnections = null;
|
|
var firstThreads = null;
|
|
var firstVirtualSize = null;
|
|
|
|
while (values.hasNext()) {
|
|
var raw = values.next();
|
|
|
|
if (lastRaw === null) {
|
|
lastRaw = raw;
|
|
}
|
|
else {
|
|
var d = raw.time - lastRaw.time;
|
|
|
|
if (d !== 0) {
|
|
var n1 = (raw.requestsAsync - lastRaw.requestsAsync) / d;
|
|
var n2 = raw.clientConnections;
|
|
var n3 = raw.numberOfThreads;
|
|
var n4 = raw.virtualSize;
|
|
|
|
count++;
|
|
sumAsync += n1;
|
|
sumConnections += n2;
|
|
sumThreads += n3;
|
|
sumVirtualSize += n4;
|
|
|
|
if (firstAsync === null) {
|
|
firstAsync = n1;
|
|
}
|
|
|
|
if (firstConnections === null) {
|
|
firstConnections = n2;
|
|
}
|
|
|
|
if (firstThreads === null) {
|
|
firstThreads = n3;
|
|
}
|
|
|
|
if (firstVirtualSize === null) {
|
|
firstVirtualSize = n4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count !== 0) {
|
|
sumAsync /= count;
|
|
sumConnections /= count;
|
|
sumThreads /= count;
|
|
sumVirtualSize /= count;
|
|
}
|
|
|
|
if (firstAsync === null) {
|
|
firstAsync = 0;
|
|
}
|
|
else if (firstAsync !== 0) {
|
|
firstAsync = (sumAsync - firstAsync) / firstAsync;
|
|
}
|
|
|
|
if (firstConnections === null) {
|
|
firstConnections = 0;
|
|
}
|
|
else if (firstConnections !== 0) {
|
|
firstConnections = (sumConnections - firstConnections) / firstConnections;
|
|
}
|
|
|
|
if (firstThreads === null) {
|
|
firstThreads = 0;
|
|
}
|
|
else if (firstThreads !== 0) {
|
|
firstThreads = (sumThreads - firstThreads) / firstThreads;
|
|
}
|
|
|
|
if (firstVirtualSize === null) {
|
|
firstVirtualSize = 0;
|
|
}
|
|
else if (firstVirtualSize !== 0) {
|
|
firstVirtualSize = (sumVirtualSize - firstVirtualSize) / firstVirtualSize;
|
|
}
|
|
|
|
return {
|
|
asyncPerSecond: sumAsync,
|
|
asyncPerSecondPercentChange: firstAsync,
|
|
clientConnections: sumConnections,
|
|
clientConnectionsPercentChange: firstConnections,
|
|
numberOfThreads: sumThreads,
|
|
numberOfThreadsPercentChange: firstThreads,
|
|
virtualSize: sumVirtualSize,
|
|
virtualSizePercentChange: firstVirtualSize
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief convertSeries
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function convertSeries (series, name) {
|
|
var result = [];
|
|
var i;
|
|
|
|
for (i = 0; i < series.length; ++i) {
|
|
result.push(series[i][name]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief computeStatisticsSeries
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function computeStatisticsSeries (start, attrs) {
|
|
var result = {};
|
|
var raw = computeStatisticsRaw(start);
|
|
|
|
result.nextStart = raw.next;
|
|
result.waitFor = (raw.next + STATISTICS_INTERVALL) - internal.time();
|
|
result.times = raw.times;
|
|
|
|
if (result.waitFor < 1) {
|
|
result.waitFor = 1;
|
|
}
|
|
|
|
if (attrs === null || attrs.avgTotalTime) {
|
|
result.avgTotalTime = convertSeries(raw.series, "totalTime");
|
|
}
|
|
|
|
if (attrs === null || attrs.totalTimeDistributionPercent) {
|
|
result.totalTimeDistributionPercent = raw.distribution.totalTimePercent;
|
|
}
|
|
|
|
if (attrs === null || attrs.avgRequestTime) {
|
|
result.avgRequestTime = convertSeries(raw.series, "requestTime");
|
|
}
|
|
|
|
if (attrs === null || attrs.requestTimeDistribution) {
|
|
result.requestTimeDistributionPercent = raw.distribution.requestTimePercent;
|
|
}
|
|
|
|
if (attrs === null || attrs.avgQueueTime) {
|
|
result.avgQueueTime = convertSeries(raw.series, "queueTime");
|
|
}
|
|
|
|
if (attrs === null || attrs.queueTimeDistributionPercent) {
|
|
result.queueTimeDistributionPercent = raw.distribution.queueTimePercent;
|
|
}
|
|
|
|
if (attrs === null || attrs.avgIoTime) {
|
|
result.avgIoTime = convertSeries(raw.series, "ioTime");
|
|
}
|
|
|
|
if (attrs === null || attrs.bytesSentPerSecond) {
|
|
result.bytesSentPerSecond = convertSeries(raw.series, "bytesSent");
|
|
}
|
|
|
|
if (attrs === null || attrs.bytesSentDistributionPercent) {
|
|
result.bytesSentDistributionPercent = raw.distribution.bytesSentPercent;
|
|
}
|
|
|
|
if (attrs === null || attrs.bytesReceivedPerSecond) {
|
|
result.bytesReceivedPerSecond = convertSeries(raw.series, "bytesReceived");
|
|
}
|
|
|
|
if (attrs === null || attrs.bytesReceivedDistributionPercent) {
|
|
result.bytesReceivedDistributionPercent = raw.distribution.bytesReceivedPercent;
|
|
}
|
|
|
|
if (attrs === null || attrs.optionsPerSecond) {
|
|
result.optionsPerSecond = convertSeries(raw.series, "optionsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.putsPerSecond) {
|
|
result.putsPerSecond = convertSeries(raw.series, "putsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.headsPerSecond) {
|
|
result.headsPerSecond = convertSeries(raw.series, "headsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.postsPerSecond) {
|
|
result.postsPerSecond = convertSeries(raw.series, "postsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.getsPerSecond) {
|
|
result.getsPerSecond = convertSeries(raw.series, "getsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.deletesPerSecond) {
|
|
result.deletesPerSecond = convertSeries(raw.series, "deletesPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.othersPerSecond) {
|
|
result.othersPerSecond = convertSeries(raw.series, "othersPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.patchesPerSecond) {
|
|
result.patchesPerSecond = convertSeries(raw.series, "patchesPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.asyncPerSecond) {
|
|
result.asyncPerSecond = convertSeries(raw.series, "asyncPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.asyncRequestsCurrent) {
|
|
result.asyncRequestsCurrent = raw.current.asyncRequests;
|
|
}
|
|
|
|
if (attrs === null || attrs.asyncRequestsCurrentPercentChange) {
|
|
result.asyncRequestsCurrentPercentChange = raw.current.asyncRequestsPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.clientConnections) {
|
|
result.clientConnections = convertSeries(raw.series, "clientConnections");
|
|
}
|
|
|
|
if (attrs === null || attrs.clientConnectionsCurrent) {
|
|
result.clientConnectionsCurrent = raw.current.clientConnections;
|
|
}
|
|
|
|
if (attrs === null || attrs.clientConnectionsCurrentPercentChange) {
|
|
result.clientConnectionsCurrentPercentChange = raw.current.clientConnectionsPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.numberOfThreads) {
|
|
result.numberOfThreads = convertSeries(raw.series, "numberOfThreads");
|
|
}
|
|
|
|
if (attrs === null || attrs.numberOfThreadsCurrent) {
|
|
result.numberOfThreadsCurrent = raw.current.numberOfThreads;
|
|
}
|
|
|
|
if (attrs === null || attrs.numberOfThreadsCurrentPercentChange) {
|
|
result.numberOfThreadsCurrentPercentChange = raw.current.numberOfThreadsPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.residentSize) {
|
|
result.residentSize = convertSeries(raw.series, "residentSize");
|
|
}
|
|
|
|
if (attrs === null || attrs.residentSizePercent) {
|
|
result.residentSizePercent = convertSeries(raw.series, "residentSizePercent");
|
|
}
|
|
|
|
if (attrs === null || attrs.virtualSize) {
|
|
result.virtualSize = convertSeries(raw.series, "virtualSize");
|
|
}
|
|
|
|
if (attrs === null || attrs.asyncRequestsCurrentPercentChange) {
|
|
result.asyncRequestsCurrentPercentChange = raw.current.asyncRequestsPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.virtualSizeCurrent) {
|
|
result.virtualSizeCurrent = raw.current.virtualSize;
|
|
}
|
|
|
|
if (attrs === null || attrs.virtualSizePercentChange) {
|
|
result.virtualSizePercentChange = raw.current.virtualSizePercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.majorPageFaultsPerSecond) {
|
|
result.majorPageFaultsPerSecond = convertSeries(raw.series, "majorPageFaultsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.minorPageFaultsPerSecond) {
|
|
result.minorPageFaultsPerSecond = convertSeries(raw.series, "minorPageFaultsPerSecond");
|
|
}
|
|
|
|
if (attrs === null || attrs.cpuUserTime) {
|
|
result.cpuUserTime = convertSeries(raw.series, "userTime");
|
|
}
|
|
|
|
if (attrs === null || attrs.cpuSystemTime) {
|
|
result.cpuSystemTime = convertSeries(raw.series, "systemTime");
|
|
}
|
|
|
|
if (attrs === null || attrs.uptime) {
|
|
result.uptime = raw.server.uptime;
|
|
}
|
|
|
|
if (attrs === null || attrs.physicalMemory) {
|
|
result.physicalMemory = raw.server.physicalMemory;
|
|
}
|
|
|
|
if (result.next !== null) {
|
|
var raw15 = computeStatisticsRaw15M(raw.next);
|
|
|
|
if (attrs === null || attrs.asyncPerSecond15M) {
|
|
result.asyncPerSecond15M = raw15.asyncPerSecond;
|
|
}
|
|
|
|
if (attrs === null || attrs.asyncPerSecondPercentChange15M) {
|
|
result.asyncPerSecondPercentChange15M = raw15.asyncPerSecondPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.clientConnections15M) {
|
|
result.clientConnections15M = raw15.clientConnections;
|
|
}
|
|
|
|
if (attrs === null || attrs.clientConnectionsPercentChange15M) {
|
|
result.clientConnectionsPercentChange15M = raw15.clientConnectionsPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.numberOfThreads15M) {
|
|
result.numberOfThreads15M = raw15.numberOfThreads;
|
|
}
|
|
|
|
if (attrs === null || attrs.numberOfThreadsPercentChange15M) {
|
|
result.numberOfThreadsPercentChange15M = raw15.numberOfThreadsPercentChange;
|
|
}
|
|
|
|
if (attrs === null || attrs.virtualSize15M) {
|
|
result.virtualSize15M = raw15.virtualSize;
|
|
}
|
|
|
|
if (attrs === null || attrs.virtualSizePercentChange15M) {
|
|
result.virtualSizePercentChange15M = raw15.virtualSizePercentChange;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- public routes
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief full statistics history
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
controller.get("full", function (req, res) {
|
|
var start = req.params("start");
|
|
var filter = req.params("filter");
|
|
var serverEndpoint = decodeURIComponent(req.params("serverEndpoint"));
|
|
var DbServer = req.params("DbServer");
|
|
var attrs = null;
|
|
|
|
if (start !== null && start !== undefined) {
|
|
start = parseInt(start, 10);
|
|
}
|
|
|
|
if (filter !== null && filter !== undefined && filter !== "") {
|
|
var s = filter.split(",");
|
|
var i;
|
|
|
|
attrs = {};
|
|
|
|
for (i = 0; i < s.length; ++i) {
|
|
attrs[s[i]] = true;
|
|
}
|
|
}
|
|
|
|
var series = computeStatisticsSeries(start, attrs);
|
|
|
|
res.json(series);
|
|
}).summary("Returns the complete or partial history")
|
|
.notes("This function is just to get the complete or partial statistics history");
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @\\}"
|
|
// End:
|