couchbase 3.5.7 → 3.6.0

data/ext/couchbase/core/logger/logger.hxx

@@ -25,6 +25,8 @@
 
 #pragma once
 
+#include <functional>
+
 #include "level.hxx"
 
 #include <spdlog/fmt/bundled/core.h>
@@ -36,8 +38,17 @@
 
 namespace couchbase::core::logger
 {
+
 struct configuration;
 
+struct log_location {
+  std::string file;
+  std::string function;
+  int line;
+};
+
+using log_callback = std::function<void(std::string_view, level, log_location)>;
+
 auto
 level_from_str(const std::string& str) -> level;
 
@@ -113,6 +124,12 @@ get() -> spdlog::logger*;
 void
 reset();
 
+void
+register_log_callback(log_callback callback);
+
+void
+unregister_log_callback();
+
 /**
  * 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
@@ -179,6 +196,13 @@ log(const char* file, int line, const char* function, level lvl, std::string_vie
 
 void
 log_protocol(const char* file, int line, const char* function, std::string_view msg);
+
+void
+log_custom_logger(const char* file,
+                  int line,
+                  const char* function,
+                  level lvl,
+                  std::string_view msg);
 } // namespace detail
 
 /**
@@ -199,6 +223,19 @@ log(const char* file,
   detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
 }
 
+template<typename... Args>
+inline void
+log_custom_logger(const char* file,
+                  int line,
+                  const char* function,
+                  level lvl,
+                  fmt::format_string<Args...> msg,
+                  Args&&... args)
+{
+  detail::log_custom_logger(
+    file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
+}
+
 template<typename... Args>
 inline void
 log_protocol(const char* file,
@@ -228,7 +265,6 @@ shutdown();
  */
 auto
 is_initialized() -> bool;
-
 } // namespace couchbase::core::logger
 
 #if defined(__GNUC__) || defined(__clang__)
