couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/metrics/meter_wrapper.cxx

@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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 "meter_wrapper.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <mutex>
+#include <system_error>
+
+namespace couchbase::core::metrics
+{
+namespace
+{
+auto
+snake_case_to_camel_case(const std::string& s) -> std::string
+{
+  std::string res{};
+  bool capitalize{ true }; // First letter should be capitalized
+  for (const char c : s) {
+    if (c == '_') {
+      capitalize = true; // Next letter should be capitalized
+      continue;
+    }
+    if (capitalize) {
+      res += static_cast<char>(std::toupper(c));
+      capitalize = false;
+    } else {
+      res += c;
+    }
+  }
+  return res;
+}
+
+auto
+extract_error_name(std::error_code ec) -> std::string
+{
+  const std::string::size_type pos = ec.message().find(' ');
+  if (pos != std::string::npos) {
+    return ec.message().substr(0, pos);
+  }
+  return ec.message();
+}
+
+auto
+service_to_string(service_type s) -> std::string
+{
+  switch (s) {
+    case service_type::analytics:
+      return "analytics";
+    case service_type::search:
+      return "search";
+    case service_type::key_value:
+      return "kv";
+    case service_type::management:
+      return "management";
+    case service_type::eventing:
+      return "eventing";
+    case service_type::query:
+      return "query";
+    case service_type::view:
+      return "views";
+  }
+  return {};
+}
+
+auto
+get_standardized_outcome(std::error_code ec) -> std::string
+{
+  if (!ec) {
+    return "Success";
+  }
+
+  // SDK-specific errors
+  if (ec.value() >= 1000) {
+    return "CouchbaseError";
+  }
+
+  // Errors where message and RFC-message don't match
+  if (ec == errc::field_level_encryption::generic_cryptography_failure) {
+    return "CryptoError";
+  }
+
+  return snake_case_to_camel_case(extract_error_name(ec));
+}
+} // namespace
+
+auto
+metric_attributes::encode() const -> std::map<std::string, std::string>
+{
+  std::map<std::string, std::string> tags = { { "db.couchbase.service",
+                                                service_to_string(service) },
+                                              { "db.operation", operation },
+                                              { "outcome", get_standardized_outcome(ec) } };
+
+  if (internal.cluster_name.has_value()) {
+    tags.emplace("db.couchbase.cluster_name", internal.cluster_name.value());
+  }
+  if (internal.cluster_uuid.has_value()) {
+    tags.emplace("db.couchbase.cluster_uuid", internal.cluster_uuid.value());
+  }
+  if (bucket_name) {
+    tags.emplace("db.name", bucket_name.value());
+  }
+  if (scope_name) {
+    tags.emplace("db.couchbase.scope", scope_name.value());
+  }
+  if (collection_name) {
+    tags.emplace("db.couchbase.collection", collection_name.value());
+  }
+
+  return tags;
+}
+
+meter_wrapper::meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter)
+  : meter_{ std::move(meter) }
+{
+}
+
+void
+meter_wrapper::start()
+{
+  meter_->start();
+}
+
+void
+meter_wrapper::stop()
+{
+  meter_->stop();
+}
+
+void
+meter_wrapper::record_value(metric_attributes attrs,
+                            std::chrono::steady_clock::time_point start_time)
+{
+  static const std::string meter_name{ "db.couchbase.operations" };
+
+  {
+    const std::shared_lock lock{ cluster_labels_mutex_ };
+
+    if (cluster_name_) {
+      attrs.internal.cluster_name = cluster_name_;
+    }
+    if (cluster_uuid_) {
+      attrs.internal.cluster_uuid = cluster_uuid_;
+    }
+  }
+
+  auto tags = attrs.encode();
+  meter_->get_value_recorder(meter_name, tags)
+    ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::steady_clock::now() - start_time)
+                     .count());
+}
+
+void
+meter_wrapper::update_config(topology::configuration config)
+{
+  const std::scoped_lock<std::shared_mutex> lock{ cluster_labels_mutex_ };
+  if (config.cluster_uuid.has_value()) {
+    cluster_uuid_ = config.cluster_uuid;
+  }
+  if (config.cluster_name.has_value()) {
+    cluster_name_ = config.cluster_name;
+  }
+}
+
+auto
+meter_wrapper::create(std::shared_ptr<couchbase::metrics::meter> meter)
+  -> std::shared_ptr<meter_wrapper>
+{
+  return std::make_shared<meter_wrapper>(std::move(meter));
+}
+} // namespace couchbase::core::metrics

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

