couchbase 4.4.6 → 4.5.1

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

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2024-Present Couchbase, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *     https://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 "config_listener.hxx"
+
+#include <memory>
+
+namespace asio
+{
+class io_context;
+namespace ssl
+{
+class context;
+} // namespace ssl
+} // namespace asio
+
+namespace couchbase::core
+{
+class app_telemetry_reporter_impl;
+class app_telemetry_meter;
+struct cluster_options;
+struct cluster_credentials;
+
+class app_telemetry_reporter : public config_listener
+{
+public:
+  app_telemetry_reporter() = delete;
+  app_telemetry_reporter(app_telemetry_reporter&&) = default;
+  app_telemetry_reporter(const app_telemetry_reporter&) = delete;
+  auto operator=(app_telemetry_reporter&&) -> app_telemetry_reporter& = default;
+  auto operator=(const app_telemetry_reporter&) -> app_telemetry_reporter& = delete;
+
+  app_telemetry_reporter(std::shared_ptr<app_telemetry_meter> meter,
+                         const cluster_options& options,
+                         const cluster_credentials& credentials,
+                         asio::io_context& ctx,
+                         asio::ssl::context& tls);
+  ~app_telemetry_reporter() override;
+  void update_config(topology::configuration config) override;
+  void stop();
+
+private:
+  std::shared_ptr<app_telemetry_reporter_impl> impl_{};
+};
+} // namespace couchbase::core

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

@@ -18,6 +18,7 @@
 #include "bucket.hxx"
 
 #include "collection_id_cache_entry.hxx"
+#include "core/app_telemetry_meter.hxx"
 #include "core/config_listener.hxx"
 #include "core/document_id.hxx"
 #include "core/error_context/key_value_error_map_info.hxx"
@@ -84,6 +85,7 @@ public:
               couchbase::core::origin origin,
               std::shared_ptr<tracing::tracer_wrapper> tracer,
               std::shared_ptr<metrics::meter_wrapper> meter,
+              std::shared_ptr<core::app_telemetry_meter> app_telemetry,
               std::vector<protocol::hello_feature> known_features,
               std::shared_ptr<impl::bootstrap_state_listener> state_listener,
               asio::io_context& ctx,
@@ -94,6 +96,7 @@ public:
     , origin_{ std::move(origin) }
     , tracer_{ std::move(tracer) }
     , meter_{ std::move(meter) }
+    , app_telemetry_meter_{ std::move(app_telemetry) }
     , known_features_{ std::move(known_features) }
     , state_listener_{ std::move(state_listener) }
     , codec_{ { known_features_.begin(), known_features_.end() } }