@@ -243,6 +279,8 @@ is_initialized() -> bool;
  */
 #define COUCHBASE_LOG(file, line, function, severity, ...)                                         \
   do {                                                                                             \
+    couchbase::core::logger::log_custom_logger(file, line, function, severity, __VA_ARGS__);       \
+                                                                                                   \
     if (couchbase::core::logger::should_log(severity)) {                                           \
       couchbase::core::logger::log(file, line, function, severity, __VA_ARGS__);                   \
     }                                                                                              \
@@ -305,6 +343,8 @@ is_initialized() -> bool;
  */
 #define COUCHBASE_LOG_RAW(file, line, function, severity, msg)                                     \
   do {                                                                                             \
+    couchbase::core::logger::log_custom_logger(file, line, function, severity, msg);               \
+                                                                                                   \
     if (couchbase::core::logger::should_log(severity)) {                                           \
       couchbase::core::logger::detail::log(file, line, function, severity, msg);                   \
     }                                                                                              \

data/ext/couchbase/core/management/bucket_settings.hxx

@@ -136,6 +136,7 @@ struct bucket_settings {
   std::optional<bool> history_retention_collection_default{};
   std::optional<std::uint32_t> history_retention_bytes{};
   std::optional<std::uint32_t> history_retention_duration{};
+  std::optional<std::uint16_t> num_vbuckets{};
 
   /**
    * UNCOMMITTED: This API may change in the future

data/ext/couchbase/core/management/bucket_settings_json.hxx

@@ -56,6 +56,10 @@ struct traits<couchbase::core::management::cluster::bucket_settings> {
         history_retention_duration->template as<std::optional<std::uint32_t>>();
     }
 
+    if (auto* num_vbuckets = v.find("numVBuckets"); num_vbuckets != nullptr) {
+      result.num_vbuckets = num_vbuckets->template as<std::optional<std::uint16_t>>();
+    }
+
     if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
       result.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
     } else if (str == "ephemeral") {

data/ext/couchbase/core/meta/features.hxx

@@ -207,7 +207,39 @@
  */
 #define COUCHBASE_CXX_CLIENT_PUBLIC_API_PARENT_SPAN 1
 
+/**
+ * The library can be configured to use application telemetry (default is enabled)
+ * See couchbase::application_telemetry_options for available options
+ * to pass into couchbase::cluster_options
+ */
+#define COUCHBASE_CXX_CLIENT_SUPPORTS_APP_TELEMETRY 1
+
 /**
  * core API like with_bucket_configuration() yields shared_ptr instead of configuration copy
  */
 #define COUCHBASE_CXX_CLIENT_CORE_RETURNS_POINTER_TO_CONFIG 1
+
+/**
+ * bucket_settings in both the public and core management APIs have a num_vbuckets attribute
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_BUCKET_SETTINGS_NUM_VBUCKETS 1
+
+/**
+ * couchbase::query_options and couchbase::analytics_options provide the methods:
+ *   - add_positional_parameter
+ *   - add_named_parameter
+ *   - clear_positional_parameters
+ *   - clear_named_parameters
+ */
+#define COUCHBASE_CXX_CLIENT_QUERY_OPTIONS_HAVE_ADD_PARAMETER 1
+
+/**
+ * couchbase::query_options and couchbase::analytics_options allow setting both positional and named
+ * parameters.
+ */
+#define COUCHBASE_CXX_CLIENT_QUERY_SUPPORTS_BOTH_POSITIONAL_NAMED_PARAMETERS 1
+
+/**
+ * get_multi API is implemented for transactions
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_TRANSACTIONS_GET_MULTI 1

data/ext/couchbase/core/operations/document_analytics.cxx

@@ -35,16 +35,16 @@ analytics_request::encode_to(analytics_request::encoded_request_type& encoded,
   tao::json::value body{ { "statement", statement },
                          { "client_context_id", encoded.client_context_id },
                          { "timeout", fmt::format("{}ms", encoded.timeout.count()) } };
-  if (positional_parameters.empty()) {
-    for (const auto& [name, value] : named_parameters) {
-      Expects(name.empty() == false);
-      std::string key = name;
-      if (key[0] != '$') {
-        key.insert(key.begin(), '$');
-      }
-      body[key] = utils::json::parse(value);
+
+  for (const auto& [name, value] : named_parameters) {
+    Expects(name.empty() == false);
+    std::string key = name;
+    if (key[0] != '$') {
+      key.insert(key.begin(), '$');
     }
-  } else {
+    body[key] = utils::json::parse(value);
+  }
+  if (!positional_parameters.empty()) {
     std::vector<tao::json::value> parameters;
     parameters.reserve(positional_parameters.size());
     for (const auto& value : positional_parameters) {

data/ext/couchbase/core/operations/document_append.cxx

@@ -28,6 +28,7 @@ append_request::encode_to(protocol::client_request<protocol::append_request_body
 {
   encoded.opaque(opaque);
   encoded.partition(partition);
+  encoded.cas(cas);
   encoded.body().id(id);
   encoded.body().content(value);
   return {};

data/ext/couchbase/core/operations/document_append.hxx

@@ -50,6 +50,7 @@ struct append_request {
   std::vector<std::byte> value;
   std::uint16_t partition{};
   std::uint32_t opaque{};
+  couchbase::cas cas{ 0 };
   couchbase::durability_level durability_level{ durability_level::none };
   std::optional<std::chrono::milliseconds> timeout{};
   io::retry_context<false> retries{};

data/ext/couchbase/core/operations/document_get_all_replicas.hxx

@@ -131,7 +131,11 @@ struct get_all_replicas_request {
                   }
                 }
                 if (local_handler) {
-                  return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                  if (ctx->result_.empty()) {
+                    // Return an error only when we have no results from any replica.
+                    return local_handler({ std::move(resp.ctx), {} });
+                  }
+                  return local_handler({ {}, std::move(ctx->result_) });
                 }
               });
           } else {
@@ -158,7 +162,11 @@ struct get_all_replicas_request {
                 }
               }
               if (local_handler) {
-                return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                if (ctx->result_.empty()) {
+                  // Return an error only when we have no results from any replica.
+                  return local_handler({ std::move(resp.ctx), {} });
+                }
+                return local_handler({ {}, std::move(ctx->result_) });
               }
             });
           }

data/ext/couchbase/core/operations/document_lookup_in.cxx

@@ -31,6 +31,10 @@ auto
 lookup_in_request::encode_to(lookup_in_request::encoded_request_type& encoded,
                              mcbp_context&& context) -> std::error_code
 {
+  if (specs.empty()) {
+    return errc::common::invalid_argument;
+  }
+
   for (std::size_t i = 0; i < specs.size(); ++i) {
     specs[i].original_index_ = i;
 

data/ext/couchbase/core/operations/document_lookup_in_all_replicas.hxx

@@ -115,6 +115,10 @@ struct lookup_in_all_replicas_request {
               ec = errc::key_value::document_irretrievable;
             }
 
+            if (!ec && specs.empty()) {
+              ec = errc::common::invalid_argument;
+            }
+
             if (ec) {
               return h(response_type{ make_subdocument_error_context(
                 make_key_value_error_context(ec, id), ec, {}, {}, false) });
@@ -183,7 +187,11 @@ struct lookup_in_all_replicas_request {
                       }
                     }
                     if (local_handler) {
-                      return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                      if (ctx->result_.empty()) {
+                        // Return an error only when we have no results from any replica.
+                        return local_handler({ std::move(resp.ctx), {} });
+                      }
+                      return local_handler({ {}, std::move(ctx->result_) });
                     }
                   });
               } else {
@@ -227,7 +235,11 @@ struct lookup_in_all_replicas_request {
                       }
                     }
                     if (local_handler) {
-                      return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                      if (ctx->result_.empty()) {
+                        // Return an error only when we have no results from any replica.
+                        return local_handler({ std::move(resp.ctx), {} });
+                      }
+                      return local_handler({ {}, std::move(ctx->result_) });
                     }
                   });
               }

data/ext/couchbase/core/operations/document_lookup_in_any_replica.hxx

@@ -112,6 +112,10 @@ struct lookup_in_any_replica_request {
               ec = errc::key_value::document_irretrievable;
             }
 
+            if (!ec && specs.empty()) {
+              ec = errc::common::invalid_argument;
+            }
+
             if (ec) {
               return h(response_type{ make_subdocument_error_context(
                 make_key_value_error_context(ec, id), ec, {}, {}, false) });

data/ext/couchbase/core/operations/document_mutate_in.cxx

@@ -36,6 +36,9 @@ mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded,
       !context.supports_feature(protocol::hello_feature::subdoc_create_as_deleted)) {
     return errc::common::unsupported_operation;
   }
+  if (specs.empty()) {
+    return errc::common::invalid_argument;
+  }
   for (std::size_t i = 0; i < specs.size(); ++i) {
     auto& entry = specs[i];
     entry.original_index_ = i;
@@ -60,6 +63,7 @@ mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded,
   }
   encoded.body().access_deleted(access_deleted);
   encoded.body().create_as_deleted(create_as_deleted);
+  encoded.body().revive_document(revive_document);
   encoded.body().store_semantics(store_semantics);
   encoded.body().specs(specs);
   if (preserve_expiry) {

data/ext/couchbase/core/operations/document_mutate_in.hxx

@@ -63,6 +63,7 @@ struct mutate_in_request {
   couchbase::cas cas{ 0 };
   bool access_deleted{ false };
   bool create_as_deleted{ false };
+  bool revive_document{ false };
   std::optional<std::uint32_t> expiry{};
   couchbase::store_semantics store_semantics{ couchbase::store_semantics::replace };
   std::vector<couchbase::core::impl::subdoc::command> specs{};

data/ext/couchbase/core/operations/document_prepend.cxx

@@ -28,6 +28,7 @@ prepend_request::encode_to(prepend_request::encoded_request_type& encoded,
 {
   encoded.opaque(opaque);
   encoded.partition(partition);
+  encoded.cas(cas);
   encoded.body().id(id);
   encoded.body().content(value);
   return {};

data/ext/couchbase/core/operations/document_prepend.hxx

@@ -50,6 +50,7 @@ struct prepend_request {
   std::vector<std::byte> value;
   std::uint16_t partition{};
   std::uint32_t opaque{};
+  couchbase::cas cas{ 0 };
   couchbase::durability_level durability_level{ durability_level::none };
   std::optional<std::chrono::milliseconds> timeout{};
   io::retry_context<false> retries{};

data/ext/couchbase/core/operations/document_query.cxx

@@ -64,16 +64,16 @@ query_request::encode_to(query_request::encoded_request_type& encoded,
     timeout_for_service -= std::chrono::milliseconds(500);
   }
   body["timeout"] = fmt::format("{}ms", timeout_for_service.count());
-  if (positional_parameters.empty()) {
-    for (const auto& [name, value] : named_parameters) {
-      Expects(name.empty() == false);
-      std::string key = name;
-      if (key[0] != '$') {
-        key.insert(key.begin(), '$');
-      }
-      body[key] = utils::json::parse(value);
+
+  for (const auto& [name, value] : named_parameters) {
+    Expects(name.empty() == false);
+    std::string key = name;
+    if (key[0] != '$') {
+      key.insert(key.begin(), '$');
     }
-  } else {
+    body[key] = utils::json::parse(value);
+  }
+  if (!positional_parameters.empty()) {
     std::vector<tao::json::value> parameters;
     parameters.reserve(positional_parameters.size());
     for (const auto& value : positional_parameters) {
@@ -237,7 +237,9 @@ query_request::make_response(error_context::query&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    response.meta.request_id = payload.at("requestID").get_string();
+    if (const auto* i = payload.find("requestID"); i != nullptr) {
+      response.meta.request_id = i->get_string();
+    }
 
     if (const auto* i = payload.find("clientContextID"); i != nullptr) {
       response.meta.client_context_id = i->get_string();

data/ext/couchbase/core/operations/http_noop.cxx

@@ -25,6 +25,7 @@ auto
 http_noop_request::encode_to(http_noop_request::encoded_request_type& encoded,
                              http_context& /* context */) -> std::error_code
 {
+  encoded.type = type;
   encoded.headers["connection"] = "keep-alive";
   encoded.method = "GET";
   encoded.path = "/";

data/ext/couchbase/core/operations/management/bucket_create.cxx

@@ -86,6 +86,9 @@ bucket_create_request::encode_to(encoded_request_type& encoded,
   if (bucket.flush_enabled.has_value()) {
     encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
   }
+  if (bucket.num_vbuckets.has_value()) {
+    encoded.body.append(fmt::format("&numVBuckets={}", bucket.num_vbuckets.value()));
+  }
 
   switch (bucket.eviction_policy) {
     case couchbase::core::management::cluster::bucket_eviction_policy::full:

data/ext/couchbase/core/operations/management/bucket_update.cxx

@@ -69,6 +69,9 @@ bucket_update_request::encode_to(encoded_request_type& encoded,
   if (bucket.flush_enabled.has_value()) {
     encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
   }
+  if (bucket.num_vbuckets.has_value()) {
+    encoded.body.append(fmt::format("&numVBuckets={}", bucket.num_vbuckets.value()));
+  }
 
   switch (bucket.eviction_policy) {
     case couchbase::core::management::cluster::bucket_eviction_policy::full:

data/ext/couchbase/core/origin.cxx

@@ -298,11 +298,6 @@ origin::to_json() const -> std::string
   return tao::json::to_string(json);
 }
 
-auto
-cluster_credentials::uses_certificate() const -> bool
-{
-  return !certificate_path.empty();
-}
 } // namespace couchbase::core
 
 couchbase::core::origin::origin(const couchbase::core::origin& other)

data/ext/couchbase/core/origin.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "cluster_credentials.hxx"
 #include "cluster_options.hxx"
 
 #include <string>
@@ -30,20 +31,10 @@ namespace utils
 struct connection_string;
 } // namespace utils
 
-struct cluster_credentials {
-  std::string username{};
-  std::string password{};
-  std::string certificate_path{};
-  std::string key_path{};
-  std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
-
-  [[nodiscard]] bool uses_certificate() const;
-};
-
 namespace topology
 {
 struct configuration;
-}
+} // namespace topology
 
 struct origin {
   using node_entry = std::pair<std::string, std::string>;

data/ext/couchbase/core/platform/random.cc

@@ -82,9 +82,12 @@ public:
 #ifdef WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
-    // TODO(CXXCBC-549)
-    // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
-    return static_cast<std::size_t>(read(handle, dest, size)) == size;
+#if defined(__clang__) && defined(__clang_analyzer__)
+    [[clang::suppress]]
+#endif
+      // TODO(CXXCBC-549)
+      // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
+      return static_cast<std::size_t>(read(handle, dest, size)) == size;
 #endif
   }
 

data/ext/couchbase/core/platform/random.h

@@ -32,8 +32,8 @@ class RandomGenerator
 public:
   RandomGenerator();
 
-  std::uint64_t next();
+  auto next() -> std::uint64_t;
 
-  static bool getBytes(void* dest, size_t size);
+  static auto getBytes(void* dest, size_t size) -> bool;
 };
 } // namespace couchbase::core

data/ext/couchbase/core/protocol/cmd_mutate_in.hxx

@@ -151,6 +151,15 @@ public:
     }
   }
 
