couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/cmake/tarball_glob.txt

@@ -0,0 +1,91 @@
+asio/*/LICENSE*
+asio/*/asio/COPYING
+asio/*/asio/asio/include/*.hpp
+asio/*/asio/asio/include/asio/**/*.[hi]pp
+asio/*/asio/asio/include/asio/*.[hi]pp
+asio/*/asio/src/*.cpp
+boringssl/*/boringssl/**/*.S
+boringssl/*/boringssl/**/*.asm
+boringssl/*/boringssl/**/*.c
+boringssl/*/boringssl/**/*.cc
+boringssl/*/boringssl/**/*.h
+boringssl/*/boringssl/**/CMakeLists.txt
+boringssl/*/boringssl/*.S
+boringssl/*/boringssl/*.asm
+boringssl/*/boringssl/*.c
+boringssl/*/boringssl/*.cc
+boringssl/*/boringssl/*.h
+boringssl/*/boringssl/CMakeLists.txt
+boringssl/*/boringssl/LICENSE
+cli11/*/cli11/CMakeLists.txt
+cli11/*/cli11/LICENSE
+cli11/*/cli11/cmake/*
+cli11/*/cli11/fuzz/CMakeLists.txt
+cli11/*/cli11/include/*
+cli11/*/cli11/include/**/*
+cli11/*/cli11/src/*
+cli11/*/cli11/src/**/*
+cpm/*.cmake
+fmt/*/fmt/CMakeLists.txt
+fmt/*/fmt/ChangeLog.md
+fmt/*/fmt/LICENSE
+fmt/*/fmt/README.md
+fmt/*/fmt/include/*
+fmt/*/fmt/include/**/*
+fmt/*/fmt/src/*
+fmt/*/fmt/src/**/*
+fmt/*/fmt/support/cmake/*
+fmt/*/fmt/support/cmake/**/*
+gsl/*/gsl/CMakeLists.txt
+gsl/*/gsl/GSL.natvis
+gsl/*/gsl/LICENSE*
+gsl/*/gsl/ThirdPartyNotices.txt
+gsl/*/gsl/cmake/*
+gsl/*/gsl/include/*
+gsl/*/gsl/include/**/*
+hdr_histogram/*/hdr_histogram/*.pc.in
+hdr_histogram/*/hdr_histogram/CMakeLists.txt
+hdr_histogram/*/hdr_histogram/COPYING.txt
+hdr_histogram/*/hdr_histogram/LICENSE.txt
+hdr_histogram/*/hdr_histogram/cmake/*
+hdr_histogram/*/hdr_histogram/config.cmake.in
+hdr_histogram/*/hdr_histogram/include/*
+hdr_histogram/*/hdr_histogram/include/**/*
+hdr_histogram/*/hdr_histogram/src/*
+hdr_histogram/*/hdr_histogram/src/**/*
+json/*/json/.cmake/taocpp-json-config.cmake.in
+json/*/json/CMakeLists.txt
+json/*/json/LICENSE*
+json/*/json/external/PEGTL/.cmake/*
+json/*/json/external/PEGTL/CMakeLists.txt
+json/*/json/external/PEGTL/LICENSE*
+json/*/json/external/PEGTL/include/*
+json/*/json/external/PEGTL/include/**/*
+json/*/json/include/*
+json/*/json/include/**/*
+llhttp/*/llhttp/*.pc.in
+llhttp/*/llhttp/CMakeLists.txt
+llhttp/*/llhttp/LICENSE*
+llhttp/*/llhttp/include/*.h
+llhttp/*/llhttp/src/*.c
+mozilla-ca-bundle.*
+snappy/*/snappy/CMakeLists.txt
+snappy/*/snappy/COPYING
+snappy/*/snappy/cmake/*
+snappy/*/snappy/snappy-c.cc
+snappy/*/snappy/snappy-c.h
+snappy/*/snappy/snappy-internal.h
+snappy/*/snappy/snappy-sinksource.cc
+snappy/*/snappy/snappy-sinksource.h
+snappy/*/snappy/snappy-stubs-internal.cc
+snappy/*/snappy/snappy-stubs-internal.h
+snappy/*/snappy/snappy-stubs-public.h.in
+snappy/*/snappy/snappy.cc
+snappy/*/snappy/snappy.h
+spdlog/*/spdlog/CMakeLists.txt
+spdlog/*/spdlog/LICENSE
+spdlog/*/spdlog/cmake/*
+spdlog/*/spdlog/include/*
+spdlog/*/spdlog/include/**/*
+spdlog/*/spdlog/src/*
+spdlog/*/spdlog/src/**/*

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