@@ -201,7 +204,10 @@ public:
       return errc::network::bucket_closed;
     }
     if (!configured_) {
-      return defer_command([self = shared_from_this(), req]() {
+      return defer_command([self = shared_from_this(), req](std::error_code ec) {
+        if (ec == errc::common::request_canceled) {
+          return req->cancel(ec);
+        }
         self->direct_dispatch(req);
       });
     }
@@ -210,7 +216,10 @@ public:
 
     auto session = route_request(req);
     if (!session || !session->has_config()) {
-      return defer_command([self = shared_from_this(), req]() mutable {
+      return defer_command([self = shared_from_this(), req](std::error_code ec) mutable {
+        if (ec == errc::common::request_canceled) {
+          return req->cancel(ec);
+        }
         self->direct_dispatch(std::move(req));
       });
     }
@@ -241,7 +250,10 @@ public:
 
     auto session = route_request(req);
     if (!session || !session->has_config()) {
-      return defer_command([self = shared_from_this(), req]() {
+      return defer_command([self = shared_from_this(), req](std::error_code ec) {
+        if (ec == errc::common::request_canceled) {
+          return req->cancel(ec);
+        }
         self->direct_dispatch(req);
       });
     }
@@ -417,9 +429,16 @@ public:
         origin_.credentials(), hostname, port, origin_.options());
       io::mcbp_session session =
         origin_.options().enable_tls
-          ? io::mcbp_session(
-              client_id_, ctx_, tls_, origin, state_listener_, name_, known_features_)
-          : io::mcbp_session(client_id_, ctx_, origin, state_listener_, name_, known_features_);
+          ? io::mcbp_session(client_id_,
+                             node.node_uuid,
+                             ctx_,
+                             tls_,
+                             origin,
+                             state_listener_,
+                             name_,
+                             known_features_)
+          : io::mcbp_session(
+              client_id_, node.node_uuid, ctx_, origin, state_listener_, name_, known_features_);
       CB_LOG_DEBUG(R"({} rev={}, restart idx={}, session="{}", address="{}:{}")",
                    log_prefix_,
                    config_->rev_str(),
@@ -438,7 +457,7 @@ public:
           session.on_stop([id = session.id(), self]() {
             self->remove_session(id);
           });
-          self->drain_deferred_queue();
+          self->drain_deferred_queue({});
         },
         true);
       sessions_.insert_or_assign(index, std::move(session));
@@ -479,8 +498,9 @@ public:
     }
     io::mcbp_session new_session =
       origin_.options().enable_tls
-        ? io::mcbp_session(client_id_, ctx_, tls_, origin_, state_listener_, name_, known_features_)
-        : io::mcbp_session(client_id_, ctx_, origin_, state_listener_, name_, known_features_);
+        ? io::mcbp_session(
+            client_id_, {}, ctx_, tls_, origin_, state_listener_, name_, known_features_)
+        : io::mcbp_session(client_id_, {}, ctx_, origin_, state_listener_, name_, known_features_);
     new_session.bootstrap([self = shared_from_this(), new_session, h = std::move(handler)](
                             std::error_code ec, topology::configuration cfg) mutable {
       if (ec) {
@@ -501,7 +521,7 @@ public:
           self->sessions_.insert_or_assign(this_index, std::move(new_session));
         }
         self->update_config(cfg);
-        self->drain_deferred_queue();
+        self->drain_deferred_queue({});
         self->poll_config({});
       }
       asio::post(
@@ -530,26 +550,27 @@ public:
       return handler(errc::network::configuration_not_available, nullptr);
     }
     const std::scoped_lock lock(deferred_commands_mutex_);
-    deferred_commands_.emplace([self = shared_from_this(), handler = std::move(handler)]() mutable {
-      if (self->closed_ || !self->configured_) {
-        return handler(errc::network::configuration_not_available, nullptr);
-      }
+    deferred_commands_.emplace(
+      [self = shared_from_this(), handler = std::move(handler)](std::error_code ec) mutable {
+        if (ec == errc::common::request_canceled || self->closed_ || !self->configured_) {
+          return handler(errc::network::configuration_not_available, nullptr);
+        }
 
-      std::shared_ptr<topology::configuration> config{};
-      {
-        const std::scoped_lock config_lock(self->config_mutex_);
-        config = self->config_;
-      }
-      if (config) {
-        return handler({}, std::move(config));
-      }
-      return handler(errc::network::configuration_not_available, nullptr);
-    });
+        std::shared_ptr<topology::configuration> config{};
+        {
+          const std::scoped_lock config_lock(self->config_mutex_);
+          config = self->config_;
+        }
+        if (config) {
+          return handler({}, config);
+        }
+        return handler(errc::network::configuration_not_available, nullptr);
+      });
   }
 
-  void drain_deferred_queue()
+  void drain_deferred_queue(std::error_code ec)
   {
-    std::queue<utils::movable_function<void()>> commands{};
+    std::queue<utils::movable_function<void(std::error_code)>> commands{};
     {
       const std::scoped_lock lock(deferred_commands_mutex_);
       std::swap(deferred_commands_, commands);
@@ -559,7 +580,7 @@ public:
         R"({} draining deferred operation queue, size={})", log_prefix_, commands.size());
     }
     while (!commands.empty()) {
-      commands.front()();
+      commands.front()(ec);
       commands.pop();
     }
   }
@@ -629,7 +650,7 @@ public:
 
     heartbeat_timer_.cancel();
 
-    drain_deferred_queue();
+    drain_deferred_queue(errc::common::request_canceled);
 
     if (state_listener_ != nullptr) {
       state_listener_->unregister_config_listener(shared_from_this());
@@ -793,9 +814,16 @@ public:
           origin_.credentials(), hostname, port, origin_.options());
         io::mcbp_session session =
           origin_.options().enable_tls
-            ? io::mcbp_session(
-                client_id_, ctx_, tls_, origin, state_listener_, name_, known_features_)
-            : io::mcbp_session(client_id_, ctx_, origin, state_listener_, name_, known_features_);
+            ? io::mcbp_session(client_id_,
+                               node.node_uuid,
+                               ctx_,
+                               tls_,
+                               origin,
+                               state_listener_,
+                               name_,
+                               known_features_)
+            : io::mcbp_session(
+                client_id_, node.node_uuid, ctx_, origin, state_listener_, name_, known_features_);
         CB_LOG_DEBUG(R"({} rev={}, add session="{}", address="{}:{}", index={})",
                      log_prefix_,
                      config.rev_str(),
@@ -822,7 +850,7 @@ public:
             session.on_stop([id = session.id(), self]() {
               self->remove_session(id);
             });
-            self->drain_deferred_queue();
+            self->drain_deferred_queue({});
           },
           true);
         new_sessions.insert_or_assign(next_index, std::move(session));
@@ -901,6 +929,11 @@ public:
     return meter_;
   }
 