+  void revive_document(bool value)
+  {
+    if (value) {
+      flags_ |= doc_flag_revive_document;
+    } else {
+      flags_ &= ~doc_flag_revive_document;
+    }
+  }
+
   void store_semantics(couchbase::store_semantics semantics)
   {
     flags_ &= std::byte{ 0b1111'1100U }; /* reset first two bits */

data/ext/couchbase/core/timeout_defaults.hxx

@@ -42,4 +42,8 @@ constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };
 constexpr std::chrono::milliseconds config_poll_floor{ 50 };
 constexpr std::chrono::milliseconds config_idle_redial_timeout{ 5 * 60'000 };
 constexpr std::chrono::milliseconds idle_http_connection_timeout{ 1'000 };
+
+constexpr std::chrono::milliseconds app_telemetry_ping_interval{ 30'000 };
+constexpr std::chrono::milliseconds app_telemetry_ping_timeout{ 2'000 };
+constexpr std::chrono::milliseconds app_telemetry_backoff_interval{ std::chrono::hours{ 1 } };
 } // namespace couchbase::core::timeout_defaults

data/ext/couchbase/core/topology/configuration.cxx

@@ -29,9 +29,8 @@
 namespace couchbase::core::topology
 {
 auto
-configuration::node::port_or(service_type type,
-                             bool is_tls,
-                             std::uint16_t default_value) const -> std::uint16_t
+configuration::node::port_or(service_type type, bool is_tls, std::uint16_t default_value) const
+  -> std::uint16_t
 {
   if (is_tls) {
     switch (type) {
@@ -90,7 +89,7 @@ configuration::node::hostname_for(const std::string& network) const -> const std
   }
   const auto& address = alt.find(network);
   if (address == alt.end()) {
-    CB_LOG_WARNING(R"(requested network "{}" is not found, fallback to "default" host)", network);
+    CB_LOG_DEBUG(R"(requested network "{}" is not found, fallback to "default" host)", network);
     return hostname;
   }
   return address->second.hostname;
@@ -107,10 +106,9 @@ configuration::node::port_or(const std::string& network,
   }
   const auto& address = alt.find(network);
   if (address == alt.end()) {
-    CB_LOG_WARNING(
-      R"(requested network "{}" is not found, fallback to "default" port of {} service)",
-      network,
-      type);
+    CB_LOG_DEBUG(R"(requested network "{}" is not found, fallback to "default" port of {} service)",
+                 network,
+                 type);
     return port_or(type, is_tls, default_value);
   }
   if (is_tls) {
@@ -163,9 +161,8 @@ configuration::node::port_or(const std::string& network,
 }
 
 auto
-configuration::node::endpoint(const std::string& network,
-                              service_type type,
-                              bool is_tls) const -> std::optional<std::string>
+configuration::node::endpoint(const std::string& network, service_type type, bool is_tls) const
+  -> std::optional<std::string>
 {
   auto p = port_or(type, is_tls, 0);
   if (p == 0) {
@@ -234,8 +231,8 @@ configuration::index_for_this_node() const -> std::size_t
 }
 
 auto
-configuration::server_by_vbucket(std::uint16_t vbucket,
-                                 std::size_t index) const -> std::optional<std::size_t>
+configuration::server_by_vbucket(std::uint16_t vbucket, std::size_t index) const
+  -> std::optional<std::size_t>
 {
   if (!vbmap.has_value() || vbucket >= vbmap->size()) {
     return {};

data/ext/couchbase/core/topology/configuration.hxx

@@ -61,6 +61,8 @@ struct configuration {
     port_map services_tls{};
     std::map<std::string, alternate_address> alt{};
     std::string server_group{};
+    std::optional<std::string> app_telemetry_path{};
+    std::string node_uuid{};
 
     auto operator!=(const node& other) const -> bool
     {
@@ -69,9 +71,8 @@ struct configuration {
              services_tls.key_value != other.services_tls.key_value;
     }
 
-    [[nodiscard]] auto port_or(service_type type,
-                               bool is_tls,
-                               std::uint16_t default_value) const -> std::uint16_t;
+    [[nodiscard]] auto port_or(service_type type, bool is_tls, std::uint16_t default_value) const
+      -> std::uint16_t;
 
     [[nodiscard]] auto port_or(const std::string& network,
                                service_type type,
@@ -80,9 +81,8 @@ struct configuration {
 
     [[nodiscard]] auto hostname_for(const std::string& network) const -> const std::string&;
 
-    [[nodiscard]] auto endpoint(const std::string& network,
-                                service_type type,
-                                bool is_tls) const -> std::optional<std::string>;
+    [[nodiscard]] auto endpoint(const std::string& network, service_type type, bool is_tls) const
+      -> std::optional<std::string>;
   };
 
   [[nodiscard]] auto select_network(const std::string& bootstrap_hostname) const -> std::string;
@@ -128,13 +128,13 @@ struct configuration {
                               const std::string& hostname,
                               const std::string& port) const -> bool;
 
-  auto map_key(const std::string& key,
-               std::size_t index) const -> std::pair<std::uint16_t, std::optional<std::size_t>>;
-  auto map_key(const std::vector<std::byte>& key,
-               std::size_t index) const -> std::pair<std::uint16_t, std::optional<std::size_t>>;
+  auto map_key(const std::string& key, std::size_t index) const
+    -> std::pair<std::uint16_t, std::optional<std::size_t>>;
+  auto map_key(const std::vector<std::byte>& key, std::size_t index) const
+    -> std::pair<std::uint16_t, std::optional<std::size_t>>;
 
-  auto server_by_vbucket(std::uint16_t vbucket,
-                         std::size_t index) const -> std::optional<std::size_t>;
+  auto server_by_vbucket(std::uint16_t vbucket, std::size_t index) const
+    -> std::optional<std::size_t>;
 };
 
 using endpoint = std::pair<std::string, std::string>;
@@ -145,7 +145,6 @@ make_blank_configuration(const std::string& hostname,
                          std::uint16_t tls_port) -> configuration;
 
 auto
-make_blank_configuration(const std::vector<endpoint>& endpoints,
-                         bool use_tls,
-                         bool force = false) -> configuration;
+make_blank_configuration(const std::vector<endpoint>& endpoints, bool use_tls, bool force = false)
+  -> configuration;
 } // namespace couchbase::core::topology

data/ext/couchbase/core/topology/configuration_json.hxx

@@ -61,6 +61,12 @@ struct traits<couchbase::core::topology::configuration> {
         if (const auto& group = o.find("serverGroup"); group != o.end()) {
           n.server_group = group->second.get_string();
         }
+        if (const auto& path = o.find("appTelemetryPath"); path != o.end()) {
+          n.app_telemetry_path = path->second.get_string();
+        }
+        if (const auto& uuid = o.find("nodeUUID"); uuid != o.end()) {
+          n.node_uuid = uuid->second.get_string();
+        }
         const auto& s = o.at("services");
         n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
         n.services_plain.management = s.template optional<std::uint16_t>("mgmt");