From f782dfd562cd168bac4cfde6be009a1343bb0787 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Tue, 10 Sep 2024 16:22:07 +0000
Subject: [PATCH 01/12] stats: remove double indentation in header file

---
 src/statsd_client.h | 64 ++++++++++++++++++++++-----------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/statsd_client.h b/src/statsd_client.h
index 7568d8cd0e769..cdda53d2e2f32 100644
--- a/src/statsd_client.h
+++ b/src/statsd_client.h
@@ -26,45 +26,45 @@ static constexpr int MAX_STATSD_PERIOD{60 * 60};
 
 namespace statsd {
 class StatsdClient {
-    public:
-        explicit StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
-                              const std::string& ns, bool enabled);
+public:
+    explicit StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
+                            const std::string& ns, bool enabled);
 
-    public:
-        bool inc(const std::string& key, float sample_rate = 1.f);
-        bool dec(const std::string& key, float sample_rate = 1.f);
-        bool count(const std::string& key, int64_t value, float sample_rate = 1.f);
-        bool gauge(const std::string& key, int64_t value, float sample_rate = 1.f);
-        bool gaugeDouble(const std::string& key, double value, float sample_rate = 1.f);
-        bool timing(const std::string& key, int64_t ms, float sample_rate = 1.f);
+public:
+    bool inc(const std::string& key, float sample_rate = 1.f);
+    bool dec(const std::string& key, float sample_rate = 1.f);
+    bool count(const std::string& key, int64_t value, float sample_rate = 1.f);
+    bool gauge(const std::string& key, int64_t value, float sample_rate = 1.f);
+    bool gaugeDouble(const std::string& key, double value, float sample_rate = 1.f);
+    bool timing(const std::string& key, int64_t ms, float sample_rate = 1.f);
 
-        /* (Low Level Api) manually send a message
-         * type = "c", "g" or "ms"
-         */
-        bool send(std::string key, int64_t value, const std::string& type, float sample_rate);
-        bool sendDouble(std::string key, double value, const std::string& type, float sample_rate);
+    /* (Low Level Api) manually send a message
+        * type = "c", "g" or "ms"
+        */
+    bool send(std::string key, int64_t value, const std::string& type, float sample_rate);
+    bool sendDouble(std::string key, double value, const std::string& type, float sample_rate);
 
-    private:
-        /**
-         * (Low Level Api) manually send a message
-         * which might be composed of several lines.
-         */
-        bool send(const std::string& message);
+private:
+    /**
+        * (Low Level Api) manually send a message
+        * which might be composed of several lines.
+        */
+    bool send(const std::string& message);
 
-        void cleanup(std::string& key);
-        bool ShouldSend(float sample_rate);
+    void cleanup(std::string& key);
+    bool ShouldSend(float sample_rate);
 
-    private:
-        mutable Mutex cs;
-        mutable FastRandomContext insecure_rand GUARDED_BY(cs);
+private:
+    mutable Mutex cs;
+    mutable FastRandomContext insecure_rand GUARDED_BY(cs);
 
-        std::unique_ptr<Sock> m_sock{nullptr};
-        std::pair<struct sockaddr_storage, socklen_t> m_server{{}, sizeof(struct sockaddr_storage)};
+    std::unique_ptr<Sock> m_sock{nullptr};
+    std::pair<struct sockaddr_storage, socklen_t> m_server{{}, sizeof(struct sockaddr_storage)};
 
-        const uint16_t m_port;
-        const std::string m_host;
-        const std::string m_nodename;
-        const std::string m_ns;
+    const uint16_t m_port;
+    const std::string m_host;
+    const std::string m_nodename;
+    const std::string m_ns;
 };
 } // namespace statsd
 

From 92690685be62c89c3bdfc707029873e539fedb7d Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 15:25:38 +0000
Subject: [PATCH 02/12] stats: move `statsd_client` to `stats` directory

In upcoming commits, message sending will be split off into a separate
file and stats capabilities will be fleshed out. Prepare for that by
giving it its own directory.

Also get rid of `statsd` namespace, it is entirely unnecessary.

Co-authored-by: UdjinM6 <UdjinM6@users.noreply.github.com>
---
 contrib/devtools/copyright_header.py        |  2 +-
 src/Makefile.am                             |  4 ++--
 src/init.cpp                                | 12 ++++++------
 src/net.cpp                                 |  2 +-
 src/net_processing.cpp                      |  2 +-
 src/{statsd_client.cpp => stats/client.cpp} |  6 ++----
 src/{statsd_client.h => stats/client.h}     | 15 +++++++--------
 src/test/util/setup_common.cpp              |  4 ++--
 src/txorphanage.cpp                         |  2 +-
 src/validation.cpp                          |  2 +-
 test/lint/lint-locale-dependence.sh         |  2 +-
 test/util/data/non-backported.txt           |  3 ++-
 12 files changed, 27 insertions(+), 29 deletions(-)
 rename src/{statsd_client.cpp => stats/client.cpp} (98%)
 rename src/{statsd_client.h => stats/client.h} (91%)

diff --git a/contrib/devtools/copyright_header.py b/contrib/devtools/copyright_header.py
index e6efff75fd9d6..0f9d2aaae2686 100755
--- a/contrib/devtools/copyright_header.py
+++ b/contrib/devtools/copyright_header.py
@@ -26,7 +26,7 @@
     'src/crypto/*',
     'src/ctpl_stl.h',
     'src/reverse_iterator.h',
-    'src/statsd_client.cpp',
+    'src/stats/client.cpp',
     'src/test/fuzz/FuzzedDataProvider.h',
     'src/tinyformat.h',
     'src/bench/nanobench.h',
diff --git a/src/Makefile.am b/src/Makefile.am
index ae6b3863e2fa0..e35efcc506003 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -313,7 +313,7 @@ BITCOIN_CORE_H = \
   spork.h \
   stacktraces.h \
   streams.h \
-  statsd_client.h \
+  stats/client.h \
   support/allocators/mt_pooled_secure.h \
   support/allocators/pool.h \
   support/allocators/pooled_secure.h \
@@ -526,7 +526,7 @@ libbitcoin_server_a_SOURCES = \
   script/sigcache.cpp \
   shutdown.cpp \
   spork.cpp \
-  statsd_client.cpp \
+  stats/client.cpp \
   timedata.cpp \
   torcontrol.cpp \
   txdb.cpp \
diff --git a/src/init.cpp b/src/init.cpp
index 18decacf04163..1afff5b6de236 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -105,7 +105,7 @@
 #include <llmq/snapshot.h>
 #include <llmq/signing_shares.h>
 
-#include <statsd_client.h>
+#include <stats/client.h>
 
 #include <algorithm>
 #include <condition_variable>
@@ -1539,11 +1539,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // We need to initialize g_stats_client early as currently, g_stats_client is called
     // regardless of whether transmitting stats are desirable or not and if
     // g_stats_client isn't present when that attempt is made, the client will crash.