+  [[nodiscard]] auto app_telemetry_meter() const -> std::shared_ptr<core::app_telemetry_meter>
+  {
+    return app_telemetry_meter_;
+  }
+
   void export_diag_info(diag::diagnostics_result& res) const
   {
     std::map<size_t, io::mcbp_session> sessions;
@@ -937,7 +970,7 @@ public:
     config_listeners_.emplace_back(std::move(handler));
   }
 
-  auto defer_command(utils::movable_function<void()> command) -> std::error_code
+  auto defer_command(utils::movable_function<void(std::error_code)> command) -> std::error_code
   {
     const std::scoped_lock lock_for_deferred_commands(deferred_commands_mutex_);
     deferred_commands_.emplace(std::move(command));
@@ -951,6 +984,7 @@ private:
   const origin origin_;
   const std::shared_ptr<tracing::tracer_wrapper> tracer_;
   const std::shared_ptr<metrics::meter_wrapper> meter_;
+  const std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_;
   const std::vector<protocol::hello_feature> known_features_;
   const std::shared_ptr<impl::bootstrap_state_listener> state_listener_;
   mcbp::codec codec_;
@@ -971,7 +1005,7 @@ private:
   std::vector<std::shared_ptr<config_listener>> config_listeners_{};
   std::mutex config_listeners_mutex_{};
 
-  std::queue<utils::movable_function<void()>> deferred_commands_{};
+  std::queue<utils::movable_function<void(std::error_code)>> deferred_commands_{};
   std::mutex deferred_commands_mutex_{};
 
   std::map<size_t, io::mcbp_session> sessions_{};
@@ -984,6 +1018,7 @@ bucket::bucket(std::string client_id,
                asio::ssl::context& tls,
                std::shared_ptr<tracing::tracer_wrapper> tracer,
                std::shared_ptr<metrics::meter_wrapper> meter,
+               std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
                std::string name,
                couchbase::core::origin origin,
                std::vector<protocol::hello_feature> known_features,
@@ -995,6 +1030,7 @@ bucket::bucket(std::string client_id,
                                          std::move(origin),
                                          std::move(tracer),
                                          std::move(meter),
+                                         std::move(app_telemetry_meter),
                                          std::move(known_features),
                                          std::move(state_listener),
                                          ctx,
@@ -1062,6 +1098,12 @@ bucket::meter() const -> std::shared_ptr<metrics::meter_wrapper>
   return impl_->meter();
 }
 
+auto
+bucket::app_telemetry_meter() const -> std::shared_ptr<core::app_telemetry_meter>
+{
+  return impl_->app_telemetry_meter();
+}
+
 auto
 bucket::default_retry_strategy() const -> std::shared_ptr<couchbase::retry_strategy>
 {
@@ -1101,7 +1143,7 @@ bucket::is_configured() const -> bool
 }
 
 void
-bucket::defer_command(utils::movable_function<void()> command)
+bucket::defer_command(utils::movable_function<void(std::error_code)> command)
 {
   impl_->defer_command(std::move(command));
 }

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

@@ -31,9 +31,7 @@
 #include <utility>
 #include <vector>
 
-namespace couchbase
-{
-namespace core
+namespace couchbase::core
 {
 namespace mcbp
 {
@@ -57,6 +55,8 @@ namespace impl
 class bootstrap_state_listener;
 } // namespace impl
 
+class app_telemetry_meter;
+
 class bucket_impl;
 struct origin;
 
@@ -70,6 +70,7 @@ public:
          asio::ssl::context& tls,
          std::shared_ptr<tracing::tracer_wrapper> tracer,
          std::shared_ptr<metrics::meter_wrapper> meter,
+         std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
          std::string name,
          couchbase::core::origin origin,
          std::vector<protocol::hello_feature> known_features,
@@ -95,7 +96,10 @@ public:
     if (is_configured()) {
       return map_and_send(cmd);
     }
-    return defer_command([self = shared_from_this(), cmd]() {
+    return defer_command([self = shared_from_this(), cmd](std::error_code ec) {
+      if (ec == errc::common::request_canceled) {
+        return cmd->cancel(retry_reason::do_not_retry);
+      }
       self->map_and_send(cmd);
     });
   }
@@ -137,7 +141,10 @@ public:
         session.has_value() ? session->bootstrap_address() : "",
         session.has_value() && session->has_config(),
         config_rev());
-      return defer_command([self = shared_from_this(), cmd]() {
+      return defer_command([self = shared_from_this(), cmd](std::error_code ec) {
+        if (ec == errc::common::request_canceled) {
+          return cmd->cancel(retry_reason::do_not_retry);
+        }
         self->map_and_send(cmd);
       });
     }
@@ -197,19 +204,20 @@ public:
   void export_diag_info(diag::diagnostics_result& res) const;
   void ping(const std::shared_ptr<diag::ping_collector>& collector,
             std::optional<std::chrono::milliseconds> timeout);
-  void defer_command(utils::movable_function<void()> command);
+  void defer_command(utils::movable_function<void(std::error_code)> command);
 
   [[nodiscard]] auto name() const -> const std::string&;
   [[nodiscard]] auto log_prefix() const -> const std::string&;
   [[nodiscard]] auto tracer() const -> std::shared_ptr<tracing::tracer_wrapper>;
   [[nodiscard]] auto meter() const -> std::shared_ptr<metrics::meter_wrapper>;
+  [[nodiscard]] auto app_telemetry_meter() const -> std::shared_ptr<app_telemetry_meter>;
   [[nodiscard]] auto default_retry_strategy() const -> std::shared_ptr<couchbase::retry_strategy>;
   [[nodiscard]] auto is_closed() const -> bool;
   [[nodiscard]] auto is_configured() const -> bool;
 
   auto direct_dispatch(std::shared_ptr<mcbp::queue_request> req) -> std::error_code;
-  auto direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req,
-                       bool is_retry) -> std::error_code;
+  auto direct_re_queue(const std::shared_ptr<mcbp::queue_request>& req, bool is_retry)
+    -> std::error_code;
 
 private:
   [[nodiscard]] auto default_timeout() const -> std::chrono::milliseconds;
@@ -223,5 +231,4 @@ private:
   asio::io_context& ctx_;
   std::shared_ptr<bucket_impl> impl_;
 };
-} // namespace core
-} // namespace couchbase
+} // namespace couchbase::core

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

