couchbase 4.2.1 → 4.2.2

package/deps/couchbase-cxx-client/core/metrics/logging_meter.hxx

@@ -29,45 +29,29 @@ namespace couchbase::core::metrics
 {
 class logging_value_recorder;
 
-class logging_meter : public couchbase::metrics::meter
+class logging_meter
+  : public couchbase::metrics::meter
+  , public std::enable_shared_from_this<logging_meter>
 {
   private:
     asio::steady_timer emit_report_;
     logging_meter_options options_;
     std::mutex recorders_mutex_{};
+    // service name -> operation name -> recorder
     std::map<std::string, std::map<std::string, std::shared_ptr<logging_value_recorder>>> recorders_{};
 
     void log_report() const;
 
-    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();
-        });
-    }
+    void rearm_reporter();
 
   public:
-    logging_meter(asio::io_context& ctx, logging_meter_options options)
-      : emit_report_(ctx)
-      , options_(options)
-    {
-    }
+    logging_meter(asio::io_context& ctx, logging_meter_options options);
 
-    ~logging_meter() override
-    {
-        emit_report_.cancel();
-        log_report();
-    }
+    ~logging_meter() override;
 
-    void start()
-    {
-        rearm_reporter();
-    }
+    void start() override;
+
+    void stop() override;
 
     std::shared_ptr<couchbase::metrics::value_recorder> get_value_recorder(const std::string& name,
                                                                            const std::map<std::string, std::string>& tags) override;

package/deps/couchbase-cxx-client/core/operations/document_get_projected.cxx

@@ -224,8 +224,9 @@ get_projected_request::make_response(key_value_error_context&& ctx, const encode
                         return response;
                     }
                     subdoc_apply_projection(new_doc, projection, value_to_apply, preserve_array_indexes);
-                } else {
-                    response.ctx.override_ec(errc::key_value::path_not_found);
+                } else if (field.status != key_value_status_code::subdoc_path_not_found) {
+                    response.ctx.override_ec(
+                      protocol::map_status_code(protocol::client_opcode::subdoc_multi_lookup, static_cast<std::uint16_t>(field.status)));
                     return response;
                 }
             }

package/deps/couchbase-cxx-client/core/operations/document_query.cxx

@@ -138,14 +138,8 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
         body["scan_wait"] = fmt::format("{}ms", scan_wait.value().count());
     }
 
