couchbase 4.4.2 → 4.4.4

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

@@ -39,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"
@@ -145,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"
@@ -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

@@ -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

@@ -49,7 +49,7 @@ public:
 
   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));
   }
@@ -102,7 +102,7 @@ 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));
 }

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

@@ -46,7 +46,7 @@ public:
 
   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>;
 
   auto free_form_http_request_buffered(const http_request& request,
                                        buffered_free_form_http_request_callback&& callback)

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

@@ -189,7 +189,7 @@ public:
       "SELECT d.* FROM `System`.`Metadata`.`Database` AS d",
       options.timeout,
     };
-    return execute(std::move(req), [cb = std::move(callback)](auto raw_res, auto err) {
+    return execute(std::move(req), [cb = std::move(callback)](const auto& raw_res, auto err) {
       if (err) {
         cb({}, std::move(err));
         return;
@@ -216,7 +216,7 @@ public:
     if (options.ignore_if_exists) {
       req.statement += " IF NOT EXISTS";
     }
-    return execute(std::move(req), [cb = std::move(callback)](auto /*raw_res*/, auto err) {
+    return execute(std::move(req), [cb = std::move(callback)](const auto& /*raw_res*/, auto err) {
       cb(std::move(err));
     });
   }
@@ -231,7 +231,7 @@ public:
     if (options.ignore_if_not_exists) {
       req.statement += " IF EXISTS";
     }
-    return execute(std::move(req), [cb = std::move(callback)](auto /*raw_res*/, auto err) {
+    return execute(std::move(req), [cb = std::move(callback)](const auto& /*raw_res*/, auto err) {
       cb(std::move(err));
     });
   }

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

@@ -79,17 +79,28 @@ public:
 
   auto dispatch() -> error
   {
-    auto op =
-      http_.do_http_request(http_req_, [self = shared_from_this()](auto resp, auto ec) mutable {
+    auto op = http_.do_http_request(
+      http_req_, [self = shared_from_this()](auto resp, error_union err) mutable {
         std::shared_ptr<pending_operation> op;
         {
           const std::scoped_lock lock{ self->pending_op_mutex_ };
           std::swap(op, self->pending_op_);
         }
-        if (ec) {
-          self->invoke_callback(
-            {},
-            { maybe_convert_error_code(ec), "Failed to execute the HTTP request for the query" });
+        if (!std::holds_alternative<std::monostate>(err)) {
+          if (std::holds_alternative<impl::bootstrap_error>(err)) {
+            auto bootstrap_error = std::get<impl::bootstrap_error>(err);
+            auto message = fmt::format(
+              "Failed to execute the HTTP request for the query due to a bootstrap error.  "
+              "See logs for further details.  bootstrap_error.message={}",
+              bootstrap_error.error_message);
+            self->invoke_callback({}, { maybe_convert_error_code(bootstrap_error.ec), message });
+          } else {
+            auto ec = maybe_convert_error_code(std::get<std::error_code>(err));
+            if (ec == errc::timeout) {
+              return self->trigger_timeout();
+            }
+            self->invoke_callback({}, { ec, "Failed to execute the HTTP request for the query" });
+          }
           return;
         }
         // op can be null if the pending_query_operation was cancelled.
@@ -101,7 +112,7 @@ public:
         }
         auto streamer = std::make_shared<row_streamer>(self->io_, resp.body(), "/results/^");
         return streamer->start(
-          [self, streamer, resp = std::move(resp)](auto metadata_header, auto ec) mutable {
+          [self, streamer, resp = std::move(resp)](const auto& metadata_header, auto ec) mutable {
             if (ec) {
               self->invoke_callback({}, { maybe_convert_error_code(ec) });
               return;
@@ -127,7 +138,27 @@ public:
       pending_op_ = op.value();
       return {};
     }
-    return error{ op.error() };
+    retry_timer_.cancel();
+    deadline_.cancel();
+    error return_error{};
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    if (std::holds_alternative<impl::bootstrap_error>(op.error())) {
+      auto bootstrap_error = std::get<impl::bootstrap_error>(op.error());
+      auto message =
+        fmt::format("Failed to create the HTTP pending operation due to a bootstrap error.  "
+                    "See logs for further details.  bootstrap_error.message={}",
+                    bootstrap_error.error_message);
+      return_error.ec = bootstrap_error.ec;
+      return_error.message = message;
+    } else {
+      return_error.ec = std::get<std::error_code>(op.error());
+      return_error.message = "Failed to create the HTTP pending operation.";
+    }
+#else
+    return_error.ec = op.error();
+#endif
+    invoke_callback({}, return_error);
+    return return_error;
   }
 
   auto start(query_callback&& callback) -> error
@@ -252,11 +283,13 @@ private:
           break;
       }
     }
+
+    const std::chrono::milliseconds server_timeout = timeout_ + std::chrono::seconds(5);
+    payload["timeout"] = fmt::format("{}ms", server_timeout.count());
+
     for (const auto& [key, val] : options.raw) {
       payload[key] = utils::json::parse(val);
     }
-    const std::chrono::milliseconds server_timeout = timeout_ + std::chrono::seconds(5);
-    payload["timeout"] = fmt::format("{}ms", server_timeout.count());
 
     return payload;
   }
@@ -296,7 +329,7 @@ private:
     // retryable errors should be listed.
     if (err.ec == errc::timeout && retry_info_.last_error) {
       if (const auto* e = retry_info_.last_error.ctx.find("errors"); e != nullptr) {
-        err.ctx["last_errors"] = e;
+        err.ctx["last_errors"] = e->get_array();
       }
     }
   }
@@ -334,53 +367,71 @@ private:
     std::int32_t first_error_code{ 0 };
     std::string first_error_msg{};
 
+    std::int32_t first_non_retr_error_code{ 0 };
+    std::string first_non_retr_error_msg{};
+
     for (auto error_json : errors_json->get_array()) {
-      auto* retr = error_json.find("retriable");
-      if (retr == nullptr) {
-        // An error is assumed to not be retriable if the field is missing
-        res.retriable = false;
-      } else if (!retr->is_boolean()) {
-        return { { errc::generic,
-                   "Could not parse error from server response - 'retriable' was not boolean" } };
-      } else {
-        // Operation is retriable iff all errors are retriable
-        res.retriable = res.retriable && retr->get_boolean();
+      bool retr{ false }; // An error is assumed to not be retriable if the field is missing
+      {
+        auto* r = error_json.find("retriable");
+        if (r != nullptr) {
+          if (!r->is_boolean()) {
+            return {
+              { errc::generic,
+                "Could not parse error from server response - 'retriable' was not boolean" }
+            };
+          }
+          retr = r->get_boolean();
+        }
       }
 
-      auto* msg = error_json.find("msg");
-      if (msg == nullptr) {
-        return { { errc::generic,
-                   "Could not parse error from server response - could not find 'msg' field" } };
-      }
-      if (!msg->is_string()) {
-        return { { errc::generic,
-                   "Could not parse error from server response - 'msg' field was not string" } };
-      }
+      // Operation is retriable iff all errors are retriable
+      res.retriable = res.retriable && retr;
 
-      auto* c = error_json.find("code");
-      if (c == nullptr) {
-        return { { errc::generic,
-                   "Could not parse error from server response - could not find 'code' field" } };
-      }
-      if (!(c->is_unsigned() || c->is_signed())) {
-        return {
-          { errc::generic,
-            "Could not parse error from server response - 'code' field was not an integer" }
-        };
+      std::string msg{};
+      {
+        auto* m = error_json.find("msg");
+        if (m == nullptr) {
+          return { { errc::generic,
+                     "Could not parse error from server response - could not find 'msg' field" } };
+        }
+        if (!m->is_string()) {
+          return { { errc::generic,
+                     "Could not parse error from server response - 'msg' field was not string" } };
+        }
+        msg = m->get_string();
       }
 
-      std::int32_t code = c->is_signed() ? gsl::narrow_cast<std::int32_t>(c->get_signed())
-                                         : gsl::narrow_cast<std::int32_t>(c->get_unsigned());
+      std::int32_t code{};
+      {
+        auto* c = error_json.find("code");
+        if (c == nullptr) {
+          return { { errc::generic,
+                     "Could not parse error from server response - could not find 'code' field" } };
+        }
+        if (!(c->is_unsigned() || c->is_signed())) {
+          return {
+            { errc::generic,
+              "Could not parse error from server response - 'code' field was not an integer" }
+          };
+        }
+        code = c->is_signed() ? gsl::narrow_cast<std::int32_t>(c->get_signed())
+                              : gsl::narrow_cast<std::int32_t>(c->get_unsigned());
+      }
 
       tao::json::value error = {
         { "code", code },
-        { "msg", msg->get_string() },
+        { "msg", msg },
       };
       res.err.ctx["errors"].get_array().emplace_back(std::move(error));
 
       if (first_error_code == 0) {
         first_error_code = code;
-        first_error_msg = msg->get_string();
+        first_error_msg = msg;
+      }
+      if (!retr && first_non_retr_error_code == 0) {
+        first_non_retr_error_code = code;
+        first_non_retr_error_msg = msg;
       }
 
       switch (code) {
@@ -396,7 +447,14 @@ private:
     }
 
     if (res.err.ec == errc::query_error) {
-      res.err.properties = query_error_properties{ first_error_code, first_error_msg };
+      // If any of the errors is not retriable, report the first non-retriable code/message in the
+      // error properties
+      if (first_non_retr_error_code != 0) {
+        res.err.properties =
+          query_error_properties{ first_non_retr_error_code, first_non_retr_error_msg };
+      } else {
+        res.err.properties = query_error_properties{ first_error_code, first_error_msg };
+      }
     }
 
     return res;

package/deps/couchbase-cxx-client/core/columnar/query_component.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/impl/bootstrap_error.hxx"
 #include "core/pending_operation.hxx"
 #include "error.hxx"
 #include "query_options.hxx"