allow turning off statistics feature (#5883)

arangod/Agency/AgencyFeature.cpp

@@ -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() {

arangod/RestHandler/RestAdminStatisticsHandler.cpp

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

arangod/RestServer/ServerFeature.cpp

@@ -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) {

arangod/Statistics/ConnectionStatistics.cpp

@@ -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);
     }
   }
 

arangod/Statistics/ConnectionStatistics.h

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

arangod/Statistics/Descriptions.cpp

@@ -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}),
+    : _requestTimeCuts(arangodb::basics::TRI_RequestTimeDistributionVectorStatistics),
-      _connectionTimeCuts({0.1, 1.0, 60.0}),
+      _connectionTimeCuts(arangodb::basics::TRI_ConnectionTimeDistributionVectorStatistics),
-      _bytesSendCuts({250, 1000, 2 * 1000, 5 * 1000, 10 * 1000}),
+      _bytesSendCuts(arangodb::basics::TRI_BytesSentDistributionVectorStatistics),
-      _bytesReceivedCuts({250, 1000, 2 * 1000, 5 * 1000, 10 * 1000}) {
+      _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( "available", VPackValue(v8Counters.available));
-    b.add( "busy", VPackValue(static_cast<int32_t>(v8Counters.busy)));
+    b.add( "busy", VPackValue(v8Counters.busy));
-    b.add( "dirty", VPackValue(static_cast<int32_t>(v8Counters.dirty)));
+    b.add( "dirty", VPackValue(v8Counters.dirty));
-    b.add( "free", VPackValue(static_cast<int32_t>(v8Counters.free)));
+    b.add( "free", VPackValue(v8Counters.free));
-    b.add( "max", VPackValue(static_cast<int32_t>(v8Counters.max)));
+    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();
+  for (auto const& it : dist._counts) {
-       i != dist._counts.end(); ++i) {
+    b.add(VPackValue(it));
-    b.add(VPackValue(*i));
   }
   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("requestsTotal", VPackValue(totalRequests._count));
-  b.add("requestsAsync", VPackValue((double)asyncRequests._count));
+  b.add("requestsAsync", VPackValue(asyncRequests._count));
-  b.add("requestsGet", VPackValue((double)methodRequests[(int)rest::RequestType::GET]._count));
+  b.add("requestsGet", VPackValue(methodRequests[(int)rest::RequestType::GET]._count));
-  b.add("requestsHead", VPackValue((double)methodRequests[(int)rest::RequestType::HEAD]._count));
+  b.add("requestsHead", VPackValue(methodRequests[(int)rest::RequestType::HEAD]._count));
-  b.add("requestsPost", VPackValue((double)methodRequests[(int)rest::RequestType::POST]._count));
+  b.add("requestsPost", VPackValue(methodRequests[(int)rest::RequestType::POST]._count));
-  b.add("requestsPut", VPackValue((double)methodRequests[(int)rest::RequestType::PUT]._count));
+  b.add("requestsPut", VPackValue(methodRequests[(int)rest::RequestType::PUT]._count));
-  b.add("requestsPatch", VPackValue((double)methodRequests[(int)rest::RequestType::PATCH]._count));
+  b.add("requestsPatch", VPackValue(methodRequests[(int)rest::RequestType::PATCH]._count));
-  b.add("requestsDelete", VPackValue((double)methodRequests[(int)rest::RequestType::DELETE_REQ]._count));
+  b.add("requestsDelete", VPackValue(methodRequests[(int)rest::RequestType::DELETE_REQ]._count));
-  b.add("requestsOptions", VPackValue((double)methodRequests[(int)rest::RequestType::OPTIONS]._count));
+  b.add("requestsOptions", VPackValue(methodRequests[(int)rest::RequestType::OPTIONS]._count));
-  b.add("requestsOther", VPackValue((double)methodRequests[(int)rest::RequestType::ILLEGAL]._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("minorPageFaults", VPackValue(info._minorPageFaults));
-  b.add("majorPageFaults", VPackValue((double)info._majorPageFaults));
+  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));
 }

arangod/Statistics/Descriptions.h

@@ -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>
 

arangod/Statistics/RequestStatistics.cpp

@@ -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_BytesSentDistributionStatistics.addFigure(statistics->_sentBytes);
-      TRI_BytesReceivedDistributionStatistics->addFigure(
+      TRI_BytesReceivedDistributionStatistics.addFigure(
           statistics->_receivedBytes);
     }
   }
@@ -205,12 +203,12 @@ void RequestStatistics::fill(StatisticsDistribution& totalTime,
 
   MUTEX_LOCKER(mutexLocker, _dataLock);
 
-  totalTime = *TRI_TotalTimeDistributionStatistics;
+  totalTime = TRI_TotalTimeDistributionStatistics;
-  requestTime = *TRI_RequestTimeDistributionStatistics;
+  requestTime = TRI_RequestTimeDistributionStatistics;
-  queueTime = *TRI_QueueTimeDistributionStatistics;
+  queueTime = TRI_QueueTimeDistributionStatistics;
-  ioTime = *TRI_IoTimeDistributionStatistics;
+  ioTime = TRI_IoTimeDistributionStatistics;
-  bytesSent = *TRI_BytesSentDistributionStatistics;
+  bytesSent = TRI_BytesSentDistributionStatistics;
-  bytesReceived = *TRI_BytesReceivedDistributionStatistics;
+  bytesReceived = TRI_BytesReceivedDistributionStatistics;
 }
 
 std::string RequestStatistics::timingsCsv() {

arangod/Statistics/RequestStatistics.h

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

arangod/Statistics/ServerStatistics.cpp

@@ -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() {
-}

arangod/Statistics/ServerStatistics.h

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

arangod/Statistics/StatisticsFeature.cpp

@@ -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;
 }

arangod/Statistics/StatisticsFeature.h

@@ -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;
 

arangod/Statistics/StatisticsWorker.cpp

@@ -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));
   }
 

arangod/Statistics/figures.h

@@ -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)
+  explicit StatisticsDistribution(std::vector<double> const& dist)
-      : _count(0), _total(0.0), _cuts(dist._value), _counts() {
+      : _count(0), _total(0.0), _cuts(dist), _counts() {
     _counts.resize(_cuts.size() + 1);
   }
 

arangod/V8Server/v8-statistics.cpp

@@ -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) {
+  for (uint32_t i = 0; i < (uint32_t)dist.size(); ++i) {
-    result->Set(i, v8::Number::New(isolate, dist._value[i]));
+    result->Set(i, v8::Number::New(isolate, dist[i]));
   }
 
   return scope.Escape<v8::Array>(result);

js/common/bootstrap/errors.js

@@ -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" },

lib/Basics/errors.dat

@@ -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

lib/Basics/voc-errors.cpp

@@ -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");

lib/Basics/voc-errors.h

@@ -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.