-    if (scope_qualifier) {
-        body["query_context"] = scope_qualifier;
-    } else if (bucket_name) {
-        if (scope_name) {
-            body["query_context"] = fmt::format("default:`{}`.`{}`", *bucket_name, *scope_name);
-        } else {
-            body["query_context"] = fmt::format("default:`{}`", *bucket_name);
-        }
+    if (query_context) {
+        body["query_context"] = query_context.value();
     }
     for (const auto& [name, value] : raw) {
         body[name] = utils::json::parse(value);
@@ -166,16 +160,20 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
     if (!prep.is_string()) {
         prep = false;
     }
+    body.erase("statement");
+    body.erase("prepared");
     if (ctx_->options.show_queries) {
-        CB_LOG_INFO("QUERY: client_context_id=\"{}\", prep={}, {}",
+        CB_LOG_INFO("QUERY: client_context_id=\"{}\", prep={}, {}, options={}",
                     encoded.client_context_id,
                     utils::json::generate(prep),
-                    utils::json::generate(stmt));
+                    utils::json::generate(stmt),
+                    utils::json::generate(body));
     } else {
-        CB_LOG_DEBUG("QUERY: client_context_id=\"{}\", prep={}, {}",
+        CB_LOG_DEBUG("QUERY: client_context_id=\"{}\", prep={}, {}, options={}",
                      encoded.client_context_id,
                      utils::json::generate(prep),
-                     utils::json::generate(stmt));
+                     utils::json::generate(stmt),
+                     utils::json::generate(body));
     }
     if (row_callback) {
         encoded.streaming.emplace(couchbase::core::io::streaming_settings{

package/deps/couchbase-cxx-client/core/operations/document_query.hxx

@@ -92,9 +92,7 @@ struct query_request {
     std::optional<std::uint64_t> pipeline_cap{};
     std::optional<query_scan_consistency> scan_consistency{};
     std::vector<mutation_token> mutation_state{};
-    std::optional<std::string> bucket_name{};
-    std::optional<std::string> scope_name{};
-    std::optional<std::string> scope_qualifier{};
+    std::optional<std::string> query_context{};
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

package/deps/couchbase-cxx-client/core/operations/management/query_index_build.cxx

@@ -19,6 +19,7 @@
 
 #include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
 
 namespace couchbase::core::operations::management
@@ -44,23 +45,16 @@ quote_and_join_strings(const Range& values, const std::string& sep)
 std::error_code
 query_index_build_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty()) || index_names.empty()) {
+    if (!utils::check_query_management_request(*this)) {
         return errc::common::invalid_argument;
     }
-    std::string query_context = fmt::format("{}:`{}`", namespace_id, bucket_name);
-    std::string statement;
-    if (!scope_name.empty() && !collection_name.empty()) {
-        statement = fmt::format(
-          R"(BUILD INDEX ON `{}`.`{}`.`{}` ({}))", bucket_name, scope_name, collection_name, quote_and_join_strings(index_names, ","));
-        query_context += ".`" + scope_name + "`";
-    } else {
-        statement = fmt::format(R"(BUILD INDEX ON {} ({}))", query_context, quote_and_join_strings(index_names, ","));
-        query_context += fmt::format(".`{}`", couchbase::scope::default_name);
-    }
+    auto keyspace = core::utils::build_keyspace(*this);
+    std::string statement = fmt::format(R"(BUILD INDEX ON {} ({}))", keyspace, quote_and_join_strings(index_names, ","));
     encoded.headers["content-type"] = "application/json";
-    tao::json::value body{ { "statement", statement },
-                           { "client_context_id", encoded.client_context_id },
-                           { "query_context", query_context } };
+    tao::json::value body{ { "statement", statement }, { "client_context_id", encoded.client_context_id } };
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/operations/management/query_index_build.hxx

@@ -21,6 +21,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations::management
@@ -47,7 +48,7 @@ struct query_index_build_request {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-
+    query_context query_ctx;
     std::vector<std::string> index_names;
 
     std::optional<std::string> client_context_id{};

package/deps/couchbase-cxx-client/core/operations/management/query_index_build_deferred.hxx

@@ -18,10 +18,11 @@
 #pragma once
 
 #include "core/error_context/http.hxx"
-#include "core/management/query_index.hxx"
 #include "core/operations/management/query_index_build.hxx"
 #include "core/operations/management/query_index_get_all_deferred.hxx"
 #include "core/operations/operation_traits.hxx"
+#include "core/query_context.hxx"
+#include "couchbase/management/query_index.hxx"
 
 namespace couchbase::core::operations
 {
@@ -48,6 +49,7 @@ struct query_index_build_deferred_request {
     std::string bucket_name;
     std::optional<std::string> scope_name;
     std::optional<std::string> collection_name;
+    query_context query_ctx;
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
@@ -79,24 +81,29 @@ struct query_index_build_deferred_request {
     {
         core->execute(
           query_index_get_all_deferred_request{
-            bucket_name, scope_name.value_or(""), collection_name.value_or(""), client_context_id, timeout },
+            bucket_name, scope_name.value_or(""), collection_name.value_or(""), query_ctx, client_context_id, timeout },
           [core,
            handler = std::move(handler),
            bucket_name = bucket_name,
            scope_name = scope_name.value_or(""),
            collection_name = collection_name.value_or(""),
+           query_ctx = query_ctx,
            client_context_id = client_context_id,
            timeout = timeout](query_index_get_all_deferred_response resp1) mutable {
               auto list_resp = std::move(resp1);
               if (list_resp.ctx.ec || list_resp.index_names.empty()) {
                   return handler(convert_response(std::move(list_resp)));
               }
-              core->execute(
-                query_index_build_request{
-                  std::move(bucket_name), scope_name, collection_name, std::move(list_resp.index_names), client_context_id, timeout },
-                [handler = std::move(handler)](query_index_build_response build_resp) mutable {
-                    return handler(convert_response(std::move(build_resp)));
-                });
+              core->execute(query_index_build_request{ std::move(bucket_name),
+                                                       scope_name,
+                                                       collection_name,
+                                                       query_ctx,
+                                                       std::move(list_resp.index_names),
+                                                       client_context_id,
+                                                       timeout },
+                            [handler = std::move(handler)](query_index_build_response build_resp) mutable {
+                                return handler(convert_response(std::move(build_resp)));
+                            });
           });
     }
 };

package/deps/couchbase-cxx-client/core/operations/management/query_index_create.cxx

@@ -19,6 +19,7 @@
 
 #include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
 
 namespace couchbase::core::operations::management
@@ -26,7 +27,7 @@ namespace couchbase::core::operations::management
 std::error_code
 query_index_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+    if (!core::utils::check_query_management_request(*this)) {
         return errc::common::invalid_argument;
     }
     encoded.headers["content-type"] = "application/json";
@@ -45,17 +46,7 @@ query_index_create_request::encode_to(encoded_request_type& encoded, http_contex
     if (with) {
         with_clause = fmt::format("WITH {}", utils::json::generate(with));
     }
-    std::string keyspace = fmt::format("{}:`{}`", namespace_id, bucket_name);
-    auto query_context = keyspace;
-    if (!scope_name.empty()) {
-        keyspace += ".`" + scope_name + "`";
-        query_context += ".`" + scope_name + "`";
-    } else {
-        query_context += fmt::format(".`{}`", couchbase::scope::default_name);
-    }
-    if (!collection_name.empty()) {
-        keyspace += ".`" + collection_name + "`";
-    }
+    std::string keyspace = utils::build_keyspace(*this);
     tao::json::value body{ { "statement",
                              is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
                                                       index_name.empty() ? "" : fmt::format("`{}`", index_name),
@@ -67,8 +58,10 @@ query_index_create_request::encode_to(encoded_request_type& encoded, http_contex
                                                       utils::join_strings(fields, ", "),
                                                       where_clause,
                                                       with_clause) },
-                           { "client_context_id", encoded.client_context_id },
-                           { "query_context", query_context } };
+                           { "client_context_id", encoded.client_context_id } };
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/operations/management/query_index_create.hxx

@@ -21,6 +21,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations::management
@@ -49,6 +50,7 @@ struct query_index_create_request {
     std::string collection_name;
     std::string index_name{};
     std::vector<std::string> fields;
+    query_context query_ctx;
     bool is_primary{ false };
     bool ignore_if_exists{ false };
     std::optional<std::string> condition{};

package/deps/couchbase-cxx-client/core/operations/management/query_index_drop.cxx

@@ -18,6 +18,7 @@
 #include "query_index_drop.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
 
 namespace couchbase::core::operations::management
@@ -25,31 +26,25 @@ namespace couchbase::core::operations::management
 std::error_code
 query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
 {
-    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+    if (!utils::check_query_management_request(*this)) {
         return errc::common::invalid_argument;
     }
     encoded.headers["content-type"] = "application/json";
-    std::string query_context = fmt::format("{}:`{}`", namespace_id, bucket_name);
-    auto keyspace = query_context;
-    if (!scope_name.empty()) {
-        query_context += ".`" + scope_name + "`";
-        keyspace += ".`" + scope_name + "`";
-    } else {
-        query_context += fmt::format(".`{}`", couchbase::scope::default_name);
-    }
-    if (!collection_name.empty()) {
-        keyspace += ".`" + collection_name + "`";
-    }
+    auto keyspace = utils::build_keyspace(*this);
     std::string drop_index_stmt;
     if (is_primary && index_name.empty()) {
         drop_index_stmt = fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace);
-    } else {
+    } else if (bucket_name.empty() || (!collection_name.empty() && !scope_name.empty())) {
         drop_index_stmt = fmt::format(R"(DROP INDEX `{}` ON {} USING GSI)", index_name, keyspace);
+    } else {
+        // this works on 6.6 and earlier
+        drop_index_stmt = fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name);
     }
 
-    tao::json::value body{ { "statement", drop_index_stmt },
-                           { "client_context_id", encoded.client_context_id },
-                           { "query_context", query_context } };
+    tao::json::value body{ { "statement", drop_index_stmt }, { "client_context_id", encoded.client_context_id } };
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/operations/management/query_index_drop.hxx

@@ -21,6 +21,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations::management
@@ -48,6 +49,7 @@ struct query_index_drop_request {
     std::string scope_name;
     std::string collection_name;
     std::string index_name;
+    query_context query_ctx;
     bool is_primary{ false };
     bool ignore_if_does_not_exist{ false };
 

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all.cxx

@@ -38,13 +38,6 @@ query_index_get_all_request::encode_to(encoded_request_type& encoded, couchbase:
         where = bucket_cond;
     }
 
-    std::string query_context = fmt::format("{}:`{}`", namespace_id, bucket_name);
-    if (!scope_name.empty()) {
-        query_context += ".`" + scope_name + "`";
-    } else {
-        query_context += fmt::format(".`{}`", couchbase::scope::default_name);
-    }
-
     if (collection_name == "_default" || collection_name.empty()) {
         std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
         where = "(" + where + " OR " + default_collection_cond + ")";
@@ -59,10 +52,13 @@ query_index_get_all_request::encode_to(encoded_request_type& encoded, couchbase:
     encoded.headers["content-type"] = "application/json";
     tao::json::value body{ { "statement", statement },
                            { "client_context_id", encoded.client_context_id },
-                           { "$bucket_name", bucket_name },
-                           { "$scope_name", scope_name },
-                           { "$collection_name", collection_name },
-                           { "query_context", query_context } };
+                           { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
+                           { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
+                           { "$collection_name", collection_name } };
+
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);
@@ -90,7 +86,7 @@ query_index_get_all_request::make_response(couchbase::core::error_context::http&
             return response;
         }
         for (const auto& entry : payload.at("results").get_array()) {
-            couchbase::core::management::query::index index;
+            couchbase::management::query::index index;
             index.type = entry.at("using").get_string();
             index.name = entry.at("name").get_string();
             index.state = entry.at("state").get_string();

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all.hxx

@@ -20,16 +20,17 @@
 #include "core/error_context/http.hxx"
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
-#include "core/management/query_index.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
+#include "couchbase/management/query_index.hxx"
 
 namespace couchbase::core::operations::management
 {
 struct query_index_get_all_response {
     error_context::http ctx;
     std::string status{};
-    std::vector<couchbase::core::management::query::index> indexes{};
+    std::vector<couchbase::management::query::index> indexes{};
 };
 
 struct query_index_get_all_request {
@@ -44,7 +45,7 @@ struct query_index_get_all_request {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-
+    query_context query_ctx;
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all_deferred.cxx

@@ -25,18 +25,25 @@ namespace couchbase::core::operations::management
 std::error_code
 query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded, couchbase::core::http_context& /* context */) const
 {
+
+    // essentially same as query_index_get_all_request::encode_to, except for the state condition.   If you
+    // change this, you probably need to change that as well.
+    std::string bucket_cond = "bucket_id = $bucket_name";
+    std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
+    std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
+
     std::string where;
-    if (collection_name.empty()) {
-        where = "(keyspace_id = $bucket_name AND bucket_id IS MISSING)";
+    if (!collection_name.empty()) {
+        where = collection_cond;
+    } else if (!scope_name.empty()) {
+        where = scope_cond;
     } else {
-        where = "(bucket_id = $bucket_name AND scope_id = $scope_name AND keyspace_id = $collection_name)";
+        where = bucket_cond;
     }
 
-    std::string query_context = fmt::format("{}:`{}`", namespace_id, bucket_name);
-    if (!scope_name.empty()) {
-        query_context += ".`" + scope_name + "`";
-    } else {
-        query_context += fmt::format(".`{}`", couchbase::scope::default_name);
+    if (collection_name == "_default" || collection_name.empty()) {
+        std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
+        where = "(" + where + " OR " + default_collection_cond + ")";
     }
 
     std::string statement = "SELECT RAW name FROM system:indexes"
@@ -48,10 +55,12 @@ query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded, c
     encoded.headers["content-type"] = "application/json";
     tao::json::value body{ { "statement", statement },
                            { "client_context_id", encoded.client_context_id },
-                           { "$bucket_name", bucket_name },
-                           { "$scope_name", scope_name },
-                           { "$collection_name", collection_name },
-                           { "query_context", query_context } };
+                           { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
+                           { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
+                           { "$collection_name", collection_name } };
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all_deferred.hxx

@@ -20,9 +20,10 @@
 #include "core/error_context/http.hxx"
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
-#include "core/management/query_index.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
+#include "couchbase/management/query_index.hxx"
 
 namespace couchbase::core::operations::management
 {
@@ -44,7 +45,7 @@ struct query_index_get_all_deferred_request {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-
+    query_context query_ctx;
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -31,7 +31,7 @@ struct cluster_credentials {
     std::string password{};
     std::string certificate_path{};
     std::string key_path{};
-    std::vector<std::string> allowed_sasl_mechanisms{ "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1", "PLAIN" };
+    std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
 
     [[nodiscard]] bool uses_certificate() const
     {

package/deps/couchbase-cxx-client/core/platform/uuid.cc

@@ -21,12 +21,11 @@
 
 #include <iomanip>
 #include <random>
-#include <sstream>
 
 void
 couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
 {
-    static thread_local std::minstd_rand gen{ std::random_device()() };
+    static thread_local std::mt19937_64 gen{ std::random_device()() };
     std::uniform_int_distribution<std::uint64_t> dis;
 
     // The uuid is 16 bytes, which is the same as two 64-bit integers

package/deps/couchbase-cxx-client/core/protocol/cmd_hello.hxx

@@ -59,7 +59,6 @@ class hello_request_body
     std::vector<std::byte> key_;
     std::vector<hello_feature> features_{
         hello_feature::tcp_nodelay,
-        hello_feature::mutation_seqno,
         hello_feature::xattr,
         hello_feature::xerror,
         hello_feature::select_bucket,
@@ -93,6 +92,11 @@ class hello_request_body
         features_.emplace_back(hello_feature::snappy);
     }
 
+    void enable_mutation_tokens()
+    {
+        features_.emplace_back(hello_feature::mutation_seqno);
+    }
+
     [[nodiscard]] const std::vector<hello_feature>& features() const
     {
         return features_;

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

@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2023 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 <fmt/format.h>
+#include <optional>
+#include <string>
+
+namespace couchbase::core
+{
+
+class query_context
+{
+  public:
+    query_context() = default;
+    query_context(std::string namespace_id, std::string bucket_name, std::string scope_name)
+      : namespace_id_(namespace_id)
+      , bucket_name_(bucket_name)
+      , scope_name_(scope_name)
+    {
+    }
+
+    query_context(std::string bucket_name, std::string scope_name)
+      : bucket_name_(bucket_name)
+      , scope_name_(scope_name)
+    {
+    }
+
+    bool has_value() const
+    {
+        return bucket_name_.has_value() && scope_name_.has_value();
+    }
+
+    std::string value() const
+    {
+        if (has_value()) {
+            return fmt::format("{}:`{}`.`{}`", namespace_id_, bucket_name_.value(), scope_name_.value());
+        }
+        return {};
+    }
+    std::string bucket_name() const
+    {
+        if (has_value()) {
+            return bucket_name_.value();
+        }
+        return "";
+    }
+    std::string scope_name() const
+    {
+        if (has_value()) {
+            return scope_name_.value();
+        }
+        return "";
+    }
+    std::string namespace_id() const
+    {
+        return namespace_id_;
+    }
+
+  private:
+    std::string namespace_id_{ "default" };
+    std::optional<std::string> bucket_name_;
+    std::optional<std::string> scope_name_;
+};
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/tracing/CMakeLists.txt

@@ -6,4 +6,6 @@ target_link_libraries(
           project_warnings
           fmt::fmt
           spdlog::spdlog)
-target_include_directories(couchbase_tracing PRIVATE ../..)
+target_include_directories(couchbase_tracing PRIVATE
+        ${PROJECT_BINARY_DIR}/generated
+        ${PROJECT_SOURCE_DIR})