couchbase 3.9.0 → 3.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a72603dc40eb6d8ba7d1636cf67372ef65fc11f59e0617934514e96117bd5fb
-  data.tar.gz: 2adf92e075788643ed2943884221066a023c6a2e5ac7cad8636d72f3562e7bb4
+  metadata.gz: 2c9165b07ea3bb12062cc5e778c2ac9642f30b39ef9ac83227d7f056be5dedae
+  data.tar.gz: 2092c8f82df2b1a225585baeb53506f914c2fa8225e41b3eed1640ab21bd1eba
 SHA512:
-  metadata.gz: 37fbf00228a35e36bbb7e1bddb780cb634bb563159165305f7c9a1980b0dbd01777c7d2e6478fa59a3a8e13a5dd4e7d2db49b0e9ecedd05b48cad6d571cc125b
-  data.tar.gz: 206550bc22e145d9fa43dc239ed83ddf08b0ad82247aac0c5c17aecf071d73a1e77034dcf322a84ab419a45121ef890d97c64365b7e550b1c5ed58c914b8dd29
+  metadata.gz: 44cec54d8295fb96753fdb035edc77be74925cf2fc028b2fa647ba26cdb8ea018b5f48f07b1fac129853f41b7050f6680ae612690363e7c3e2ee82376a0c1d41
+  data.tar.gz: bb3802becc6da9d4aca3b085cc8f9b4ff88415d0d2d155ac62980cef6d051bcb86d2e93d3cc192ec399b5780583260d309a2c8cc07a97cf15d8e9669b50ff289

data/README.md