@@ -132,7 +132,11 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>
+#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+#endif
   {
     return cluster_agent_.free_form_http_request(request, std::move(callback));
   }
@@ -221,7 +225,11 @@ agent_group::search_query(const search_query_options& options, search_query_call
 auto
 agent_group::free_form_http_request(const http_request& request,
                                     free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  -> tl::expected<std::shared_ptr<pending_operation>, error_union>
+#else
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+#endif
 {
   return impl_->free_form_http_request(request, std::move(callback));
 }

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

@@ -70,7 +70,11 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>;
+#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
+#endif
 
   auto wait_until_ready(std::chrono::milliseconds timeout,
                         const wait_until_ready_options& options,

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

@@ -25,11 +25,13 @@
 #include "core/io/mcbp_message.hxx"
 #include "core/logger/logger.hxx"
 #include "core/mcbp/codec.hxx"
+#include "core/metrics/meter_wrapper.hxx"
 #include "core/protocol/client_opcode.hxx"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/hello_feature.hxx"
 #include "core/response_handler.hxx"
 #include "core/service_type.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "core/utils/movable_function.hxx"
 #include "dispatcher.hxx"
 #include "impl/bootstrap_state_listener.hxx"
@@ -42,10 +44,8 @@
 #include "retry_orchestrator.hxx"
 
 #include <couchbase/error_codes.hxx>
-#include <couchbase/metrics/meter.hxx>
 #include <couchbase/retry_reason.hxx>
 #include <couchbase/retry_strategy.hxx>
-#include <couchbase/tracing/request_tracer.hxx>
 
 #include <asio/bind_executor.hpp>
 #include <asio/error.hpp>
@@ -82,8 +82,8 @@ public:
   bucket_impl(std::string client_id,
               std::string name,
               couchbase::core::origin origin,
-              std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-              std::shared_ptr<couchbase::metrics::meter> meter,
+              std::shared_ptr<tracing::tracer_wrapper> tracer,
+              std::shared_ptr<metrics::meter_wrapper> meter,
               std::vector<protocol::hello_feature> known_features,
               std::shared_ptr<impl::bootstrap_state_listener> state_listener,
               asio::io_context& ctx,
@@ -114,15 +114,11 @@ public:
                         std::optional<key_value_error_map_info> error_info)
   {
     // TODO(SA): copy from mcbp_command, subject to refactor later
-    static const std::string meter_name = "db.couchbase.operations";
-    static const std::map<std::string, std::string> tags = {
-      { "db.couchbase.service", "kv" },
-      { "db.operation", fmt::format("{}", req->command_) },
+    metrics::metric_attributes attrs{
+      service_type::key_value, fmt::format("{}", req->command_), ec, name_, req->scope_name_,
+      req->collection_name_,
     };
-    meter_->get_value_recorder(meter_name, tags)
-      ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                       std::chrono::steady_clock::now() - req->dispatched_time_)
-                       .count());
+    meter_->record_value(std::move(attrs), req->dispatched_time_);
 
     if (ec == asio::error::operation_aborted) {
       // TODO(SA): fix tracing
@@ -894,12 +890,12 @@ public:
     return configured_;
   }
 
-  [[nodiscard]] auto tracer() const -> std::shared_ptr<couchbase::tracing::request_tracer>
+  [[nodiscard]] auto tracer() const -> std::shared_ptr<tracing::tracer_wrapper>
   {
     return tracer_;
   }
 
-  [[nodiscard]] auto meter() const -> std::shared_ptr<couchbase::metrics::meter>
+  [[nodiscard]] auto meter() const -> std::shared_ptr<metrics::meter_wrapper>
   {
     return meter_;
   }
@@ -952,8 +948,8 @@ private:
   const std::string name_;
   const std::string log_prefix_;
   const origin origin_;
-  const std::shared_ptr<couchbase::tracing::request_tracer> tracer_;
-  const std::shared_ptr<couchbase::metrics::meter> meter_;
+  const std::shared_ptr<tracing::tracer_wrapper> tracer_;
+  const std::shared_ptr<metrics::meter_wrapper> meter_;
   const std::vector<protocol::hello_feature> known_features_;
   const std::shared_ptr<impl::bootstrap_state_listener> state_listener_;
   mcbp::codec codec_;
@@ -985,8 +981,8 @@ private:
 bucket::bucket(std::string client_id,
                asio::io_context& ctx,
                asio::ssl::context& tls,
-               std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-               std::shared_ptr<couchbase::metrics::meter> meter,
+               std::shared_ptr<tracing::tracer_wrapper> tracer,
+               std::shared_ptr<metrics::meter_wrapper> meter,
                std::string name,
                couchbase::core::origin origin,
                std::vector<protocol::hello_feature> known_features,
@@ -1054,13 +1050,13 @@ bucket::log_prefix() const -> const std::string&
 }
 
 auto
-bucket::tracer() const -> std::shared_ptr<couchbase::tracing::request_tracer>
+bucket::tracer() const -> std::shared_ptr<tracing::tracer_wrapper>
 {
   return impl_->tracer();
 }
 
 auto
-bucket::meter() const -> std::shared_ptr<couchbase::metrics::meter>
+bucket::meter() const -> std::shared_ptr<metrics::meter_wrapper>
 {
   return impl_->meter();
 }

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

@@ -33,14 +33,6 @@
 
 namespace couchbase
 {
-namespace metrics
-{
-class meter;
-} // namespace metrics
-namespace tracing
-{
-class request_tracer;
-} // namespace tracing
 namespace core
 {
 namespace mcbp
@@ -52,6 +44,14 @@ namespace diag
 class ping_collector;
 struct diagnostics_result;
 } // namespace diag
+namespace tracing
+{
+class tracer_wrapper;
+} // namespace tracing
+namespace metrics
+{
+class meter_wrapper;
+} // namespace metrics
 namespace impl
 {
 class bootstrap_state_listener;
@@ -68,8 +68,8 @@ public:
   bucket(std::string client_id,
          asio::io_context& ctx,
          asio::ssl::context& tls,
-         std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-         std::shared_ptr<couchbase::metrics::meter> meter,
+         std::shared_ptr<tracing::tracer_wrapper> tracer,
+         std::shared_ptr<metrics::meter_wrapper> meter,
          std::string name,
          couchbase::core::origin origin,
          std::vector<protocol::hello_feature> known_features,
@@ -200,8 +200,8 @@ public:
 
   [[nodiscard]] auto name() const -> const std::string&;
   [[nodiscard]] auto log_prefix() const -> const std::string&;
-  [[nodiscard]] auto tracer() const -> std::shared_ptr<couchbase::tracing::request_tracer>;
-  [[nodiscard]] auto meter() const -> std::shared_ptr<couchbase::metrics::meter>;
+  [[nodiscard]] auto tracer() const -> std::shared_ptr<tracing::tracer_wrapper>;
+  [[nodiscard]] auto meter() const -> std::shared_ptr<metrics::meter_wrapper>;
   [[nodiscard]] auto default_retry_strategy() const -> std::shared_ptr<couchbase::retry_strategy>;
   [[nodiscard]] auto is_closed() const -> bool;
   [[nodiscard]] auto is_configured() const -> bool;

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

@@ -19,10 +19,6 @@
 
 #include "cluster.hxx"
 
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-#include "core/io/config_tracker.hxx"
-#endif
-
 #include "bucket.hxx"
 #include "capella_ca.hxx"
 #include "core/diagnostics.hxx"
@@ -33,6 +29,9 @@
 #include "core/io/http_message.hxx"
 #include "core/io/http_session_manager.hxx"
 #include "core/io/mcbp_session.hxx"
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+#include "core/io/config_tracker.hxx"
+#endif
 #include "core/logger/logger.hxx"
 #include "core/management/analytics_link_azure_blob_external.hxx"
 #include "core/management/analytics_link_couchbase_remote.hxx"
@@ -40,6 +39,7 @@
 #include "core/mcbp/queue_request.hxx"
 #include "core/meta/version.hxx"
 #include "core/metrics/logging_meter.hxx"
+#include "core/metrics/meter_wrapper.hxx"
 #include "core/metrics/noop_meter.hxx"
 #include "core/operations/document_analytics.hxx"
 #include "core/operations/document_append.hxx"
@@ -146,6 +146,7 @@
 #include "core/topology/capabilities.hxx"
 #include "core/tracing/noop_tracer.hxx"
 #include "core/tracing/threshold_logging_tracer.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "core/utils/join_strings.hxx"
 #include "core/utils/movable_function.hxx"
 #include "crud_component.hxx"
@@ -155,6 +156,7 @@
 #include "ping_collector.hxx"
 #include "ping_reporter.hxx"
 
+#include <couchbase/codec/tao_json_serializer.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/retry_reason.hxx>
 
@@ -352,30 +354,7 @@ public:
                  id_,
                  couchbase::core::meta::sdk_semver(),
                  origin_.to_json());
-    // ignore the enable_tracing flag if a tracer was passed in
-    if (nullptr != origin_.options().tracer) {
-      tracer_ = origin_.options().tracer;
-    } else {
-      if (origin_.options().enable_tracing) {
-        tracer_ = std::make_shared<tracing::threshold_logging_tracer>(
-          ctx_, origin_.options().tracing_options);
-      } else {
-        tracer_ = std::make_shared<tracing::noop_tracer>();
-      }
-    }
-    tracer_->start();
-    // ignore the metrics options if a meter was passed in.
-    if (nullptr != origin_.options().meter) {
-      meter_ = origin_.options().meter;
-    } else {
-      if (origin_.options().enable_metrics) {
-        meter_ = std::make_shared<metrics::logging_meter>(ctx_, origin_.options().metrics_options);
-      } else {
-        meter_ = std::make_shared<metrics::noop_meter>();
-      }
-    }
-    meter_->start();
-    session_manager_->set_tracer(tracer_);
+    setup_observability();
     if (origin_.options().enable_dns_srv) {
       std::string hostname;
       std::string port;
@@ -433,30 +412,7 @@ public:
                  id_,
                  couchbase::core::meta::sdk_semver(),
                  origin_.to_json());
-    // ignore the enable_tracing flag if a tracer was passed in
-    if (nullptr != origin_.options().tracer) {
-      tracer_ = origin_.options().tracer;
-    } else {
-      if (origin_.options().enable_tracing) {
-        tracer_ = std::make_shared<tracing::threshold_logging_tracer>(
-          ctx_, origin_.options().tracing_options);
-      } else {
-        tracer_ = std::make_shared<tracing::noop_tracer>();
-      }
-    }
-    tracer_->start();
-    // ignore the metrics options if a meter was passed in.
-    if (nullptr != origin_.options().meter) {
-      meter_ = origin_.options().meter;
-    } else {
-      if (origin_.options().enable_metrics) {
-        meter_ = std::make_shared<metrics::logging_meter>(ctx_, origin_.options().metrics_options);
-      } else {
-        meter_ = std::make_shared<metrics::noop_meter>();
-      }
-    }
-    meter_->start();
-    session_manager_->set_tracer(tracer_);
+    setup_observability();
     session_manager_->set_dispatch_timeout(origin_.options().dispatch_timeout);
     // at this point we will infinitely try to connect
     if (origin_.options().enable_dns_srv) {
@@ -493,6 +449,10 @@ public:
         b = std::make_shared<bucket>(
           id_, ctx_, tls_, tracer_, meter_, bucket_name, origin, known_features, dns_srv_tracker_);
         buckets_.try_emplace(bucket_name, b);
+
+        // Register the tracer & the meter for config updates to track Cluster name & UUID
+        b->on_configuration_update(tracer_);
+        b->on_configuration_update(meter_);
       }
     }
     if (b == nullptr) {
@@ -1092,7 +1052,7 @@ public:
             if (cluster->session_) {
               cluster->session_->ping(collector->build_reporter(), timeout);
             }
-            cluster->for_each_bucket([&collector, &timeout](auto bucket) {
+            cluster->for_each_bucket([&collector, &timeout](const auto& bucket) {
               bucket->ping(collector, timeout);
             });
           }
@@ -1145,7 +1105,7 @@ public:
         }
         self->retry_backoff_.cancel();
 #endif
-        self->for_each_bucket([](auto bucket) {
+        self->for_each_bucket([](const auto& bucket) {
           bucket->close();
         });
         self->session_manager_->close();
@@ -1221,6 +1181,38 @@ public:
   }
 
 private:
+  void setup_observability()
+  {
+    // ignore the enable_tracing flag if a tracer was passed in
+    if (nullptr != origin_.options().tracer) {
+      tracer_ = tracing::tracer_wrapper::create(origin_.options().tracer);
+    } else {
+      if (origin_.options().enable_tracing) {
+        tracer_ =
+          tracing::tracer_wrapper::create(std::make_shared<tracing::threshold_logging_tracer>(
+            ctx_, origin_.options().tracing_options));
+      } else {
+        tracer_ = tracing::tracer_wrapper::create(std::make_shared<tracing::noop_tracer>());
+      }
+    }
+    tracer_->start();
+    // ignore the metrics options if a meter was passed in.
+    if (nullptr != origin_.options().meter) {
+      meter_ = metrics::meter_wrapper::create(origin_.options().meter);
+    } else {
+      if (origin_.options().enable_metrics) {
+        meter_ = metrics::meter_wrapper::create(
+          std::make_shared<metrics::logging_meter>(ctx_, origin_.options().metrics_options));
+      } else {
+        meter_ = metrics::meter_wrapper::create(std::make_shared<metrics::noop_meter>());
+      }
+    }
+    meter_->start();
+
+    session_manager_->set_tracer(tracer_);
+    session_manager_->set_meter(meter_);
+  }
+
   std::string id_{ uuid::to_string(uuid::random()) };
   asio::io_context& ctx_;
   asio::executor_work_guard<asio::io_context::executor_type> work_;
@@ -1231,8 +1223,8 @@ private:
   std::mutex buckets_mutex_{};
   std::map<std::string, std::shared_ptr<bucket>> buckets_{};
   couchbase::core::origin origin_{};
-  std::shared_ptr<couchbase::tracing::request_tracer> tracer_{ nullptr };
-  std::shared_ptr<couchbase::metrics::meter> meter_{ nullptr };
+  std::shared_ptr<tracing::tracer_wrapper> tracer_{ nullptr };
+  std::shared_ptr<metrics::meter_wrapper> meter_{ nullptr };
   std::atomic_bool stopped_{ false };
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
   std::shared_ptr<couchbase::core::io::cluster_config_tracker> config_tracker_{};

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

@@ -42,7 +42,11 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>
+#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+#endif
   {
     return http_.do_http_request(request, std::move(callback));
   }
@@ -61,7 +65,11 @@ cluster_agent::cluster_agent(asio::io_context& io, cluster_agent_config config)
 auto
 cluster_agent::free_form_http_request(const couchbase::core::http_request& request,
                                       couchbase::core::free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  -> tl::expected<std::shared_ptr<pending_operation>, error_union>
+#else
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+#endif
 {
   return impl_->free_form_http_request(request, std::move(callback));
 }

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

@@ -40,7 +40,11 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>;
+#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
+#endif
 
 private:
   std::shared_ptr<cluster_agent_impl> impl_;

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

@@ -43,7 +43,7 @@
 #include <asio/io_context.hpp>
 #include <asio/steady_timer.hpp>
 #include <fmt/format.h>
-#include <tao/json/forward.hpp>
+#include <tao/json/value.hpp>
 #include <tao/pegtl/parse_error.hpp>
 #include <tl/expected.hpp>
 
@@ -430,7 +430,7 @@ collection_id_cache_entry_impl::refresh_collection_id(
         self->manager_.lock()->remove(req->scope_name_, req->collection_name_);
         auto queue = self->swap_queue();
         queue->close();
-        return queue->drain([ec](auto r) {
+        return queue->drain([ec](const auto& r) {
           r->try_callback({}, ec);
         });
       }
@@ -443,7 +443,7 @@ collection_id_cache_entry_impl::refresh_collection_id(
                    res.collection_id);
       auto queue = self->swap_queue();
       queue->close();
-      return queue->drain([self](auto r) {
+      return queue->drain([self](const auto& r) {
         if (auto ec = self->assign_collection_id(r); ec) {
           CB_LOG_DEBUG("failed to set collection ID \"{}.{}\" on request (OP={}): {}",
                        r->scope_name_,

package/deps/couchbase-cxx-client/core/columnar/agent.cxx

@@ -21,6 +21,8 @@
 #include "core/free_form_http_request.hxx"
 #include "core/http_component.hxx"
 #include "core/logger/logger.hxx"
+#include "database_management_options.hxx"
+#include "management_component.hxx"
 #include "query_component.hxx"
 #include "query_options.hxx"
 
@@ -40,28 +42,56 @@ public:
     , config_{ std::move(config) }
     , http_{ io_, config_.shim }
     , query_{ io_, http_, config_.timeouts.query_timeout }
+    , mgmt_{ http_, config_.timeouts.management_timeout }
   {
     CB_LOG_DEBUG("creating new columnar cluster agent: {}", config_.to_string());
   }
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
-    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+    -> tl::expected<std::shared_ptr<pending_operation>, error_union>
   {
     return http_.do_http_request(request, std::move(callback));
   }
 
+  auto free_form_http_request_buffered(const http_request& request,
+                                       buffered_free_form_http_request_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+  {
+    return http_.do_http_request_buffered(request, std::move(callback));
+  }
+
   auto execute_query(const query_options& options, query_callback&& callback)
     -> tl::expected<std::shared_ptr<pending_operation>, error>
   {
     return query_.execute_query(options, std::move(callback));
   }
 
+  auto database_fetch_all(const fetch_all_databases_options& options,
+                          fetch_all_databases_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>
+  {
+    return mgmt_.database_fetch_all(options, std::move(callback));
+  }
+
+  auto database_drop(const drop_database_options& options, drop_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>
+  {
+    return mgmt_.database_drop(options, std::move(callback));
+  }
+
+  auto database_create(const create_database_options& options, create_database_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, error>
+  {
+    return mgmt_.database_create(options, std::move(callback));
+  }
+
 private:
   asio::io_context& io_;
   const agent_config config_;
   http_component http_;
   query_component query_;
+  management_component mgmt_;
 };
 
 agent::agent(asio::io_context& io, couchbase::core::columnar::agent_config config)
@@ -72,15 +102,46 @@ agent::agent(asio::io_context& io, couchbase::core::columnar::agent_config confi
 auto
 agent::free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
-  -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+  -> tl::expected<std::shared_ptr<pending_operation>, error_union>
 {
   return impl_->free_form_http_request(request, std::move(callback));
 }
 
+auto
+agent::free_form_http_request_buffered(
+  const couchbase::core::http_request& request,
+  couchbase::core::buffered_free_form_http_request_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+{
+  return impl_->free_form_http_request_buffered(request, std::move(callback));
+}
+
 auto
 agent::execute_query(const query_options& options, query_callback&& callback)
   -> tl::expected<std::shared_ptr<pending_operation>, error>
 {
   return impl_->execute_query(options, std::move(callback));
 }
+
+auto
+agent::database_fetch_all(const fetch_all_databases_options& options,
+                          fetch_all_databases_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, error>
+{
+  return impl_->database_fetch_all(options, std::move(callback));
+}
+
+auto
+agent::database_create(const create_database_options& options, create_database_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, error>
+{
+  return impl_->database_create(options, std::move(callback));
+}
+
+auto
+agent::database_drop(const drop_database_options& options, drop_database_callback&& callback)
+  -> tl::expected<std::shared_ptr<pending_operation>, error>
+{
+  return impl_->database_drop(options, std::move(callback));
+}
 } // namespace couchbase::core::columnar