couchbase 4.2.5 → 4.2.6-dev.1

package/deps/couchbase-cxx-client/core/impl/watch_query_indexes.cxx

@@ -24,16 +24,6 @@
 
 namespace couchbase::core::impl
 {
-
-template<typename Response>
-static manager_error_context
-build_context(Response& resp, std::optional<std::error_code> ec = {})
-{
-    return { ec ? ec.value() : resp.ctx.ec, resp.ctx.last_dispatched_to,       resp.ctx.last_dispatched_from,
-             resp.ctx.retry_attempts,       std::move(resp.ctx.retry_reasons), std::move(resp.ctx.client_context_id),
-             resp.ctx.http_status,          std::move(resp.ctx.http_body),     std::move(resp.ctx.path) };
-}
-
 class watch_context : public std::enable_shared_from_this<watch_context>
 {
 
@@ -50,9 +40,18 @@ class watch_context : public std::enable_shared_from_this<watch_context>
     std::chrono::milliseconds timeout_{ options_.timeout.value_or(core_->origin().second.options().query_timeout) };
     std::atomic<size_t> attempts_{ 0 };
 
-    void finish(manager_error_context error_ctx)
+    template<typename Response>
+    void finish(Response& resp, std::optional<std::error_code> ec = {})
     {
-        handler_(error_ctx);
+        handler_({ manager_error_context(internal_manager_error_context{ ec ? ec.value() : resp.ctx.ec,
+                                                                         resp.ctx.last_dispatched_to,
+                                                                         resp.ctx.last_dispatched_from,
+                                                                         resp.ctx.retry_attempts,
+                                                                         std::move(resp.ctx.retry_reasons),
+                                                                         std::move(resp.ctx.client_context_id),
+                                                                         resp.ctx.http_status,
+                                                                         std::move(resp.ctx.http_body),
+                                                                         std::move(resp.ctx.path) }) });
         timer_.cancel();
     }
     std::chrono::milliseconds remaining()
@@ -79,9 +78,9 @@ class watch_context : public std::enable_shared_from_this<watch_context>
             complete &= it != resp.indexes.end() && it->state == "online";
         }
         if (complete || resp.ctx.ec == couchbase::errc::common::ambiguous_timeout) {
-            finish(build_context(resp));
+            finish(resp);
         } else if (remaining().count() <= 0) {
-            finish(build_context(resp, couchbase::errc::common::ambiguous_timeout));
+            finish(resp, couchbase::errc::common::ambiguous_timeout);
             complete = true;
         }
         return complete;
@@ -141,28 +140,53 @@ class watch_context : public std::enable_shared_from_this<watch_context>
         core_->execute(req, resp_fn);
     }
 };
+} // namespace couchbase::core::impl
 
+namespace couchbase
+{
 void
-initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::vector<std::string> index_names,
-                             couchbase::watch_query_indexes_options::built options,
-                             query_context query_ctx,
-                             std::string collection_name,
-                             watch_query_indexes_handler&& handler)
+query_index_manager::watch_indexes(std::string bucket_name,
+                                   std::vector<std::string> index_names,
+                                   const couchbase::watch_query_indexes_options& options,
+                                   couchbase::watch_query_indexes_handler&& handler)
 {
-    auto ctx = std::make_shared<watch_context>(core, bucket_name, index_names, options, query_ctx, collection_name, std::move(handler));
+    auto ctx = std::make_shared<couchbase::core::impl::watch_context>(
+      core_, std::move(bucket_name), std::move(index_names), options.build(), core::query_context{}, "", std::move(handler));
     ctx->execute();
 }
 
+auto
+query_index_manager::watch_indexes(std::string bucket_name,
+                                   std::vector<std::string> index_names,
+                                   const couchbase::watch_query_indexes_options& options) -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    watch_indexes(
+      std::move(bucket_name), std::move(index_names), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
 void
-initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::vector<std::string> index_names,
-                             couchbase::watch_query_indexes_options::built options,
-                             watch_query_indexes_handler&& handler)
+collection_query_index_manager::watch_indexes(std::vector<std::string> index_names,
+                                              const watch_query_indexes_options& options,
+                                              watch_query_indexes_handler&& handler) const
 {
-    initiate_watch_query_indexes(core, std::move(bucket_name), std::move(index_names), options, {}, "", std::move(handler));
+    auto ctx = std::make_shared<couchbase::core::impl::watch_context>(core_,
+                                                                      bucket_name_,
+                                                                      std::move(index_names),
+                                                                      options.build(),
+                                                                      core::query_context(bucket_name_, scope_name_),
+                                                                      collection_name_,
+                                                                      std::move(handler));
+    ctx->execute();
 }
 
