Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

allow turning off statistics feature (#5883)

This commit is contained in:
Jan 2018-07-16 10:46:43 +02:00 committed by GitHub
parent 1f5d2f38e7
commit 201a6a308b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 119 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
arangod/Agency/AgencyFeature.cpp
View File

@ -231,6 +231,16 @@ void AgencyFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
if (result.touched("agency.supervision")) {
_supervisionTouched = true;
}
// turn off the following features, as they are not needed in an agency:
// - MMFilesPersistentIndex: not needed by agency even if MMFiles is
// the selected storage engine
// - ArangoSearch: not needed by agency even if MMFiles is the selected
// storage engine
// - Statistics: turn off statistics gathering for agency
application_features::ApplicationServer::disableFeatures(
{"MMFilesPersistentIndex", "ArangoSearch", "Statistics"}
);
}
void AgencyFeature::prepare() {

6
arangod/RestHandler/RestAdminStatisticsHandler.cpp
View File

@ -54,8 +54,7 @@ RestStatus RestAdminStatisticsHandler::execute() {
void RestAdminStatisticsHandler::getStatistics() {
stats::Descriptions const* desc = StatisticsFeature::descriptions();
if (!desc) {
generateError(rest::ResponseCode::SERVICE_UNAVAILABLE,
TRI_ERROR_SHUTTING_DOWN);
generateError(rest::ResponseCode::NOT_FOUND, TRI_ERROR_DISABLED, "statistics not enabled");
return;
}
@ -91,8 +90,7 @@ void RestAdminStatisticsHandler::getStatistics() {
void RestAdminStatisticsHandler::getStatisticsDescription() {
stats::Descriptions const* desc = StatisticsFeature::descriptions();
if (!desc) {
generateError(rest::ResponseCode::SERVICE_UNAVAILABLE,
TRI_ERROR_SHUTTING_DOWN);
generateError(rest::ResponseCode::NOT_FOUND, TRI_ERROR_DISABLED, "statistics not enabled");
return;
}

7
arangod/RestServer/ServerFeature.cpp
View File

@ -33,7 +33,6 @@
#include "RestServer/DatabaseFeature.h"
#include "RestServer/VocbaseContext.h"
#include "Scheduler/SchedulerFeature.h"
#include "Statistics/StatisticsFeature.h"
#include "V8/v8-conv.h"
#include "V8/v8-globals.h"
#include "V8/v8-utils.h"
@ -129,7 +128,7 @@ void ServerFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
if (!_restServer) {
ApplicationServer::disableFeatures({"Daemon", "Endpoint", "GeneralServer",
"SslServer", "Supervisor"});
"SslServer", "Statistics", "Supervisor"});
if (!options->processingResult().touched("replication.auto-start")) {
// turn off replication applier when we do not have a rest server
@ -139,10 +138,6 @@ void ServerFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
ApplicationServer::getFeature<ReplicationFeature>("Replication");
replicationFeature->disableReplicationApplier();
}
StatisticsFeature* statisticsFeature =
ApplicationServer::getFeature<StatisticsFeature>("Statistics");
statisticsFeature->disableStatistics();
}
if (_operationMode == OperationMode::MODE_CONSOLE) {

6
arangod/Statistics/ConnectionStatistics.cpp
View File

@ -64,8 +64,6 @@ void ConnectionStatistics::initialize() {
}
}
void ConnectionStatistics::shutdown() {}
ConnectionStatistics* ConnectionStatistics::acquire() {
ConnectionStatistics* statistics = nullptr;
@ -96,7 +94,7 @@ void ConnectionStatistics::fill(StatisticsCounter& httpConnections,
totalRequests = TRI_TotalRequestsStatistics;
methodRequests = TRI_MethodRequestsStatistics;
asyncRequests = TRI_AsyncRequestsStatistics;
connectionTime = *TRI_ConnectionTimeDistributionStatistics;
connectionTime = TRI_ConnectionTimeDistributionStatistics;
}
// -----------------------------------------------------------------------------
@ -113,7 +111,7 @@ void ConnectionStatistics::release() {
if (_connStart != 0.0 && _connEnd != 0.0) {
double totalTime = _connEnd - _connStart;
TRI_ConnectionTimeDistributionStatistics->addFigure(totalTime);
TRI_ConnectionTimeDistributionStatistics.addFigure(totalTime);
}
}

1
arangod/Statistics/ConnectionStatistics.h
View File

@ -36,7 +36,6 @@ namespace arangodb {
class ConnectionStatistics {
public:
static void initialize();
static void shutdown();
static ConnectionStatistics* acquire();
void release();

62
arangod/Statistics/Descriptions.cpp
View File

@ -21,7 +21,6 @@
////////////////////////////////////////////////////////////////////////////////
#include "Descriptions.h"
#include "Basics/Common.h"
#include "Basics/process-utils.h"
#include "Statistics/ConnectionStatistics.h"
#include "Statistics/RequestStatistics.h"
@ -105,10 +104,10 @@ void stats::Figure::toVPack(velocypack::Builder& b) const {
}
stats::Descriptions::Descriptions()
: _requestTimeCuts({0.01, 0.05, 0.1, 0.2, 0.5, 1.0}),
_connectionTimeCuts({0.1, 1.0, 60.0}),
_bytesSendCuts({250, 1000, 2 * 1000, 5 * 1000, 10 * 1000}),
_bytesReceivedCuts({250, 1000, 2 * 1000, 5 * 1000, 10 * 1000}) {
: _requestTimeCuts(arangodb::basics::TRI_RequestTimeDistributionVectorStatistics),
_connectionTimeCuts(arangodb::basics::TRI_ConnectionTimeDistributionVectorStatistics),
_bytesSendCuts(arangodb::basics::TRI_BytesSentDistributionVectorStatistics),
_bytesReceivedCuts(arangodb::basics::TRI_BytesReceivedDistributionVectorStatistics) {
_groups.emplace_back(Group{stats::GroupType::System, "Process Statistics",
"Statistics about the ArangoDB process"});
_groups.emplace_back(Group{stats::GroupType::Client,
@ -240,7 +239,7 @@ stats::Descriptions::Descriptions()
_figures.emplace_back(
Figure{stats::GroupType::Client, "bytesReceived", "Bytes Received",
"Bytes receiveds for a request.", stats::FigureType::Distribution,
"Bytes received for a request.", stats::FigureType::Distribution,
// cuts: internal.bytesReceivedDistribution,
stats::Unit::Bytes, _bytesReceivedCuts});
@ -355,18 +354,18 @@ stats::Descriptions::Descriptions()
void stats::Descriptions::serverStatistics(velocypack::Builder& b) const {
ServerStatistics info = ServerStatistics::statistics();
b.add("uptime", VPackValue(info._uptime));
b.add("physicalMemory", VPackValue((double)TRI_PhysicalMemory));
b.add("physicalMemory", VPackValue(TRI_PhysicalMemory));
V8DealerFeature* dealer =
application_features::ApplicationServer::getFeature<V8DealerFeature>("V8Dealer");
if (dealer->isEnabled()) {
b.add("v8Context", VPackValue(VPackValueType::Object, true));
auto v8Counters = dealer->getCurrentContextNumbers();
b.add( "available", VPackValue(static_cast<int32_t>(v8Counters.available)));
b.add( "busy", VPackValue(static_cast<int32_t>(v8Counters.busy)));
b.add( "dirty", VPackValue(static_cast<int32_t>(v8Counters.dirty)));
b.add( "free", VPackValue(static_cast<int32_t>(v8Counters.free)));
b.add( "max", VPackValue(static_cast<int32_t>(v8Counters.max)));
b.add( "available", VPackValue(v8Counters.available));
b.add( "busy", VPackValue(v8Counters.busy));
b.add( "dirty", VPackValue(v8Counters.dirty));
b.add( "free", VPackValue(v8Counters.free));
b.add( "max", VPackValue(v8Counters.max));
b.close();
}
@ -377,7 +376,6 @@ void stats::Descriptions::serverStatistics(velocypack::Builder& b) const {
b.close();
}
////////////////////////////////////////////////////////////////////////////////
/// @brief fills the distribution
////////////////////////////////////////////////////////////////////////////////
@ -386,11 +384,10 @@ static void FillDistribution(VPackBuilder& b, std::string const& name,
basics::StatisticsDistribution const& dist) {
b.add(name, VPackValue(VPackValueType::Object, true));
b.add("sum", VPackValue(dist._total));
b.add("count", VPackValue((double)dist._count));
b.add("count", VPackValue(dist._count));
b.add("counts", VPackValue(VPackValueType::Array, true));
for (std::vector<uint64_t>::const_iterator i = dist._counts.begin();
i != dist._counts.end(); ++i) {
b.add(VPackValue(*i));
for (auto const& it : dist._counts) {
b.add(VPackValue(it));
}
b.close();
b.close();
@ -407,7 +404,7 @@ void stats::Descriptions::clientStatistics(velocypack::Builder& b) const {
ConnectionStatistics::fill(httpConnections, totalRequests, methodRequests,
asyncRequests, connectionTime);
b.add("httpConnections", VPackValue((double)httpConnections._count));
b.add("httpConnections", VPackValue(httpConnections._count));
FillDistribution(b, "connectionTime", connectionTime);
basics::StatisticsDistribution totalTime;
@ -439,19 +436,18 @@ void stats::Descriptions::httpStatistics(velocypack::Builder& b) const {
asyncRequests, connectionTime);
// request counters
b.add("requestsTotal", VPackValue((double)totalRequests._count));
b.add("requestsAsync", VPackValue((double)asyncRequests._count));
b.add("requestsGet", VPackValue((double)methodRequests[(int)rest::RequestType::GET]._count));
b.add("requestsHead", VPackValue((double)methodRequests[(int)rest::RequestType::HEAD]._count));
b.add("requestsPost", VPackValue((double)methodRequests[(int)rest::RequestType::POST]._count));
b.add("requestsPut", VPackValue((double)methodRequests[(int)rest::RequestType::PUT]._count));
b.add("requestsPatch", VPackValue((double)methodRequests[(int)rest::RequestType::PATCH]._count));
b.add("requestsDelete", VPackValue((double)methodRequests[(int)rest::RequestType::DELETE_REQ]._count));
b.add("requestsOptions", VPackValue((double)methodRequests[(int)rest::RequestType::OPTIONS]._count));
b.add("requestsOther", VPackValue((double)methodRequests[(int)rest::RequestType::ILLEGAL]._count));
b.add("requestsTotal", VPackValue(totalRequests._count));
b.add("requestsAsync", VPackValue(asyncRequests._count));
b.add("requestsGet", VPackValue(methodRequests[(int)rest::RequestType::GET]._count));
b.add("requestsHead", VPackValue(methodRequests[(int)rest::RequestType::HEAD]._count));
b.add("requestsPost", VPackValue(methodRequests[(int)rest::RequestType::POST]._count));
b.add("requestsPut", VPackValue(methodRequests[(int)rest::RequestType::PUT]._count));
b.add("requestsPatch", VPackValue(methodRequests[(int)rest::RequestType::PATCH]._count));
b.add("requestsDelete", VPackValue(methodRequests[(int)rest::RequestType::DELETE_REQ]._count));
b.add("requestsOptions", VPackValue(methodRequests[(int)rest::RequestType::OPTIONS]._count));
b.add("requestsOther", VPackValue(methodRequests[(int)rest::RequestType::ILLEGAL]._count));
}
void stats::Descriptions::processStatistics(VPackBuilder& b) const {
ProcessInfo info = TRI_ProcessInfoSelf();
double rss = (double)info._residentSize;
@ -461,12 +457,12 @@ void stats::Descriptions::processStatistics(VPackBuilder& b) const {
rssp = rss / TRI_PhysicalMemory;
}
b.add("minorPageFaults", VPackValue((double)info._minorPageFaults));
b.add("majorPageFaults", VPackValue((double)info._majorPageFaults));
b.add("minorPageFaults", VPackValue(info._minorPageFaults));
b.add("majorPageFaults", VPackValue(info._majorPageFaults));
b.add("userTime", VPackValue((double)info._userTime / (double)info._scClkTck));
b.add("systemTime", VPackValue((double)info._systemTime / (double)info._scClkTck));
b.add("numberOfThreads", VPackValue((double)info._numberThreads));
b.add("numberOfThreads", VPackValue(info._numberThreads));
b.add("residentSize", VPackValue(rss));
b.add("residentSizePercent", VPackValue(rssp));
b.add("virtualSize", VPackValue((double)info._virtualSize));
b.add("virtualSize", VPackValue(info._virtualSize));
}

2
arangod/Statistics/Descriptions.h
View File

@ -23,6 +23,8 @@
#ifndef ARANGOD_STATISTICS_DESCRIPTIONS_H
#define ARANGOD_STATISTICS_DESCRIPTIONS_H 1
#include "Basics/Common.h"
#include <velocypack/Builder.h>
#include <string>

26
arangod/Statistics/RequestStatistics.cpp
View File

@ -62,8 +62,6 @@ void RequestStatistics::initialize() {
}
}
void RequestStatistics::shutdown() {}
size_t RequestStatistics::processAll() {
RequestStatistics* statistics = nullptr;
size_t count = 0;
@ -130,26 +128,26 @@ void RequestStatistics::process(RequestStatistics* statistics) {
totalTime = statistics->_writeEnd - statistics->_readStart;
}
TRI_TotalTimeDistributionStatistics->addFigure(totalTime);
TRI_TotalTimeDistributionStatistics.addFigure(totalTime);
double requestTime = statistics->_requestEnd - statistics->_requestStart;
TRI_RequestTimeDistributionStatistics->addFigure(requestTime);
TRI_RequestTimeDistributionStatistics.addFigure(requestTime);
double queueTime = 0.0;
if (statistics->_queueStart != 0.0 && statistics->_queueEnd != 0.0) {
queueTime = statistics->_queueEnd - statistics->_queueStart;
TRI_QueueTimeDistributionStatistics->addFigure(queueTime);
TRI_QueueTimeDistributionStatistics.addFigure(queueTime);
}
double ioTime = totalTime - requestTime - queueTime;
if (ioTime >= 0.0) {
TRI_IoTimeDistributionStatistics->addFigure(ioTime);
TRI_IoTimeDistributionStatistics.addFigure(ioTime);
}
TRI_BytesSentDistributionStatistics->addFigure(statistics->_sentBytes);
TRI_BytesReceivedDistributionStatistics->addFigure(
TRI_BytesSentDistributionStatistics.addFigure(statistics->_sentBytes);
TRI_BytesReceivedDistributionStatistics.addFigure(
statistics->_receivedBytes);
}
}
@ -205,12 +203,12 @@ void RequestStatistics::fill(StatisticsDistribution& totalTime,
MUTEX_LOCKER(mutexLocker, _dataLock);
totalTime = *TRI_TotalTimeDistributionStatistics;
requestTime = *TRI_RequestTimeDistributionStatistics;
queueTime = *TRI_QueueTimeDistributionStatistics;
ioTime = *TRI_IoTimeDistributionStatistics;
bytesSent = *TRI_BytesSentDistributionStatistics;
bytesReceived = *TRI_BytesReceivedDistributionStatistics;
totalTime = TRI_TotalTimeDistributionStatistics;
requestTime = TRI_RequestTimeDistributionStatistics;
queueTime = TRI_QueueTimeDistributionStatistics;
ioTime = TRI_IoTimeDistributionStatistics;
bytesSent = TRI_BytesSentDistributionStatistics;
bytesReceived = TRI_BytesReceivedDistributionStatistics;
}
std::string RequestStatistics::timingsCsv() {

1
arangod/Statistics/RequestStatistics.h
View File

@ -37,7 +37,6 @@ namespace arangodb {
class RequestStatistics {
public:
static void initialize();
static void shutdown();
static size_t processAll();
static RequestStatistics* acquire();

4
arangod/Statistics/ServerStatistics.cpp
View File

@ -22,7 +22,6 @@
////////////////////////////////////////////////////////////////////////////////
#include "ServerStatistics.h"
#include "Statistics/StatisticsFeature.h"
using namespace arangodb;
@ -49,6 +48,3 @@ ServerStatistics ServerStatistics::statistics() {
void ServerStatistics::initialize() {
START_TIME = StatisticsFeature::time();
}
void ServerStatistics::shutdown() {
}

1
arangod/Statistics/ServerStatistics.h
View File

@ -29,7 +29,6 @@ class ServerStatistics {
static ServerStatistics statistics();
static void initialize();
static void shutdown();
double _startTime;
double _uptime;

90
arangod/Statistics/StatisticsFeature.cpp
View File

@ -46,21 +46,25 @@ using namespace arangodb::options;
namespace arangodb {
namespace basics {
std::vector<double> const TRI_BytesReceivedDistributionVectorStatistics({ 250, 1000, 2000, 5000, 10000 });
std::vector<double> const TRI_BytesSentDistributionVectorStatistics({ 250, 1000, 2000, 5000, 10000 });
std::vector<double> const TRI_ConnectionTimeDistributionVectorStatistics({ 0.1, 1.0, 60.0 });
std::vector<double> const TRI_RequestTimeDistributionVectorStatistics({ 0.01, 0.05, 0.1, 0.2, 0.5, 1.0 });
StatisticsCounter TRI_AsyncRequestsStatistics;
StatisticsCounter TRI_HttpConnectionsStatistics;
StatisticsCounter TRI_TotalRequestsStatistics;
StatisticsDistribution* TRI_BytesReceivedDistributionStatistics;
StatisticsDistribution* TRI_BytesSentDistributionStatistics;
StatisticsDistribution* TRI_ConnectionTimeDistributionStatistics;
StatisticsDistribution* TRI_IoTimeDistributionStatistics;
StatisticsDistribution* TRI_QueueTimeDistributionStatistics;
StatisticsDistribution* TRI_RequestTimeDistributionStatistics;
StatisticsDistribution* TRI_TotalTimeDistributionStatistics;
StatisticsVector TRI_BytesReceivedDistributionVectorStatistics;
StatisticsVector TRI_BytesSentDistributionVectorStatistics;
StatisticsVector TRI_ConnectionTimeDistributionVectorStatistics;
StatisticsVector TRI_RequestTimeDistributionVectorStatistics;
std::vector<StatisticsCounter> TRI_MethodRequestsStatistics;
StatisticsDistribution TRI_BytesReceivedDistributionStatistics(TRI_BytesReceivedDistributionVectorStatistics);
StatisticsDistribution TRI_BytesSentDistributionStatistics(TRI_BytesSentDistributionVectorStatistics);
StatisticsDistribution TRI_ConnectionTimeDistributionStatistics(TRI_ConnectionTimeDistributionVectorStatistics);
StatisticsDistribution TRI_IoTimeDistributionStatistics(TRI_RequestTimeDistributionVectorStatistics);
StatisticsDistribution TRI_QueueTimeDistributionStatistics(TRI_RequestTimeDistributionVectorStatistics);
StatisticsDistribution TRI_RequestTimeDistributionStatistics(TRI_RequestTimeDistributionVectorStatistics);
StatisticsDistribution TRI_TotalTimeDistributionStatistics(TRI_RequestTimeDistributionVectorStatistics);
}
}
@ -105,10 +109,6 @@ class arangodb::StatisticsThread final : public Thread {
}
}
}
RequestStatistics::shutdown();
ConnectionStatistics::shutdown();
ServerStatistics::shutdown();
}
};
@ -125,6 +125,7 @@ StatisticsFeature::StatisticsFeature(
_descriptions(new stats::Descriptions()) {
startsAfter("Logger");
startsAfter("Aql");
setOptional(true);
}
void StatisticsFeature::collectOptions(
@ -138,6 +139,14 @@ void StatisticsFeature::collectOptions(
new BooleanParameter(&_statistics));
}
void StatisticsFeature::validateOptions(
std::shared_ptr<ProgramOptions>) {
if (!_statistics) {
// turn ourselves off
disable();
}
}
void StatisticsFeature::prepare() {
// initialize counters for all HTTP request types
TRI_MethodRequestsStatistics.clear();
@ -146,31 +155,7 @@ void StatisticsFeature::prepare() {
StatisticsCounter c;
TRI_MethodRequestsStatistics.emplace_back(c);
}
TRI_ConnectionTimeDistributionVectorStatistics << (0.1) << (1.0) << (60.0);
TRI_BytesSentDistributionVectorStatistics << (250) << (1000) << (2 * 1000)
<< (5 * 1000) << (10 * 1000);
TRI_BytesReceivedDistributionVectorStatistics << (250) << (1000) << (2 * 1000)
<< (5 * 1000) << (10 * 1000);
TRI_RequestTimeDistributionVectorStatistics << (0.01) << (0.05) << (0.1)
<< (0.2) << (0.5) << (1.0);
TRI_ConnectionTimeDistributionStatistics = new StatisticsDistribution(
TRI_ConnectionTimeDistributionVectorStatistics);
TRI_TotalTimeDistributionStatistics =
new StatisticsDistribution(TRI_RequestTimeDistributionVectorStatistics);
TRI_RequestTimeDistributionStatistics =
new StatisticsDistribution(TRI_RequestTimeDistributionVectorStatistics);
TRI_QueueTimeDistributionStatistics =
new StatisticsDistribution(TRI_RequestTimeDistributionVectorStatistics);
TRI_IoTimeDistributionStatistics =
new StatisticsDistribution(TRI_RequestTimeDistributionVectorStatistics);
TRI_BytesSentDistributionStatistics =
new StatisticsDistribution(TRI_BytesSentDistributionVectorStatistics);
TRI_BytesReceivedDistributionStatistics =
new StatisticsDistribution(TRI_BytesReceivedDistributionVectorStatistics);
STATISTICS = this;
ServerStatistics::initialize();
@ -179,7 +164,7 @@ void StatisticsFeature::prepare() {
}
void StatisticsFeature::start() {
if (!_statistics) {
if (!isEnabled()) {
return;
}
@ -232,27 +217,6 @@ void StatisticsFeature::unprepare() {
_statisticsThread.reset();
_statisticsWorker.reset();
delete TRI_ConnectionTimeDistributionStatistics;
TRI_ConnectionTimeDistributionStatistics = nullptr;
delete TRI_TotalTimeDistributionStatistics;
TRI_TotalTimeDistributionStatistics = nullptr;
delete TRI_RequestTimeDistributionStatistics;
TRI_RequestTimeDistributionStatistics = nullptr;
delete TRI_QueueTimeDistributionStatistics;
TRI_QueueTimeDistributionStatistics = nullptr;
delete TRI_IoTimeDistributionStatistics;
TRI_IoTimeDistributionStatistics = nullptr;
delete TRI_BytesSentDistributionStatistics;
TRI_BytesSentDistributionStatistics = nullptr;
delete TRI_BytesReceivedDistributionStatistics;
TRI_BytesReceivedDistributionStatistics = nullptr;
STATISTICS = nullptr;
}

30
arangod/Statistics/StatisticsFeature.h
View File

@ -29,21 +29,25 @@
namespace arangodb {
namespace basics {
extern std::vector<double> const TRI_BytesReceivedDistributionVectorStatistics;
extern std::vector<double> const TRI_BytesSentDistributionVectorStatistics;
extern std::vector<double> const TRI_ConnectionTimeDistributionVectorStatistics;
extern std::vector<double> const TRI_RequestTimeDistributionVectorStatistics;
extern StatisticsCounter TRI_AsyncRequestsStatistics;
extern StatisticsCounter TRI_HttpConnectionsStatistics;
extern StatisticsCounter TRI_TotalRequestsStatistics;
extern StatisticsDistribution* TRI_BytesReceivedDistributionStatistics;
extern StatisticsDistribution* TRI_BytesSentDistributionStatistics;
extern StatisticsDistribution* TRI_ConnectionTimeDistributionStatistics;
extern StatisticsDistribution* TRI_IoTimeDistributionStatistics;
extern StatisticsDistribution* TRI_QueueTimeDistributionStatistics;
extern StatisticsDistribution* TRI_RequestTimeDistributionStatistics;
extern StatisticsDistribution* TRI_TotalTimeDistributionStatistics;
extern StatisticsVector TRI_BytesReceivedDistributionVectorStatistics;
extern StatisticsVector TRI_BytesSentDistributionVectorStatistics;
extern StatisticsVector TRI_ConnectionTimeDistributionVectorStatistics;
extern StatisticsVector TRI_RequestTimeDistributionVectorStatistics;
extern std::vector<StatisticsCounter> TRI_MethodRequestsStatistics;
extern StatisticsDistribution TRI_BytesReceivedDistributionStatistics;
extern StatisticsDistribution TRI_BytesSentDistributionStatistics;
extern StatisticsDistribution TRI_ConnectionTimeDistributionStatistics;
extern StatisticsDistribution TRI_IoTimeDistributionStatistics;
extern StatisticsDistribution TRI_QueueTimeDistributionStatistics;
extern StatisticsDistribution TRI_RequestTimeDistributionStatistics;
extern StatisticsDistribution TRI_TotalTimeDistributionStatistics;
}
namespace stats{
class Descriptions;
@ -69,6 +73,7 @@ class StatisticsFeature final
public:
void collectOptions(std::shared_ptr<options::ProgramOptions>) override final;
void validateOptions(std::shared_ptr<options::ProgramOptions>) override final;
void prepare() override final;
void start() override final;
void unprepare() override final;
@ -80,9 +85,6 @@ class StatisticsFeature final
return nullptr;
}
public:
void disableStatistics() { _statistics = false; }
private:
bool _statistics;

6
arangod/Statistics/StatisticsWorker.cpp
View File

@ -73,7 +73,7 @@ StatisticsWorker::StatisticsWorker(TRI_vocbase_t& vocbase)
_vocbase(vocbase) {
_bytesSentDistribution.openArray();
for (auto const& val : TRI_BytesSentDistributionVectorStatistics._value) {
for (auto const& val : TRI_BytesSentDistributionVectorStatistics) {
_bytesSentDistribution.add(VPackValue(val));
}
@ -81,7 +81,7 @@ StatisticsWorker::StatisticsWorker(TRI_vocbase_t& vocbase)
_bytesReceivedDistribution.openArray();
for (auto const& val : TRI_BytesReceivedDistributionVectorStatistics._value) {
for (auto const& val : TRI_BytesReceivedDistributionVectorStatistics) {
_bytesReceivedDistribution.add(VPackValue(val));
}
@ -89,7 +89,7 @@ StatisticsWorker::StatisticsWorker(TRI_vocbase_t& vocbase)
_requestTimeDistribution.openArray();
for (auto const& val : TRI_RequestTimeDistributionVectorStatistics._value) {
for (auto const& val : TRI_RequestTimeDistributionVectorStatistics) {
_requestTimeDistribution.add(VPackValue(val));
}

19
arangod/Statistics/figures.h
View File

@ -29,21 +29,6 @@
namespace arangodb {
namespace basics {
////////////////////////////////////////////////////////////////////////////////
/// @brief vector generator
////////////////////////////////////////////////////////////////////////////////
struct StatisticsVector {
StatisticsVector() : _value() {}
StatisticsVector& operator<<(double v) {
_value.push_back(v);
return *this;
}
std::vector<double> _value;
};
////////////////////////////////////////////////////////////////////////////////
/// @brief a simple counter
////////////////////////////////////////////////////////////////////////////////
@ -65,8 +50,8 @@ struct StatisticsCounter {
struct StatisticsDistribution {
StatisticsDistribution() : _count(0), _total(0.0), _cuts(), _counts() {}
StatisticsDistribution(StatisticsVector const& dist)
: _count(0), _total(0.0), _cuts(dist._value), _counts() {
explicit StatisticsDistribution(std::vector<double> const& dist)
: _count(0), _total(0.0), _cuts(dist), _counts() {
_counts.resize(_cuts.size() + 1);
}

6
arangod/V8Server/v8-statistics.cpp
View File

@ -47,13 +47,13 @@ using namespace arangodb::basics;
////////////////////////////////////////////////////////////////////////////////
static v8::Handle<v8::Array> DistributionList(v8::Isolate* isolate,
StatisticsVector const& dist) {
std::vector<double> const& dist) {
v8::EscapableHandleScope scope(isolate);
v8::Handle<v8::Array> result = v8::Array::New(isolate);
for (uint32_t i = 0; i < (uint32_t)dist._value.size(); ++i) {
result->Set(i, v8::Number::New(isolate, dist._value[i]));
for (uint32_t i = 0; i < (uint32_t)dist.size(); ++i) {
result->Set(i, v8::Number::New(isolate, dist[i]));
}
return scope.Escape<v8::Array>(result);

1
js/common/bootstrap/errors.js
View File

@ -41,6 +41,7 @@
"ERROR_ARANGO_ICU_ERROR" : { "code" : 33, "message" : "icu error: %s" },
"ERROR_CANNOT_READ_FILE" : { "code" : 34, "message" : "cannot read file" },
"ERROR_INCOMPATIBLE_VERSION" : { "code" : 35, "message" : "incompatible server version" },
"ERROR_DISABLED" : { "code" : 36, "message" : "disabled" },
"ERROR_HTTP_BAD_PARAMETER" : { "code" : 400, "message" : "bad parameter" },
"ERROR_HTTP_UNAUTHORIZED" : { "code" : 401, "message" : "unauthorized" },
"ERROR_HTTP_FORBIDDEN" : { "code" : 403, "message" : "forbidden" },

3
lib/Basics/errors.dat
View File

@ -19,7 +19,7 @@ ERROR_CORRUPTED_CSV,13,"csv is corrupt","Will be raised when encountering a corr
ERROR_FILE_NOT_FOUND,14,"file not found","Will be raised when a file is not found."
ERROR_CANNOT_WRITE_FILE,15,"cannot write file","Will be raised when a file cannot be written."
ERROR_CANNOT_OVERWRITE_FILE,16,"cannot overwrite file","Will be raised when an attempt is made to overwrite an existing file."
ERROR_TYPE_ERROR,17,"type error","Will be raised when a type error is unencountered."
ERROR_TYPE_ERROR,17,"type error","Will be raised when a type error is encountered."
ERROR_LOCK_TIMEOUT,18,"lock timeout","Will be raised when there's a timeout waiting for a lock."
ERROR_CANNOT_CREATE_DIRECTORY,19,"cannot create directory","Will be raised when an attempt to create a directory fails."
ERROR_CANNOT_CREATE_TEMP_FILE,20,"cannot create temporary file","Will be raised when an attempt to create a temporary file fails."
@ -35,6 +35,7 @@ ERROR_RESOURCE_LIMIT,32,"resource limit exceeded","Will be raised when the resou
ERROR_ARANGO_ICU_ERROR,33,"icu error: %s","will be raised if icu operations failed"
ERROR_CANNOT_READ_FILE,34,"cannot read file","Will be raised when a file cannot be read."
ERROR_INCOMPATIBLE_VERSION,35,"incompatible server version","Will be raised when a server is running an incompatible version of ArangoDB."
ERROR_DISABLED,36,"disabled","Will be raised when a requested resource is not enabled."
################################################################################
## HTTP error status codes

1
lib/Basics/voc-errors.cpp
View File

@ -40,6 +40,7 @@ void TRI_InitializeErrorMessages() {
REG_ERROR(ERROR_ARANGO_ICU_ERROR, "icu error: %s");
REG_ERROR(ERROR_CANNOT_READ_FILE, "cannot read file");
REG_ERROR(ERROR_INCOMPATIBLE_VERSION, "incompatible server version");
REG_ERROR(ERROR_DISABLED, "disabled");
REG_ERROR(ERROR_HTTP_BAD_PARAMETER, "bad parameter");
REG_ERROR(ERROR_HTTP_UNAUTHORIZED, "unauthorized");
REG_ERROR(ERROR_HTTP_FORBIDDEN, "forbidden");

7
lib/Basics/voc-errors.h
View File

@ -92,7 +92,7 @@ constexpr int TRI_ERROR_CANNOT_OVERWRITE_FILE
/// 17: ERROR_TYPE_ERROR
/// "type error"
/// Will be raised when a type error is unencountered.
/// Will be raised when a type error is encountered.
constexpr int TRI_ERROR_TYPE_ERROR = 17;
/// 18: ERROR_LOCK_TIMEOUT
@ -173,6 +173,11 @@ constexpr int TRI_ERROR_CANNOT_READ_FILE
/// Will be raised when a server is running an incompatible version of ArangoDB.
constexpr int TRI_ERROR_INCOMPATIBLE_VERSION = 35;
/// 36: ERROR_DISABLED
/// "disabled"
/// Will be raised when a requested resource is not enabled.
constexpr int TRI_ERROR_DISABLED = 36;
/// 400: ERROR_HTTP_BAD_PARAMETER
/// "bad parameter"
/// Will be raised when the HTTP request does not fulfill the requirements.