@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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 "core/config_listener.hxx"
+#include "core/service_type.hxx"
+#include "core/topology/configuration.hxx"
+
+#include <couchbase/metrics/meter.hxx>
+
+#include <chrono>
+#include <map>
+#include <optional>
+#include <shared_mutex>
+#include <string>
+#include <system_error>
+
+namespace couchbase::core::metrics
+{
+struct metric_attributes {
+  couchbase::core::service_type service;
+  std::string operation;
+  std::error_code ec;
+  std::optional<std::string> bucket_name{};
+  std::optional<std::string> scope_name{};
+  std::optional<std::string> collection_name{};
+
+  struct {
+    std::optional<std::string> cluster_name{};
+    std::optional<std::string> cluster_uuid{};
+  } internal{};
+
+  [[nodiscard]] auto encode() const -> std::map<std::string, std::string>;
+};
+
+class meter_wrapper : public config_listener
+{
+public:
+  explicit meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter);
+
+  void start();
+  void stop();
+
+  void record_value(metric_attributes attrs, std::chrono::steady_clock::time_point start_time);
+
+  void update_config(topology::configuration config) override;
+
+  [[nodiscard]] static auto create(std::shared_ptr<couchbase::metrics::meter> meter)
+    -> std::shared_ptr<meter_wrapper>;
+
+private:
+  std::shared_ptr<couchbase::metrics::meter> meter_;
+
+  std::optional<std::string> cluster_name_{};
+  std::optional<std::string> cluster_uuid_{};
+  std::shared_mutex cluster_labels_mutex_{};
+};
+} // namespace couchbase::core::metrics

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

@@ -16,11 +16,15 @@
  */
 
 #include "document_lookup_in.hxx"
+
 #include "core/impl/subdoc/path_flags.hxx"
 #include "core/protocol/hello_feature.hxx"
+#include "core/utils/json.hxx"
 
 #include <couchbase/error_codes.hxx>
 
+#include <tao/json/value.hpp>
+
 namespace couchbase::core::operations
 {
 auto

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

@@ -27,6 +27,7 @@
 #include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
+#include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/lookup_in_result.hxx>
 
 namespace couchbase::core::operations

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

@@ -25,8 +25,8 @@
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
 
-#include "couchbase/codec/encoded_value.hxx"
-#include "couchbase/error_codes.hxx"
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
 
 #include <functional>
 #include <memory>

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

@@ -24,9 +24,10 @@
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
-#include "couchbase/codec/encoded_value.hxx"
-#include "couchbase/error_codes.hxx"
-#include "couchbase/read_preference.hxx"
+
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/read_preference.hxx>
 
 #include <functional>
 #include <memory>

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

@@ -18,6 +18,7 @@
 #include "bucket_describe.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -33,7 +34,7 @@ bucket_describe_request::encode_to(encoded_request_type& encoded,
                                    http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/pools/default/b/{}", name);
+  encoded.path = fmt::format("/pools/default/b/{}", utils::string_codec::v2::path_escape(name));
   return {};
 }
 

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

@@ -17,6 +17,7 @@
 
 #include "bucket_drop.hxx"
 
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,7 +29,8 @@ bucket_drop_request::encode_to(encoded_request_type& encoded,
                                http_context& /* context */) const -> std::error_code
 {
   encoded.method = "DELETE";
-  encoded.path = fmt::format("/pools/default/buckets/{}", name);
+  encoded.path =
+    fmt::format("/pools/default/buckets/{}", utils::string_codec::v2::path_escape(name));
   return {};
 }
 

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