-} // namespace couchbase::core::impl
+auto
+collection_query_index_manager::watch_indexes(std::vector<std::string> index_names, const couchbase::watch_query_indexes_options& options)
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    watch_indexes(std::move(index_names), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/io/dns_client.cxx

@@ -28,6 +28,10 @@
 #include <asio/read.hpp>
 #include <asio/write.hpp>
 
+#include <fmt/chrono.h>
+
+#include <spdlog/fmt/bin_to_hex.h>
+
 #include <memory>
 #include <sstream>
 
@@ -68,13 +72,22 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
 
     void execute(std::chrono::milliseconds total_timeout, std::chrono::milliseconds udp_timeout)
     {
+        CB_LOG_TRACE("Query DNS-SRV (UDP) address=\"{}:{}\", udp_timeout={}, total_timeout={}{:a}",
+                     address_.to_string(),
+                     port_,
+                     udp_timeout,
+                     total_timeout,
+                     spdlog::to_hex(send_buf_));
         asio::ip::udp::endpoint endpoint(address_, port_);
         udp_.open(endpoint.protocol());
         udp_.async_send_to(
           asio::buffer(send_buf_), endpoint, [self = shared_from_this()](std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
               if (ec1) {
                   self->udp_deadline_.cancel();
-                  CB_LOG_DEBUG("DNS UDP write operation has got error {}, retrying with TCP", ec1.message());
+                  CB_LOG_DEBUG("DNS UDP write operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
+                               self->address_.to_string(),
+                               self->port_,
+                               ec1.message());
                   return self->retry_with_tcp();
               }
 
@@ -83,7 +96,10 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
                 asio::buffer(self->recv_buf_), self->udp_sender_, [self](std::error_code ec2, std::size_t bytes_transferred) mutable {
                     self->udp_deadline_.cancel();
                     if (ec2) {
-                        CB_LOG_DEBUG("DNS UDP read operation has got error {}, retrying with TCP", ec2.message());
+                        CB_LOG_DEBUG("DNS UDP read operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
+                                     self->address_.to_string(),
+                                     self->port_,
+                                     ec2.message());
                         return self->retry_with_tcp();
                     }
                     self->recv_buf_.resize(bytes_transferred);
@@ -104,11 +120,13 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
                 });
           });
         udp_deadline_.expires_after(udp_timeout);
-        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+        udp_deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
             if (ec == asio::error::operation_aborted) {
                 return;
             }
-            CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to TCP");
+            CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to TCP, address=\"{}:{}\"",
+                         self->address_.to_string(),
+                         self->port_);
             self->udp_.cancel();
             return self->retry_with_tcp();
         });
@@ -118,7 +136,10 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
             if (ec == asio::error::operation_aborted) {
                 return;
             }
-            CB_LOG_DEBUG("DNS deadline has been reached, cancelling in-flight operations (tcp.is_open={})", self->tcp_.is_open());
+            CB_LOG_DEBUG("DNS deadline has been reached, cancelling in-flight operations (tcp.is_open={}, address=\"{}:{}\")",
+                         self->tcp_.is_open(),
+                         self->address_.to_string(),
+                         self->port_);
             self->udp_.cancel();
             if (self->tcp_.is_open()) {
                 self->tcp_.cancel();
@@ -140,53 +161,65 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
         tcp_.async_connect(endpoint, [self = shared_from_this()](std::error_code ec1) mutable {
             if (ec1) {
                 self->deadline_.cancel();
-                CB_LOG_DEBUG("DNS TCP connection has been aborted, {}", ec1.message());
+                CB_LOG_DEBUG(
+                  "DNS TCP connection has been aborted, address=\"{}:{}\", ec={}", self->address_.to_string(), self->port_, ec1.message());
                 return self->handler_({ ec1 });
             }
             auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
             self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size & 0xffU));
             self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size >> 8U));
