fix up test

Author: kevinkreiser

include/cpp-statsd-client/StatsdClient.hpp

@@ -4,15 +4,39 @@
 #include <cpp-statsd-client/UDPSender.hpp>
 #include <cstdint>
 #include <cstdio>
+#include <functional>
 #include <iomanip>
 #include <memory>
 #include <random>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace Statsd {
 
+namespace detail {
+inline std::string sanitizePrefix(std::string prefix) {
+    // For convenience we provide the dot when generating the stat message
+    if (!prefix.empty() && prefix.back() == '.') {
+        prefix.pop_back();
+    }
+    return prefix;
+}
+
+inline float rand(unsigned int seed) {
+    static thread_local std::mt19937 twister(seed);
+    static thread_local std::uniform_real_distribution<float> dist(0.f, 1.f);
+    return dist(twister);
+}
+
+// All supported metric types
+constexpr char METRIC_TYPE_COUNT[] = "c";
+constexpr char METRIC_TYPE_GAUGE[] = "g";
+constexpr char METRIC_TYPE_TIMING[] = "ms";
+constexpr char METRIC_TYPE_SET[] = "s";
+}  // namespace detail
+
 /*!
  *
  * Statsd client
@@ -27,8 +51,8 @@ namespace Statsd {
  * nor prepend one to the key
  *
  * The sampling frequency is specified per call and uses a
- * random number generator to determine whether or not the stat
- * will be recorded this time or not.
+ * random number generator (optionally user-specified) to
+ * determine whether the stat will be recorded this time or not.
  *
  * The top level configuration includes 2 optional parameters
  * that determine how the stats are delivered to statsd. These
@@ -57,6 +81,11 @@ namespace Statsd {
  */
 class StatsdClient {
 public:
+
+    //! A functor that returns a value between 0 and 1 used
+    //! to determine whether a given message is sampled.
+    using FrequencyFunc = std::function<float()>;
+
     //!@name Constructor and destructor, non-copyable
     //!@{
 
@@ -67,7 +96,8 @@ class StatsdClient {
                  const uint64_t batchsize = 0,
                  const uint64_t sendInterval = 1000,
                  const int gaugePrecision = 4,
-                 unsigned int seed = std::random_device()()) noexcept;
+                 FrequencyFunc  frequencyFunc =
+                     std::bind(detail::rand, std::random_device()())) noexcept;
 
     StatsdClient(const StatsdClient&) = delete;
     StatsdClient& operator=(const StatsdClient&) = delete;
@@ -142,7 +172,6 @@ class StatsdClient {
 
     //!@}
 
-private:
     //! The prefix to be used for metrics
     std::string m_prefix;
 
@@ -151,41 +180,21 @@ class StatsdClient {
 
     //! Fixed floating point precision of gauges
     int m_gaugePrecision;
-};
-
-namespace detail {
-inline std::string sanitizePrefix(std::string prefix) {
-    // For convenience we provide the dot when generating the stat message
-    if (!prefix.empty() && prefix.back() == '.') {
-        prefix.pop_back();
-    }
-    return prefix;
-}
 
-inline std::mt19937& rng(unsigned int seed = 0) {
-    static thread_local std::mt19937 twister(seed);
-    return twister;
-}
-
-// All supported metric types
-constexpr char METRIC_TYPE_COUNT[] = "c";
-constexpr char METRIC_TYPE_GAUGE[] = "g";
-constexpr char METRIC_TYPE_TIMING[] = "ms";
-constexpr char METRIC_TYPE_SET[] = "s";
-}  // namespace detail
+    //! The function used to determine whether a message is sampled
+    FrequencyFunc m_frequencyFunc;
+};
 
 inline StatsdClient::StatsdClient(const std::string& host,
                                   const uint16_t port,
                                   const std::string& prefix,
                                   const uint64_t batchsize,
                                   const uint64_t sendInterval,
                                   const int gaugePrecision,
-                                  const unsigned int seed) noexcept
+                                  FrequencyFunc  frequencyFunc) noexcept
     : m_prefix(detail::sanitizePrefix(prefix)),
       m_sender(new UDPSender{host, port, batchsize, sendInterval}),