@@ -17,6 +17,7 @@
 
 #include "bucket_flush.hxx"
 
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -28,7 +29,8 @@ bucket_flush_request::encode_to(encoded_request_type& encoded,
                                 http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush", name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush",
+                             utils::string_codec::v2::path_escape(name));
   return {};
 }
 

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

@@ -19,6 +19,7 @@
 
 #include "core/management/bucket_settings_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -31,7 +32,8 @@ bucket_get_request::encode_to(encoded_request_type& encoded,
                               http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/pools/default/buckets/{}", name);
+  encoded.path =
+    fmt::format("/pools/default/buckets/{}", utils::string_codec::v2::path_escape(name));
   return {};
 }
 

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

@@ -20,6 +20,7 @@
 #include "core/management/bucket_settings.hxx"
 #include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <couchbase/durability_level.hxx>
@@ -33,7 +34,8 @@ bucket_update_request::encode_to(encoded_request_type& encoded,
                                  http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
+  encoded.path =
+    fmt::format("/pools/default/buckets/{}", utils::string_codec::v2::path_escape(bucket.name));
 
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
 

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

@@ -33,8 +33,9 @@ collection_create_request::encode_to(encoded_request_type& encoded,
                                      http_context& /*context*/) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path =
-    fmt::format("/pools/default/buckets/{}/scopes/{}/collections", bucket_name, scope_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections",
+                             utils::string_codec::v2::path_escape(bucket_name),
+                             utils::string_codec::v2::path_escape(scope_name));
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
   encoded.body = fmt::format("name={}", utils::string_codec::form_encode(collection_name));
   if (max_expiry) {

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

@@ -18,6 +18,7 @@
 #include "collection_drop.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -32,8 +33,10 @@ collection_drop_request::encode_to(encoded_request_type& encoded,
                                    http_context& /* context */) const -> std::error_code
 {
   encoded.method = "DELETE";
-  encoded.path = fmt::format(
-    "/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}",
+                             utils::string_codec::v2::path_escape(bucket_name),
+                             utils::string_codec::v2::path_escape(scope_name),
+                             utils::string_codec::v2::path_escape(collection_name));
   return {};
 }
 

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

@@ -33,8 +33,10 @@ collection_update_request::encode_to(encoded_request_type& encoded,
                                      http_context& /*context*/) const -> std::error_code
 {
   encoded.method = "PATCH";
-  encoded.path = fmt::format(
-    "/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}",
+                             utils::string_codec::v2::path_escape(bucket_name),
+                             utils::string_codec::v2::path_escape(scope_name),
+                             utils::string_codec::v2::path_escape(collection_name));
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
   std::map<std::string, std::string> values{};
   if (max_expiry.has_value()) {

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

@@ -46,11 +46,11 @@ group_upsert_request::encode_to(encoded_request_type& encoded,
   for (const auto& role : group.roles) {
     std::string spec = role.name;
     if (role.bucket) {
-      spec += fmt::format("[{}", role.bucket.value());
+      spec += fmt::format("[{}", utils::string_codec::v2::path_escape(role.bucket.value()));
       if (role.scope) {
-        spec += fmt::format(":{}", role.scope.value());
+        spec += fmt::format(":{}", utils::string_codec::v2::path_escape(role.scope.value()));
         if (role.collection) {
-          spec += fmt::format(":{}", role.collection.value());
+          spec += fmt::format(":{}", utils::string_codec::v2::path_escape(role.collection.value()));
         }
       }
       spec += "]";

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

@@ -33,7 +33,8 @@ scope_create_request::encode_to(encoded_request_type& encoded,
                                 http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes",
+                             utils::string_codec::v2::path_escape(bucket_name));
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
   encoded.body = fmt::format("name={}", utils::string_codec::form_encode(scope_name));
   return {};

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

@@ -18,6 +18,7 @@
 #include "scope_drop.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -32,7 +33,9 @@ scope_drop_request::encode_to(encoded_request_type& encoded,
                               http_context& /* context */) const -> std::error_code
 {
   encoded.method = "DELETE";
-  encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}", bucket_name, scope_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}",
+                             utils::string_codec::v2::path_escape(bucket_name),
+                             utils::string_codec::v2::path_escape(scope_name));
   return {};
 }
 

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

@@ -19,6 +19,7 @@
 
 #include "core/topology/collections_manifest_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -31,7 +32,8 @@ scope_get_all_request::encode_to(encoded_request_type& encoded,
                                  http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes",
+                             utils::string_codec::v2::path_escape(bucket_name));
   return {};
 }
 

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

@@ -18,6 +18,7 @@
 #include "search_index_analyze_document.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -38,8 +39,8 @@ search_index_analyze_document_request::encode_to(encoded_request_type& encoded,
   encoded.headers["content-type"] = "application/json";
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/analyzeDoc",
-                               bucket_name.value(),
-                               scope_name.value(),
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
                                index_name);
   } else {
     encoded.path = fmt::format("/api/index/{}/analyzeDoc", index_name);

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

@@ -18,6 +18,7 @@
 #include "search_index_control_ingest.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -35,8 +36,8 @@ search_index_control_ingest_request::encode_to(encoded_request_type& encoded,
   encoded.method = "POST";
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/ingestControl/{}",
-                               bucket_name.value(),
-                               scope_name.value(),
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
                                index_name,
                                pause ? "pause" : "resume");
   } else {

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

@@ -18,6 +18,7 @@
 #include "search_index_control_plan_freeze.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -36,8 +37,8 @@ search_index_control_plan_freeze_request::encode_to(encoded_request_type& encode
   encoded.method = "POST";
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/planFreezeControl/{}",
-                               bucket_name.value(),
-                               scope_name.value(),
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
                                index_name,
                                freeze ? "freeze" : "unfreeze");
   } else {

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

@@ -18,6 +18,7 @@
 #include "search_index_control_query.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -35,8 +36,8 @@ search_index_control_query_request::encode_to(encoded_request_type& encoded,
   encoded.method = "POST";
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/queryControl/{}",
-                               bucket_name.value(),
-                               scope_name.value(),
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
                                index_name,
                                allow ? "allow" : "disallow");
   } else {

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

@@ -18,6 +18,7 @@
 #include "search_index_drop.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -34,8 +35,10 @@ search_index_drop_request::encode_to(encoded_request_type& encoded,
   }
   encoded.method = "DELETE";
   if (bucket_name.has_value() && scope_name.has_value()) {
-    encoded.path = fmt::format(
-      "/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
+    encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}",
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
+                               index_name);
   } else {
     encoded.path = fmt::format("/api/index/{}", index_name);
   }

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

@@ -19,6 +19,7 @@
 
 #include "core/management/search_index_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -35,8 +36,10 @@ search_index_get_request::encode_to(encoded_request_type& encoded,
   }
   encoded.method = "GET";
   if (bucket_name.has_value() && scope_name.has_value()) {
-    encoded.path = fmt::format(
-      "/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
+    encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}",
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
+                               index_name);
   } else {
     encoded.path = fmt::format("/api/index/{}", index_name);
   }

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

@@ -19,6 +19,7 @@
 
 #include "core/management/search_index_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -32,8 +33,9 @@ search_index_get_all_request::encode_to(encoded_request_type& encoded,
 {
   encoded.method = "GET";
   if (bucket_name.has_value() && scope_name.has_value()) {
-    encoded.path =
-      fmt::format("/api/bucket/{}/scope/{}/index", bucket_name.value(), scope_name.value());
+    encoded.path = fmt::format("/api/bucket/{}/scope/{}/index",
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()));
   } else {
     encoded.path = "/api/index";
   }