mongo_sink.h

Go to the documentation of this file.

// 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