[#1005] Changed default interaction with existing stats

diff --git a/ChangeLog b/ChangeLog
index 53629a4b926ac6c22695a1188373dde954d38316..a789bf2c8eeca7170eba6a81d83a3fe4f74ad2d0 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,7 +1,7 @@
 1738.  [func]          fdupont
        Added new global parameters statistic-default-sample-count and
-       statistic-default-sample-age to set the default values uses
-       a sample keeping limits in new statistics.
+       statistic-default-sample-age to set the default values used
+       for sample keeping limits.
        (Gitlab #1005)
 
 1737.   [func]         tmark

diff --git a/doc/sphinx/arm/dhcp4-srv.rst b/doc/sphinx/arm/dhcp4-srv.rst
index de840d0ffae32b7056a468a0e8245a658777a546..144caccc623ec3ed2f8b6dca9123c195582b8fb1 100644 (file)
--- a/doc/sphinx/arm/dhcp4-srv.rst
+++ b/doc/sphinx/arm/dhcp4-srv.rst
@@ -5320,13 +5320,6 @@ parameters to control statistics default sample limits:
 - ``statistic-default-sample-age`` - determines the default maximum
   age in seconds of samples which will be kept.
 
-.. note::
-
-   These apply to default values and have no action on existing statistics.
-   To change sample limits on an existing (or all) statistic use commands
-   of the dedicated hook described in :ref:`command-statistic-sample-count-set`
-   and :ref:`command-statistic-sample-age-set-all`.
-
 For instance to reduce the statistic keeping overhead you can set
 the default maximum sample count to 1 so only one sample will be kept by:
 

diff --git a/doc/sphinx/arm/dhcp6-srv.rst b/doc/sphinx/arm/dhcp6-srv.rst
index 55e579463ee0e95d730be0c7b5021a768f930a95..c0fa7ba820bcd8e8def31f8340f9e377b2587e90 100644 (file)
--- a/doc/sphinx/arm/dhcp6-srv.rst
+++ b/doc/sphinx/arm/dhcp6-srv.rst
@@ -5196,13 +5196,6 @@ parameters to control statistics default sample limits:
 - ``statistic-default-sample-age`` - determines the default maximum
   age in seconds of samples which will be kept.
 
-.. note::
-
-   These apply to default values and have no action on existing statistics.
-   To change sample limits on an existing (or all) statistic use commands
-   of the dedicated hook described in :ref:`command-statistic-sample-count-set`
-   and :ref:`command-statistic-sample-age-set-all`.
-
 For instance to reduce the statistic keeping overhead you can set
 the default maximum sample count to 1 so only one sample will be kept by:
 

diff --git a/doc/sphinx/arm/stats.rst b/doc/sphinx/arm/stats.rst
index f86da080cd44bd08aacad790bb7929f38fcb45a3..fddbd321968cac07a35e6a204e61e9d3bb0cb08d 100644 (file)
--- a/doc/sphinx/arm/stats.rst
+++ b/doc/sphinx/arm/stats.rst
@@ -91,11 +91,6 @@ statistic completely (-remove). We can change the statistics time based
 limit (-sample-age-set) and size based limit (-sample-count-set) which
 control how long or how many samples of the given statistic are retained.
 
-This only applies for existing statistics: to change the default limits used
-when a new statistic is created, for instance during server startup,
-the statistic-default-sample-count and statistic-default-sample-age
-global configuration parameters must be used.
-
 The difference between reset and remove is somewhat subtle.
 The reset command sets the value of the statistic to zero or a neutral value,
 so after this operation, the statistic will have a value of 0 (integer),

diff --git a/src/bin/dhcp4/ctrl_dhcp4_srv.cc b/src/bin/dhcp4/ctrl_dhcp4_srv.cc
index c6e6bac8874c385785eae51631d2ce1b12ab5dc8..e89504cebd9df7fd186e0ccd98963c309ac1b660 100644 (file)
--- a/src/bin/dhcp4/ctrl_dhcp4_srv.cc
+++ b/src/bin/dhcp4/ctrl_dhcp4_srv.cc
@@ -636,6 +636,29 @@ ControlledDhcpv4Srv::commandStatusGetHandler(const string&,
     return (createAnswer(0, status));
 }
 
+ConstElementPtr
+ControlledDhcpv4Srv::commandStatisticSetMaxSampleCountAllHandler(const string&,
+                                                                 ConstElementPtr args) {
+    ConstElementPtr answer = StatsMgr::statisticSetMaxSampleCountAllHandler(args);
+    // Update the default parameter.
+    long max_samples = StatsMgr::instance().getMaxSampleCountDefault();
+    CfgMgr::instance().getCurrentCfg()->addConfiguredGlobal(
+        "statistic-default-sample-count", Element::create(max_samples));
+    return (answer);
+}
+
+ConstElementPtr
+ControlledDhcpv4Srv::commandStatisticSetMaxSampleAgeAllHandler(const string&,
+                                                                 ConstElementPtr args) {
+    ConstElementPtr answer = StatsMgr::statisticSetMaxSampleAgeAllHandler(args);
+    // Update the default parameter.
+    auto duration = StatsMgr::instance().getMaxSampleAgeDefault();
+    long max_age = duration.total_seconds();
+    CfgMgr::instance().getCurrentCfg()->addConfiguredGlobal(
+        "statistic-default-sample-age", Element::create(max_age));
+    return (answer);
+}
+
 ConstElementPtr
 ControlledDhcpv4Srv::processCommand(const string& command,
                                     ConstElementPtr args) {
@@ -971,13 +994,13 @@ ControlledDhcpv4Srv::ControlledDhcpv4Srv(uint16_t server_port /*= DHCP4_SERVER_P
         boost::bind(&StatsMgr::statisticSetMaxSampleAgeHandler, _1, _2));
 
     CommandMgr::instance().registerCommand("statistic-sample-age-set-all",
-        boost::bind(&StatsMgr::statisticSetMaxSampleAgeAllHandler, _1, _2));
+        boost::bind(&ControlledDhcpv4Srv::commandStatisticSetMaxSampleAgeAllHandler, this, _1, _2));
 
     CommandMgr::instance().registerCommand("statistic-sample-count-set",
         boost::bind(&StatsMgr::statisticSetMaxSampleCountHandler, _1, _2));
 
     CommandMgr::instance().registerCommand("statistic-sample-count-set-all",
-        boost::bind(&StatsMgr::statisticSetMaxSampleCountAllHandler, _1, _2));
+        boost::bind(&ControlledDhcpv4Srv::commandStatisticSetMaxSampleCountAllHandler, this, _1, _2));
 }
 
 void ControlledDhcpv4Srv::shutdownServer(int exit_value) {

diff --git a/src/bin/dhcp4/ctrl_dhcp4_srv.h b/src/bin/dhcp4/ctrl_dhcp4_srv.h
index 352b91b767c93d249a4764c361a1ac24cb9824ee..eeaf47e8577ed98c7479df711f8d10e577bbbf8e 100644 (file)
--- a/src/bin/dhcp4/ctrl_dhcp4_srv.h
+++ b/src/bin/dhcp4/ctrl_dhcp4_srv.h
@@ -329,6 +329,32 @@ private:
     commandStatusGetHandler(const std::string& command,
                             isc::data::ConstElementPtr args);
 
+    /// @brief handler for processing 'statistic-sample-count-set-all' command
+    ///
+    /// This handler processes statistic-sample-count-set-all command,
+    /// which set max_sample_count_ limit of all statistics and the default.
+    /// @ref isc::stats::StatsMgr::statisticSetMaxSampleCountAllHandler
+    ///
+    /// @param command (ignored)
+    /// @param args structure containing a map that contains "max-samples"
+    /// @return process information wrapped in a response
+    isc::data::ConstElementPtr
+    commandStatisticSetMaxSampleCountAllHandler(const std::string& command,
+                                                isc::data::ConstElementPtr args);
+
+    /// @brief handler for processing 'statistic-sample-age-set-all' command
+    ///
+    /// This handler processes statistic-sample-age-set-all command,
+    /// which set max_sample_age_ limit of all statistics and the default.
+    /// @ref isc::stats::StatsMgr::statisticSetMaxSampleAgeAllHandler
+    ///
+    /// @param command (ignored)
+    /// @param args structure containing a map that contains "duration"
+    /// @return process information wrapped in a response
+    isc::data::ConstElementPtr
+    commandStatisticSetMaxSampleAgeAllHandler(const std::string& command,
+                                              isc::data::ConstElementPtr args);
+
     /// @brief Reclaims expired IPv4 leases and reschedules timer.
     ///
     /// This is a wrapper method for @c AllocEngine::reclaimExpiredLeases4.

diff --git a/src/bin/dhcp6/ctrl_dhcp6_srv.cc b/src/bin/dhcp6/ctrl_dhcp6_srv.cc
index 3929b86b1cb6ea3b86b35bba936e328a5a525483..bb7899cd575b93fbfbba781e116165272c153cb4 100644 (file)
--- a/src/bin/dhcp6/ctrl_dhcp6_srv.cc
+++ b/src/bin/dhcp6/ctrl_dhcp6_srv.cc
@@ -640,6 +640,29 @@ ControlledDhcpv6Srv::commandStatusGetHandler(const string&,
     return (createAnswer(0, status));
 }
 
+ConstElementPtr
+ControlledDhcpv6Srv::commandStatisticSetMaxSampleCountAllHandler(const string&,
+                                                                 ConstElementPtr args) {
+    ConstElementPtr answer = StatsMgr::statisticSetMaxSampleCountAllHandler(args);
+    // Update the default parameter.
+    long max_samples = StatsMgr::instance().getMaxSampleCountDefault();
+    CfgMgr::instance().getCurrentCfg()->addConfiguredGlobal(
+        "statistic-default-sample-count", Element::create(max_samples));
+    return (answer);
+}
+
+ConstElementPtr
+ControlledDhcpv6Srv::commandStatisticSetMaxSampleAgeAllHandler(const string&,
+                                                                 ConstElementPtr args) {
+    ConstElementPtr answer = StatsMgr::statisticSetMaxSampleAgeAllHandler(args);
+    // Update the default parameter.
+    auto duration = StatsMgr::instance().getMaxSampleAgeDefault();
+    long max_age = duration.total_seconds();
+    CfgMgr::instance().getCurrentCfg()->addConfiguredGlobal(
+        "statistic-default-sample-age", Element::create(max_age));
+    return (answer);
+}
+
 ConstElementPtr
 ControlledDhcpv6Srv::processCommand(const string& command,
                                     ConstElementPtr args) {
@@ -993,13 +1016,13 @@ ControlledDhcpv6Srv::ControlledDhcpv6Srv(uint16_t server_port,
         boost::bind(&StatsMgr::statisticSetMaxSampleAgeHandler, _1, _2));
 
     CommandMgr::instance().registerCommand("statistic-sample-age-set-all",
-        boost::bind(&StatsMgr::statisticSetMaxSampleAgeAllHandler, _1, _2));
+        boost::bind(&ControlledDhcpv6Srv::commandStatisticSetMaxSampleAgeAllHandler, this, _1, _2));
 
     CommandMgr::instance().registerCommand("statistic-sample-count-set",
         boost::bind(&StatsMgr::statisticSetMaxSampleCountHandler, _1, _2));
 
     CommandMgr::instance().registerCommand("statistic-sample-count-set-all",
-        boost::bind(&StatsMgr::statisticSetMaxSampleCountAllHandler, _1, _2));
+        boost::bind(&ControlledDhcpv6Srv::commandStatisticSetMaxSampleCountAllHandler, this, _1, _2));
 }
 
 void ControlledDhcpv6Srv::shutdownServer(int exit_value) {

diff --git a/src/bin/dhcp6/ctrl_dhcp6_srv.h b/src/bin/dhcp6/ctrl_dhcp6_srv.h
index 7e268a506e74f71f54b7d98cc8e4da72934a3cf1..a09f084c96d3c3fa3e2ac9147adb499f70150d3e 100644 (file)
--- a/src/bin/dhcp6/ctrl_dhcp6_srv.h
+++ b/src/bin/dhcp6/ctrl_dhcp6_srv.h
@@ -329,6 +329,32 @@ private:
     commandStatusGetHandler(const std::string& command,
                             isc::data::ConstElementPtr args);
 
+    /// @brief handler for processing 'statistic-sample-count-set-all' command
+    ///
+    /// This handler processes statistic-sample-count-set-all command,
+    /// which set max_sample_count_ limit of all statistics and the default.
+    /// @ref isc::stats::StatsMgr::statisticSetMaxSampleCountAllHandler
+    ///
+    /// @param command (ignored)
+    /// @param args structure containing a map that contains "max-samples"
+    /// @return process information wrapped in a response
+    isc::data::ConstElementPtr
+    commandStatisticSetMaxSampleCountAllHandler(const std::string& command,
+                                                isc::data::ConstElementPtr args);
+
+    /// @brief handler for processing 'statistic-sample-age-set-all' command
+    ///
+    /// This handler processes statistic-sample-age-set-all command,
+    /// which set max_sample_age_ limit of all statistics and the default.
+    /// @ref isc::stats::StatsMgr::statisticSetMaxSampleAgeAllHandler
+    ///
+    /// @param command (ignored)
+    /// @param args structure containing a map that contains "duration"
+    /// @return process information wrapped in a response
+    isc::data::ConstElementPtr
+    commandStatisticSetMaxSampleAgeAllHandler(const std::string& command,
+                                              isc::data::ConstElementPtr args);
+
     /// @brief Reclaims expired IPv6 leases and reschedules timer.
     ///
     /// This is a wrapper method for @c AllocEngine::reclaimExpiredLeases6.

diff --git a/src/lib/dhcpsrv/srv_config.cc b/src/lib/dhcpsrv/srv_config.cc
index 58a97fee9bea3700ea808ac0350a91c16efd832f..d5be04a4f155542c40016e540435afd5b36b1900 100644 (file)
--- a/src/lib/dhcpsrv/srv_config.cc
+++ b/src/lib/dhcpsrv/srv_config.cc
@@ -255,7 +255,6 @@ SrvConfig::mergeGlobals(SrvConfig& other) {
     }
 }
 
-
 void
 SrvConfig::removeStatistics() {
     // Removes statistics for v4 and v6 subnets
@@ -268,10 +267,15 @@ void
 SrvConfig::updateStatistics() {
     // Update default sample limits.
     stats::StatsMgr& stats_mgr = stats::StatsMgr::instance();
-    ConstElementPtr max_samples =
+    ConstElementPtr samples =
         getConfiguredGlobal("statistic-default-sample-count");
-    if (max_samples) {
-        stats_mgr.setMaxSampleCountDefault(max_samples->intValue());
+    uint32_t max_samples = 0;
+    if (samples) {
+        max_samples = samples->intValue();
+        stats_mgr.setMaxSampleCountDefault(max_samples);
+        if (max_samples != 0) {
+            stats_mgr.setMaxSampleCountAll(max_samples);
+        }
     }
     ConstElementPtr duration =
         getConfiguredGlobal("statistic-default-sample-age");
@@ -282,7 +286,12 @@ SrvConfig::updateStatistics() {
         int64_t minutes = time_duration / 60;
         time_duration -= minutes * 60;
         int64_t seconds = time_duration;
-        stats_mgr.setMaxSampleAgeDefault(boost::posix_time::time_duration(hours, minutes, seconds, 0));
+        auto max_age =
+            boost::posix_time::time_duration(hours, minutes, seconds, 0);
+        stats_mgr.setMaxSampleAgeDefault(max_age);
+        if (max_samples == 0) {
+            stats_mgr.setMaxSampleAgeAll(max_age);
+        }
     }
 
     // Updating subnet statistics involves updating lease statistics, which

diff --git a/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc b/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc
index 3cfd5dd450af5313626eda3d76c712ca9c0e12e4..57dc7a4a01eb9089d08739ca4982181b90ac1ad1 100644 (file)
--- a/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc
+++ b/src/lib/dhcpsrv/tests/cfgmgr_unittest.cc
@@ -627,6 +627,10 @@ TEST_F(CfgMgrTest, commitStats4) {
     EXPECT_NO_THROW(total_addrs = stats_mgr.getObservation("subnet[42].total-addresses"));
     ASSERT_TRUE(total_addrs);
     EXPECT_EQ(128, total_addrs->getInteger().first);
+    EXPECT_TRUE(total_addrs->getMaxSampleCount().first);
+    EXPECT_EQ(15, total_addrs->getMaxSampleCount().second);
+    EXPECT_FALSE(total_addrs->getMaxSampleAge().first);
+    EXPECT_EQ("00:00:02", durationToText(total_addrs->getMaxSampleAge().second, 0));
 }
 
 // This test verifies that once the configuration is merged into the current
@@ -771,10 +775,19 @@ TEST_F(CfgMgrTest, commitStats6) {
     EXPECT_NO_THROW(total_addrs = stats_mgr.getObservation("subnet[42].total-nas"));
     ASSERT_TRUE(total_addrs);
     EXPECT_EQ(128, total_addrs->getInteger().first);
-
-    EXPECT_NO_THROW(total_addrs = stats_mgr.getObservation("subnet[42].total-pds"));
-    ASSERT_TRUE(total_addrs);
-    EXPECT_EQ(65536, total_addrs->getInteger().first);
+    EXPECT_TRUE(total_addrs->getMaxSampleCount().first);
+    EXPECT_EQ(14, total_addrs->getMaxSampleCount().second);
+    EXPECT_FALSE(total_addrs->getMaxSampleAge().first);
+    EXPECT_EQ("00:00:10", durationToText(total_addrs->getMaxSampleAge().second, 0));
+
+    ObservationPtr total_prfx;
+    EXPECT_NO_THROW(total_prfx = stats_mgr.getObservation("subnet[42].total-pds"));
+    ASSERT_TRUE(total_prfx);
+    EXPECT_EQ(65536, total_prfx->getInteger().first);
+    EXPECT_TRUE(total_prfx->getMaxSampleCount().first);
+    EXPECT_EQ(14, total_prfx->getMaxSampleCount().second);
+    EXPECT_FALSE(total_prfx->getMaxSampleAge().first);
+    EXPECT_EQ("00:00:10", durationToText(total_prfx->getMaxSampleAge().second, 0));
 }
 
 // This test verifies that once the configuration is merged into the current

diff --git a/src/lib/stats/stats_mgr.cc b/src/lib/stats/stats_mgr.cc
index f4ce0e0edca6fb5c99ce303f7422732db162f5c5..026816299dc24b75083359f28b9a9291b718cc8f 100644 (file)
--- a/src/lib/stats/stats_mgr.cc
+++ b/src/lib/stats/stats_mgr.cc
@@ -538,27 +538,43 @@ StatsMgr::statisticResetAllHandler(const string& /*name*/,
 }
 
 ConstElementPtr
-StatsMgr::statisticSetMaxSampleAgeAllHandler(const string& /*name*/,
-                                             const ConstElementPtr& params) {
+StatsMgr::statisticSetMaxSampleAgeAllHandler(const ConstElementPtr& params) {
     string error;
     StatsDuration duration;
     if (!StatsMgr::getStatDuration(params, duration, error)) {
         return (createAnswer(CONTROL_RESULT_ERROR, error));
     }
-    StatsMgr::instance().setMaxSampleAgeAll(duration);
+    if (MultiThreadingMgr::instance().getMode()) {
+        StatsMgr::instance().setMaxSampleCountDefaultInternal(0);
+        StatsMgr::instance().setMaxSampleAgeDefaultInternal(duration);
+        StatsMgr::instance().setMaxSampleAgeAllInternal(duration);
+    } else {
+        StatsMgr::instance().setMaxSampleCountDefaultInternal(0);
+        StatsMgr::instance().setMaxSampleAgeDefaultInternal(duration);
+        StatsMgr::instance().setMaxSampleAgeAllInternal(duration);
+    }
     return (createAnswer(CONTROL_RESULT_SUCCESS,
                          "All statistics duration limit are set."));
 }
 
 ConstElementPtr
-StatsMgr::statisticSetMaxSampleCountAllHandler(const string& /*name*/,
-                                               const ConstElementPtr& params) {
+StatsMgr::statisticSetMaxSampleCountAllHandler(const ConstElementPtr& params) {
     string error;
     uint32_t max_samples;
     if (!StatsMgr::getStatMaxSamples(params, max_samples, error)) {
         return (createAnswer(CONTROL_RESULT_ERROR, error));
     }
-    StatsMgr::instance().setMaxSampleCountAll(max_samples);
+    if (max_samples == 0) {
+        error = "'max-samples' parameter must not be zero";
+        return (createAnswer(CONTROL_RESULT_ERROR, error));
+    }
+    if (MultiThreadingMgr::instance().getMode()) {
+        StatsMgr::instance().setMaxSampleCountDefaultInternal(max_samples);
+        StatsMgr::instance().setMaxSampleCountAllInternal(max_samples);
+    } else {
+        StatsMgr::instance().setMaxSampleCountDefaultInternal(max_samples);
+        StatsMgr::instance().setMaxSampleCountAllInternal(max_samples);
+    }
     return (createAnswer(CONTROL_RESULT_SUCCESS,
                          "All statistics count limit are set."));
 }
@@ -628,5 +644,5 @@ StatsMgr::getStatMaxSamples(const ConstElementPtr& params,
     return (true);
 }
 
-};
-};
+} // end of namespace stats
+} // end of namespace isc

diff --git a/src/lib/stats/stats_mgr.h b/src/lib/stats/stats_mgr.h
index e55ad18e4f60f425fa57514a3747e5fdbc122a20..845429c5f99c7304b7e61a242db204377b66526a 100644 (file)
--- a/src/lib/stats/stats_mgr.h
+++ b/src/lib/stats/stats_mgr.h
@@ -427,7 +427,7 @@ public:
     /// @brief Handles statistic-sample-age-set-all command
     ///
     /// This method handles statistic-sample-age-set-all command,
-    /// which set max_sample_age_ limit to all statistics.
+    /// which set max_sample_age_ limit to all statistics and the default.
     /// It expects one parameter stored in params map:
     /// duration: limit expressed as a number of seconds
     ///
@@ -436,31 +436,28 @@ public:
     ///     "duration": 1245
     /// }
     ///
-    /// @param name name of the command (ignored, should be "statistic-sample-age-set-all")
     /// @param params structure containing a map that contains "duration"
     /// @return answer confirming success of this operation
     static isc::data::ConstElementPtr
-    statisticSetMaxSampleAgeAllHandler(const std::string& name,
-                                       const isc::data::ConstElementPtr& params);
+    statisticSetMaxSampleAgeAllHandler(const isc::data::ConstElementPtr& params);
 
     /// @brief Handles statistic-sample-count-set-all command
     ///
     /// This method handles statistic-sample-count-set-all command,
-    /// which set max_sample_count_ limit of all statistics.
+    /// which set max_sample_count_ limit of all statistics and the default.
     /// It expects one parameter stored in params map:
     /// max-samples: count limit
+    /// The value 0 is out of range.
     ///
     /// Example params structure:
     /// {
     ///     "max-samples": 15
     /// }
     ///
-    /// @param name name of the command (ignored, should be "statistic-sample-count-set-all")
     /// @param params structure containing a map that contains "max-samples"
     /// @return answer confirming success of this operation
     static isc::data::ConstElementPtr
-    statisticSetMaxSampleCountAllHandler(const std::string& name,
-                                         const isc::data::ConstElementPtr& params);
+    statisticSetMaxSampleCountAllHandler(const isc::data::ConstElementPtr& params);
 
     /// @}
 

diff --git a/src/lib/stats/tests/stats_mgr_unittest.cc b/src/lib/stats/tests/stats_mgr_unittest.cc
index 091acb78f109baf4b5c3194367029435a8bcd35b..178de720470af9a363e9c76ed22cd29537438e0c 100644 (file)
--- a/src/lib/stats/tests/stats_mgr_unittest.cc
+++ b/src/lib/stats/tests/stats_mgr_unittest.cc
@@ -251,6 +251,25 @@ TEST_F(StatsMgrTest, setLimitsDefault) {
     ASSERT_EQ(StatsMgr::instance().getMaxSampleCountDefault(), 10);
     ASSERT_EQ(StatsMgr::instance().getMaxSampleAgeDefault(), time_duration(0, 0, 5, 0));
 
+    // Check the existing statistics were not updated.
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 20);
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second, time_duration(0, 0, 0, 0));
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().second, 20);
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().second, time_duration(0, 0, 0, 0));
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().second, 20);
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().second, time_duration(0, 0, 0, 0));
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().second, 20);
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().second, time_duration(0, 0, 0, 0));
+
+    // Remove all test statistics.
     EXPECT_NO_THROW(StatsMgr::instance().removeAll());
 
     StatsMgr::instance().setValue("alpha", static_cast<int64_t>(1234));
