couchbase 3.1.1 → 3.2.0

data/ext/couchbase/io/query_cache.hxx

@@ -35,13 +35,13 @@ class query_cache
     void put(const std::string& statement, const std::string& prepared)
     {
         std::scoped_lock lock(store_mutex_);
-        store_.emplace(statement, entry{ prepared });
+        store_.try_emplace(statement, entry{ prepared });
     }
 
     void put(const std::string& statement, const std::string& name, const std::string& encoded_plan)
     {
         std::scoped_lock lock(store_mutex_);
-        store_.emplace(statement, entry{ name, encoded_plan });
+        store_.try_emplace(statement, entry{ name, encoded_plan });
     }
 
     std::optional<entry> get(const std::string& statement)

data/ext/couchbase/io/retry_orchestrator.hxx

@@ -33,8 +33,7 @@ cap_duration(std::chrono::milliseconds uncapped, std::shared_ptr<Command> comman
 {
     auto theoretical_deadline = std::chrono::steady_clock::now() + uncapped;
     auto absolute_deadline = command->deadline.expiry();
-    auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(theoretical_deadline - absolute_deadline);
-    if (delta.count() > 0) {
+    if (auto delta = std::chrono::duration_cast<std::chrono::milliseconds>(theoretical_deadline - absolute_deadline); delta.count() > 0) {
         auto capped = uncapped - delta;
         if (capped.count() < 0) {
             return uncapped; // something went wrong, return the uncapped one as a safety net
@@ -93,8 +92,7 @@ maybe_retry(std::shared_ptr<Manager> manager, std::shared_ptr<Command> command,
         return priv::retry_with_duration(manager, command, reason, priv::controlled_backoff(command->request.retries.retry_attempts));
     }
 
-    retry_action action = command->request.retries.strategy.should_retry(command->request, reason);
-    if (action.retry_requested) {
+    if (retry_action action = command->request.retries.strategy.should_retry(command->request, reason); action.retry_requested) {
         return priv::retry_with_duration(manager, command, reason, priv::cap_duration(action.duration, command));
     }
 

data/ext/couchbase/io/retry_reason.hxx

@@ -95,7 +95,7 @@ enum class retry_reason {
     views_no_active_partition,
 };
 
-constexpr inline bool
+constexpr bool
 allows_non_idempotent_retry(retry_reason reason)
 {
     switch (reason) {
@@ -126,7 +126,7 @@ allows_non_idempotent_retry(retry_reason reason)
     return false;
 }
 
-constexpr inline bool
+constexpr bool
 always_retry(retry_reason reason)
 {
     switch (reason) {

data/ext/couchbase/io/retry_strategy.hxx

@@ -124,11 +124,6 @@ class exponential
 class best_effort
 {
   public:
-    best_effort()
-      : backoff_(std::chrono::milliseconds(1), 2, std::chrono::milliseconds(500))
-    {
-    }
-
     template<class Request>
     retry_action should_retry(Request& request, retry_reason reason)
     {
@@ -140,7 +135,7 @@ class best_effort
     }
 
   private:
-    backoff::exponential backoff_;
+    backoff::exponential backoff_{ std::chrono::milliseconds(1), 2, std::chrono::milliseconds(500) };
 };
 
 class fail_fast

data/ext/couchbase/io/streams.hxx

@@ -87,7 +87,7 @@ class plain_stream_impl : public stream_impl
         return stream_.is_open();
     }
 
-    [[nodiscard]] virtual asio::ip::tcp::endpoint local_endpoint() const override
+    [[nodiscard]] asio::ip::tcp::endpoint local_endpoint() const override
     {
         std::error_code ec;
         auto res = stream_.local_endpoint(ec);
@@ -120,17 +120,17 @@ class plain_stream_impl : public stream_impl
     void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
                        std::function<void(std::error_code)>&& handler) override
     {
-        return stream_.async_connect(endpoint, handler);
+        return stream_.async_connect(endpoint, std::move(handler));
     }
 
     void async_write(std::vector<asio::const_buffer>& buffers, std::function<void(std::error_code, std::size_t)>&& handler) override
     {
-        return asio::async_write(stream_, buffers, handler);
+        return asio::async_write(stream_, buffers, std::move(handler));
     }
 
     void async_read_some(asio::mutable_buffer buffer, std::function<void(std::error_code, std::size_t)>&& handler) override
     {
-        return stream_.async_read_some(buffer, handler);
+        return stream_.async_read_some(buffer, std::move(handler));
     }
 };
 
@@ -153,7 +153,7 @@ class tls_stream_impl : public stream_impl
         return stream_->lowest_layer().is_open();
     }
 
-    [[nodiscard]] virtual asio::ip::tcp::endpoint local_endpoint() const override
+    [[nodiscard]] asio::ip::tcp::endpoint local_endpoint() const override
     {
         std::error_code ec;
         auto res = stream_->lowest_layer().local_endpoint(ec);
@@ -204,12 +204,12 @@ class tls_stream_impl : public stream_impl
 
     void async_write(std::vector<asio::const_buffer>& buffers, std::function<void(std::error_code, std::size_t)>&& handler) override
     {
-        return asio::async_write(*stream_, buffers, handler);
+        return asio::async_write(*stream_, buffers, std::move(handler));
     }
 
     void async_read_some(asio::mutable_buffer buffer, std::function<void(std::error_code, std::size_t)>&& handler) override
     {
-        return stream_->async_read_some(buffer, handler);
+        return stream_->async_read_some(buffer, std::move(handler));
     }
 };
 

data/ext/couchbase/metrics/logging_meter.hxx

@@ -0,0 +1,228 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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 <hdr_histogram.h>
+#include <tao/json.hpp>
+
+#include "logging_meter_options.hxx"
+#include "meter.hxx"
+
+namespace couchbase::metrics
+{
+
+class logging_value_recorder : public value_recorder
+{
+  private:
+    std::string name_;
+    std::map<std::string, std::string> tags_;
+    hdr_histogram* histogram_{ nullptr };
+
+    void initialize_histogram()
+    {
+        histogram_ = nullptr;
+        hdr_init(/* minimum - 1 ns*/ 1,
+                 /* maximum - 30 s*/ 30e9,
+                 /* significant figures */ 3,
+                 /* pointer */ &histogram_);
+        Expects(histogram_ != nullptr);
+    }
+
+  public:
+    logging_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags)
+      : name_(name)
+      , tags_(tags)
+    {
+        initialize_histogram();
+    }
+
+    logging_value_recorder(const logging_value_recorder& other)
+      : value_recorder()
+      , name_(other.name_)
+      , tags_(other.tags_)
+      , histogram_(nullptr)
+    {
+        initialize_histogram();
+    }
+
+    logging_value_recorder(logging_value_recorder&& other)
+      : value_recorder()
+      , name_(std::move(other.name_))
+      , tags_(std::move(other.tags_))
+      , histogram_(nullptr)
+    {
+        initialize_histogram();
+    }
+
+    logging_value_recorder& operator=(const logging_value_recorder& other)
+    {
+        if (this == &other) {
+            return *this;
+        }
+        name_ = other.name_;
+        tags_ = other.tags_;
+        initialize_histogram();
+        return *this;
+    }
+
+    logging_value_recorder& operator=(logging_value_recorder&& other)
+    {
+        if (this == &other) {
+            return *this;
+        }
+        name_ = std::move(other.name_);
+        tags_ = std::move(other.tags_);
+        initialize_histogram();
+        return *this;
+    }
+
+    ~logging_value_recorder() override
+    {
+        if (histogram_ != nullptr) {
+            hdr_close(histogram_);
+            histogram_ = nullptr;
+        }
+    }
+
+    void record_value(std::int64_t value) override
+    {
+        if (histogram_ == nullptr) {
+            return;
+        }
+        // Expects(histogram_ != nullptr);
+        hdr_record_value(histogram_, value);
+    }
+
+    [[nodiscard]] tao::json::value emit() const
+    {
+        auto total_count = histogram_->total_count;
+        auto val_50_0 = hdr_value_at_percentile(histogram_, 50.0);
+        auto val_90_0 = hdr_value_at_percentile(histogram_, 90.0);
+        auto val_99_0 = hdr_value_at_percentile(histogram_, 99.0);
+        auto val_99_9 = hdr_value_at_percentile(histogram_, 99.9);
+        auto val_100_0 = hdr_value_at_percentile(histogram_, 100.0);
+
+        hdr_reset(histogram_);
+
+        return {
+            { "total_count", total_count },
+            { "percentiles_us",
+              {
+                { "50.0", val_50_0 },
+                { "90.0", val_90_0 },
+                { "99.0", val_99_0 },
+                { "99.9", val_99_9 },
+                { "100.0", val_100_0 },
+              } },
+        };
+    }
+};
+
+class logging_meter : public meter
+{
+  private:
+    asio::steady_timer emit_report_;
+    logging_meter_options options_;
+    std::map<std::string, std::map<std::string, logging_value_recorder>> recorders_{};
+
+    void log_report() const
+    {
+        tao::json::value report{
+            {
+              "meta",
+              {
+
+                { "emit_interval_s", std::chrono::duration_cast<std::chrono::seconds>(options_.emit_interval).count() },
+#if BACKEND_DEBUG_BUILD
+                { "emit_interval_ms", options_.emit_interval.count() },
+#endif
+              },
+            },
+        };
+        for (const auto& [service, operations] : recorders_) {
+            for (const auto& [operation, recorder] : operations) {
+                report["operations"][service][operation] = recorder.emit();
+            }
+        }
+        spdlog::info("Metrics: {}", tao::json::to_string(report));
+    }
+
+    void rearm_reporter()
+    {
+        emit_report_.expires_after(options_.emit_interval);
+        emit_report_.async_wait([this](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            log_report();
+            rearm_reporter();
+        });
+    }
+
+  public:
+    logging_meter(asio::io_context& ctx, logging_meter_options options)
+      : emit_report_(ctx)
+      , options_(options)
+    {
+    }
+
+    ~logging_meter() override
+    {
+        emit_report_.cancel();
+        log_report();
+    }
+
+    void start()
+    {
+        rearm_reporter();
+    }
+
+    value_recorder* get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags) override
+    {
+        static noop_value_recorder noop_recorder{};
+
+        static std::string meter_name = "db.couchbase.operations";
+        if (name != meter_name) {
+            return &noop_recorder;
+        }
+
+        static std::string service_tag = "db.couchbase.service";
+        auto service = tags.find(service_tag);
+        if (service == tags.end()) {
+            return &noop_recorder;
+        }
+        auto& service_recorders = recorders_[service->second];
+
+        static std::string operation_tag = "db.operation";
+        auto operation = tags.find(operation_tag);
+        if (operation == tags.end()) {
+            return &noop_recorder;
+        }
+
+        auto recorder = service_recorders.find(operation->second);
+        if (recorder != service_recorders.end()) {
+            return &recorder->second;
+        }
+
+        service_recorders.emplace(operation->second, logging_value_recorder(operation->second, tags));
+        recorder = service_recorders.find(operation->second);
+        return &recorder->second;
+    }
+};
+
+} // namespace couchbase::metrics

data/ext/couchbase/metrics/logging_meter_options.hxx

@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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 <chrono>
+
+namespace couchbase::metrics
+{
+struct logging_meter_options {
+    std::chrono::milliseconds emit_interval{ std::chrono::minutes{ 10 } };
+};
+
+} // namespace couchbase::metrics

data/ext/couchbase/metrics/meter.hxx

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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
+
+namespace couchbase::metrics
+{
+
+class value_recorder
+{
+  public:
+    value_recorder() = default;
+    value_recorder(const value_recorder& other) = default;
+    value_recorder(value_recorder&& other) = default;
+    value_recorder& operator=(const value_recorder& other) = default;
+    value_recorder& operator=(value_recorder&& other) = default;
+    virtual ~value_recorder() = default;
+
+    virtual void record_value(std::int64_t value) = 0;
+};
+
+class meter
+{
+  public:
+    meter() = default;
+    meter(const meter& other) = default;
+    meter(meter&& other) = default;
+    meter& operator=(const meter& other) = default;
+    meter& operator=(meter&& other) = default;
+    virtual ~meter() = default;
+
+    virtual value_recorder* get_value_recorder(const std::string& /* name */, const std::map<std::string, std::string>& /* tags */) = 0;
+};
+
+} // namespace couchbase::metrics

data/ext/couchbase/metrics/noop_meter.hxx

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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 "meter.hxx"
+
+namespace couchbase::metrics
+{
+
+class noop_value_recorder : public value_recorder
+{
+  public:
+    void record_value(std::int64_t /* value */) override
+    {
+    }
+};
+
+class noop_meter : public meter
+{
+  public:
+    value_recorder* get_value_recorder(const std::string& /* name */, const std::map<std::string, std::string>& /* tags */)
+    {
+        static noop_value_recorder instance{};
+        return &instance;
+    }
+};
+
+} // namespace couchbase::metrics