+            CB_LOG_TRACE(
+              "Query DNS-SRV (TCP) address=\"{}:{}\"{:a}", self->address_.to_string(), self->port_, spdlog::to_hex(self->send_buf_));
             asio::async_write(
               self->tcp_, asio::buffer(self->send_buf_), [self](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
                   if (ec2) {
-                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, {}", ec2.message());
+                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, address=\"{}:{}\", ec={}",
+                                   self->address_.to_string(),
+                                   self->port_,
+                                   ec2.message());
                       self->deadline_.cancel();
                       if (ec2 == asio::error::operation_aborted) {
                           ec2 = errc::common::unambiguous_timeout;
                       }
                       return self->handler_({ ec2 });
                   }
-                  asio::async_read(self->tcp_,
-                                   asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
-                                   [self](std::error_code ec3, std::size_t /* bytes_transferred */) mutable {
-                                       if (ec3) {
-                                           CB_LOG_DEBUG("DNS TCP buf size read operation has been aborted, {}", ec3.message());
-                                           self->deadline_.cancel();
-                                           return self->handler_({ ec3 });
-                                       }
-                                       self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
-                                       self->recv_buf_.resize(self->recv_buf_size_);
-                                       CB_LOG_DEBUG("DNS TCP schedule read of {} bytes", self->recv_buf_size_);
-                                       asio::async_read(self->tcp_,
-                                                        asio::buffer(self->recv_buf_),
-                                                        [self](std::error_code ec4, std::size_t bytes_transferred) mutable {
-                                                            self->deadline_.cancel();
-                                                            if (ec4) {
-                                                                CB_LOG_DEBUG("DNS TCP read operation has been aborted, {}", ec4.message());
-                                                                return self->handler_({ ec4 });
-                                                            }
-                                                            self->recv_buf_.resize(bytes_transferred);
-                                                            const dns_message message = dns_codec::decode(self->recv_buf_);
-                                                            dns_srv_response resp{ ec4 };
-                                                            resp.targets.reserve(message.answers.size());
-                                                            for (const auto& answer : message.answers) {
-                                                                resp.targets.emplace_back(dns_srv_response::address{
-                                                                  utils::join_strings(answer.target.labels, "."), answer.port });
-                                                            }
-                                                            CB_LOG_DEBUG("DNS TCP returned {} records", resp.targets.size());
-                                                            return self->handler_(std::move(resp));
-                                                        });
-                                   });
+                  asio::async_read(
+                    self->tcp_,
+                    asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
+                    [self](std::error_code ec3, std::size_t /* bytes_transferred */) mutable {
+                        if (ec3) {
+                            CB_LOG_DEBUG("DNS TCP buf size read operation has been aborted, address=\"{}:{}\", ec={}",
+                                         self->address_.to_string(),
+                                         self->port_,
+                                         ec3.message());
+                            self->deadline_.cancel();
+                            return self->handler_({ ec3 });
+                        }
+                        self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
+                        self->recv_buf_.resize(self->recv_buf_size_);
+                        CB_LOG_DEBUG("DNS TCP schedule read of {} bytes", self->recv_buf_size_);
+                        asio::async_read(
+                          self->tcp_, asio::buffer(self->recv_buf_), [self](std::error_code ec4, std::size_t bytes_transferred) mutable {
+                              self->deadline_.cancel();
+                              if (ec4) {
+                                  CB_LOG_DEBUG("DNS TCP read operation has been aborted, address=\"{}:{}\", ec={}",
+                                               self->address_.to_string(),
+                                               self->port_,
+                                               ec4.message());
+                                  return self->handler_({ ec4 });
+                              }
+                              self->recv_buf_.resize(bytes_transferred);
+                              const dns_message message = dns_codec::decode(self->recv_buf_);
+                              dns_srv_response resp{ ec4 };
+                              resp.targets.reserve(message.answers.size());
+                              for (const auto& answer : message.answers) {
+                                  resp.targets.emplace_back(
+                                    dns_srv_response::address{ utils::join_strings(answer.target.labels, "."), answer.port });
+                              }
+                              CB_LOG_DEBUG("DNS TCP returned {} records", resp.targets.size());
+                              return self->handler_(std::move(resp));
+                          });
+                    });
               });
         });
     }