-    ::g_stats_client = std::make_unique<statsd::StatsdClient>(args.GetArg("-statshost", DEFAULT_STATSD_HOST),
-                                                              args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
-                                                              args.GetArg("-statsport", DEFAULT_STATSD_PORT),
-                                                              args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
-                                                              args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE));
+    ::g_stats_client = std::make_unique<StatsdClient>(args.GetArg("-statshost", DEFAULT_STATSD_HOST),
+                                                      args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
+                                                      args.GetArg("-statsport", DEFAULT_STATSD_PORT),
+                                                      args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
+                                                      args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE));
 
     {
 
diff --git a/src/net.cpp b/src/net.cpp
index d7863ab05b6c8..c3a51a103a38d 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -41,7 +41,7 @@
 #include <coinjoin/coinjoin.h>
 #include <evo/deterministicmns.h>
 
-#include <statsd_client.h>
+#include <stats/client.h>
 
 #ifdef WIN32
 #include <string.h>
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 1735df86697f5..bdaf5b660b10c 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -69,7 +69,7 @@
 #include <llmq/signing_shares.h>
 #include <llmq/snapshot.h>
 
-#include <statsd_client.h>
+#include <stats/client.h>
 
 /** Maximum number of in-flight objects from a peer */
 static constexpr int32_t MAX_PEER_OBJECT_IN_FLIGHT = 100;
diff --git a/src/statsd_client.cpp b/src/stats/client.cpp
similarity index 98%
rename from src/statsd_client.cpp
rename to src/stats/client.cpp
index d9ef85242b1d4..a2683e6156207 100644
--- a/src/statsd_client.cpp
+++ b/src/stats/client.cpp
@@ -33,7 +33,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **/
 
-#include <statsd_client.h>
+#include <stats/client.h>
 
 #include <compat.h>
 #include <netbase.h>
@@ -43,9 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cstdio>
 #include <random>
 
-std::unique_ptr<statsd::StatsdClient> g_stats_client;
+std::unique_ptr<StatsdClient> g_stats_client;
 
-namespace statsd {
 bool StatsdClient::ShouldSend(float sample_rate)
 {
     sample_rate = std::clamp(sample_rate, 0.f, 1.f);
@@ -193,4 +192,3 @@ bool StatsdClient::send(const std::string& message)
 
     return true;
 }
-} // namespace statsd
diff --git a/src/statsd_client.h b/src/stats/client.h
similarity index 91%
rename from src/statsd_client.h
rename to src/stats/client.h
index cdda53d2e2f32..eb8a48399882e 100644
--- a/src/statsd_client.h
+++ b/src/stats/client.h
@@ -3,15 +3,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_STATSD_CLIENT_H
-#define BITCOIN_STATSD_CLIENT_H
+#ifndef BITCOIN_STATS_CLIENT_H
+#define BITCOIN_STATS_CLIENT_H
 
 #include <random.h>
 #include <threadsafety.h>
 #include <util/sock.h>
 
-#include <string>
 #include <memory>
+#include <string>
 
 static constexpr bool DEFAULT_STATSD_ENABLE{false};
 static constexpr uint16_t DEFAULT_STATSD_PORT{8125};
@@ -24,8 +24,8 @@ static constexpr int DEFAULT_STATSD_PERIOD{60};
 static constexpr int MIN_STATSD_PERIOD{5};
 static constexpr int MAX_STATSD_PERIOD{60 * 60};
 
-namespace statsd {
-class StatsdClient {
+class StatsdClient
+{
 public:
     explicit StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
                             const std::string& ns, bool enabled);
@@ -66,8 +66,7 @@ class StatsdClient {
     const std::string m_nodename;
     const std::string m_ns;
 };
-} // namespace statsd
 
-extern std::unique_ptr<statsd::StatsdClient> g_stats_client;
+extern std::unique_ptr<StatsdClient> g_stats_client;
 
-#endif // BITCOIN_STATSD_CLIENT_H
+#endif // BITCOIN_STATS_CLIENT_H
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index e3453a9a6e401..04bcfe43bb035 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -39,7 +39,7 @@
 #include <scheduler.h>
 #include <script/sigcache.h>
 #include <spork.h>
-#include <statsd_client.h>
+#include <stats/client.h>
 #include <streams.h>
 #include <test/util/index.h>
 #include <txdb.h>
@@ -183,7 +183,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     SetupNetworking();
     InitSignatureCache();
     InitScriptExecutionCache();
-    ::g_stats_client = std::make_unique<statsd::StatsdClient>(
+    ::g_stats_client = std::make_unique<StatsdClient>(
         m_node.args->GetArg("-statshost", DEFAULT_STATSD_HOST),
         m_node.args->GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
         m_node.args->GetArg("-statsport", DEFAULT_STATSD_PORT),
diff --git a/src/txorphanage.cpp b/src/txorphanage.cpp
index 31f6997da5b0e..84835e0aad61e 100644
--- a/src/txorphanage.cpp
+++ b/src/txorphanage.cpp
@@ -7,7 +7,7 @@
 #include <consensus/validation.h>
 #include <logging.h>
 #include <policy/policy.h>
-#include <statsd_client.h>
+#include <stats/client.h>
 
 #include <cassert>
 
diff --git a/src/validation.cpp b/src/validation.cpp
index 5f422c122e1a3..f3488d5bdd88e 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -66,7 +66,7 @@
 #include <llmq/instantsend.h>
 #include <llmq/chainlocks.h>
 
-#include <statsd_client.h>
+#include <stats/client.h>
 
 #include <algorithm>
 #include <cassert>
diff --git a/test/lint/lint-locale-dependence.sh b/test/lint/lint-locale-dependence.sh
index 2dfe779b6fe13..a1c579ea83f08 100755
--- a/test/lint/lint-locale-dependence.sh
+++ b/test/lint/lint-locale-dependence.sh
@@ -45,7 +45,7 @@ KNOWN_VIOLATIONS=(
     "src/bitcoin-tx.cpp.*stoul"
     "src/dbwrapper.cpp:.*vsnprintf"
     "src/rest.cpp:.*strtol"
-    "src/statsd_client.cpp:.*snprintf"
+    "src/stats/client.cpp:.*snprintf"
     "src/test/dbwrapper_tests.cpp:.*snprintf"
     "src/test/fuzz/locale.cpp"
     "src/test/fuzz/string.cpp"
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 150bbb70c1898..7684074874286 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -29,7 +29,8 @@ src/rpc/quorums.cpp
 src/saltedhasher.*
 src/spork.*
 src/stacktraces.*
-src/statsd_client.*
+src/stats/*.cpp
+src/stats/*.h
 src/test/block_reward_reallocation_tests.cpp
 src/test/bls_tests.cpp
 src/test/dip0020opcodes_tests.cpp

From fc4a736e2a0e8b9b528613db65aed07595bc6be8 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Fri, 4 Oct 2024 08:47:36 +0000
Subject: [PATCH 03/12] stats: move message sending logic to `RawSender`

`RawSender` is inspired by `UDPSender` from `vthiery/cpp-statsd-client`
and separating it out of `StatsdClient` is needed to implement queueing
and batching support in upcoming commits.

This is the start of migrating our Statsd codebase to `cpp-statsd-client`.
---
 src/Makefile.am         |  2 +
 src/stats/client.cpp    | 70 +++++++++++++---------------------
 src/stats/client.h      | 18 +++------
 src/stats/rawsender.cpp | 74 ++++++++++++++++++++++++++++++++++++
 src/stats/rawsender.h   | 84 +++++++++++++++++++++++++++++++++++++++++
 5 files changed, 192 insertions(+), 56 deletions(-)
 create mode 100644 src/stats/rawsender.cpp
 create mode 100644 src/stats/rawsender.h

diff --git a/src/Makefile.am b/src/Makefile.am
index e35efcc506003..1ef871118750f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -314,6 +314,7 @@ BITCOIN_CORE_H = \
   stacktraces.h \
   streams.h \
   stats/client.h \
+  stats/rawsender.h \
   support/allocators/mt_pooled_secure.h \
   support/allocators/pool.h \
   support/allocators/pooled_secure.h \
@@ -527,6 +528,7 @@ libbitcoin_server_a_SOURCES = \
   shutdown.cpp \
   spork.cpp \
   stats/client.cpp \
+  stats/rawsender.cpp \
   timedata.cpp \
   torcontrol.cpp \
   txdb.cpp \
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index a2683e6156207..f89b283eab651 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2017 Statoshi Developers
+// Copyright (c) 2017-2023 Vincent Thiery
 // Copyright (c) 2020-2024 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -35,8 +36,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stats/client.h>
 
-#include <compat.h>
-#include <netbase.h>
+#include <stats/rawsender.h>
 #include <util/system.h>
 
 #include <cmath>
@@ -60,10 +60,8 @@ bool StatsdClient::ShouldSend(float sample_rate)
     return sample_rate > std::uniform_real_distribution<float>(0.f, 1.f)(insecure_rand);
 }
 
-StatsdClient::StatsdClient(const std::string& host, const std::string& nodename, uint16_t port, const std::string& ns,
-                           bool enabled) :
-    m_port{port},
-    m_host{host},
+StatsdClient::StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
+                           const std::string& ns, bool enabled) :
     m_nodename{nodename},
     m_ns{ns}
 {
@@ -72,31 +70,19 @@ StatsdClient::StatsdClient(const std::string& host, const std::string& nodename,
         return;
     }
 
-    if (auto netaddr = LookupHost(m_host, /*fAllowLookup=*/true); netaddr.has_value()) {
-        if (!netaddr->IsIPv4()) {
-            LogPrintf("ERROR: Host %s on unsupported network, cannot init StatsdClient\n", m_host);
-            return;
-        }
-        if (!CService(*netaddr, port).GetSockAddr(reinterpret_cast<struct sockaddr*>(&m_server.first), &m_server.second)) {
-            LogPrintf("ERROR: Cannot get socket address for %s, cannot init StatsdClient\n", m_host);
-            return;
-        }
-    } else {
-        LogPrintf("Unable to lookup host %s, cannot init StatsdClient\n", m_host);
+    std::optional<std::string> error_opt;
+    m_sender = std::make_unique<RawSender>(host, port, error_opt);
+    if (error_opt.has_value()) {
+        LogPrintf("ERROR: %s, cannot initialize StatsdClient.\n", error_opt.value());
+        m_sender.reset();
         return;
     }
 
-    SOCKET hSocket = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    if (hSocket == INVALID_SOCKET) {
-        LogPrintf("ERROR: Cannot create socket (socket() returned error %s), cannot init StatsdClient\n",
-                  NetworkErrorString(WSAGetLastError()));
-        return;
-    }
-    m_sock = std::make_unique<Sock>(hSocket);
-
-    LogPrintf("StatsdClient initialized to transmit stats to %s:%d\n", m_host, m_port);
+    LogPrintf("StatsdClient initialized to transmit stats to %s:%d\n", host, port);
 }
 
+StatsdClient::~StatsdClient() {}
+
 /* will change the original string */
 void StatsdClient::cleanup(std::string& key)
 {
@@ -133,7 +119,7 @@ bool StatsdClient::timing(const std::string& key, int64_t ms, float sample_rate)
 
 bool StatsdClient::send(std::string key, int64_t value, const std::string& type, float sample_rate)
 {
-    if (!m_sock) {
+    if (!m_sender) {
         return false;
     }
 
@@ -147,17 +133,22 @@ bool StatsdClient::send(std::string key, int64_t value, const std::string& type,
 
     cleanup(key);
 
-    std::string buf{strprintf("%s%s:%d|%s", m_ns, key, value, type)};
+    RawMessage msg{strprintf("%s%s:%d|%s", m_ns, key, value, type)};
     if (sample_rate < 1.f) {
-        buf += strprintf("|@%.2f", sample_rate);
+        msg += strprintf("|@%.2f", sample_rate);
+    }
+
+    if (auto error_opt = m_sender->Send(msg); error_opt.has_value()) {
+        LogPrintf("ERROR: %s.\n", error_opt.value());
+        return false;
     }
 
-    return send(buf);
+    return true;
 }
 
 bool StatsdClient::sendDouble(std::string key, double value, const std::string& type, float sample_rate)
 {
-    if (!m_sock) {
+    if (!m_sender) {
         return false;
     }
 
@@ -171,22 +162,13 @@ bool StatsdClient::sendDouble(std::string key, double value, const std::string&
 
     cleanup(key);
 
-    std::string buf{strprintf("%s%s:%f|%s", m_ns, key, value, type)};
+    RawMessage msg{strprintf("%s%s:%f|%s", m_ns, key, value, type)};
     if (sample_rate < 1.f) {
-        buf += strprintf("|@%.2f", sample_rate);
+        msg += strprintf("|@%.2f", sample_rate);
     }
 
-    return send(buf);
-}
-
-bool StatsdClient::send(const std::string& message)
-{
-    assert(m_sock);
-
-    if (::sendto(m_sock->Get(), message.data(), message.size(), /*flags=*/0,
-                 reinterpret_cast<struct sockaddr*>(&m_server.first), m_server.second) == SOCKET_ERROR) {
-        LogPrintf("ERROR: Unable to send message (sendto() returned error %s), host=%s:%d\n",
-                  NetworkErrorString(WSAGetLastError()), m_host, m_port);
+    if (auto error_opt = m_sender->Send(msg); error_opt.has_value()) {
+        LogPrintf("ERROR: %s.\n", error_opt.value());
         return false;
     }
 
diff --git a/src/stats/client.h b/src/stats/client.h
index eb8a48399882e..32780de7fc309 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -1,4 +1,5 @@
 // Copyright (c) 2014-2017 Statoshi Developers
+// Copyright (c) 2017-2023 Vincent Thiery
 // Copyright (c) 2020-2023 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -7,12 +8,13 @@
 #define BITCOIN_STATS_CLIENT_H
 
 #include <random.h>
-#include <threadsafety.h>
-#include <util/sock.h>
+#include <sync.h>
 
 #include <memory>
 #include <string>
 
+class RawSender;
+
 static constexpr bool DEFAULT_STATSD_ENABLE{false};
 static constexpr uint16_t DEFAULT_STATSD_PORT{8125};
 static const std::string DEFAULT_STATSD_HOST{"127.0.0.1"};
@@ -29,6 +31,7 @@ class StatsdClient
 public:
     explicit StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
                             const std::string& ns, bool enabled);
+    ~StatsdClient();
 
 public:
     bool inc(const std::string& key, float sample_rate = 1.f);
@@ -45,12 +48,6 @@ class StatsdClient
     bool sendDouble(std::string key, double value, const std::string& type, float sample_rate);
 
 private:
-    /**
-        * (Low Level Api) manually send a message
-        * which might be composed of several lines.
-        */
-    bool send(const std::string& message);
-
     void cleanup(std::string& key);
     bool ShouldSend(float sample_rate);
 
@@ -58,11 +55,8 @@ class StatsdClient
     mutable Mutex cs;
     mutable FastRandomContext insecure_rand GUARDED_BY(cs);
 
-    std::unique_ptr<Sock> m_sock{nullptr};
-    std::pair<struct sockaddr_storage, socklen_t> m_server{{}, sizeof(struct sockaddr_storage)};
+    std::unique_ptr<RawSender> m_sender{nullptr};
 
-    const uint16_t m_port;
-    const std::string m_host;
     const std::string m_nodename;
     const std::string m_ns;
 };
diff --git a/src/stats/rawsender.cpp b/src/stats/rawsender.cpp
new file mode 100644
index 0000000000000..98b42464b1f17
--- /dev/null
+++ b/src/stats/rawsender.cpp
@@ -0,0 +1,74 @@
+// Copyright (c) 2017-2023 Vincent Thiery
+// Copyright (c) 2024 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <stats/rawsender.h>
+
+#include <netaddress.h>
+#include <netbase.h>
+#include <util/sock.h>
+
+RawSender::RawSender(const std::string& host, uint16_t port, std::optional<std::string>& error) :
+    m_host{host},
+    m_port{port}
+{
+    if (host.empty()) {
+        error = "No host specified";
+        return;
+    }
+
+    if (auto netaddr = LookupHost(m_host, /*fAllowLookup=*/true); netaddr.has_value()) {
+        if (!netaddr->IsIPv4()) {
+            error = strprintf("Host %s on unsupported network", m_host);
+            return;
+        }
+        if (!CService(*netaddr, port).GetSockAddr(reinterpret_cast<struct sockaddr*>(&m_server.first), &m_server.second)) {
+            error = strprintf("Cannot get socket address for %s", m_host);
+            return;
+        }
+    } else {
+        error = strprintf("Unable to lookup host %s", m_host);
+        return;
+    }
+
+    SOCKET hSocket = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if (hSocket == INVALID_SOCKET) {
+        error = strprintf("Cannot create socket (socket() returned error %s)", NetworkErrorString(WSAGetLastError()));
+        return;
+    }
+    m_sock = std::make_unique<Sock>(hSocket);
+
+    LogPrintf("Started RawSender sending messages to %s:%d\n", m_host, m_port);
+}
+
+RawSender::~RawSender()
+{
+    LogPrintf("Stopping RawSender instance sending messages to %s:%d. %d successes, %d failures.\n",
+              m_host, m_port, m_successes, m_failures);
+}
+
+std::optional<std::string> RawSender::Send(const RawMessage& msg)
+{
+    if (!m_sock) {
+        m_failures++;
+        return "Socket not initialized, cannot send message";
+    }
+
+    if (::sendto(m_sock->Get(), reinterpret_cast<const char*>(msg.data()),
+#ifdef WIN32
+                 static_cast<int>(msg.size()),
+#else
+                 msg.size(),
+#endif // WIN32
+                 /*flags=*/0, reinterpret_cast<struct sockaddr*>(&m_server.first), m_server.second) == SOCKET_ERROR) {
+        m_failures++;
+        return strprintf("Unable to send message to %s (sendto() returned error %s)", this->ToStringHostPort(),
+                         NetworkErrorString(WSAGetLastError()));
+    }
+
+    m_successes++;
+    return std::nullopt;
+}
+
+std::string RawSender::ToStringHostPort() const { return strprintf("%s:%d", m_host, m_port); }
diff --git a/src/stats/rawsender.h b/src/stats/rawsender.h
new file mode 100644
index 0000000000000..dd12f14635ede
--- /dev/null
+++ b/src/stats/rawsender.h
@@ -0,0 +1,84 @@
+// Copyright (c) 2017-2023 Vincent Thiery
+// Copyright (c) 2024 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_STATS_RAWSENDER_H
+#define BITCOIN_STATS_RAWSENDER_H
+
+#include <compat.h>
+#include <sync.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+class Sock;
+
+struct RawMessage : public std::vector<uint8_t>
+{
+    using parent_type = std::vector<value_type>;
+    using parent_type::parent_type;
+
+    explicit RawMessage(const std::string& data) : parent_type{data.begin(), data.end()} {}
+
+    parent_type& operator+=(value_type rhs) { return append(rhs); }
+    parent_type& operator+=(std::string::value_type rhs) { return append(rhs); }
+    parent_type& operator+=(const parent_type& rhs) { return append(rhs); }
+    parent_type& operator+=(const std::string& rhs) { return append(rhs); }
+
+    parent_type& append(value_type rhs)
+    {
+        push_back(rhs);
+        return *this;
+    }
+    parent_type& append(std::string::value_type rhs)
+    {
+        push_back(static_cast<value_type>(rhs));
+        return *this;
+    }
+    parent_type& append(const parent_type& rhs)
+    {
+        insert(end(), rhs.begin(), rhs.end());
+        return *this;
+    }
+    parent_type& append(const std::string& rhs)
+    {
+        insert(end(), rhs.begin(), rhs.end());
+        return *this;
+    }
+};
+
+class RawSender
+{
+public:
+    RawSender(const std::string& host, uint16_t port, std::optional<std::string>& error);
+    ~RawSender();
+
+    RawSender(const RawSender&) = delete;
+    RawSender& operator=(const RawSender&) = delete;
+    RawSender(RawSender&&) = delete;
+
+    std::optional<std::string> Send(const RawMessage& msg);
+
+    std::string ToStringHostPort() const;
+
+private:
+    /* Socket used to communicate with host */
+    std::unique_ptr<Sock> m_sock{nullptr};
+    /* Socket address containing host information */
+    std::pair<struct sockaddr_storage, socklen_t> m_server{{}, sizeof(struct sockaddr_storage)};
+
+    /* Hostname of server receiving messages */
+    const std::string m_host;
+    /* Port of server receiving messages */
+    const uint16_t m_port;
+
+    /* Number of messages sent */
+    uint64_t m_successes{0};
+    /* Number of messages not sent */
+    uint64_t m_failures{0};
+};
+
+#endif // BITCOIN_STATS_RAWSENDER_H

From 38b1643fe6de4b84465dd8331db4c73267feddcc Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 15:28:37 +0000
Subject: [PATCH 04/12] feat(stats): introduce support for queuing messages

---
 src/init.cpp                   |  4 +-
 src/stats/client.cpp           |  4 +-
 src/stats/client.h             | 10 +++--
 src/stats/rawsender.cpp        | 76 ++++++++++++++++++++++++++++++++--
 src/stats/rawsender.h          | 23 +++++++++-
 src/test/util/setup_common.cpp |  3 +-
 6 files changed, 107 insertions(+), 13 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 1afff5b6de236..c847b4bfb6d6c 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -772,6 +772,7 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     argsman.AddArg("-statsenabled", strprintf("Publish internal stats to statsd (default: %u)", DEFAULT_STATSD_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    argsman.AddArg("-statsduration=<ms>", strprintf("Specify the number of milliseconds between stats messages (default: %d)", DEFAULT_STATSD_DURATION), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statshost=<ip>", strprintf("Specify statsd host (default: %s)", DEFAULT_STATSD_HOST), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statshostname=<ip>", strprintf("Specify statsd host name (default: %s)", DEFAULT_STATSD_HOSTNAME), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statsport=<port>", strprintf("Specify statsd port (default: %u)", DEFAULT_STATSD_PORT), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
@@ -1540,8 +1541,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // regardless of whether transmitting stats are desirable or not and if
     // g_stats_client isn't present when that attempt is made, the client will crash.
     ::g_stats_client = std::make_unique<StatsdClient>(args.GetArg("-statshost", DEFAULT_STATSD_HOST),
-                                                      args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
                                                       args.GetArg("-statsport", DEFAULT_STATSD_PORT),
+                                                      args.GetArg("-statsduration", DEFAULT_STATSD_DURATION),
+                                                      args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
                                                       args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
                                                       args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE));
 
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index f89b283eab651..ba9fa60f7c7ba 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -60,7 +60,7 @@ bool StatsdClient::ShouldSend(float sample_rate)
     return sample_rate > std::uniform_real_distribution<float>(0.f, 1.f)(insecure_rand);
 }
 
-StatsdClient::StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
+StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t interval_ms, const std::string& nodename,
                            const std::string& ns, bool enabled) :
     m_nodename{nodename},
     m_ns{ns}
@@ -71,7 +71,7 @@ StatsdClient::StatsdClient(const std::string& host, const std::string& nodename,
     }
 
     std::optional<std::string> error_opt;
-    m_sender = std::make_unique<RawSender>(host, port, error_opt);
+    m_sender = std::make_unique<RawSender>(host, port, interval_ms, error_opt);
     if (error_opt.has_value()) {
         LogPrintf("ERROR: %s, cannot initialize StatsdClient.\n", error_opt.value());
         m_sender.reset();
diff --git a/src/stats/client.h b/src/stats/client.h
index 32780de7fc309..0cad8bc6005d8 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -21,16 +21,20 @@ static const std::string DEFAULT_STATSD_HOST{"127.0.0.1"};
 static const std::string DEFAULT_STATSD_HOSTNAME{""};
 static const std::string DEFAULT_STATSD_NAMESPACE{""};
 
-// schedule periodic measurements, in seconds: default - 1 minute, min - 5 sec, max - 1h.
+/** Default number of milliseconds between flushing a queue of messages */
+static constexpr int DEFAULT_STATSD_DURATION{1000};
+/** Default number of seconds between recording periodic stats */
 static constexpr int DEFAULT_STATSD_PERIOD{60};
+/** Minimum number of seconds between recording periodic stats */
 static constexpr int MIN_STATSD_PERIOD{5};
+/** Maximum number of seconds between recording periodic stats */
 static constexpr int MAX_STATSD_PERIOD{60 * 60};
 
 class StatsdClient
 {
 public:
-    explicit StatsdClient(const std::string& host, const std::string& nodename, uint16_t port,
-                            const std::string& ns, bool enabled);
+    explicit StatsdClient(const std::string& host, uint16_t port, uint64_t interval_ms, const std::string& nodename,
+                          const std::string& ns, bool enabled);
     ~StatsdClient();
 
 public:
diff --git a/src/stats/rawsender.cpp b/src/stats/rawsender.cpp
index 98b42464b1f17..0c2f10ffa6b9b 100644
--- a/src/stats/rawsender.cpp
+++ b/src/stats/rawsender.cpp
@@ -8,10 +8,13 @@
 #include <netaddress.h>
 #include <netbase.h>
 #include <util/sock.h>
+#include <util/thread.h>
 
-RawSender::RawSender(const std::string& host, uint16_t port, std::optional<std::string>& error) :
+RawSender::RawSender(const std::string& host, uint16_t port, uint64_t interval_ms,
+                     std::optional<std::string>& error) :
     m_host{host},
-    m_port{port}
+    m_port{port},
+    m_interval_ms{interval_ms}
 {
     if (host.empty()) {
         error = "No host specified";
@@ -39,16 +42,42 @@ RawSender::RawSender(const std::string& host, uint16_t port, std::optional<std::
     }
     m_sock = std::make_unique<Sock>(hSocket);
 
-    LogPrintf("Started RawSender sending messages to %s:%d\n", m_host, m_port);
+    if (m_interval_ms == 0) {
+        LogPrintf("Send interval is zero, not starting RawSender queueing thread.\n");
+    } else {
+        m_interrupt.reset();
+        m_thread = std::thread(&util::TraceThread, "rawsender", [this] { QueueThreadMain(); });
+    }
+
+    LogPrintf("Started %sRawSender sending messages to %s:%d\n", m_thread.joinable() ? "threaded " : "", m_host, m_port);
 }
 
 RawSender::~RawSender()
 {
-    LogPrintf("Stopping RawSender instance sending messages to %s:%d. %d successes, %d failures.\n",
+    // If there is a thread, interrupt and stop it
+    if (m_thread.joinable()) {
+        m_interrupt();
+        m_thread.join();
+    }
+    // Flush queue of uncommitted messages
+    QueueFlush();
+
+    LogPrintf("Stopped RawSender instance sending messages to %s:%d. %d successes, %d failures.\n",
               m_host, m_port, m_successes, m_failures);
 }
 
 std::optional<std::string> RawSender::Send(const RawMessage& msg)
+{
+    // If there is a thread, append to queue
+    if (m_thread.joinable()) {
+        QueueAdd(msg);
+        return std::nullopt;
+    }
+    // There isn't a queue, send directly
+    return SendDirectly(msg);
+}
+
+std::optional<std::string> RawSender::SendDirectly(const RawMessage& msg)
 {
     if (!m_sock) {
         m_failures++;
@@ -72,3 +101,42 @@ std::optional<std::string> RawSender::Send(const RawMessage& msg)
 }
 
 std::string RawSender::ToStringHostPort() const { return strprintf("%s:%d", m_host, m_port); }
+
+void RawSender::QueueAdd(const RawMessage& msg)
+{
+    AssertLockNotHeld(cs);
+    WITH_LOCK(cs, m_queue.push_back(msg));
+}
+
+void RawSender::QueueFlush()
+{
+    AssertLockNotHeld(cs);
+    WITH_LOCK(cs, QueueFlush(m_queue));
+}
+
+void RawSender::QueueFlush(std::deque<RawMessage>& queue)
+{
+    while (!queue.empty()) {
+        SendDirectly(queue.front());
+        queue.pop_front();
+    }
+}
+
+void RawSender::QueueThreadMain()
+{
+    AssertLockNotHeld(cs);
+
+    while (!m_interrupt) {
+        // Swap the queues to commit the existing queue of messages
+        std::deque<RawMessage> queue;
+        WITH_LOCK(cs, m_queue.swap(queue));
+
+        // Flush the committed queue
+        QueueFlush(queue);
+        assert(queue.empty());
+
+        if (!m_interrupt.sleep_for(std::chrono::milliseconds(m_interval_ms))) {
+            return;
+        }
+    }
+}
diff --git a/src/stats/rawsender.h b/src/stats/rawsender.h
index dd12f14635ede..24dadcde940d2 100644
--- a/src/stats/rawsender.h
+++ b/src/stats/rawsender.h
@@ -8,7 +8,9 @@
 
 #include <compat.h>
 #include <sync.h>
+#include <threadinterrupt.h>
 
+#include <deque>
 #include <memory>
 #include <optional>
 #include <string>
@@ -53,27 +55,44 @@ struct RawMessage : public std::vector<uint8_t>
 class RawSender
 {
 public:
-    RawSender(const std::string& host, uint16_t port, std::optional<std::string>& error);
+    RawSender(const std::string& host, uint16_t port, uint64_t interval_ms, std::optional<std::string>& error);
     ~RawSender();
 
     RawSender(const RawSender&) = delete;
     RawSender& operator=(const RawSender&) = delete;
     RawSender(RawSender&&) = delete;
 
-    std::optional<std::string> Send(const RawMessage& msg);
+    std::optional<std::string> Send(const RawMessage& msg) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    std::optional<std::string> SendDirectly(const RawMessage& msg);
 
     std::string ToStringHostPort() const;
 
+    void QueueAdd(const RawMessage& msg) EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void QueueFlush() EXCLUSIVE_LOCKS_REQUIRED(!cs);
+    void QueueFlush(std::deque<RawMessage>& queue);
+    void QueueThreadMain() EXCLUSIVE_LOCKS_REQUIRED(!cs);
+
 private:
     /* Socket used to communicate with host */
     std::unique_ptr<Sock> m_sock{nullptr};
     /* Socket address containing host information */
     std::pair<struct sockaddr_storage, socklen_t> m_server{{}, sizeof(struct sockaddr_storage)};
 
+    /* Mutex to protect messages queue */
+    mutable Mutex cs;
+    /* Interrupt for queue processing thread */
+    CThreadInterrupt m_interrupt;
+    /* Queue of messages to be sent */
+    std::deque<RawMessage> m_queue GUARDED_BY(cs);
+    /* Thread that processes queue every m_interval_ms */
+    std::thread m_thread;
+
     /* Hostname of server receiving messages */
     const std::string m_host;
     /* Port of server receiving messages */
     const uint16_t m_port;
+    /* Time between queue thread runs (expressed in milliseconds) */
+    const uint64_t m_interval_ms;
 
     /* Number of messages sent */
     uint64_t m_successes{0};
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 04bcfe43bb035..67ce533d8bf9a 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -185,8 +185,9 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     InitScriptExecutionCache();
     ::g_stats_client = std::make_unique<StatsdClient>(
         m_node.args->GetArg("-statshost", DEFAULT_STATSD_HOST),
-        m_node.args->GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
         m_node.args->GetArg("-statsport", DEFAULT_STATSD_PORT),
+        m_node.args->GetArg("-statsduration", DEFAULT_STATSD_DURATION),
+        m_node.args->GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
         m_node.args->GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
         m_node.args->GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE)
     );

From bf44fc3bf623c797de4e28c9141e71979c392ea3 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 15:24:37 +0000
Subject: [PATCH 05/12] feat(stats): introduce support for batching messages

Co-authored-by: UdjinM6 <UdjinM6@users.noreply.github.com>
---
 src/init.cpp                   |  2 ++
 src/stats/client.cpp           | 11 ++++++++---
 src/stats/client.h             |  6 ++++--
 src/stats/rawsender.cpp        | 27 ++++++++++++++++++++++++---
 src/stats/rawsender.h          |  9 ++++++---
 src/test/util/setup_common.cpp |  1 +
 6 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index c847b4bfb6d6c..639a6f2395d9a 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -772,6 +772,7 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     argsman.AddArg("-statsenabled", strprintf("Publish internal stats to statsd (default: %u)", DEFAULT_STATSD_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    argsman.AddArg("-statsbatchsize=<bytes>", strprintf("Specify the size of each batch of stats messages (default: %d)", DEFAULT_STATSD_BATCH_SIZE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statsduration=<ms>", strprintf("Specify the number of milliseconds between stats messages (default: %d)", DEFAULT_STATSD_DURATION), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statshost=<ip>", strprintf("Specify statsd host (default: %s)", DEFAULT_STATSD_HOST), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statshostname=<ip>", strprintf("Specify statsd host name (default: %s)", DEFAULT_STATSD_HOSTNAME), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
@@ -1542,6 +1543,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // g_stats_client isn't present when that attempt is made, the client will crash.
     ::g_stats_client = std::make_unique<StatsdClient>(args.GetArg("-statshost", DEFAULT_STATSD_HOST),
                                                       args.GetArg("-statsport", DEFAULT_STATSD_PORT),
+                                                      args.GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
                                                       args.GetArg("-statsduration", DEFAULT_STATSD_DURATION),
                                                       args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
                                                       args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index ba9fa60f7c7ba..ddd5b0a738256 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -43,6 +43,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cstdio>
 #include <random>
 
+/** Delimiter segmenting two fully formed Statsd messages */
+static constexpr char STATSD_MSG_DELIMITER{'\n'};
+
 std::unique_ptr<StatsdClient> g_stats_client;
 
 bool StatsdClient::ShouldSend(float sample_rate)
@@ -60,8 +63,8 @@ bool StatsdClient::ShouldSend(float sample_rate)
     return sample_rate > std::uniform_real_distribution<float>(0.f, 1.f)(insecure_rand);
 }
 
-StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t interval_ms, const std::string& nodename,
-                           const std::string& ns, bool enabled) :
+StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
+                           const std::string& nodename, const std::string& ns, bool enabled) :
     m_nodename{nodename},
     m_ns{ns}
 {
@@ -71,7 +74,9 @@ StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t inte
     }
 
     std::optional<std::string> error_opt;
-    m_sender = std::make_unique<RawSender>(host, port, interval_ms, error_opt);
+    m_sender = std::make_unique<RawSender>(host, port,
+                                           std::make_pair(batch_size, static_cast<uint8_t>(STATSD_MSG_DELIMITER)),
+                                           interval_ms, error_opt);
     if (error_opt.has_value()) {
         LogPrintf("ERROR: %s, cannot initialize StatsdClient.\n", error_opt.value());
         m_sender.reset();
diff --git a/src/stats/client.h b/src/stats/client.h
index 0cad8bc6005d8..40d74c25059c0 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -25,6 +25,8 @@ static const std::string DEFAULT_STATSD_NAMESPACE{""};
 static constexpr int DEFAULT_STATSD_DURATION{1000};
 /** Default number of seconds between recording periodic stats */
 static constexpr int DEFAULT_STATSD_PERIOD{60};
+/** Default size in bytes of a batch of messages */
+static constexpr int DEFAULT_STATSD_BATCH_SIZE{1024};
 /** Minimum number of seconds between recording periodic stats */
 static constexpr int MIN_STATSD_PERIOD{5};
 /** Maximum number of seconds between recording periodic stats */
@@ -33,8 +35,8 @@ static constexpr int MAX_STATSD_PERIOD{60 * 60};
 class StatsdClient
 {
 public:
-    explicit StatsdClient(const std::string& host, uint16_t port, uint64_t interval_ms, const std::string& nodename,
-                          const std::string& ns, bool enabled);
+    explicit StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
+                          const std::string& nodename, const std::string& ns, bool enabled);
     ~StatsdClient();
 
 public:
diff --git a/src/stats/rawsender.cpp b/src/stats/rawsender.cpp
index 0c2f10ffa6b9b..eb423e37d5f0c 100644
--- a/src/stats/rawsender.cpp
+++ b/src/stats/rawsender.cpp
@@ -10,10 +10,11 @@
 #include <util/sock.h>
 #include <util/thread.h>
 
-RawSender::RawSender(const std::string& host, uint16_t port, uint64_t interval_ms,
-                     std::optional<std::string>& error) :
+RawSender::RawSender(const std::string& host, uint16_t port, std::pair<uint64_t, uint8_t> batching_opts,
+                     uint64_t interval_ms, std::optional<std::string>& error) :
     m_host{host},
     m_port{port},
+    m_batching_opts{batching_opts},
     m_interval_ms{interval_ms}
 {
     if (host.empty()) {
@@ -105,7 +106,27 @@ std::string RawSender::ToStringHostPort() const { return strprintf("%s:%d", m_ho
 void RawSender::QueueAdd(const RawMessage& msg)
 {
     AssertLockNotHeld(cs);
-    WITH_LOCK(cs, m_queue.push_back(msg));
+    LOCK(cs);
+
+    const auto& [batch_size, batch_delim] = m_batching_opts;
+    // If no batch size has been specified, simply add to queue
+    if (batch_size == 0) {
+        m_queue.push_back(msg);
+        return;
+    }
+
+    // We can batch, either create a new batch in queue or append to existing batch in queue
+    if (m_queue.empty() || m_queue.back().size() + msg.size() >= batch_size) {
+        // Either we don't have a place to batch our message or we exceeded the batch size, make a new batch
+        m_queue.emplace_back();
+        m_queue.back().reserve(batch_size);
+    } else if (!m_queue.back().empty()) {
+        // When there is already a batch open we need a delimiter when its not empty
+        m_queue.back() += batch_delim;
+    }
+
+    // Add the new message to the batch
+    m_queue.back() += msg;
 }
 
 void RawSender::QueueFlush()
diff --git a/src/stats/rawsender.h b/src/stats/rawsender.h
index 24dadcde940d2..d91f6c0def751 100644
--- a/src/stats/rawsender.h
+++ b/src/stats/rawsender.h
@@ -55,7 +55,8 @@ struct RawMessage : public std::vector<uint8_t>
 class RawSender
 {
 public:
-    RawSender(const std::string& host, uint16_t port, uint64_t interval_ms, std::optional<std::string>& error);
+    RawSender(const std::string& host, uint16_t port, std::pair<uint64_t, uint8_t> batching_opts,
+              uint64_t interval_ms, std::optional<std::string>& error);
     ~RawSender();
 
     RawSender(const RawSender&) = delete;
@@ -78,11 +79,11 @@ class RawSender
     /* Socket address containing host information */
     std::pair<struct sockaddr_storage, socklen_t> m_server{{}, sizeof(struct sockaddr_storage)};
 
-    /* Mutex to protect messages queue */
+    /* Mutex to protect (batches of) messages queue */
     mutable Mutex cs;
     /* Interrupt for queue processing thread */
     CThreadInterrupt m_interrupt;
-    /* Queue of messages to be sent */
+    /* Queue of (batches of) messages to be sent */
     std::deque<RawMessage> m_queue GUARDED_BY(cs);
     /* Thread that processes queue every m_interval_ms */
     std::thread m_thread;
@@ -91,6 +92,8 @@ class RawSender
     const std::string m_host;
     /* Port of server receiving messages */
     const uint16_t m_port;
+    /* Batching parameters */
+    const std::pair</*size=*/uint64_t, /*delimiter=*/uint8_t> m_batching_opts{0, 0};
     /* Time between queue thread runs (expressed in milliseconds) */
     const uint64_t m_interval_ms;
 
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 67ce533d8bf9a..7d7c898d58974 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -186,6 +186,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     ::g_stats_client = std::make_unique<StatsdClient>(
         m_node.args->GetArg("-statshost", DEFAULT_STATSD_HOST),
         m_node.args->GetArg("-statsport", DEFAULT_STATSD_PORT),
+        m_node.args->GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
         m_node.args->GetArg("-statsduration", DEFAULT_STATSD_DURATION),
         m_node.args->GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
         m_node.args->GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),

From 3e12ac0e09d1aab7d50ba2e68f711cf03317770c Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 16:43:39 +0000
Subject: [PATCH 06/12] stats: deduplicate `send` and `sendDouble` logic

Additionally, let's remove the key sanitation logic since keys are
hardcoded.

Co-authored-by: UdjinM6 <UdjinM6@users.noreply.github.com>
---
 src/stats/client.cpp | 76 ++++++++++----------------------------------
 src/stats/client.h   | 14 +++++---
 2 files changed, 27 insertions(+), 63 deletions(-)

diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index ddd5b0a738256..90aa940c5115d 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -43,26 +43,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cstdio>
 #include <random>
 
+namespace {
+/** Threshold below which a value is considered effectively zero */
+static constexpr float EPSILON{0.0001f};
+
 /** Delimiter segmenting two fully formed Statsd messages */
 static constexpr char STATSD_MSG_DELIMITER{'\n'};
+} // anonymous namespace
 
 std::unique_ptr<StatsdClient> g_stats_client;
 
-bool StatsdClient::ShouldSend(float sample_rate)
-{
-    sample_rate = std::clamp(sample_rate, 0.f, 1.f);
-
-    constexpr float EPSILON{0.0001f};
-    /* If sample rate is 1, we should always send */
-    if (std::fabs(sample_rate - 1.f) < EPSILON) return true;
-    /* If sample rate is 0, we should never send */
-    if (std::fabs(sample_rate) < EPSILON) return false;
-
-    /* Sample rate is >0 and <1, roll the dice */
-    LOCK(cs);
-    return sample_rate > std::uniform_real_distribution<float>(0.f, 1.f)(insecure_rand);
-}
-
 StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
                            const std::string& nodename, const std::string& ns, bool enabled) :
     m_nodename{nodename},
@@ -88,16 +78,6 @@ StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t batc
 
 StatsdClient::~StatsdClient() {}
 
-/* will change the original string */
-void StatsdClient::cleanup(std::string& key)
-{
-    auto pos = key.find_first_of(":|@");
-    while (pos != std::string::npos) {
-        key[pos] = '_';
-        pos = key.find_first_of(":|@");
-    }
-}
-
 bool StatsdClient::dec(const std::string& key, float sample_rate) { return count(key, -1, sample_rate); }
 
 bool StatsdClient::inc(const std::string& key, float sample_rate) { return count(key, 1, sample_rate); }
@@ -122,56 +102,34 @@ bool StatsdClient::timing(const std::string& key, int64_t ms, float sample_rate)
     return send(key, ms, "ms", sample_rate);
 }
 
-bool StatsdClient::send(std::string key, int64_t value, const std::string& type, float sample_rate)
+template <typename T1>
+bool StatsdClient::Send(const std::string& key, T1 value, const std::string& type, float sample_rate)
 {
-    if (!m_sender) {
-        return false;
-    }
+    static_assert(std::is_arithmetic<T1>::value, "Must specialize to an arithmetic type");
 
-    if (!ShouldSend(sample_rate)) {
-        // Not our turn to send but report that we have
-        return true;
-    }
-
-    // partition stats by node name if set
-    if (!m_nodename.empty()) key = key + "." + m_nodename;
-
-    cleanup(key);
-
-    RawMessage msg{strprintf("%s%s:%d|%s", m_ns, key, value, type)};
-    if (sample_rate < 1.f) {
-        msg += strprintf("|@%.2f", sample_rate);
-    }
-
-    if (auto error_opt = m_sender->Send(msg); error_opt.has_value()) {
-        LogPrintf("ERROR: %s.\n", error_opt.value());
-        return false;
-    }
-
-    return true;
-}
-
-bool StatsdClient::sendDouble(std::string key, double value, const std::string& type, float sample_rate)
-{
     if (!m_sender) {
         return false;
     }
 
-    if (!ShouldSend(sample_rate)) {
-        // Not our turn to send but report that we have
+    // Determine if we should send the message at all but claim that we did even if we don't
+    sample_rate = std::clamp(sample_rate, 0.f, 1.f);
+    bool always_send = std::fabs(sample_rate - 1.f) < EPSILON;
+    bool never_send = std::fabs(sample_rate) < EPSILON;
+    if (never_send || (!always_send &&
+                       WITH_LOCK(cs, return sample_rate < std::uniform_real_distribution<float>(0.f, 1.f)(insecure_rand)))) {
         return true;
     }
 
     // partition stats by node name if set
     if (!m_nodename.empty()) key = key + "." + m_nodename;
 
-    cleanup(key);
-
+    // Construct the message and if our message isn't always-send, report the sample rate
     RawMessage msg{strprintf("%s%s:%f|%s", m_ns, key, value, type)};
-    if (sample_rate < 1.f) {
+    if (!always_send) {
         msg += strprintf("|@%.2f", sample_rate);
     }
 
+    // Send it and report an error if we encounter one
     if (auto error_opt = m_sender->Send(msg); error_opt.has_value()) {
         LogPrintf("ERROR: %s.\n", error_opt.value());
         return false;
diff --git a/src/stats/client.h b/src/stats/client.h
index 40d74c25059c0..bfc1d67f115b3 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -50,12 +50,18 @@ class StatsdClient
     /* (Low Level Api) manually send a message
         * type = "c", "g" or "ms"
         */
-    bool send(std::string key, int64_t value, const std::string& type, float sample_rate);
-    bool sendDouble(std::string key, double value, const std::string& type, float sample_rate);
+    bool send(const std::string& key, int64_t value, const std::string& type, float sample_rate = 1.f)
+    {
+        return Send(key, value, type, sample_rate);
+    }
+    bool sendDouble(const std::string& key, double value, const std::string& type, float sample_rate = 1.f)
+    {
+        return Send(key, value, type, sample_rate);
+    }
 
 private:
-    void cleanup(std::string& key);
-    bool ShouldSend(float sample_rate);
+    template <typename T1>
+    bool Send(const std::string& key, T1 value, const std::string& type, float sample_rate);
 
 private:
     mutable Mutex cs;

From 69603a83fab9d0d7f3fdce0fd4a3906ca21f6003 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 17:02:28 +0000
Subject: [PATCH 07/12] stats: miscellaneous changes and housekeeping

- `timing` cannot contain a negative value, change to `uint64_t`
- remove `sendDouble`, use template specialization of `Send` instead,
  that can be reused as `send`
- rename `value` in `count()` to `delta`
- add more comments

`gaugeDouble` has been kept around because utilizing templates for it
would require us to either write template specializations for every kind
of `gauge` value (implicit conversions will not save us from this) or
move all logic to the header, neither option seems desirable.
---
 src/net.cpp          |  2 +-
 src/stats/client.cpp | 26 +++++++++++++++++++-------
 src/stats/client.h   | 34 +++++++++++++++++-----------------
 3 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/src/net.cpp b/src/net.cpp
index c3a51a103a38d..98daa1711754a 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -4145,7 +4145,7 @@ void CConnman::RecordBytesRecv(uint64_t bytes)
 {
     nTotalBytesRecv += bytes;
     ::g_stats_client->count("bandwidth.bytesReceived", bytes, 0.1f);
-    ::g_stats_client->gauge("bandwidth.totalBytesReceived", nTotalBytesRecv, 0.01f);
+    ::g_stats_client->gauge("bandwidth.totalBytesReceived", nTotalBytesRecv.load(), 0.01f);
 }
 
 void CConnman::RecordBytesSent(uint64_t bytes)
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index 90aa940c5115d..df5c3ea027b26 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -49,6 +49,12 @@ static constexpr float EPSILON{0.0001f};
 
 /** Delimiter segmenting two fully formed Statsd messages */
 static constexpr char STATSD_MSG_DELIMITER{'\n'};
+/** Character used to denote Statsd message type as count */
+static constexpr char STATSD_METRIC_COUNT[]{"c"};
+/** Character used to denote Statsd message type as gauge */
+static constexpr char STATSD_METRIC_GAUGE[]{"g"};
+/** Characters used to denote Statsd message type as timing */
+static constexpr char STATSD_METRIC_TIMING[]{"ms"};
 } // anonymous namespace
 
 std::unique_ptr<StatsdClient> g_stats_client;
@@ -82,28 +88,28 @@ bool StatsdClient::dec(const std::string& key, float sample_rate) { return count
 
 bool StatsdClient::inc(const std::string& key, float sample_rate) { return count(key, 1, sample_rate); }
 
-bool StatsdClient::count(const std::string& key, int64_t value, float sample_rate)
+bool StatsdClient::count(const std::string& key, int64_t delta, float sample_rate)
 {
-    return send(key, value, "c", sample_rate);
+    return send(key, delta, STATSD_METRIC_COUNT, sample_rate);
 }
 
 bool StatsdClient::gauge(const std::string& key, int64_t value, float sample_rate)
 {
-    return send(key, value, "g", sample_rate);
+    return send(key, value, STATSD_METRIC_GAUGE, sample_rate);
 }
 
 bool StatsdClient::gaugeDouble(const std::string& key, double value, float sample_rate)
 {
-    return sendDouble(key, value, "g", sample_rate);
+    return send(key, value, STATSD_METRIC_GAUGE, sample_rate);
 }
 
-bool StatsdClient::timing(const std::string& key, int64_t ms, float sample_rate)
+bool StatsdClient::timing(const std::string& key, uint64_t ms, float sample_rate)
 {
-    return send(key, ms, "ms", sample_rate);
+    return send(key, ms, STATSD_METRIC_TIMING, sample_rate);
 }
 
 template <typename T1>
-bool StatsdClient::Send(const std::string& key, T1 value, const std::string& type, float sample_rate)
+bool StatsdClient::send(const std::string& key, T1 value, const std::string& type, float sample_rate)
 {
     static_assert(std::is_arithmetic<T1>::value, "Must specialize to an arithmetic type");
 
@@ -137,3 +143,9 @@ bool StatsdClient::Send(const std::string& key, T1 value, const std::string& typ
 
     return true;
 }
+
+template bool StatsdClient::send(const std::string& key, double value, const std::string& type, float sample_rate);
+template bool StatsdClient::send(const std::string& key, int32_t value, const std::string& type, float sample_rate);
+template bool StatsdClient::send(const std::string& key, int64_t value, const std::string& type, float sample_rate);
+template bool StatsdClient::send(const std::string& key, uint32_t value, const std::string& type, float sample_rate);
+template bool StatsdClient::send(const std::string& key, uint64_t value, const std::string& type, float sample_rate);
diff --git a/src/stats/client.h b/src/stats/client.h
index bfc1d67f115b3..fb152daec8270 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -15,10 +15,15 @@
 
 class RawSender;
 
+/** Default state of Statsd enablement */
 static constexpr bool DEFAULT_STATSD_ENABLE{false};
+/** Default port used to connect to a Statsd server */
 static constexpr uint16_t DEFAULT_STATSD_PORT{8125};
+/** Default host assumed to be running a Statsd server */
 static const std::string DEFAULT_STATSD_HOST{"127.0.0.1"};
+/** Default suffix appended to Statsd message keys */
 static const std::string DEFAULT_STATSD_HOSTNAME{""};
+/** Default prefix prepended to Statsd message keys */
 static const std::string DEFAULT_STATSD_NAMESPACE{""};
 
 /** Default number of milliseconds between flushing a queue of messages */
@@ -40,39 +45,34 @@ class StatsdClient
     ~StatsdClient();
 
 public:
-    bool inc(const std::string& key, float sample_rate = 1.f);
+    /* Statsd-defined APIs */
     bool dec(const std::string& key, float sample_rate = 1.f);
-    bool count(const std::string& key, int64_t value, float sample_rate = 1.f);
+    bool inc(const std::string& key, float sample_rate = 1.f);
+    bool count(const std::string& key, int64_t delta, float sample_rate = 1.f);
     bool gauge(const std::string& key, int64_t value, float sample_rate = 1.f);
     bool gaugeDouble(const std::string& key, double value, float sample_rate = 1.f);
-    bool timing(const std::string& key, int64_t ms, float sample_rate = 1.f);
+    bool timing(const std::string& key, uint64_t ms, float sample_rate = 1.f);
 
-    /* (Low Level Api) manually send a message
-        * type = "c", "g" or "ms"
-        */
-    bool send(const std::string& key, int64_t value, const std::string& type, float sample_rate = 1.f)
-    {
-        return Send(key, value, type, sample_rate);
-    }
-    bool sendDouble(const std::string& key, double value, const std::string& type, float sample_rate = 1.f)
-    {
-        return Send(key, value, type, sample_rate);
-    }
-
-private:
+    /* Statsd-compatible APIs */
     template <typename T1>
-    bool Send(const std::string& key, T1 value, const std::string& type, float sample_rate);
+    bool send(const std::string& key, T1 value, const std::string& type, float sample_rate = 1.f);
 
 private:
+    /* Mutex to protect PRNG */
     mutable Mutex cs;
+    /* PRNG used to dice-roll messages that are 0 < f < 1 */
     mutable FastRandomContext insecure_rand GUARDED_BY(cs);
 
+    /* Broadcasts messages crafted by StatsdClient */
     std::unique_ptr<RawSender> m_sender{nullptr};
 
+    /* Phrase prepended to keys */
     const std::string m_nodename;
+    /* Phrase appended to keys */
     const std::string m_ns;
 };
 
+/** Global smart pointer containing StatsdClient instance */
 extern std::unique_ptr<StatsdClient> g_stats_client;
 
 #endif // BITCOIN_STATS_CLIENT_H

From f3a4844b0ae143988b2732d6841d21a4bb2eca22 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 16:25:13 +0000
Subject: [PATCH 08/12] stats: implicitly treat stats as enabled if `statshost`
 is specified

This is to avoid the odd circumstance where stats don't work because you
specified everything but didn't explicitly enable it. Using
`-statsenabled` has been deprecated and will be removed in the next
major release.
---
 src/init.cpp                   | 14 ++++----------
 src/net.cpp                    |  2 +-
 src/stats/client.cpp           | 28 ++++++++++++++++++++++++++++
 src/stats/client.h             |  9 +++++++--
 src/test/util/setup_common.cpp | 10 +---------
 5 files changed, 41 insertions(+), 22 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 639a6f2395d9a..4ee582dde6c87 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -771,7 +771,7 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-rpcworkqueue=<n>", strprintf("Set the depth of the work queue to service RPC calls (default: %d)", DEFAULT_HTTP_WORKQUEUE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::RPC);
     argsman.AddArg("-server", "Accept command line and JSON-RPC commands", ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
-    argsman.AddArg("-statsenabled", strprintf("Publish internal stats to statsd (default: %u)", DEFAULT_STATSD_ENABLE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    hidden_args.emplace_back("-statsenabled");
     argsman.AddArg("-statsbatchsize=<bytes>", strprintf("Specify the size of each batch of stats messages (default: %d)", DEFAULT_STATSD_BATCH_SIZE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statsduration=<ms>", strprintf("Specify the number of milliseconds between stats messages (default: %d)", DEFAULT_STATSD_DURATION), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statshost=<ip>", strprintf("Specify statsd host (default: %s)", DEFAULT_STATSD_HOST), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
@@ -838,7 +838,7 @@ static void StartupNotify(const ArgsManager& args)
 
 static void PeriodicStats(ArgsManager& args, ChainstateManager& chainman, const CTxMemPool& mempool)
 {
-    assert(args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE));
+    assert(::g_stats_client->active());
     CCoinsStats stats{CoinStatsHashType::NONE};
     chainman.ActiveChainstate().ForceFlushStateToDisk();
     if (WITH_LOCK(cs_main, return GetUTXOStats(&chainman.ActiveChainstate().CoinsDB(), std::ref(chainman.m_blockman), stats, RpcInterruptionPoint, chainman.ActiveChain().Tip()))) {
@@ -1541,13 +1541,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // We need to initialize g_stats_client early as currently, g_stats_client is called
     // regardless of whether transmitting stats are desirable or not and if
     // g_stats_client isn't present when that attempt is made, the client will crash.
-    ::g_stats_client = std::make_unique<StatsdClient>(args.GetArg("-statshost", DEFAULT_STATSD_HOST),
-                                                      args.GetArg("-statsport", DEFAULT_STATSD_PORT),
-                                                      args.GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
-                                                      args.GetArg("-statsduration", DEFAULT_STATSD_DURATION),
-                                                      args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
-                                                      args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
-                                                      args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE));
+    ::g_stats_client = InitStatsClient(args);
 
     {
 
@@ -2278,7 +2272,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 #endif // ENABLE_WALLET
     }
 
-    if (args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE)) {
+    if (::g_stats_client->active()) {
         int nStatsPeriod = std::min(std::max((int)args.GetArg("-statsperiod", DEFAULT_STATSD_PERIOD), MIN_STATSD_PERIOD), MAX_STATSD_PERIOD);
         node.scheduler->scheduleEvery(std::bind(&PeriodicStats, std::ref(*node.args), std::ref(chainman), std::cref(*node.mempool)), std::chrono::seconds{nStatsPeriod});
     }
diff --git a/src/net.cpp b/src/net.cpp
index 98daa1711754a..8561b6982815d 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -1688,7 +1688,7 @@ void CConnman::NotifyNumConnectionsChanged(CMasternodeSync& mn_sync)
 
 void CConnman::CalculateNumConnectionsChangedStats()
 {
-    if (!gArgs.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE)) {
+    if (!::g_stats_client->active()) {
         return;
     }
 
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index df5c3ea027b26..f9c1e66355c81 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -59,6 +59,34 @@ static constexpr char STATSD_METRIC_TIMING[]{"ms"};
 
 std::unique_ptr<StatsdClient> g_stats_client;
 
+std::unique_ptr<StatsdClient> InitStatsClient(const ArgsManager& args)
+{
+    auto is_enabled = args.GetBoolArg("-statsenabled", /*fDefault=*/false);
+    auto host = args.GetArg("-statshost", /*fDefault=*/"");
+
+    if (is_enabled && host.empty()) {
+        // Stats are enabled but host has not been specified, then use
+        // default host. This is to preserve old behavior.
+        host = DEFAULT_STATSD_HOST;
+    } else if (!host.empty()) {
+        // Host is specified but stats are not explcitly enabled. Assume
+        // that if a host has been specified, we want stats enabled. This
+        // is new behaviour and will substitute old behaviour in a future
+        // release.
+        is_enabled = true;
+    }
+
+    return std::make_unique<StatsdClient>(
+        host,
+        args.GetArg("-statsport", DEFAULT_STATSD_PORT),
+        args.GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
+        args.GetArg("-statsduration", DEFAULT_STATSD_DURATION),
+        args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
+        args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
+        is_enabled
+    );
+}
+
 StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
                            const std::string& nodename, const std::string& ns, bool enabled) :
     m_nodename{nodename},
diff --git a/src/stats/client.h b/src/stats/client.h
index fb152daec8270..c06c8dda05112 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -13,10 +13,9 @@
 #include <memory>
 #include <string>
 
+class ArgsManager;
 class RawSender;
 
-/** Default state of Statsd enablement */
-static constexpr bool DEFAULT_STATSD_ENABLE{false};
 /** Default port used to connect to a Statsd server */
 static constexpr uint16_t DEFAULT_STATSD_PORT{8125};
 /** Default host assumed to be running a Statsd server */
@@ -57,6 +56,9 @@ class StatsdClient
     template <typename T1>
     bool send(const std::string& key, T1 value, const std::string& type, float sample_rate = 1.f);
 
+    /* Check if a StatsdClient instance is ready to send messages */
+    bool active() const { return m_sender != nullptr; }
+
 private:
     /* Mutex to protect PRNG */
     mutable Mutex cs;
@@ -72,6 +74,9 @@ class StatsdClient
     const std::string m_ns;
 };
 
+/** Parses arguments and constructs a StatsdClient instance */
+std::unique_ptr<StatsdClient> InitStatsClient(const ArgsManager& args);
+
 /** Global smart pointer containing StatsdClient instance */
 extern std::unique_ptr<StatsdClient> g_stats_client;
 
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 7d7c898d58974..c9265b85e0210 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -183,15 +183,7 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     SetupNetworking();
     InitSignatureCache();
     InitScriptExecutionCache();
-    ::g_stats_client = std::make_unique<StatsdClient>(
-        m_node.args->GetArg("-statshost", DEFAULT_STATSD_HOST),
-        m_node.args->GetArg("-statsport", DEFAULT_STATSD_PORT),
-        m_node.args->GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
-        m_node.args->GetArg("-statsduration", DEFAULT_STATSD_DURATION),
-        m_node.args->GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
-        m_node.args->GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
-        m_node.args->GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE)
-    );
+    ::g_stats_client = InitStatsClient(*m_node.args);
     m_node.chain = interfaces::MakeChain(m_node);
 
     m_node.netgroupman = std::make_unique<NetGroupManager>(/*asmap=*/std::vector<bool>());

From 42918c2cdcb42cacaef90ebc4321037169c69e6a Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 15:18:22 +0000
Subject: [PATCH 09/12] stats: rename `statshostname` to more appropriate
 `statssuffix`

`statshostname` implies that alongside specifying the host, the user
needs to specify a separate "hostname" field in order to connect when
in fact, it is an entirely optional suffix field applied to stats keys.

Rename it to `statssuffix` and deprecate `statshostname`, the latter
will be removed in a subsequent major release.
---
 src/init.cpp         |  5 +++--
 src/stats/client.cpp | 35 +++++++++++++++++++++++++++--------
 src/stats/client.h   | 10 +++++-----
 3 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 4ee582dde6c87..6b1f89542752e 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -775,10 +775,11 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-statsbatchsize=<bytes>", strprintf("Specify the size of each batch of stats messages (default: %d)", DEFAULT_STATSD_BATCH_SIZE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statsduration=<ms>", strprintf("Specify the number of milliseconds between stats messages (default: %d)", DEFAULT_STATSD_DURATION), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statshost=<ip>", strprintf("Specify statsd host (default: %s)", DEFAULT_STATSD_HOST), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
-    argsman.AddArg("-statshostname=<ip>", strprintf("Specify statsd host name (default: %s)", DEFAULT_STATSD_HOSTNAME), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    hidden_args.emplace_back("-statshostname");
     argsman.AddArg("-statsport=<port>", strprintf("Specify statsd port (default: %u)", DEFAULT_STATSD_PORT), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
-    argsman.AddArg("-statsns=<ns>", strprintf("Specify additional namespace prefix (default: %s)", DEFAULT_STATSD_NAMESPACE), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    argsman.AddArg("-statsns=<ns>", strprintf("Specify additional namespace prefix (default: %s)", DEFAULT_STATSD_SUFFIX), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statsperiod=<seconds>", strprintf("Specify the number of seconds between periodic measurements (default: %d)", DEFAULT_STATSD_PERIOD), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    argsman.AddArg("-statssuffix=<string>", strprintf("Specify an optional string appended to every stats key (default: %s)", DEFAULT_STATSD_SUFFIX), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
 #if HAVE_DECL_FORK
     argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
     argsman.AddArg("-daemonwait", strprintf("Wait for initialization to be finished before exiting. This implies -daemon (default: %d)", DEFAULT_DAEMONWAIT), ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index f9c1e66355c81..865c05bb41c59 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -49,6 +49,8 @@ static constexpr float EPSILON{0.0001f};
 
 /** Delimiter segmenting two fully formed Statsd messages */
 static constexpr char STATSD_MSG_DELIMITER{'\n'};
+/** Delimiter segmenting namespaces in a Statsd key */
+static constexpr char STATSD_NS_DELIMITER{'.'};
 /** Character used to denote Statsd message type as count */
 static constexpr char STATSD_METRIC_COUNT[]{"c"};
 /** Character used to denote Statsd message type as gauge */
@@ -76,21 +78,41 @@ std::unique_ptr<StatsdClient> InitStatsClient(const ArgsManager& args)
         is_enabled = true;
     }
 
+    auto sanitize_string = [](std::string& string) {
+        // Remove key delimiters from the front and back as they're added back
+        // in formatting
+        if (!string.empty()) {
+            if (string.front() == STATSD_NS_DELIMITER) string.erase(string.begin());
+            if (string.back() == STATSD_NS_DELIMITER) string.pop_back();
+        }
+    };
+
+    // Get our suffix and if we get nothing, try again with the deprecated
+    // argument. If we still get nothing, that's fine, suffixes are optional.
+    auto suffix = args.GetArg("-statssuffix", DEFAULT_STATSD_SUFFIX);
+    if (suffix.empty()) {
+        suffix = args.GetArg("-statshostname", DEFAULT_STATSD_SUFFIX);
+    } else {
+        // We restrict sanitization logic to our newly added arguments to
+        // prevent breaking changes.
+        sanitize_string(suffix);
+    }
+
     return std::make_unique<StatsdClient>(
         host,
         args.GetArg("-statsport", DEFAULT_STATSD_PORT),
         args.GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
         args.GetArg("-statsduration", DEFAULT_STATSD_DURATION),
-        args.GetArg("-statshostname", DEFAULT_STATSD_HOSTNAME),
         args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
+        suffix,
         is_enabled
     );
 }
 
 StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
-                           const std::string& nodename, const std::string& ns, bool enabled) :
-    m_nodename{nodename},
-    m_ns{ns}
+                           const std::string& ns, const std::string& suffix, bool enabled) :
+    m_ns{ns},
+    m_suffix{[suffix]() { return !suffix.empty() ? STATSD_NS_DELIMITER + suffix : suffix; }()}
 {
     if (!enabled) {
         LogPrintf("Transmitting stats are disabled, will not init StatsdClient\n");
@@ -154,11 +176,8 @@ bool StatsdClient::send(const std::string& key, T1 value, const std::string& typ
         return true;
     }
 
-    // partition stats by node name if set
-    if (!m_nodename.empty()) key = key + "." + m_nodename;
-
     // Construct the message and if our message isn't always-send, report the sample rate
-    RawMessage msg{strprintf("%s%s:%f|%s", m_ns, key, value, type)};
+    RawMessage msg{strprintf("%s%s%s:%f|%s", m_ns, key, m_suffix, value, type)};
     if (!always_send) {
         msg += strprintf("|@%.2f", sample_rate);
     }
diff --git a/src/stats/client.h b/src/stats/client.h
index c06c8dda05112..729d4dc5a8283 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -20,10 +20,10 @@ class RawSender;
 static constexpr uint16_t DEFAULT_STATSD_PORT{8125};
 /** Default host assumed to be running a Statsd server */
 static const std::string DEFAULT_STATSD_HOST{"127.0.0.1"};
-/** Default suffix appended to Statsd message keys */
-static const std::string DEFAULT_STATSD_HOSTNAME{""};
 /** Default prefix prepended to Statsd message keys */
 static const std::string DEFAULT_STATSD_NAMESPACE{""};
+/** Default suffix appended to Statsd message keys */
+static const std::string DEFAULT_STATSD_SUFFIX{""};
 
 /** Default number of milliseconds between flushing a queue of messages */
 static constexpr int DEFAULT_STATSD_DURATION{1000};
@@ -40,7 +40,7 @@ class StatsdClient
 {
 public:
     explicit StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
-                          const std::string& nodename, const std::string& ns, bool enabled);
+                          const std::string& ns, const std::string& suffix, bool enabled);
     ~StatsdClient();
 
 public:
@@ -69,9 +69,9 @@ class StatsdClient
     std::unique_ptr<RawSender> m_sender{nullptr};
 
     /* Phrase prepended to keys */
-    const std::string m_nodename;
-    /* Phrase appended to keys */
     const std::string m_ns;
+    /* Phrase appended to keys */
+    const std::string m_suffix{""};
 };
 
 /** Parses arguments and constructs a StatsdClient instance */

From 18a2e48eb93f9810d0dff5ea7fe3bb96104a9ce6 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Tue, 10 Sep 2024 18:52:28 +0000
Subject: [PATCH 10/12] stats: rename `statsns` to clearer `statsprefix`

`statsns`, aside from being an unclear name, in its default behaviour,
doesn't use the namespace delimiter contaminates the root namespace
of the key.

Let's take care of that by deprecating `statsns` with its replacement,
`statsprefix`, that behaves properly.
---
 src/init.cpp         |  3 ++-
 src/stats/client.cpp | 28 +++++++++++++++++++++-------
 src/stats/client.h   |  6 +++---
 3 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/src/init.cpp b/src/init.cpp
index 6b1f89542752e..b43f04f345c65 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -777,8 +777,9 @@ void SetupServerArgs(ArgsManager& argsman)
     argsman.AddArg("-statshost=<ip>", strprintf("Specify statsd host (default: %s)", DEFAULT_STATSD_HOST), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     hidden_args.emplace_back("-statshostname");
     argsman.AddArg("-statsport=<port>", strprintf("Specify statsd port (default: %u)", DEFAULT_STATSD_PORT), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
-    argsman.AddArg("-statsns=<ns>", strprintf("Specify additional namespace prefix (default: %s)", DEFAULT_STATSD_SUFFIX), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    hidden_args.emplace_back("-statsns");
     argsman.AddArg("-statsperiod=<seconds>", strprintf("Specify the number of seconds between periodic measurements (default: %d)", DEFAULT_STATSD_PERIOD), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
+    argsman.AddArg("-statsprefix=<string>", strprintf("Specify an optional string prepended to every stats key (default: %s)", DEFAULT_STATSD_PREFIX), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
     argsman.AddArg("-statssuffix=<string>", strprintf("Specify an optional string appended to every stats key (default: %s)", DEFAULT_STATSD_SUFFIX), ArgsManager::ALLOW_ANY, OptionsCategory::STATSD);
 #if HAVE_DECL_FORK
     argsman.AddArg("-daemon", strprintf("Run in the background as a daemon and accept commands (default: %d)", DEFAULT_DAEMON), ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index 865c05bb41c59..90bdcbdbeec12 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -80,15 +80,29 @@ std::unique_ptr<StatsdClient> InitStatsClient(const ArgsManager& args)
 
     auto sanitize_string = [](std::string& string) {
         // Remove key delimiters from the front and back as they're added back
-        // in formatting
         if (!string.empty()) {
             if (string.front() == STATSD_NS_DELIMITER) string.erase(string.begin());
             if (string.back() == STATSD_NS_DELIMITER) string.pop_back();
         }
     };
 
-    // Get our suffix and if we get nothing, try again with the deprecated
-    // argument. If we still get nothing, that's fine, suffixes are optional.
+    // Get our prefix and suffix and if we get nothing, try again with the
+    // deprecated argument. If we still get nothing, that's fine, they're optional.
+    auto prefix = args.GetArg("-statsprefix", DEFAULT_STATSD_PREFIX);
+    if (prefix.empty()) {
+        prefix = args.GetArg("-statsns", DEFAULT_STATSD_PREFIX);
+    } else {
+        // We restrict sanitization logic to our newly added arguments to
+        // prevent breaking changes.
+        sanitize_string(prefix);
+        // We need to add the delimiter here for backwards compatibility with
+        // the deprecated argument.
+        //
+        // TODO: Move this step into the constructor when removing deprecated
+        //       args support
+        prefix += STATSD_NS_DELIMITER;
+    }
+
     auto suffix = args.GetArg("-statssuffix", DEFAULT_STATSD_SUFFIX);
     if (suffix.empty()) {
         suffix = args.GetArg("-statshostname", DEFAULT_STATSD_SUFFIX);
@@ -103,15 +117,15 @@ std::unique_ptr<StatsdClient> InitStatsClient(const ArgsManager& args)
         args.GetArg("-statsport", DEFAULT_STATSD_PORT),
         args.GetArg("-statsbatchsize", DEFAULT_STATSD_BATCH_SIZE),
         args.GetArg("-statsduration", DEFAULT_STATSD_DURATION),
-        args.GetArg("-statsns", DEFAULT_STATSD_NAMESPACE),
+        prefix,
         suffix,
         is_enabled
     );
 }
 
 StatsdClient::StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
-                           const std::string& ns, const std::string& suffix, bool enabled) :
-    m_ns{ns},
+                           const std::string& prefix, const std::string& suffix, bool enabled) :
+    m_prefix{prefix},
     m_suffix{[suffix]() { return !suffix.empty() ? STATSD_NS_DELIMITER + suffix : suffix; }()}
 {
     if (!enabled) {
@@ -177,7 +191,7 @@ bool StatsdClient::send(const std::string& key, T1 value, const std::string& typ
     }
 
     // Construct the message and if our message isn't always-send, report the sample rate
-    RawMessage msg{strprintf("%s%s%s:%f|%s", m_ns, key, m_suffix, value, type)};
+    RawMessage msg{strprintf("%s%s%s:%f|%s", m_prefix, key, m_suffix, value, type)};
     if (!always_send) {
         msg += strprintf("|@%.2f", sample_rate);
     }
diff --git a/src/stats/client.h b/src/stats/client.h
index 729d4dc5a8283..0fa8538260ee0 100644
--- a/src/stats/client.h
+++ b/src/stats/client.h
@@ -21,7 +21,7 @@ static constexpr uint16_t DEFAULT_STATSD_PORT{8125};
 /** Default host assumed to be running a Statsd server */
 static const std::string DEFAULT_STATSD_HOST{"127.0.0.1"};
 /** Default prefix prepended to Statsd message keys */
-static const std::string DEFAULT_STATSD_NAMESPACE{""};
+static const std::string DEFAULT_STATSD_PREFIX{""};
 /** Default suffix appended to Statsd message keys */
 static const std::string DEFAULT_STATSD_SUFFIX{""};
 
@@ -40,7 +40,7 @@ class StatsdClient
 {
 public:
     explicit StatsdClient(const std::string& host, uint16_t port, uint64_t batch_size, uint64_t interval_ms,
-                          const std::string& ns, const std::string& suffix, bool enabled);
+                          const std::string& prefix, const std::string& suffix, bool enabled);
     ~StatsdClient();
 
 public:
@@ -69,7 +69,7 @@ class StatsdClient
     std::unique_ptr<RawSender> m_sender{nullptr};
 
     /* Phrase prepended to keys */
-    const std::string m_ns;
+    const std::string m_prefix{""};
     /* Phrase appended to keys */
     const std::string m_suffix{""};
 };

From 39625f16f01537baf70bdb22dbafb3910d58a67f Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 11 Sep 2024 07:13:54 +0000
Subject: [PATCH 11/12] stats: drop copyright notice from `stats/client.cpp`

This marks the completion of our transition from code based on
`talebook/statsd-client-cpp` to code based on `vthiery/cpp-statsd-client`.

Also, we long stopped using `snprintf`, remove it from exclusions list.
---
 contrib/devtools/copyright_header.py |  1 -
 src/stats/client.cpp                 | 30 ----------------------------
 test/lint/lint-locale-dependence.sh  |  1 -
 3 files changed, 32 deletions(-)

diff --git a/contrib/devtools/copyright_header.py b/contrib/devtools/copyright_header.py
index 0f9d2aaae2686..2b222e8ac715b 100755
--- a/contrib/devtools/copyright_header.py
+++ b/contrib/devtools/copyright_header.py
@@ -26,7 +26,6 @@
     'src/crypto/*',
     'src/ctpl_stl.h',
     'src/reverse_iterator.h',
-    'src/stats/client.cpp',
     'src/test/fuzz/FuzzedDataProvider.h',
     'src/tinyformat.h',
     'src/bench/nanobench.h',
diff --git a/src/stats/client.cpp b/src/stats/client.cpp
index 90bdcbdbeec12..c09dbc9bdf14d 100644
--- a/src/stats/client.cpp
+++ b/src/stats/client.cpp
@@ -4,36 +4,6 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-/**
-Copyright (c) 2014, Rex
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the {organization} nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-**/
-
 #include <stats/client.h>
 
 #include <stats/rawsender.h>
diff --git a/test/lint/lint-locale-dependence.sh b/test/lint/lint-locale-dependence.sh
index a1c579ea83f08..076753e720dfd 100755
--- a/test/lint/lint-locale-dependence.sh
+++ b/test/lint/lint-locale-dependence.sh
@@ -45,7 +45,6 @@ KNOWN_VIOLATIONS=(
     "src/bitcoin-tx.cpp.*stoul"
     "src/dbwrapper.cpp:.*vsnprintf"
     "src/rest.cpp:.*strtol"
-    "src/stats/client.cpp:.*snprintf"
     "src/test/dbwrapper_tests.cpp:.*snprintf"
     "src/test/fuzz/locale.cpp"
     "src/test/fuzz/string.cpp"

From cc1a75ab3abe81813bc4edb605ce7ce6c5b578ed Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 11 Sep 2024 18:27:40 +0000
Subject: [PATCH 12/12] docs: add release notes

---
 doc/release-notes-6267.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 doc/release-notes-6267.md

diff --git a/doc/release-notes-6267.md b/doc/release-notes-6267.md
new file mode 100644
index 0000000000000..73881366a382a
--- /dev/null
+++ b/doc/release-notes-6267.md
@@ -0,0 +1,25 @@
+Statistics
+-----------
+
+### New Features
+
+- The Statsd client now supports queueing and batching messages, reducing the number of packets and the rate at which
+  they are sent to the Statsd daemon.
+
+- The maximum size of each batch of messages (default, 1KiB) can be adjusted using `-statsbatchsize` (in bytes)
+  and the frequency at which queued messages are sent to the daemon (default, 1 second) can be adjusted using
+  `-statsduration` (in milliseconds)
+  - `-statsduration` has no bearing on `-statsperiod`, which dictates how frequently some stats are _collected_.
+
+### Deprecations
+
+- `-statsenabled` has been deprecated and enablement will now be implied by the presence of `-statshost`. `-statsenabled`
+  will be removed in a future release.
+
+- `-statshostname` has been deprecated and replaced with `-statssuffix` as the latter is better representative of the
+  argument's purpose. They behave identically to each other. `-statshostname` will be removed in a future
+  release.
+
+- `-statsns` has been deprecated and replaced with `-statsprefix` as the latter is better representative of the
+  argument's purpose. `-statsprefix`, unlike `-statsns`, will enforce the usage of a delimiter between the prefix
+  and key. `-statsns` will be removed in a future release.