THUAI6/CAPI/cpp/spdlog/include/spdlog/sinks/mongo_sink.h

// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)

#pragma once

//
// Custom sink for mongodb
// Building and using requires mongocxx library.
// For building mongocxx library check the url below
// http://mongocxx.org/mongocxx-v3/installation/
//

#include "spdlog/common.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/sinks/base_sink.h"
#include <spdlog/details/synchronous_factory.h>

#include <bsoncxx/builder/stream/document.hpp>
#include <bsoncxx/types.hpp>
#include <bsoncxx/view_or_value.hpp>

#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/uri.hpp>

namespace spdlog
{
    namespace sinks
    {
        template<typename Mutex>
        class mongo_sink : public base_sink<Mutex>
        {
        public:
            mongo_sink(const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017")
            try : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri)
            {
            }
            catch (const std::exception& e)
            {
                throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
            }

            mongo_sink(std::shared_ptr<mongocxx::instance> instance, const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017") :
                instance_(std::move(instance)),
                db_name_(db_name),
                coll_name_(collection_name)
            {
                try
                {
                    client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri});
                }
                catch (const std::exception& e)
                {
                    throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
                }
            }

            ~mongo_sink()
            {
                flush_();
            }

        protected:
            void sink_it_(const details::log_msg& msg) override
            {
                using bsoncxx::builder::stream::document;
                using bsoncxx::builder::stream::finalize;

                if (client_ != nullptr)
                {
                    auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level" << level::to_string_view(msg.level).data()
                                          << "level_num" << msg.level << "message" << std::string(msg.payload.begin(), msg.payload.end())
                                          << "logger_name" << std::string(msg.logger_name.begin(), msg.logger_name.end()) << "thread_id"
                                          << static_cast<int>(msg.thread_id) << finalize;
                    client_->database(db_name_).collection(coll_name_).insert_one(doc.view());
                }
            }

            void flush_() override
            {
            }

        private:
            std::shared_ptr<mongocxx::instance> instance_;
            std::string db_name_;
            std::string coll_name_;
            std::unique_ptr<mongocxx::client> client_ = nullptr;
        };

#include "spdlog/details/null_mutex.h"
#include <mutex>
        using mongo_sink_mt = mongo_sink<std::mutex>;
        using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>;

    }  // namespace sinks

    template<typename Factory = spdlog::synchronous_factory>
    inline std::shared_ptr<logger> mongo_logger_mt(const std::string& logger_name, const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017")
    {
        return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name, uri);
    }

    template<typename Factory = spdlog::synchronous_factory>
    inline std::shared_ptr<logger> mongo_logger_st(const std::string& logger_name, const std::string& db_name, const std::string& collection_name, const std::string& uri = "mongodb://localhost:27017")
    {
        return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name, uri);
    }

}  // namespace spdlog