LogSpamTest.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ArmarXCore::ArmarXObjects::LogSpamTest
 * @date       2026
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "LogSpamTest.h"
 
#include <algorithm>
#include <chrono>
#include <sstream>
#include <thread>
#include <unistd.h>
 
#include <ArmarXCore/core/logging/LoggingUtil.h>
 
namespace armarx
{
    namespace
    {
        // Word pool for the generated message bodies. Deliberately log-like, so the
        // resulting lines have a realistic length distribution and a realistic amount of
        // shared prefix between them.
        const std::vector<std::string>&
        wordPool()
        {
            static const std::vector<std::string> words{
                "trajectory",   "pose",        "gripper",      "velocity",   "joint",
                "torque",       "waypoint",    "frame",        "transform",  "solver",
                "converged",    "residual",    "iteration",    "timeout",    "retry",
                "planner",      "collision",   "segment",      "cartesian",  "orientation",
                "calibration",  "offset",      "threshold",    "controller", "setpoint",
                "measurement",  "estimate",    "covariance",   "landmark",   "keyframe",
                "descriptor",   "match",       "inlier",       "outlier",    "cloud",
                "voxel",        "octree",      "occupancy",    "path",       "goal",
                "obstacle",     "footprint",   "odometry",     "drift",      "latency",
                "buffer",       "queue",       "dropped",      "stale",      "resynced"};
            return words;
        }
 
        // A short random hex id, so that two messages that happen to draw the same words
        // are still distinct.
        std::string
        randomId(std::mt19937& rng)
        {
            static const char* digits = "0123456789abcdef";
            std::uniform_int_distribution<int> dist(0, 15);
            std::string id(8, '0');
            for (char& c : id)
            {
                c = digits[dist(rng)];
            }
            return id;
        }
    } // namespace
 
    LogSpamTestPropertyDefinitions::LogSpamTestPropertyDefinitions(std::string prefix) :
        armarx::ComponentPropertyDefinitions(prefix)
    {
        defineOptionalProperty<int>(
            "MessagesPerSecond",
            200,
            "Target number of log messages per second, summed over all threads. <= 0 disables "
            "the component (it then starts but stays silent).");
        defineOptionalProperty<int>(
            "ThreadCount",
            1,
            "Number of concurrent sender threads. They share MessagesPerSecond between them.");
        defineOptionalProperty<int>(
            "Seed",
            0,
            "Seed for the random message content. 0 picks a seed from the clock and the process "
            "id, so instances differ; any other value makes the run reproducible.");
 
        defineOptionalProperty<int>(
            "WarningPercent",
            5,
            "Percentage of messages emitted at WARN. Note that WARN and above attach a full "
            "backtrace, which is by far the largest per-message cost on the sender side.");
        defineOptionalProperty<int>(
            "ErrorPercent", 2, "Percentage of messages emitted at ERROR (also backtraced).");
        defineOptionalProperty<int>("VerbosePercent",
                                    0,
                                    "Percentage of messages emitted at VERBOSE. Only visible if "
                                    "ArmarX.Verbosity is set to Verbose or Debug.");
 
        defineOptionalProperty<int>(
            "MultilinePercent",
            5,
            "Percentage of messages spanning several lines. These are what give the viewer's "
            "table rows individual heights.");
        defineOptionalProperty<int>(
            "MultilineMaxLines", 12, "Upper bound on the line count of a multi-line message.");
 
        defineOptionalProperty<int>("MinWords", 6, "Lower bound on the word count of a message.");
        defineOptionalProperty<int>("MaxWords", 20, "Upper bound on the word count of a message.");
 
        defineOptionalProperty<int>(
            "TagCount", 4, "Number of distinct tags to spread the messages over (at least 1).");
 
        defineOptionalProperty<int>(
            "BurstEveryMs",
            0,
            "If > 0, emit a burst of BurstSize messages every this many milliseconds, on top of "
            "the steady rate. Use this to exercise the viewer's staging queue rather than only "
            "its steady-state throughput.");
        defineOptionalProperty<int>("BurstSize", 500, "Number of messages in one burst.");
    }
 
    std::string
    LogSpamTest::getDefaultName() const
    {
        return "LogSpamTest";
    }
 
    void
    LogSpamTest::onInitComponent()
    {
        getProperty(messagesPerSecond, "MessagesPerSecond");
        getProperty(threadCount, "ThreadCount");
        getProperty(seed, "Seed");
        getProperty(warningPercent, "WarningPercent");
        getProperty(errorPercent, "ErrorPercent");
        getProperty(verbosePercent, "VerbosePercent");
        getProperty(multilinePercent, "MultilinePercent");
        getProperty(multilineMaxLines, "MultilineMaxLines");
        getProperty(minWords, "MinWords");
        getProperty(maxWords, "MaxWords");
        getProperty(tagCount, "TagCount");
        getProperty(burstEveryMs, "BurstEveryMs");
        getProperty(burstSize, "BurstSize");
 
        threadCount = std::max(1, threadCount);
        tagCount = std::max(1, tagCount);
        minWords = std::max(1, minWords);
        maxWords = std::max(minWords, maxWords);
        multilineMaxLines = std::max(2, multilineMaxLines);
        burstSize = std::max(0, burstSize);
 
        if (seed == 0)
        {
            seed = static_cast<int>(
                std::chrono::steady_clock::now().time_since_epoch().count() ^ ::getpid());
        }
 
        ARMARX_IMPORTANT << "LogSpamTest: " << messagesPerSecond << " msg/s over " << threadCount
                         << " thread(s), " << warningPercent << "% warnings, " << errorPercent
                         << "% errors, " << multilinePercent << "% multi-line, seed " << seed;
    }
 