@@ -23,7 +23,7 @@ The library has been tested with MRI 3.2, 3.3, 3.4 and 4.0. Supported platforms
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.9.0"
+gem "couchbase", "3.9.1"
 ```
 
 And then execute:

data/ext/cache/extconf_include.rb

@@ -3,7 +3,7 @@ cmake_flags << "-DCPM_USE_NAMED_CACHE_DIRECTORIES=ON"
 cmake_flags << "-DCPM_USE_LOCAL_PACKAGES=OFF"
 cmake_flags << "-DCPM_SOURCE_CACHE=#{__dir__}"
 cmake_flags << "-DCOUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE_ROOT=#{__dir__}"
-cmake_flags << "-DEXT_GIT_REVISION=efbce2324574ed7bfaa7c9db131b82154dbdd178"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=380784c1f5a69aecc464911b2d29a68c7150a0ba"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.5.0-0-g380784c1"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP=2026-10-20T15:47:48"
+cmake_flags << "-DEXT_GIT_REVISION=18481d03bfc5d030af5235fc7daf35b9d58ba38c"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=33c90f28cede04652cfb7edae748b84fe82c39a1"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.5.1-0-g33c90f28"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP=2026-10-23T22:11:52"

data/ext/couchbase/CMakeLists.txt

@@ -16,7 +16,7 @@ endif()
 
 project(
   couchbase_cxx_client
-  VERSION "1.5.0"
+  VERSION "1.5.1"
   LANGUAGES CXX C)
 message(
   STATUS
@@ -562,8 +562,12 @@ if(COUCHBASE_CXX_CLIENT_BUILD_SHARED OR BUILD_SHARED_LIBS)
   add_library(couchbase_cxx_client SHARED ${couchbase_cxx_client_FILES})
   add_library(couchbase_cxx_client::couchbase_cxx_client ALIAS couchbase_cxx_client)
 
-  set_target_properties(couchbase_cxx_client PROPERTIES VERSION ${couchbase_cxx_client_VERSION_MAJOR}
-                                                        SOVERSION ${couchbase_cxx_client_VERSION})
+  # The soname carries MAJOR.MINOR. A patch release keeps the ABI, so a binary linked against one
+  # MAJOR.MINOR release loads every later patch of it; a minor release may change the ABI and the soname.
+  set_target_properties(
+    couchbase_cxx_client
+    PROPERTIES VERSION ${couchbase_cxx_client_VERSION}
+               SOVERSION ${couchbase_cxx_client_VERSION_MAJOR}.${couchbase_cxx_client_VERSION_MINOR})
   list(APPEND couchbase_cxx_client_LIBRARIES couchbase_cxx_client)
   if(NOT WIN32)
     set(couchbase_cxx_client_DEFAULT_LIBRARY couchbase_cxx_client::couchbase_cxx_client)

data/ext/couchbase/cmake/OpenSSL.cmake

@@ -238,15 +238,29 @@ set(CA_BUNDLE_CPP_FILE "${CMAKE_CURRENT_BINARY_DIR}/generated/mozilla_ca_bundle.
 # seems to be cross-platform and fast.
 string(
   REGEX MATCHALL
-        "[^=#]+=+\n-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----"
+        "[^\n]+\n=+\n(#[^\n]*\n)*-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----"
         CERTIFICATES
         "${CA_BUNDLE_CONTENT}")
 list(LENGTH CERTIFICATES NUMBER_OF_CERTIFICATES)
+if(COUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE)
+  # A bundle layout that the certificate expressions do not recognise fails configure. Otherwise the
+  # library builds with fewer default roots than the bundle carries, or none.
+  string(REGEX MATCHALL "-----BEGIN CERTIFICATE-----" PEM_BLOCKS "${CA_BUNDLE_CONTENT}")
+  list(LENGTH PEM_BLOCKS NUMBER_OF_PEM_BLOCKS)
+  if(NUMBER_OF_CERTIFICATES EQUAL 0 OR NOT NUMBER_OF_CERTIFICATES EQUAL NUMBER_OF_PEM_BLOCKS)
+    message(
+      FATAL_ERROR
+        "Extracted ${NUMBER_OF_CERTIFICATES} of ${NUMBER_OF_PEM_BLOCKS} certificates from "
+        "${COUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE_ROOT}/mozilla-ca-bundle.crt")
+  endif()
+endif()
 file(
   WRITE ${CA_BUNDLE_CPP_FILE}
   "
 #include \"core/mozilla_ca_bundle.hxx\"
 
+#include <couchbase/build_config.hxx>
+
 #include <gsl/span>
 
 #include <array>
@@ -256,23 +270,77 @@ namespace couchbase::core::default_ca
 {
 constexpr inline std::array<certificate, ${NUMBER_OF_CERTIFICATES}> certificates{
 ")
+set(CERTIFICATE_BODIES "")
 foreach(CERTIFICATE ${CERTIFICATES})
   string(
     REGEX MATCH
-          "[ \t\r\n]*([^=\n]+)[ \t\r\n]*=+\n(-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----)"
+          "^([^\n]+)\n=+\n(#[^\n]*\n)*(-----BEGIN CERTIFICATE-----[^-]+-----END CERTIFICATE-----)$"
           PARTS
-          ${CERTIFICATE})
+          "${CERTIFICATE}")
+  if(NOT PARTS)
+    message(FATAL_ERROR "Unable to split CA bundle entry into name and certificate:\n${CERTIFICATE}")
+  endif()
+  set(CERTIFICATE_NAME "${CMAKE_MATCH_1}")
+  set(CERTIFICATE_BODY "${CMAKE_MATCH_3}")
+  if(NOT CERTIFICATE_BODY MATCHES "^-----BEGIN CERTIFICATE-----\n([A-Za-z0-9+/=]+\n)+-----END CERTIFICATE-----$")
+    message(FATAL_ERROR "CA bundle entry \"${CERTIFICATE_NAME}\" is not a PEM certificate:\n${CERTIFICATE_BODY}")
+  endif()
+  # The name is emitted as an R"(...)" literal, which ends at the first )" it contains. The body
+  # cannot contain one: the PEM check above admits no ')'.
+  string(FIND "${CERTIFICATE_NAME}" ")\"" CLOSING_DELIMITER)
+  if(NOT CLOSING_DELIMITER EQUAL -1)
+    message(FATAL_ERROR "CA bundle entry name cannot be embedded as a raw string: ${CERTIFICATE_NAME}")
+  endif()
+  list(APPEND CERTIFICATE_BODIES "${CERTIFICATE_BODY}")
   file(APPEND ${CA_BUNDLE_CPP_FILE}
-"  certificate{ R\"(${CMAKE_MATCH_1})\",
-               R\"(${CMAKE_MATCH_2})\", },
+"  certificate{ R\"(${CERTIFICATE_NAME})\",
+               R\"(${CERTIFICATE_BODY})\", },
 
 ")
 endforeach()
+set(UNIQUE_CERTIFICATE_BODIES ${CERTIFICATE_BODIES})
+list(REMOVE_DUPLICATES UNIQUE_CERTIFICATE_BODIES)
+list(LENGTH UNIQUE_CERTIFICATE_BODIES NUMBER_OF_UNIQUE_CERTIFICATES)
+if(NOT NUMBER_OF_UNIQUE_CERTIFICATES EQUAL NUMBER_OF_CERTIFICATES)
+  message(FATAL_ERROR "CA bundle carries ${NUMBER_OF_CERTIFICATES} certificates, but only "
+                      "${NUMBER_OF_UNIQUE_CERTIFICATES} are distinct")
+endif()
 
 file(
   APPEND ${CA_BUNDLE_CPP_FILE}
 "};
 
+namespace
+{
+constexpr auto
+is_pem_certificate(std::string_view body) -> bool
+{
+  constexpr std::string_view header{ \"-----BEGIN CERTIFICATE-----\\n\" };
+  constexpr std::string_view footer{ \"\\n-----END CERTIFICATE-----\" };
+  return body.size() > header.size() + footer.size() && body.substr(0, header.size()) == header &&
+         body.substr(body.size() - footer.size()) == footer;
+}
+
+constexpr auto
+every_entry_is_named_certificate() -> bool
+{
+  for (const auto& entry : certificates) {
+    if (entry.authority.empty() || !is_pem_certificate(entry.body)) {
+      return false;
+    }
+  }
+  return true;
+}
+} // namespace
+
+// An array sized larger than its initialiser list value-initialises the remaining entries.
+static_assert(every_entry_is_named_certificate(),
+              \"every embedded CA bundle entry carries a name and a PEM certificate\");
+#if defined(COUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE)
+static_assert(!certificates.empty(),
+              \"COUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE is enabled, but no certificates were embedded\");
+#endif
+
 auto
 mozilla_ca_certs() -> gsl::span<const certificate>
 {

data/ext/couchbase/core/cluster.cxx

@@ -2651,22 +2651,21 @@ cluster::query_stream(operations::query_request request,
         std::chrono::steady_clock::now() +
         request.timeout.value_or(impl_->default_timeout_for(service_type::query));
       impl_->defer_until_open(
-        [&] {
-          return
-            [self = *this, deadline, request = std::move(request), handler = std::move(handler)](
-              std::error_code ec) mutable {
-              if (ec) {
-                error_context::query ctx{};
-                ctx.ec = ec;
-                ctx.statement = request.statement;
-                ctx.client_context_id = request.client_context_id.has_value()
-                                          ? *request.client_context_id
-                                          : uuid::to_string(uuid::random());
-                return handler({}, std::move(ctx));
-              }
-              request.timeout = remaining_until(deadline);
-              self.query_stream(std::move(request), std::move(handler));
-            };
+        [&, self = *this] {
+          return [self, deadline, request = std::move(request), handler = std::move(handler)](
+                   std::error_code ec) mutable {
+            if (ec) {
+              error_context::query ctx{};
+              ctx.ec = ec;
+              ctx.statement = request.statement;
+              ctx.client_context_id = request.client_context_id.has_value()
+                                        ? *request.client_context_id
+                                        : uuid::to_string(uuid::random());
+              return handler({}, std::move(ctx));
+            }
+            request.timeout = remaining_until(deadline);
+            self.query_stream(std::move(request), std::move(handler));
+          };
         },
         deadline)) {
     return;
@@ -2718,22 +2717,21 @@ cluster::analytics_query_stream(
         std::chrono::steady_clock::now() +
         request.timeout.value_or(impl_->default_timeout_for(service_type::analytics));
       impl_->defer_until_open(
-        [&] {
-          return
-            [self = *this, deadline, request = std::move(request), handler = std::move(handler)](
-              std::error_code ec) mutable {
-              if (ec) {
-                error_context::analytics ctx{};
-                ctx.ec = ec;
-                ctx.statement = request.statement;
-                ctx.client_context_id = request.client_context_id.has_value()
-                                          ? *request.client_context_id
-                                          : uuid::to_string(uuid::random());
-                return handler({}, std::move(ctx));
-              }
-              request.timeout = remaining_until(deadline);
-              self.analytics_query_stream(std::move(request), std::move(handler));
-            };
+        [&, self = *this] {
+          return [self, deadline, request = std::move(request), handler = std::move(handler)](
+                   std::error_code ec) mutable {
+            if (ec) {
+              error_context::analytics ctx{};
+              ctx.ec = ec;
+              ctx.statement = request.statement;
+              ctx.client_context_id = request.client_context_id.has_value()
+                                        ? *request.client_context_id
+                                        : uuid::to_string(uuid::random());
+              return handler({}, std::move(ctx));
+            }
+            request.timeout = remaining_until(deadline);
+            self.analytics_query_stream(std::move(request), std::move(handler));
+          };
         },
         deadline)) {
     return;

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

@@ -109,7 +109,7 @@ extract_eventing_error_code(const tao::json::value& response, std::uint32_t stat
       name->get_string(),
       description,
     };
-    if (problem.name == "ERR_APP_NOT_FOUND_TS") {
+    if (problem.name == "ERR_APP_NOT_FOUND_TS" || problem.name == "ERR_APP_NOT_FOUND") {
       return { errc::management::eventing_function_not_found, problem };
     }
     if (problem.name == "ERR_APP_NOT_DEPLOYED") {

data/ext/couchbase/core/websocket_codec.cxx

@@ -443,16 +443,18 @@ encode_payload_length(std::size_t length) -> std::vector<std::byte>
   }
   // 7 + 64
   constexpr std::uint8_t field_7_bit = 127 | flag_mask;
+  // std::size_t is 32 bits on 32-bit targets, where shifting it by 32 or more is undefined.
+  const std::uint64_t wide_length = length;
   return {
     std::byte{ field_7_bit },
-    static_cast<std::byte>((length >> 56) & 0xff),
-    static_cast<std::byte>((length >> 48) & 0xff),
-    static_cast<std::byte>((length >> 40) & 0xff),
-    static_cast<std::byte>((length >> 32) & 0xff),
-    static_cast<std::byte>((length >> 24) & 0xff),
-    static_cast<std::byte>((length >> 16) & 0xff),
-    static_cast<std::byte>((length >> 8) & 0xff),
-    static_cast<std::byte>(length & 0xff),
+    static_cast<std::byte>((wide_length >> 56) & 0xff),
+    static_cast<std::byte>((wide_length >> 48) & 0xff),
+    static_cast<std::byte>((wide_length >> 40) & 0xff),
+    static_cast<std::byte>((wide_length >> 32) & 0xff),
+    static_cast<std::byte>((wide_length >> 24) & 0xff),
+    static_cast<std::byte>((wide_length >> 16) & 0xff),
+    static_cast<std::byte>((wide_length >> 8) & 0xff),
+    static_cast<std::byte>(wide_length & 0xff),
   };
 }
 

data/ext/couchbase/couchbase/error_codes.hxx

@@ -888,7 +888,7 @@ enum class management {
   bucket_not_flushable = 607,
 
   /// Occurs if the function is not found
-  /// name is "ERR_APP_NOT_FOUND_TS"
+  /// name is "ERR_APP_NOT_FOUND_TS" or "ERR_APP_NOT_FOUND"
   eventing_function_not_found = 608,
 
   /// Occurs if the function is not deployed, but the action expects it to

data/lib/couchbase/version.rb

@@ -21,5 +21,5 @@ module Couchbase
   #   $ ruby -rcouchbase -e 'pp Couchbase::VERSION'
   #   {:sdk=>"3.4.0", :ruby_abi=>"3.1.0", :revision=>"416fe68e6029ec8a4c40611cf6e6b30d3b90d20f"}
   VERSION = {} unless defined?(VERSION) # rubocop:disable Style/MutableConstant
-  VERSION.update(:sdk => "3.9.0")
+  VERSION.update(:sdk => "3.9.1")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: couchbase
 version: !ruby/object:Gem::Version
-  version: 3.9.0
+  version: 3.9.1
 platform: ruby
 authors:
 - Sergey Avseyev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-21 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -3729,9 +3729,9 @@ metadata:
   homepage_uri: https://docs.couchbase.com/ruby-sdk/current/hello-world/start-using-sdk.html
   bug_tracker_uri: https://jira.issues.couchbase.com/browse/RCBC
   mailing_list_uri: https://www.couchbase.com/forums/c/ruby-sdk
-  source_code_uri: https://github.com/couchbase/couchbase-ruby-client/tree/3.9.0
-  changelog_uri: https://github.com/couchbase/couchbase-ruby-client/releases/tag/3.9.0
-  documentation_uri: https://docs.couchbase.com/sdk-api/couchbase-ruby-client-3.9.0/index.html
+  source_code_uri: https://github.com/couchbase/couchbase-ruby-client/tree/3.9.1
+  changelog_uri: https://github.com/couchbase/couchbase-ruby-client/releases/tag/3.9.1
+  documentation_uri: https://docs.couchbase.com/sdk-api/couchbase-ruby-client-3.9.1/index.html
   github_repo: https://github.com/couchbase/couchbase-ruby-client
   rubygems_mfa_required: 'true'
 post_install_message: