couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/core/logger/logger.cxx

@@ -0,0 +1,340 @@
+/* -*- MODE: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+#include "logger.hxx"
+
+#include "configuration.hxx"
+#include "custom_rotating_file_sink.hxx"
+
+#include <chrono>
+#include <spdlog/async.h>
+#include <spdlog/async_logger.h>
+#include <spdlog/sinks/dist_sink.h>
+#include <spdlog/sinks/null_sink.h>
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include <spdlog/spdlog.h>
+
+static const std::string logger_name{ "couchbase_cxx_client_file_logger" };
+
+/**
+ * Custom log pattern which the loggers will use.
+ * This pattern is duplicated for some test cases. If you need to update it,
+ * please also update in all relevant places.
+ */
+static const std::string log_pattern{ "[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v" };
+
+/**
+ * Instances of spdlog (async) file logger.
+ * The files logger requires a rotating file sink which is manually configured
+ * from the parsed settings.
+ * The loggers act as a handle to the sinks. They do the processing of log
+ * messages and send them to the sinks, which do the actual writing (to file,
+ * to stream etc.) or further processing.
+ */
+static std::shared_ptr<spdlog::logger> file_logger;
+
+namespace couchbase::core::logger
+{
+spdlog::level::level_enum
+translate_level(level level)
+{
+    switch (level) {
+        case level::trace:
+            return spdlog::level::level_enum::trace;
+        case level::debug:
+            return spdlog::level::level_enum::debug;
+        case level::info:
+            return spdlog::level::level_enum::info;
+        case level::warn:
+            return spdlog::level::level_enum::warn;
+        case level::err:
+            return spdlog::level::level_enum::err;
+        case level::critical:
+            return spdlog::level::level_enum::critical;
+        case level::off:
+            return spdlog::level::level_enum::off;
+    }
+    return spdlog::level::level_enum::trace;
+}
+
+level
+level_from_str(const std::string& str)
+{
+    switch (spdlog::level::from_str(str)) {
+        case spdlog::level::level_enum::trace:
+            return level::trace;
+        case spdlog::level::level_enum::debug:
+            return level::debug;
+        case spdlog::level::level_enum::info:
+            return level::info;
+        case spdlog::level::level_enum::warn:
+            return level::warn;
+        case spdlog::level::level_enum::err:
+            return level::err;
+        case spdlog::level::level_enum::critical:
+            return level::critical;
+        case spdlog::level::level_enum::off:
+            return level::off;
+        default:
+            break;
+    }
+    // return highest level if we don't understand
+    return level::trace;
+}
+
+bool
+should_log(level lvl)
+{
+    if (is_initialized()) {
+        return file_logger->should_log(translate_level(lvl));
+    }
+    return false;
+}
+
+namespace detail
+{
+void
+log(const char* file, int line, const char* function, level lvl, std::string_view msg)
+{
+    if (is_initialized()) {
+        return file_logger->log(spdlog::source_loc{ file, line, function }, translate_level(lvl), msg);
+    }
+}
+} // namespace detail
+
+void
+flush()
+{
+    if (is_initialized()) {
+        file_logger->flush();
+    }
+}
+
+void
+shutdown()
+{
+    // Force a flush (posts a message to the async logger if we are not in unit
+    // test mode)
+    flush();
+
+    /**
+     * This will drop all spdlog instances from the registry, and destruct the
+     * thread pool which will post terminate message(s) (one per thread) to the
+     * thread pool message queue. The calling thread will then block until all
+     * thread pool workers have joined. This ensures that any messages queued
+     * before shutdown is called will be flushed to disk. Any messages that are
+     * queued after the final terminate message will not be logged.
+     *
+     * If the logger is running in unit test mode (synchronous) then this is a
+     * no-op.
+     */
+    file_logger.reset();
+    spdlog::details::registry::instance().shutdown();
+}
+
+bool
+is_initialized()
+{
+    return file_logger != nullptr;
+}
+
+/**
+ * Initialises the loggers. Called if the logger configuration is
+ * specified in a separate settings object.
+ */
+std::optional<std::string>
+create_file_logger(const configuration& logger_settings)
+{
+    auto fname = logger_settings.filename;
+    auto buffersz = logger_settings.buffer_size;
+    auto cyclesz = logger_settings.cycle_size;
+
+    if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
+        cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
+    }
+
+    try {
+        // Initialise the loggers.
+        //
+        // The structure is as follows:
+        //
+        // file_logger = sends log messages to sink
+        //   |__dist_sink_mt = Distribute log messages to multiple sinks
+        //       |     |__custom_rotating_file_sink_mt = adds opening & closing
+        //       |                                       hooks to the file
+        //       |__ (color)__stderr_sink_mt = Send log messages to console
+        //
+        // When a new log message is being submitted to the file_logger it
+        // is subject to the log level specified on the file_logger. If it
+        // is to be included it is passed down to the dist_sink which will
+        // evaluate if the message should be passed on based on its log level.
+        // It'll then try to pass the message to the file sink and the
+        // console sink and they will evaluate if the message should be
+        // logged or not. This means that we should set the file sink
+        // loglevel to TRACE so that all messages which goes all the way
+        // will end up in the file. Due to the fact that ns_server can't
+        // keep up with the rate we might produce log we want the console
+        // sink to drop everything below WARNING (unless we're running
+        // unit tests (through testapp).
+        //
+        // When the user change the verbosity level we'll modify the
+        // level for the file_logger object causing it to allow more
+        // messages to go down to the various sinks.
+
+        auto sink = std::make_shared<spdlog::sinks::dist_sink_mt>();
+        sink->set_level(spdlog::level::trace);
+
+        if (!fname.empty()) {
+            auto fsink = std::make_shared<custom_rotating_file_sink_mt>(fname, cyclesz, log_pattern);
+            fsink->set_level(spdlog::level::trace);
+            sink->add_sink(fsink);
+        }
+
+        if (logger_settings.console) {
+            auto stderrsink = std::make_shared<spdlog::sinks::stderr_color_sink_mt>();
+
+            // Set the formatting pattern of this sink
+            stderrsink->set_pattern(log_pattern);
+            if (logger_settings.unit_test) {
+                stderrsink->set_level(spdlog::level::trace);
+            } else {
+                stderrsink->set_level(spdlog::level::err);
+            }
+            sink->add_sink(stderrsink);
+        }
+        if (nullptr != logger_settings.sink) {
+            logger_settings.sink->set_pattern(log_pattern);
+            sink->add_sink(logger_settings.sink);
+        }
+
+        spdlog::drop(logger_name);
+
+        if (logger_settings.unit_test) {
+            file_logger = std::make_shared<spdlog::logger>(logger_name, sink);
+        } else {
+            // Create the default thread pool for async logging
+            spdlog::init_thread_pool(buffersz, 1);
+
+            // Get the thread pool so that we can actually construct the
+            // object with already created sinks...
+            auto tp = spdlog::thread_pool();
+            file_logger = std::make_shared<spdlog::async_logger>(logger_name, sink, tp, spdlog::async_overflow_policy::block);
+        }
+
+        file_logger->set_pattern(log_pattern);
+        file_logger->set_level(translate_level(logger_settings.log_level));
+
+        // Set the flushing interval policy
+        spdlog::flush_every(std::chrono::seconds(1));
+
+        spdlog::register_logger(file_logger);
+    } catch (const spdlog::spdlog_ex& ex) {
+        std::string msg = std::string{ "Log initialization failed: " } + ex.what();
+        return std::optional<std::string>{ msg };
+    }
+    return {};
+}
+
+spdlog::logger*
+get()
+{
+    return file_logger.get();
+}
+
+void
+reset()
+{
+    spdlog::drop(logger_name);
+    file_logger.reset();
+}
+
+void
+create_blackhole_logger()
+{
+    // delete if already exists
+    spdlog::drop(logger_name);
+
+    file_logger = std::make_shared<spdlog::logger>(logger_name, std::make_shared<spdlog::sinks::null_sink_mt>());
+
+    file_logger->set_level(spdlog::level::off);
+    file_logger->set_pattern(log_pattern);
+
+    spdlog::register_logger(file_logger);
+}
+
+void
+create_console_logger()
+{
+    // delete if already exists
+    spdlog::drop(logger_name);
+
+    auto stderrsink = std::make_shared<spdlog::sinks::stderr_color_sink_mt>();
+
+    file_logger = std::make_shared<spdlog::logger>(logger_name, stderrsink);
+    file_logger->set_level(spdlog::level::info);
+    file_logger->set_pattern(log_pattern);
+
+    spdlog::register_logger(file_logger);
+}
+
+void
+register_spdlog_logger(std::shared_ptr<spdlog::logger> l)
+{
+    try {
+        file_logger->debug("Registering logger {}", l->name());
+        spdlog::register_logger(l);
+    } catch (const spdlog::spdlog_ex& e) {
+        file_logger->warn("Exception caught when attempting to register the logger {} in the spdlog registry. The verbosity of this logger "
+                          "cannot be changed at runtime. e.what()={}",
+                          l->name(),
+                          e.what());
+    }
+}
+
+void
+unregister_spdlog_logger(const std::string& n)
+{
+    spdlog::drop(n);
+}
+
+bool
+check_log_levels(level lvl)
+{
+    auto level = translate_level(lvl);
+    bool correct = true;
+    spdlog::apply_all([level, &correct](std::shared_ptr<spdlog::logger> l) {
+        if (l->level() != level) {
+            correct = false;
+        }
+    });
+    return correct;
+}
+
+void
+set_log_levels(level lvl)
+{
+    auto level = translate_level(lvl);
+    // Apply the function to each registered spdlog::logger
+    spdlog::apply_all([level](std::shared_ptr<spdlog::logger> l) {
+        try {
+            l->set_level(level);
+        } catch (const spdlog::spdlog_ex& e) {
+            l->warn("Exception caught when attempting to change the verbosity "
+                    "of logger {} to spdlog level {}. e.what()={}",
+                    l->name(),
+                    to_short_c_str(level),
+                    e.what());
+        }
+    });
+
+    flush();
+}
+} // namespace couchbase::core::logger