    void
    LogSpamTest::onConnectComponent()
    {
        if (messagesPerSecond <= 0)
        {
            ARMARX_IMPORTANT << "LogSpamTest: MessagesPerSecond <= 0, staying silent.";
            return;
        }
 
        running = true;
        for (int i = 0; i < threadCount; ++i)
        {
            tasks.push_back(new RunningTask<LogSpamTest>(
                this, &LogSpamTest::spamTaskRun, "LogSpamTask" + std::to_string(i)));
        }
        // Started only after the vector is complete, so no thread observes a partial list.
        for (auto& task : tasks)
        {
            task->start();
        }
    }
 
    void
    LogSpamTest::onDisconnectComponent()
    {
        running = false;
        for (auto& task : tasks)
        {
            if (task)
            {
                task->stop(true);
            }
        }
        tasks.clear();
    }
 
    void
    LogSpamTest::onExitComponent()
    {
    }
 
    std::string
    LogSpamTest::buildMessage(std::mt19937& rng, long counter) const
    {
        const std::vector<std::string>& words = wordPool();
        std::uniform_int_distribution<std::size_t> wordDist(0, words.size() - 1);
        std::uniform_int_distribution<int> countDist(minWords, maxWords);
        std::uniform_int_distribution<int> percentDist(0, 99);
 
        std::ostringstream out;
        // The counter and the id guarantee uniqueness even when the drawn words repeat.
        out << "#" << counter << " [" << randomId(rng) << "]";
 
        const int count = countDist(rng);
        for (int i = 0; i < count; ++i)
        {
            out << " " << words[wordDist(rng)];
        }
 
        if (percentDist(rng) < multilinePercent)
        {
            std::uniform_int_distribution<int> lineDist(2, multilineMaxLines);
            const int lines = lineDist(rng);
            for (int line = 0; line < lines; ++line)
            {
                out << "\n    " << line << ": ";
                const int inner = countDist(rng);
                for (int i = 0; i < inner; ++i)
                {
                    out << words[wordDist(rng)] << " ";
                }
            }
        }
 
        return out.str();
    }
 
    void
    LogSpamTest::emitOne(std::mt19937& rng, long& counter)
    {
        const std::string body = buildMessage(rng, counter++);
 
        std::uniform_int_distribution<int> percentDist(0, 99);
        const int roll = percentDist(rng);
 
        const std::string tag = "spam" + std::to_string(counter % tagCount);
 
// The logging macros expand to a conditional expression, so the stream chain has to be
// written out per severity rather than kept in a variable.
#define ARMARX_LOG_SPAM(MACRO) MACRO << LogTag(tag) << body
 
        if (roll < errorPercent)
        {
            ARMARX_LOG_SPAM(ARMARX_ERROR);
        }
        else if (roll < errorPercent + warningPercent)
        {
            ARMARX_LOG_SPAM(ARMARX_WARNING);
        }
        else if (roll < errorPercent + warningPercent + verbosePercent)
        {
            ARMARX_LOG_SPAM(ARMARX_VERBOSE);
        }
        else if (roll % 10 == 0)
        {
            ARMARX_LOG_SPAM(ARMARX_IMPORTANT);
        }
        else
        {
            ARMARX_LOG_SPAM(ARMARX_INFO);
        }
 
#undef ARMARX_LOG_SPAM
    }
 
    void
    LogSpamTest::spamTaskRun()
    {
        const int index = nextThreadIndex++;
        std::mt19937 rng(static_cast<std::mt19937::result_type>(seed + index * 7919));
        long counter = 0;
 
        // Each thread carries its share of the target rate.
        const int perThreadRate = std::max(1, messagesPerSecond / threadCount);
        const auto period = std::chrono::nanoseconds(std::chrono::seconds(1)) / perThreadRate;
 
        auto nextMessage = std::chrono::steady_clock::now();
        auto nextBurst = nextMessage + std::chrono::milliseconds(std::max(0, burstEveryMs));
 
        while (running.load())
        {
            emitOne(rng, counter);
 
            const auto now = std::chrono::steady_clock::now();
 
            // Bursts are emitted by the first thread only, so BurstSize means the same
            // thing regardless of ThreadCount.
            if (burstEveryMs > 0 && index == 0 && now >= nextBurst)
            {
                for (int i = 0; i < burstSize && running.load(); ++i)
                {
                    emitOne(rng, counter);
                }
                nextBurst = std::chrono::steady_clock::now() +
                            std::chrono::milliseconds(burstEveryMs);
            }
 
            nextMessage += period;
            if (nextMessage < now)
            {
                // We cannot keep up with the requested rate (or a burst just ran); resync
                // rather than spinning to catch up on a backlog that will never shrink.
                nextMessage = now;
            }
            else
            {
                std::this_thread::sleep_until(nextMessage);
            }
        }
    }
 
    armarx::PropertyDefinitionsPtr
    LogSpamTest::createPropertyDefinitions()
    {
        return armarx::PropertyDefinitionsPtr(
            new LogSpamTestPropertyDefinitions(getConfigIdentifier()));
    }
} // namespace armarx