@@ -279,6 +298,25 @@ TEST_F(StatsMgrTest, setLimitsDefault) {
     EXPECT_NO_THROW(StatsMgr::instance().setMaxSampleCountDefault(0));
     ASSERT_EQ(StatsMgr::instance().getMaxSampleCountDefault(), 0);
 
+    // Check the existing statistics were not updated.
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 10);
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second, time_duration(0, 0, 5, 0));
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().second, 10);
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().second, time_duration(0, 0, 5, 0));
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().second, 10);
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().second, time_duration(0, 0, 5, 0));
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().second, 10);
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().second, time_duration(0, 0, 5, 0));
+
+    // Remove all test statistics.
     EXPECT_NO_THROW(StatsMgr::instance().removeAll());
 
     StatsMgr::instance().setValue("alpha", static_cast<int64_t>(1234));
@@ -931,11 +969,16 @@ TEST_F(StatsMgrTest, commandSetMaxSampleAgeAll) {
     params->set("duration", Element::create(3765)); // time_duration(1, 2, 45, 0)
 
     ConstElementPtr rsp =
-        StatsMgr::instance().statisticSetMaxSampleAgeAllHandler("statistic-sample-age-set-all", params);
+        StatsMgr::instance().statisticSetMaxSampleAgeAllHandler(params);
     int status_code;
     ASSERT_NO_THROW(parseAnswer(status_code, rsp));
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
+    // check defaults
+    EXPECT_EQ(StatsMgr::instance().getMaxSampleAgeDefault(),
+              time_duration(1, 2, 45, 0));
+    EXPECT_EQ(StatsMgr::instance().getMaxSampleCountDefault(), 0);
+
     // check if time limit was set properly and whether count limit is disabled
     EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true);
     EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second,