@@ -21,6 +21,8 @@
 
 #include "bucket.hxx"
 #include "capella_ca.hxx"
+#include "core/app_telemetry_meter.hxx"
+#include "core/app_telemetry_reporter.hxx"
 #include "core/diagnostics.hxx"
 #include "core/impl/get_replica.hxx"
 #include "core/impl/lookup_in_replica.hxx"
@@ -348,9 +350,10 @@ public:
     }
 
     origin_ = std::move(origin);
-    CB_LOG_DEBUG(R"(open cluster, id: "{}", core version: "{}", {})",
+    CB_LOG_DEBUG(R"(open cluster, id: "{}", core version: "{}", connection string: {}, {})",
                  id_,
                  couchbase::core::meta::sdk_semver(),
+                 origin_.connection_string(),
                  origin_.to_json());
     setup_observability();
     if (origin_.options().enable_dns_srv) {
@@ -444,13 +447,22 @@ public:
           }
         }
 
-        b = std::make_shared<bucket>(
-          id_, ctx_, tls_, tracer_, meter_, bucket_name, origin, known_features, dns_srv_tracker_);
+        b = std::make_shared<bucket>(id_,
+                                     ctx_,
+                                     tls_,
+                                     tracer_,
+                                     meter_,
+                                     app_telemetry_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_);
+        b->on_configuration_update(app_telemetry_reporter_);
       }
     }
     if (b == nullptr) {
@@ -766,9 +778,9 @@ public:
           });
         }
       }
