spdlog/example/example.cpp

//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)

// spdlog usage example

#include <chrono>
#include <clocale>
#include <cstdio>

#include "/home/gabi//spdlog2/tests/test_sink.h"
#include "spdlog/sinks/async_sink.h"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/spdlog.h"
#include "spdlog/stopwatch.h"

using namespace spdlog::sinks;

void worker_thread(std::shared_ptr<spdlog::logger> logger, int n_messages) {
    for (int i = 0; i < n_messages; ++i) {
        // std::this_thread::sleep_for(std::chrono::milliseconds(10));
        logger->info("Worker thread message #{}", i);
    }
}

bool async_example2(size_t n_threads, size_t n_messages) {
    auto test_sink = std::make_shared<test_sink_st>();
    auto n_total_messages = n_messages * n_threads;
    {
        std::vector<std::thread> threads;
        auto async_sink = std::make_shared<async_sink_mt>();
        async_sink->add_sink(test_sink);
        auto logger = std::make_shared<spdlog::logger>("async_logger", async_sink);
        logger->set_level(spdlog::level::trace);

        spdlog::stopwatch sw;

        for (int i = 0; i < n_threads; ++i) {
            threads.emplace_back(worker_thread, logger, n_messages);
        }

        // wait for worker threads to finish
        for (auto &t : threads) {
            t.join();
        }


        auto millis = sw.elapsed_ms().count();
        if (millis == 0) {
            millis = 1;
        }
        spdlog::info("Elapsed {} millis ({:L}/sec)", millis, n_total_messages * 1000 / millis);
    }

    // wait for the worker thread to finish
    // check that all messages were processed
    if (test_sink->msg_counter() != n_messages * n_threads) {
        spdlog::error("Expected: {:L}, Counted: {:L}", n_total_messages,
                      test_sink->msg_counter());
        return false;
    }
    spdlog::info("OK: {:L}", test_sink->msg_counter());
    return true;
}

#include <random>
int main(int, char *[]) {
    std::locale::global(std::locale("en_US.UTF-8"));
    // constexpr size_t n_messages = 1'00;
    // constexpr size_t n_threads = 1;
    try {
        // random n_messages and n_threads
        std::mt19937 gen(std::random_device{}());
        for (int i = 0; i < 100; i++) {
            auto n_threads = std::uniform_int_distribution<size_t>(1, 10)(gen);
            auto n_messages = std::uniform_int_distribution<size_t>(1, 1'000'000)(gen);

            spdlog::info("***********************************");
            spdlog::info("Test #{}. Threads: {}, Count: {:L}", i, n_threads, n_messages);
            if (!async_example2(n_threads, n_messages)) {
                spdlog::error("Stopped");
                break;
            }
        }

        spdlog::shutdown();
    }

    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
    catch (const spdlog::spdlog_ex &ex) {
        std::printf("Log initialization failed: %s\n", ex.what());
        return 1;
    }
}