@@ -1024,11 +1067,14 @@ TEST_F(StatsMgrTest, commandSetMaxSampleCountAll) {
     params->set("max-samples", Element::create(200));
 
     ConstElementPtr rsp =
-        StatsMgr::instance().statisticSetMaxSampleCountAllHandler("statistic-sample-count-set-all", params);
+        StatsMgr::instance().statisticSetMaxSampleCountAllHandler(params);
     int status_code;
     ASSERT_NO_THROW(parseAnswer(status_code, rsp));
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
+    // check default
+    EXPECT_EQ(StatsMgr::instance().getMaxSampleCountDefault(), 200);
+
     // check if count limit was set properly and whether count limit is disabled
     EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true);
     EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 200);
@@ -1047,4 +1093,16 @@ TEST_F(StatsMgrTest, commandSetMaxSampleCountAll) {
     EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false);
 }
 
+// Test checks if statistics-sample-count-set-all fails on zero.
+TEST_F(StatsMgrTest, commandSetMaxSampleCountAllZero) {
+    ElementPtr params = Element::createMap();
+    params->set("max-samples", Element::create(0));
+
+    ConstElementPtr rsp =
+        StatsMgr::instance().statisticSetMaxSampleCountAllHandler(params);
+    int status_code;
+    ASSERT_NO_THROW(parseAnswer(status_code, rsp));
+    EXPECT_EQ(status_code, CONTROL_RESULT_ERROR);
+}
+
 };