couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/couchbase/lookup_in_result.hxx

@@ -0,0 +1,254 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 <couchbase/codec/json_transcoder.hxx>
+#include <couchbase/result.hxx>
+#include <couchbase/subdoc/lookup_in_macro.hxx>
+
+#include <optional>
+
+namespace couchbase
+{
+
+/**
+ * Represents result of lookup_in operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class lookup_in_result : public result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    struct entry {
+        std::string path;
+        codec::binary value;
+        std::size_t original_index;
+        bool exists;
+    };
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    lookup_in_result() = default;
+
+    /**
+     * Constructs result for lookup_in_result operation
+     *
+     * @param cas
+     * @param entries list of the fields returned by the server
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    lookup_in_result(couchbase::cas cas, std::vector<entry> entries, bool is_deleted)
+      : result{ cas }
+      , entries_{ std::move(entries) }
+      , is_deleted_{ is_deleted }
+    {
+    }
+
+    /**
+     * Decodes field of the document into type.
+     *
+     * @tparam Document custom type that codec::json_transcoder should use to decode the field
+     * @param index the index of the result field
+     * @return decoded document content
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Document, std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true>
+    [[nodiscard]] auto content_as(std::size_t index) const -> Document
+    {
+        for (const entry& e : entries_) {
+            if (e.original_index == index) {
+                return codec::json_transcoder::template decode<Document>(e.value);
+            }
+        }
+        throw std::system_error(errc::key_value::path_invalid, "invalid index for lookup_in result: {}" + std::to_string(index));
+    }
+
+    /**
+     * Decodes field of the document into type.
+     *
+     * @tparam Document custom type that codec::json_transcoder should use to decode the field
+     * @param path the path of the result field
+     * @return decoded document content
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Document, std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true>
+    [[nodiscard]] auto content_as(const std::string& path) const -> Document
+    {
+        for (const entry& e : entries_) {
+            if (e.path == path) {
+                return codec::json_transcoder::template decode<Document>(e.value);
+            }
+        }
+        throw std::system_error(errc::key_value::path_invalid, "invalid path for lookup_in result: " + path);
+    }
+
+    /**
+     * Decodes field of the document into type.
+     *
+     * @tparam Document custom type that codec::json_transcoder should use to decode the field
+     * @param macro the path of the result field
+     * @return decoded document content
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Document, std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true>
+    [[nodiscard]] auto content_as(subdoc::lookup_in_macro macro) const -> Document
+    {
+        const auto& macro_string = subdoc::to_string(macro);
+        for (const entry& e : entries_) {
+            if (e.path == macro_string) {
+                return codec::json_transcoder::template decode<Document>(e.value);
+            }
+        }
+        throw std::system_error(errc::key_value::path_invalid,
+                                "invalid path for lookup_in result: macro#" + std::to_string(static_cast<std::uint32_t>(macro)));
+    }
+
+    /**
+     * Allows to check if a value at the given index exists.
+     *
+     * @param index the index at which to check.
+     * @return true if a value is present at the index, false otherwise.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto exists(std::size_t index) const -> bool
+    {
+        for (const entry& e : entries_) {
+            if (e.original_index == index) {
+                return e.exists;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Allows to check if a value at the given index exists.
+     *
+     * @param macro the path of the result field
+     * @return true if a value is present at the index, false otherwise.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto exists(subdoc::lookup_in_macro macro) const -> bool
+    {
+        const auto& macro_string = subdoc::to_string(macro);
+        for (const entry& e : entries_) {
+            if (e.path == macro_string) {
+                return e.exists;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Allows to check if a value at the given index exists.
+     *
+     * @param path the path of the result field
+     * @return true if a value is present at the index, false otherwise.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto exists(const std::string& path) const -> bool
+    {
+        for (const entry& e : entries_) {
+            if (e.path == path) {
+                return e.exists;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns whether this document was deleted (a tombstone).
+     *
+     * Will always be false unless {@link lookup_in_options#access_deleted()} has been set.
+     *
+     * For internal use only: applications should not require it.
+     *
+     * @return whether this document was a tombstone
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto is_deleted() const -> bool
+    {
+        return is_deleted_;
+    }
+
+    /**
+     * Returns whether the field has value
+     *
+     * @param index the index of the result field
+     * @return true if the server returned value for the field
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto has_value(std::size_t index) const -> bool
+    {
+        for (const entry& e : entries_) {
+            if (e.original_index == index) {
+                return !e.value.empty();
+            }
+        }
+        throw std::system_error(errc::key_value::path_invalid, "invalid index for mutate_in result: " + std::to_string(index));
+    }
+
+    /**
+     * Returns whether the field has value
+     *
+     * @param path the path of the result field
+     * @return true if the server returned value for the field
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto has_value(const std::string& path) const -> bool
+    {
+        for (const entry& e : entries_) {
+            if (e.path == path) {
+                return !e.value.empty();
+            }
+        }
+        throw std::system_error(errc::key_value::path_invalid, "invalid path for mutate_in result: " + path);
+    }
+
+  private:
+    std::vector<entry> entries_{};
+    bool is_deleted_{ false };
+};
+
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/lookup_in_specs.hxx

@@ -0,0 +1,146 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 <couchbase/subdoc/fwd/command.hxx>
+#include <couchbase/subdoc/fwd/command_bundle.hxx>
+
+#include <couchbase/codec/json_transcoder.hxx>
+#include <couchbase/subdoc/count.hxx>
+#include <couchbase/subdoc/exists.hxx>
+#include <couchbase/subdoc/get.hxx>
+
+#include <vector>
+
+namespace couchbase
+{
+class lookup_in_specs
+{
+  public:
+    lookup_in_specs() = default;
+
+    template<typename... Operation>
+    explicit lookup_in_specs(Operation... args)
+    {
+        push_back(args...);
+    }
+
+    /**
+     * Fetches the content from a field (if present) at the given path.
+     *
+     * @param path the path identifying where to get the value.
+     * @return the created spec
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    static auto get(std::string path) -> subdoc::get
+    {
+        return subdoc::get{ std::move(path) };
+    }
+
+    /**
+     * Fetches the content from a field represented by given virtual attribute (macro).
+     *
+     * @param path the path identifying where to get the value.
+     * @return the created spec
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    static auto get(subdoc::lookup_in_macro macro) -> subdoc::get
+    {
+        return subdoc::get{ macro };
+    }
+
+    /**
+     * Checks if a value at the given path exists in the document.
+     *
+     * @param path the path to check if the field exists.
+     * @return the created spec
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    static auto exists(std::string path) -> subdoc::exists
+    {
+        return subdoc::exists{ std::move(path) };
+    }
+
+    /**
+     * Counts the number of values at a given path in the document.
+     *
+     * @param path the path identifying where to count the values.
+     * @return the created spec
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    static auto count(std::string path) -> subdoc::count
+    {
+        return subdoc::count{ std::move(path) };
+    }
+
+    /**
+     * Add subdocument operation to list of specs
+     *
+     * @tparam Operation type of the subdocument operation
+     * @param operation operation to execute
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Operation>
+    void push_back(const Operation& operation)
+    {
+        operation.encode(bundle());
+    }
+
+    /**
+     * Add subdocument operations to list of specs
+     *
+     * @tparam Operation type of the subdocument operation
+     * @tparam Rest types of the rest of the operations
+     * @param operation operation to execute
+     * @param args the rest of the arguments
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    template<typename Operation, typename... Rest>
+    void push_back(const Operation& operation, Rest... args)
+    {
+        push_back(operation);
+        push_back(args...);
+    }
+
+    /**
+     * Returns internal representation of the specs.
+     * @return specs
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto specs() const -> const std::vector<core::impl::subdoc::command>&;
+
+  private:
+    [[nodiscard]] auto bundle() -> core::impl::subdoc::command_bundle&;
+
+    std::shared_ptr<core::impl::subdoc::command_bundle> specs_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/manager_error_context.hxx

@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 <couchbase/error_context.hxx>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+/**
+ * The error context returned with manager operations.
+ *
+ * @since 1.0.0
+ * @committed
+ */
+class manager_error_context : public error_context
+{
+  public:
+    /**
+     * Creates empty error context
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    manager_error_context() = default;
+
+    /**
+     * Creates and initializes error context with given parameters.
+     *
+     * @param ec
+     * @param last_dispatched_to
+     * @param last_dispatched_from
+     * @param retry_attempts
+     * @param retry_reasons
+     * @param client_context_id
+     * @param http_status
+     * @param content
+     * @param path
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    manager_error_context(std::error_code ec,
+                          std::optional<std::string> last_dispatched_to,
+                          std::optional<std::string> last_dispatched_from,
+                          int retry_attempts,
+                          std::set<retry_reason> retry_reasons,
+                          std::string client_context_id,
+                          std::uint32_t http_status,
+                          std::string content,
+                          std::string path)
+      : error_context{ ec, std::move(last_dispatched_to), std::move(last_dispatched_from), retry_attempts, std::move(retry_reasons) }
+      , client_context_id_{ std::move(client_context_id) }
+      , http_status_{ http_status }
+      , content_{ std::move(content) }
+      , path_{ std::move(path) }
+    {
+    }
+
+    /**
+     * Returns request path.
+     *
+     * @return request path
+     *
+     * @since 1.0.0
+     * @uncommitted
+     */
+    [[nodiscard]] auto path() const -> const std::string&
+    {
+        return path_;
+    }
+
+    /**
+     * Returns response body.
+     *
+     * @return response body
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto content() const -> const std::string&
+    {
+        return content_;
+    }
+
+    /**
+     * Returns the unique
+     *
+     * @return collection name
+     *
+     * @since 1.0.0
+     * @uncommitted
+     */
+    [[nodiscard]] auto client_context_id() const -> const std::string&
+    {
+        return client_context_id_;
+    }
+
+    /**
+     * Returns HTTP status of response
+     *
+     * @return HTTP status of response
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto http_status() const -> std::uint32_t
+    {
+        return http_status_;
+    }
+
+  private:
+    std::string client_context_id_{};
+    std::uint32_t http_status_{};
+    std::string content_{};
+    std::string path_{};
+};
+} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/metrics/otel_meter.hxx

@@ -0,0 +1,131 @@
+/* -*- 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 "opentelemetry/sdk/metrics/meter.h"
+#include <couchbase/metrics/meter.hxx>
+
+#include <iostream>
+#include <thread>
+#include <utility>
+
+using couchbase::metrics::meter;
+using couchbase::metrics::value_recorder;
+
+namespace nostd = opentelemetry::nostd;
+namespace metrics_api = opentelemetry::metrics;
+namespace metrics_sdk = opentelemetry::sdk::metrics;
+
+namespace couchbase::metrics
+{
+
+class otel_sync_histogram
+{
+  public:
+    otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter)
+      : histogram_counter_(histogram_counter)
+    {
+    }
+    void record(uint64_t value, const opentelemetry::common::KeyValueIterable& tags, opentelemetry::context::Context& ctx)
+    {
+        // overflow
+        if (value > LONG_MAX) {
+            value = LONG_MAX;
+        }
+        long lvalue = static_cast<long>(value);
+        histogram_counter_->Record(lvalue, tags, ctx);
+    }
+
+  private:
+    nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+    std::mutex mutex_;
+};
+
+class otel_value_recorder : public couchbase::metrics::value_recorder
+{
+  public:
+    explicit otel_value_recorder(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter,
+                                 const std::map<std::string, std::string>& tags)
+      : histogram_counter_(histogram_counter)
+      , tags_(tags)
+    {
+    }
+    void record_value(std::int64_t value) override
+    {
+        if (value > LONG_MAX) {
+            value = LONG_MAX;
+        }
+        long lvalue = static_cast<long>(value);
+        histogram_counter_->Record(value, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
+    }
+
+    const std::map<std::string, std::string> tags()
+    {
+        return tags_;
+    }
+
+    nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter()
+    {
+        return histogram_counter_;
+    }
+
+  private:
+    nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+    const std::map<std::string, std::string> tags_;
+    opentelemetry::context::Context context_{};
+    std::mutex mutex_;
+};
+
+class otel_meter : public couchbase::metrics::meter
+{
+  public:
+    explicit otel_meter(nostd::shared_ptr<metrics_api::Meter> meter)
+      : meter_(meter)
+    {
+    }
+
+    std::shared_ptr<value_recorder> get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags) override
+    {
+        // first look up the histogram, in case we already have it...
+        std::scoped_lock<std::mutex> lock(mutex_);
+        auto it = recorders_.equal_range(name);
+        if (it.first == it.second) {
+            // this name isn't associated with any histogram, so make one and return it.
+            // Note we'd like to make one with more buckets than default, given the range of
+            // response times we'd like to display (queries vs kv for instance), but otel
+            // api doesn't seem to allow this.
+            return recorders_.insert({ name, std::make_shared<otel_value_recorder>(meter_->CreateLongHistogram(name, "", "us"), tags) })
+              ->second;
+        }
+        // so it is already, lets see if we already have one with those tags, or need
+        // to make a new one (using the histogram we already have).
+        for (auto itr = it.first; itr != it.second; itr++) {
+            if (tags == itr->second->tags()) {
+                return itr->second;
+            }
+        }
+        // if you are here, we need to add one with these tags and the histogram associated with the name.
+        return recorders_.insert({ name, std::make_shared<otel_value_recorder>(it.first->second->histogram_counter(), tags) })->second;
+    }
+
+  private:
+    nostd::shared_ptr<metrics_api::Meter> meter_;
+    std::mutex mutex_;
+    std::multimap<std::string, std::shared_ptr<otel_value_recorder>> recorders_;
+};
+} // namespace couchbase::metrics