-      session_ = io::mcbp_session(id_, ctx_, tls_, origin_, dns_srv_tracker_);
+      session_ = io::mcbp_session(id_, {}, ctx_, tls_, origin_, dns_srv_tracker_);
     } else {
-      session_ = io::mcbp_session(id_, ctx_, origin_, dns_srv_tracker_);
+      session_ = io::mcbp_session(id_, {}, ctx_, origin_, dns_srv_tracker_);
     }
     session_->bootstrap([self = shared_from_this(), handler = std::move(handler)](
                           std::error_code ec, const topology::configuration& config) mutable {
@@ -793,8 +805,12 @@ public:
             self->origin_.options().network,
             utils::join_strings(self->origin_.get_nodes(), ","));
         }
+        // FIXME(SA): fix the session manager to receive initial configuration and cluster-wide
+        // session to poll for updates like the bucket does. Or just subscribe before the bootstrap.
         self->session_manager_->set_configuration(config, self->origin_.options());
         self->session_->on_configuration_update(self->session_manager_);
+        self->session_->on_configuration_update(self->app_telemetry_reporter_);
+        self->app_telemetry_reporter_->update_config(config);
         self->session_->on_stop([self]() {
           if (self->session_) {
             self->session_.reset();
@@ -972,6 +988,8 @@ public:
         } else {
           self->session_manager_->set_configuration(cfg, options);
           self->config_tracker_->on_configuration_update(self->session_manager_);
+          self->config_tracker_->on_configuration_update(self->app_telemetry_reporter_);
+          self->app_telemetry_reporter_->update_config(cfg);
           self->config_tracker_->register_state_listener();
         }
       });