package/deps/couchbase-cxx-client/core/io/dns_config.cxx

@@ -87,7 +87,7 @@ load_resolv_conf()
 
     if (dns_servers.size() > 0) {
         CB_LOG_DEBUG(
-          "Found DNS Servers: [{}], using nameserver: {}", couchbase::core::utils::join_strings(dns_servers, ", "), dns_servers[0]);
+          "Found DNS Servers: [{}], selected nameserver: \"{}\"", couchbase::core::utils::join_strings(dns_servers, ", "), dns_servers[0]);
         return dns_servers[0];
     }
     CB_LOG_WARNING("Unable to find DNS nameserver");
@@ -118,13 +118,13 @@ load_resolv_conf(const char* conf_path)
             if (space == std::string::npos || space == offset || line.size() < space + 2) {
                 continue;
             }
-            if (std::string keyword = line.substr(offset, space); keyword != "nameserver") {
+            if (const auto keyword = line.substr(offset, space); keyword != "nameserver") {
                 continue;
             }
             offset = space + 1;
             space = line.find(' ', offset);
-            auto nameserver = line.substr(offset, space);
-            CB_LOG_DEBUG("Using nameserver: {}", nameserver);
+            auto nameserver = (space == std::string::npos) ? line.substr(offset) : line.substr(offset, space - offset);
+            CB_LOG_DEBUG("Selected nameserver: \"{}\" from \"{}\"", nameserver, conf_path);
             return nameserver;
         }
     }
@@ -147,6 +147,7 @@ dns_config::system_config()
         std::error_code ec;
         asio::ip::address::from_string(nameserver, ec);
         if (ec) {
+            CB_LOG_DEBUG("Unable to parse \"{}\" as a network address, fall back to \"{}\"", nameserver, default_nameserver);
             nameserver = default_nameserver;
         }
         instance.nameserver_ = nameserver;

package/deps/couchbase-cxx-client/core/io/mcbp_session.cxx

@@ -1279,16 +1279,15 @@ class mcbp_session_impl
         }
         last_active_ = std::chrono::steady_clock::now();
         if (it != endpoints_.end()) {
-            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
-                         log_prefix_,
-                         it->endpoint().address().to_string(),
-                         it->endpoint().port(),
-                         origin_.options().connect_timeout.count());
+            auto hostname = it->endpoint().address().to_string();
+            auto port = it->endpoint().port();
+            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms", log_prefix_, hostname, port, origin_.options().connect_timeout.count());
             connection_deadline_.expires_after(origin_.options().connect_timeout);
-            connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+            connection_deadline_.async_wait([self = shared_from_this(), hostname, port](const auto timer_ec) {
                 if (timer_ec == asio::error::operation_aborted || self->stopped_) {
                     return;
                 }
+                CB_LOG_DEBUG("{} unable to connect to {}:{} in time, reconnecting", self->log_prefix_, hostname, port);
                 return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
             });
             stream_->async_connect(it->endpoint(),

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -29,3 +29,9 @@
  * couchbase::core::meta::sdk_version() function is available
  */
 #define COUCHBASE_CXX_CLIENT_HAS_SDK_SEMVER 1
+
+/**
+ * couchbase::core::cluster_options and couchbase::security_options support
+ * passing TLS trust certificate by value
+ */
+#define COUCHBASE_CXX_CLIENT_CAN_PASS_TLS_TRUST_CERTIFICATE_BY_VALUE 1

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

@@ -85,6 +85,17 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
         case couchbase::query_profile::off:
             break;
     }
+    if (use_replica.has_value()) {
+        if (context.config.supports_read_from_replica()) {
+            if (use_replica.value()) {
+                body["use_replica"] = "on";
+            } else {
+                body["use_replica"] = "off";
+            }
+        } else {
+            return errc::common::feature_not_available;
+        }
+    }
     if (max_parallelism) {
         body["max_parallelism"] = std::to_string(max_parallelism.value());
     }

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