package/deps/couchbase-cxx-client/core/logger/logger.hxx

@@ -0,0 +1,242 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+/*
+ *   A note on the thread safety of the logger API:
+ *
+ *   The API is thread safe unless the underlying logger object is changed
+ * during runtime. This means some methods can only be safely called if the
+ * caller guarantees no other threads exist and/or are calling the logging
+ * functions.
+ *
+ *   The caveat being we should not change the underlying logger object during
+ * run-time, the exception to this is during the initial memcached startup,
+ * where we are running in a single thread at the point we switch from console
+ * logging to file logging.
+ */
+
+#pragma once
+
+#include <fmt/core.h>
+#include <memory>
+#include <optional>
+#include <spdlog/fwd.h>
+#include <string>
+
+namespace couchbase::core::logger
+{
+struct configuration;
+
+/**
+ * the various severity levels we can log at
+ */
+enum class level { trace, debug, info, warn, err, critical, off };
+
+level
+level_from_str(const std::string& str);
+
+/**
+ * Initialize the logger.
+ *
+ * The default level for the created logger is set to INFO
+ *
+ * See note about thread safety at the top of the file
+ *
+ * @param logger_settings the configuration for the logger
+ * @return optional error message if something goes wrong
+ */
+std::optional<std::string>
+create_file_logger(const configuration& logger_settings);
+
+/**
+ * Initialize the logger with the blackhole logger object
+ *
+ * This method is intended to be used by unit tests which don't need any output (but may call methods who tries to fetch the logger)
+ *
+ * See note about thread safety at the top of the file
+ *
+ * @throws std::bad_alloc
+ * @throws spdlog::spdlog_ex if an error occurs creating the logger
+ *                           (if it already exists for instance)
+ */
+void
+create_blackhole_logger();
+
+/**
+ * Initialize the logger with the logger which logs to the console
+ *
+ * See note about thread safety at the top of the file
+ *
+ * @throws std::bad_alloc
+ * @throws spdlog::spdlog_ex if an error occurs creating the logger
+ */
+void
+create_console_logger();
+
+/**
+ * Get the underlying logger object
+ *
+ * See note about thread safety at the top of the file.
+ *
+ * This will return null if a logger has not been initialized through one of the following:
+ *
+ * - create_file_logger()
+ * - create_blackhole_logger()
+ * - create_console_logger()
+ */
+spdlog::logger*
+get();
+
+/**
+ * Reset the underlying logger object
+ *
+ * See note about thread safety at the top of the file
+ */
+void
+reset();
+
+/**
+ * Engines that create their own instances of an spdlog::logger should register the logger here to ensure that the verbosity of the logger
+ * is updated when memcached receives a request to update verbosity
+ *
+ * @param l spdlog::logger instance
+ */
+void
+register_spdlog_logger(std::shared_ptr<spdlog::logger> l);
+
+/**
+ * Engines that create their own instances of an spdlog::logger should unregister
+ * the logger here to ensure that resources can be freed when their loggers
+ * go out of scope, or unsubscribe from runtime verbosity changes
+ *
+ * @param n The name of the spdlog::logger
+ */
+void
+unregister_spdlog_logger(const std::string& n);
+
+/**
+ * Check the log level of all spdLoggers is equal to the given level
+ * @param log severity level
+ * @return true if all registered loggers have the specified severity level
+ */
+bool
+check_log_levels(level lvl);
+
+/**
+ * Set the log level of all registered spdLoggers
+ * @param log severity level
+ */
+void
+set_log_levels(level lvl);
+
+/**
+ * Checks whether a specific level should be logged based on the current
+ * configuration.
+ * @param level severity level to check
+ * @return true if we should log at this level
+ */
+bool
+should_log(level lvl);
+
+namespace detail
+{
+/**
+ * Logs a message at a specific severity level.
+ * @param lvl severity level to log at
+ * @param msg message to log
+ */
+void
+log(const char* file, int line, const char* function, level lvl, std::string_view msg);
+} // namespace detail
+
+/**
+ * Logs a formatted message at a specific severity level.
+ * @param lvl severity level to log at
+ * @param msg message to log
+ * @param args the formatting arguments
+ */
+template<typename String, typename... Args>
+inline void
+log(const char* file, int line, const char* function, level lvl, const String& msg, Args&&... args)
+{
+    detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
+}
+
+/**
+ * Tell the logger to flush its buffers
+ */
+void
+flush();
+
+/**
+ * Tell the logger to shut down (flush buffers) and release _ALL_
+ * loggers (you'd need to create new loggers after this method)
+ */
+void
+shutdown();
+
+/**
+ * @return whether or not the logger has been initialized
+ */
+bool
+is_initialized();
+
+} // namespace couchbase::core::logger
+
+#if defined(__GNUC__) || defined(__clang__)
+#define COUCHBASE_LOGGER_FUNCTION __PRETTY_FUNCTION__
+#else
+#define COUCHBASE_LOGGER_FUNCTION __FUNCTION__
+#endif
+/**
+ * We implement this macro to avoid having argument evaluation performed
+ * on log messages which likely will not actually be logged due to their
+ * severity value not matching the logger.
+ */
+#define COUCHBASE_LOG(file, line, function, severity, ...)                                                                                 \
+    do {                                                                                                                                   \
+        if (couchbase::core::logger::should_log(severity)) {                                                                               \
+            couchbase::core::logger::log(file, line, function, severity, __VA_ARGS__);                                                     \
+        }                                                                                                                                  \
+    } while (false)
+
+#define LOG_TRACE(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, __VA_ARGS__)
+#define LOG_DEBUG(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, __VA_ARGS__)
+#define LOG_INFO(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, __VA_ARGS__)
+#define LOG_WARNING(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, __VA_ARGS__)
+#define LOG_ERROR(...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, __VA_ARGS__)
+#define LOG_CRITICAL(...)                                                                                                                  \
+    COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, __VA_ARGS__)
+
+/**
+ * Convenience macros which log with the given level, and message, if the given
+ * level is currently enabled.
+ * @param msg Fixed string (implicitly convertible to `std::string_view`)
+ *
+ * For example:
+ *
+ *   LOG_INFO_RAW("Starting flusher");
+ *   LOG_INFO_RAW(std:string{...});
+ */
+#define COUCHBASE_LOG_RAW(file, line, function, severity, msg)                                                                             \
+    do {                                                                                                                                   \
+        if (couchbase::core::logger::should_log(severity)) {                                                                               \
+            couchbase::core::logger::detail::log(file, line, function, severity, msg);                                                     \
+        }                                                                                                                                  \
+    } while (false)
+
+#define LOG_TRACE_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::trace, msg)
+#define LOG_DEBUG_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::debug, msg)
+#define LOG_INFO_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::info, msg)
+#define LOG_WARNING_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::warn, msg)
+#define LOG_ERROR_RAW(msg) COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::err, msg)
+#define LOG_CRITICAL_RAW(msg)                                                                                                              \
+    COUCHBASE_LOG_RAW(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, msg)

package/deps/couchbase-cxx-client/core/management/analytics_dataset.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace couchbase::core::management::analytics
+{
+struct dataset {
+    std::string name;
+    std::string dataverse_name;
+    std::string link_name;
+    std::string bucket_name;
+};
+} // namespace couchbase::core::management::analytics

package/deps/couchbase-cxx-client/core/management/analytics_index.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace couchbase::core::management::analytics
+{
+struct index {
+    std::string name;
+    std::string dataverse_name;
+    std::string dataset_name;
+    bool is_primary;
+};
+} // namespace couchbase::core::management::analytics

package/deps/couchbase-cxx-client/core/management/analytics_link.hxx

@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "analytics_link_azure_blob_external.hxx"
+#include "analytics_link_couchbase_remote.hxx"
+#include "analytics_link_s3_external.hxx"