@@ -1092,9 +1110,8 @@ public:
     stopped_ = true;
     asio::post(asio::bind_executor(
       ctx_, [self = shared_from_this(), handler = std::move(handler)]() mutable {
-        if (self->session_) {
-          self->session_->stop(retry_reason::do_not_retry);
-          self->session_.reset();
+        if (auto session = std::move(self->session_); session) {
+          session->stop(retry_reason::do_not_retry);
         }
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
         if (self->config_tracker_) {
@@ -1104,19 +1121,31 @@ public:
         }
         self->retry_backoff_.cancel();
 #endif
-        self->for_each_bucket([](const auto& bucket) {
+
+        std::map<std::string, std::shared_ptr<bucket>> buckets{};
+        {
+          const std::scoped_lock lock(self->buckets_mutex_);
+          buckets = std::move(self->buckets_);
+        }
+        for (const auto& [_, bucket] : buckets) {
           bucket->close();
-        });
-        self->session_manager_->close();
+        }
+        if (auto session_manager = std::move(self->session_manager_); session_manager) {
+          session_manager->close();
+        }
         self->work_.reset();
-        if (self->tracer_) {
-          self->tracer_->stop();
+        if (auto tracer = std::move(self->tracer_); tracer) {
+          tracer->stop();
+        }
+        if (auto meter = std::move(self->meter_); meter) {
+          meter->stop();
+        }
+        if (auto meter = std::move(self->app_telemetry_meter_); meter) {
+          meter->disable();
         }
-        self->tracer_.reset();
-        if (self->meter_) {
-          self->meter_->stop();
+        if (auto reporter = std::move(self->app_telemetry_reporter_); reporter) {
+          reporter->stop();
         }
-        self->meter_.reset();
         handler();
       }));
   }
@@ -1210,6 +1239,11 @@ private:
 
     session_manager_->set_tracer(tracer_);
     session_manager_->set_meter(meter_);
+
+    app_telemetry_meter_->update_agent(origin_.options().user_agent_extra);
+    session_manager_->set_app_telemetry_meter(app_telemetry_meter_);
+    app_telemetry_reporter_ = std::make_shared<app_telemetry_reporter>(
+      app_telemetry_meter_, origin_.options(), origin_.credentials(), ctx_, tls_);
   }
 
   std::string id_{ uuid::to_string(uuid::random()) };
@@ -1217,6 +1251,7 @@ private:
   asio::executor_work_guard<asio::io_context::executor_type> work_;
   asio::ssl::context tls_{ asio::ssl::context::tls_client };
   std::shared_ptr<io::http_session_manager> session_manager_;
+  std::shared_ptr<app_telemetry_reporter> app_telemetry_reporter_{};
   std::optional<io::mcbp_session> session_{};
   std::shared_ptr<impl::dns_srv_tracker> dns_srv_tracker_{};
   std::mutex buckets_mutex_{};
@@ -1225,6 +1260,10 @@ private:
   std::shared_ptr<tracing::tracer_wrapper> tracer_{ nullptr };
   std::shared_ptr<metrics::meter_wrapper> meter_{ nullptr };
   std::atomic_bool stopped_{ false };
+  std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_{
+    std::make_shared<core::app_telemetry_meter>()
+  };
+
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
   std::shared_ptr<couchbase::core::io::cluster_config_tracker> config_tracker_{};
   asio::steady_timer retry_backoff_;

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

@@ -0,0 +1,27 @@
+/* -*- 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 "cluster_credentials.hxx"
+
+namespace couchbase::core
+{
+auto
+cluster_credentials::uses_certificate() const -> bool
+{
+  return !certificate_path.empty();
+}
+} // namespace couchbase::core

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

@@ -0,0 +1,36 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::core
+{
+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]] auto uses_certificate() const -> bool;
+};
+
+} // namespace couchbase::core

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

@@ -95,6 +95,19 @@ public:
   bool dump_configuration{ false };
   bool disable_mozilla_ca_certificates{ false };
   couchbase::core::columnar::security_options security_options{};
+
+  bool enable_app_telemetry{ true };
+  std::string app_telemetry_endpoint{};
+  std::chrono::milliseconds app_telemetry_ping_interval{
+    timeout_defaults::app_telemetry_ping_interval
+  };
+  std::chrono::milliseconds app_telemetry_ping_timeout{
+    timeout_defaults::app_telemetry_ping_timeout
+  };
+  std::chrono::milliseconds app_telemetry_backoff_interval{
+    timeout_defaults::app_telemetry_backoff_interval
+  };
+  bool preserve_bootstrap_nodes_order{ false };
 };
 
 } // namespace couchbase::core