@@ -91,6 +91,7 @@ struct query_request {
     bool flex_index{ false };
     bool preserve_expiry{ false };
 
+    std::optional<bool> use_replica{};
     std::optional<std::uint64_t> max_parallelism{};
     std::optional<std::uint64_t> scan_cap{};
     std::optional<std::chrono::milliseconds> scan_wait{};

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

@@ -0,0 +1,270 @@
+/* -*- 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.
+ */
+
+#include "origin.hxx"
+
+#include <fmt/chrono.h>
+#include <fmt/format.h>
+
+#include <tao/json.hpp>
+
+namespace tao::json
+{
+
+template<>
+struct traits<std::chrono::milliseconds> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const std::chrono::milliseconds& o)
+    {
+        v = fmt::format("{}", o);
+    }
+};
+
+template<>
+struct traits<std::chrono::nanoseconds> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const std::chrono::nanoseconds& o)
+    {
+        v = fmt::format("{}", o);
+    }
+};
+
+template<>
+struct traits<couchbase::core::tls_verify_mode> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::core::tls_verify_mode& o)
+    {
+        switch (o) {
+            case couchbase::core::tls_verify_mode::none:
+                v = "none";
+                break;
+            case couchbase::core::tls_verify_mode::peer:
+                v = "peer";
+                break;
+        }
+    }
+};
+
+template<>
+struct traits<couchbase::core::io::ip_protocol> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::core::io::ip_protocol& o)
+    {
+        switch (o) {
+            case couchbase::core::io::ip_protocol::any:
+                v = "any";
+                break;
+            case couchbase::core::io::ip_protocol::force_ipv4:
+                v = "force_ipv4";
+                break;
+            case couchbase::core::io::ip_protocol::force_ipv6:
+                v = "force_ipv6";
+                break;
+        }
+    }
+};
+
+template<>
+struct traits<couchbase::core::io::dns::dns_config> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::core::io::dns::dns_config& o)
+    {
+        v = {
+            { "port", o.port() },
+            { "nameserver", o.nameserver() },
+            { "timeout", o.timeout() },
+        };
+    }
+};
+
+template<>
+struct traits<couchbase::core::tracing::threshold_logging_options> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::core::tracing::threshold_logging_options& o)
+    {
+        v = {
+            { "orphaned_emit_interval", o.orphaned_emit_interval },
+            { "orphaned_sample_size", o.orphaned_sample_size },
+            { "threshold_emit_interval", o.threshold_emit_interval },
+            { "threshold_sample_size", o.threshold_sample_size },
+            { "key_value_threshold", o.key_value_threshold },
+            { "query_threshold", o.query_threshold },
+            { "view_threshold", o.view_threshold },
+            { "search_threshold", o.search_threshold },
+            { "analytics_threshold", o.analytics_threshold },
+            { "management_threshold", o.management_threshold },
+        };
+    }
+};
+
+template<>
+struct traits<couchbase::core::metrics::logging_meter_options> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::core::metrics::logging_meter_options& o)
+    {
+        v = {
+            { "emit_interval", o.emit_interval },
+        };
+    }
+};
+
+template<>
+struct traits<couchbase::durability_level> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::durability_level& o)
+    {
+        switch (o) {
+            case couchbase::durability_level::none:
+                v = "none";
+                break;
+            case couchbase::durability_level::majority:
+                v = "majority";
+                break;
+            case couchbase::durability_level::majority_and_persist_to_active:
+                v = "majority_and_persist_to_active";
+                break;
+            case couchbase::durability_level::persist_to_majority:
+                v = "persist_to_majority";
+                break;
+        }
+    }
+};
+
+template<>
+struct traits<couchbase::query_scan_consistency> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::query_scan_consistency& o)
+    {
+        switch (o) {
+            case couchbase::query_scan_consistency::not_bounded:
+                v = "not_bounded";
+                break;
+            case couchbase::query_scan_consistency::request_plus:
+                v = "request_plus";
+                break;
+        }
+    }
+};
+
+template<>
+struct traits<couchbase::transactions::transactions_config::built> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const couchbase::transactions::transactions_config::built& o)
+    {
+        v = {
+            { "expiration_time", o.expiration_time },
+            { "durability_level", o.level },
+            {
+              "query_config",
+              {
+                { "scan_consistency", o.query_config.scan_consistency },
+              },
+            },
+            {
+              "cleanup_config",
+              {
+                { "cleanup_lost_attempts", o.cleanup_config.cleanup_lost_attempts },
+                { "cleanup_client_attempts", o.cleanup_config.cleanup_client_attempts },
+                { "cleanup_window", o.cleanup_config.cleanup_window },
+                { "collections", tao::json::empty_array },
+              },
+            },
+        };
+        if (const auto& p = o.kv_timeout; p.has_value()) {
+            v["key_value_timeout"] = p.value();
+        }
+        if (const auto& p = o.metadata_collection; p.has_value()) {
+            v["metadata_collection"] = {
+                { "bucket", p.value().bucket },
+                { "scope", p.value().scope },
+                { "collection", p.value().collection },
+            };
+        }
+        for (const auto& c : o.cleanup_config.collections) {
+            v["cleanup_config"]["collections"].emplace_back(tao::json::value{
+              { "bucket", c.bucket },
+              { "scope", c.scope },
+              { "collection", c.collection },
+            });
+        }
+    }
+};
+
+} // namespace tao::json
+
+namespace couchbase::core
+{
+auto
+origin::to_json() const -> std::string
+{
+    tao::json::value json = {
+        {
+          "options",
+          {
+            { "bootstrap_timeout", options_.bootstrap_timeout },
+            { "resolve_timeout", options_.resolve_timeout },
+            { "connect_timeout", options_.connect_timeout },
+            { "key_value_timeout", options_.key_value_timeout },
+            { "key_value_durable_timeout", options_.key_value_durable_timeout },
+            { "view_timeout", options_.view_timeout },
+            { "query_timeout", options_.query_timeout },
+            { "analytics_timeout", options_.analytics_timeout },
+            { "search_timeout", options_.search_timeout },
+            { "management_timeout", options_.management_timeout },
+            { "enable_tls", options_.enable_tls },
+            { "trust_certificate", options_.trust_certificate },
+            { "enable_mutation_tokens", options_.enable_mutation_tokens },
+            { "enable_tcp_keep_alive", options_.enable_tcp_keep_alive },
+            { "use_ip_protocol", options_.use_ip_protocol },
+            { "enable_dns_srv", options_.enable_dns_srv },
+            { "dns_config", options_.dns_config },
+            { "show_queries", options_.show_queries },
+            { "enable_unordered_execution", options_.enable_unordered_execution },
+            { "enable_clustermap_notification", options_.enable_clustermap_notification },
+            { "enable_compression", options_.enable_compression },
+            { "enable_tracing", options_.enable_tracing },
+            { "enable_metrics", options_.enable_metrics },
+            { "tcp_keep_alive_interval", options_.tcp_keep_alive_interval },
+            { "config_poll_interval", options_.config_poll_interval },
+            { "config_poll_floor", options_.config_poll_floor },
+            { "config_idle_redial_timeout", options_.config_idle_redial_timeout },
+            { "max_http_connections", options_.max_http_connections },
+            { "idle_http_connection_timeout", options_.idle_http_connection_timeout },
+            { "user_agent_extra", options_.user_agent_extra },
+            { "dump_configuration", options_.dump_configuration },
+            { "disable_mozilla_ca_certificates", options_.disable_mozilla_ca_certificates },
+            { "metrics_options", options_.metrics_options },
+            { "network", options_.network },
+            { "tls_verify", options_.tls_verify },
+            { "tracing_options", options_.tracing_options },
+            { "transactions_options", options_.transactions },
+          },
+        },
+    };
+    {
+        tao::json::value nodes = tao::json::empty_array;
+        for (const auto& [hostname, port] : nodes_) {
+            nodes.emplace_back(tao::json::value{
+              { "hostname", hostname },
+              { "port", port },
+            });
+        }
+        json["bootstrap_nodes"] = nodes;
+    }
+    return tao::json::to_string(json);
+}
+} // namespace couchbase::core