-      m_gaugePrecision(gaugePrecision) {
-    // Initialize the random generator to be used for sampling
-    detail::rng(seed);
+      m_gaugePrecision(gaugePrecision), m_frequencyFunc(std::move(frequencyFunc)) {
 }
 
 inline const std::string& StatsdClient::errorMessage() const noexcept {
@@ -260,7 +269,7 @@ inline void StatsdClient::send(const std::string& key,
     const bool isFrequencyOne = std::fabs(frequency - 1.0f) < epsilon;
     const bool isFrequencyZero = std::fabs(frequency) < epsilon;
     if (isFrequencyZero ||
-        (!isFrequencyOne && (frequency < std::uniform_real_distribution<float>(0.f, 1.f)(detail::rng())))) {
+        (!isFrequencyOne && (frequency < m_frequencyFunc()))) {
         return;
     }
 

tests/testStatsdClient.cpp

@@ -58,15 +58,19 @@ void testSendRecv(uint64_t batchSize, uint64_t sendInterval) {
     std::vector<std::string> messages, expected;
     std::thread server(mock, std::ref(mock_server), std::ref(messages));
 
+    std::mt19937 twister(std::random_device{}());
+    std::uniform_real_distribution<float> dist(0.f, 1.f);
+    auto rand = [&]()->float{return dist(twister);};
+
     // Set a new config that has the client send messages to a proper address that can be resolved
-    StatsdClient client("localhost", 8125, "sendRecv.", batchSize, sendInterval, 3, 19); // this seed works for the testing below
+    StatsdClient client("localhost", 8125, "sendRecv.", batchSize, sendInterval, 3, rand);
     throwOnError(client);
 
     // TODO: I forget if we need to wait for the server to be ready here before sending the first stats
     //  is there a race condition where the client sending before the server binds would drop that clients message
 
     for (int i = 0; i < 3; ++i) {
-        // Increment "coco"
+                // Increment "coco"
         client.increment("coco");
         throwOnError(client);
         expected.emplace_back("sendRecv.coco:1|c");
@@ -77,6 +81,7 @@ void testSendRecv(uint64_t batchSize, uint64_t sendInterval) {
         expected.emplace_back("sendRecv.kiki:-1|c");
 
         // Adjusts "toto" by +2
+        twister.seed(19);  // this seed gets a hit on the first call
         client.count("toto", 2, 0.1f);
         throwOnError(client);
         expected.emplace_back("sendRecv.toto:2|c|@0.10");
@@ -96,6 +101,7 @@ void testSendRecv(uint64_t batchSize, uint64_t sendInterval) {
         expected.emplace_back("sendRecv.titifloat:-123.457|g");
 
         // Record a timing of 2ms for "myTiming"
+        twister.seed(19);
         client.timing("myTiming", 2, 0.1f);
         throwOnError(client);
         expected.emplace_back("sendRecv.myTiming:2|ms|@0.10");
@@ -134,13 +140,18 @@ void testSendRecv(uint64_t batchSize, uint64_t sendInterval) {
 
     // Make sure we get the exactly correct output
     if (messages != expected) {
-        std::cerr << "Unexpected stats received by server, got:" << std::endl;
-        for (const auto& message : messages) {
-            std::cerr << message << std::endl;
+        for (size_t i = 0; i < expected.size(); ++i) {
+            if (i >= messages.size()) {
+                std::cerr << "Missing messages at index " << i << ": expected '" << expected[i] << "'" << std::endl;
+                break;
+            }
+            if (messages[i] != expected[i]) {
+                std::cerr << "Mismatch at index " << i << ": expected '" << expected[i] << "', got '" << messages[i] << "'" << std::endl;
+                break;
+            }
         }
-        std::cerr << std::endl << "But we expected:" << std::endl;
-        for (const auto& message : expected) {
-            std::cerr << message << std::endl;
+        if (messages.size() > expected.size()) {
+            std::cerr << "Got more messages than expected, got " << messages.size() << ", expected " << expected.size() << std::endl;
         }
         throw std::runtime_error("Unexpected stats");
     }