couchbase 3.0.0.alpha.4 → 3.0.0.alpha.5

data/ext/couchbase/couchbase.cxx

@@ -86,6 +86,10 @@ init_versions(VALUE mCouchbase)
 #endif
 
 #undef VERSION_SPLIT_
+
+    VALUE version_info = rb_inspect(cb_Version);
+    spdlog::info("couchbase backend has been initialized: {}",
+                 std::string_view(RSTRING_PTR(version_info), static_cast<std::size_t>(RSTRING_LEN(version_info))));
 }
 
 struct cb_backend_data {
@@ -261,7 +265,7 @@ init_exceptions(VALUE mCouchbase)
     eIndexFailure = rb_define_class_under(mError, "IndexFailure", rb_eStandardError);
     eIndexNotFound = rb_define_class_under(mError, "IndexNotFound", rb_eStandardError);
     eInternalServerFailure = rb_define_class_under(mError, "InternalServerFailure", rb_eStandardError);
-    eInvalidArgument = rb_define_class_under(mError, "InvalidArgument", rb_eStandardError);
+    eInvalidArgument = rb_define_class_under(mError, "InvalidArgument", rb_eArgError);
     eJobQueueFull = rb_define_class_under(mError, "JobQueueFull", rb_eStandardError);
     eLinkNotFound = rb_define_class_under(mError, "LinkNotFound", rb_eStandardError);
     eNumberTooBig = rb_define_class_under(mError, "NumberTooBig", rb_eStandardError);
@@ -619,7 +623,7 @@ cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, VA
         backend->cluster->execute(req, [barrier](couchbase::operations::get_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -681,7 +685,7 @@ cb_Backend_document_get_projected(VALUE self,
         backend->cluster->execute(req, [barrier](couchbase::operations::get_projected_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch with projections {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch with projections {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -729,7 +733,7 @@ cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VAL
         backend->cluster->execute(req, [barrier](couchbase::operations::get_and_lock_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable lock and fetch {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable lock and fetch {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -774,7 +778,7 @@ cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VA
         backend->cluster->execute(req, [barrier](couchbase::operations::get_and_touch_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch and touch {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch and touch {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -836,7 +840,7 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         backend->cluster->execute(req, [barrier](couchbase::operations::touch_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to touch {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to touch {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -877,7 +881,7 @@ cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         backend->cluster->execute(req, [barrier](couchbase::operations::exists_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to exists {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to exists {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -944,7 +948,7 @@ cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         backend->cluster->execute(req, [barrier](couchbase::operations::unlock_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to unlock {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to unlock {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -1019,7 +1023,7 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -1103,7 +1107,7 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
         backend->cluster->execute(req, [barrier](couchbase::operations::replace_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to replace {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to replace {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -1176,7 +1180,7 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         backend->cluster->execute(req, [barrier](couchbase::operations::insert_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to insert {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to insert {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -1239,7 +1243,7 @@ cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         backend->cluster->execute(req, [barrier](couchbase::operations::remove_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to remove {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to remove {} (opaque={})", doc_id, resp.opaque));
             break;
         }
         return cb__extract_mutation_result(resp);
@@ -1328,7 +1332,7 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
         backend->cluster->execute(req, [barrier](couchbase::operations::increment_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to increment {} by {}", doc_id, req.delta));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to increment {} by {} (opaque={})", doc_id, req.delta, resp.opaque));
             break;
         }
         VALUE res = cb__extract_mutation_result(resp);
@@ -1420,7 +1424,7 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
         backend->cluster->execute(req, [barrier](couchbase::operations::decrement_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to decrement {} by {}", doc_id, req.delta));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to decrement {} by {} (opaque={})", doc_id, req.delta, resp.opaque));
             break;
         }
         VALUE res = cb__extract_mutation_result(resp);
@@ -1473,64 +1477,132 @@ cb__map_subdoc_opcode(couchbase::protocol::subdoc_opcode opcode)
 
         case couchbase::protocol::subdoc_opcode::get_doc:
             return rb_id2sym(rb_intern("get_doc"));
+
+        case couchbase::protocol::subdoc_opcode::set_doc:
+            return rb_id2sym(rb_intern("set_doc"));
     }
     return rb_id2sym(rb_intern("unknown"));
 }
 
-static VALUE
-cb__map_subdoc_status(couchbase::protocol::status status)
+static void
+cb__map_subdoc_status(couchbase::protocol::status status, std::size_t index, const std::string& path, VALUE entry)
 {
     switch (status) {
         case couchbase::protocol::status::success:
-            return rb_id2sym(rb_intern("success"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("success")));
+            return;
+
+        case couchbase::protocol::status::subdoc_path_not_found:
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("path_not_found")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(ePathNotFound, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_path_mismatch:
-            return rb_id2sym(rb_intern("path_mismatch"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("path_mismatch")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(ePathMismatch, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_path_invalid:
-            return rb_id2sym(rb_intern("path_invalid"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("path_invalid")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(ePathInvalid, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_path_too_big:
-            return rb_id2sym(rb_intern("path_too_big"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("path_too_big")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(ePathTooBig, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_value_cannot_insert:
-            return rb_id2sym(rb_intern("value_cannot_insert"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("value_cannot_insert")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(eValueInvalid, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_doc_not_json:
-            return rb_id2sym(rb_intern("doc_not_json"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("doc_not_json")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eDocumentNotJson, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_num_range_error:
-            return rb_id2sym(rb_intern("num_range"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("num_range")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(eNumberTooBig, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_delta_invalid:
-            return rb_id2sym(rb_intern("delta_invalid"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("delta_invalid")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(eDeltaInvalid, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_path_exists:
-            return rb_id2sym(rb_intern("path_exists"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("path_exists")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(ePathExists, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_value_too_deep:
-            return rb_id2sym(rb_intern("value_too_deep"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("value_too_deep")));
+            rb_hash_aset(
+              entry, rb_id2sym(rb_intern("error")), rb_exc_new_cstr(eValueTooDeep, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_invalid_combo:
-            return rb_id2sym(rb_intern("invalid_combo"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("invalid_combo")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eInvalidArgument, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_xattr_invalid_flag_combo:
-            return rb_id2sym(rb_intern("xattr_invalid_flag_combo"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("xattr_invalid_flag_combo")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eXattrInvalidKeyCombo, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_xattr_invalid_key_combo:
-            return rb_id2sym(rb_intern("xattr_invalid_key_combo"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("xattr_invalid_key_combo")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eXattrInvalidKeyCombo, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_xattr_unknown_macro:
-            return rb_id2sym(rb_intern("xattr_unknown_macro"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("xattr_unknown_macro")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eXattrUnknownMacro, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_xattr_unknown_vattr:
-            return rb_id2sym(rb_intern("xattr_unknown_vattr"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("xattr_unknown_vattr")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eXattrUnknownVirtualAttribute, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         case couchbase::protocol::status::subdoc_xattr_cannot_modify_vattr:
-            return rb_id2sym(rb_intern("xattr_cannot_modify_vattr"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("xattr_cannot_modify_vattr")));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("error")),
+                         rb_exc_new_cstr(eXattrCannotModifyVirtualAttribute, fmt::format("index={}, path={}", index, path).c_str()));
+            return;
 
         default:
-            return rb_id2sym(rb_intern("unknown"));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), rb_id2sym(rb_intern("unknown")));
+            rb_hash_aset(
+              entry,
+              rb_id2sym(rb_intern("error")),
+              rb_exc_new_cstr(eInternalServerFailure,
+                              fmt::format("unknown subdocument error status={}, index={}, path={}", status, index, path).c_str()));
+            return;
     }
 }
 
@@ -1593,7 +1665,7 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         backend->cluster->execute(req, [barrier](couchbase::operations::lookup_in_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -1603,13 +1675,14 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
         for (size_t i = 0; i < resp.fields.size(); ++i) {
             VALUE entry = rb_hash_new();
+            rb_hash_aset(entry, rb_id2sym(rb_intern("index")), ULL2NUM(i));
             rb_hash_aset(entry, rb_id2sym(rb_intern("exists")), resp.fields[i].exists ? Qtrue : Qfalse);
             rb_hash_aset(
               entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
             rb_hash_aset(entry,
                          rb_id2sym(rb_intern("value")),
                          rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
-            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), cb__map_subdoc_status(resp.fields[i].status));
+            cb__map_subdoc_status(resp.fields[i].status, i, resp.fields[i].path, entry);
             if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::get && resp.fields[i].path.empty()) {
                 rb_hash_aset(entry, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("get_doc")));
             } else {
@@ -1624,14 +1697,7 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
 }
 
 static VALUE
-cb_Backend_document_mutate_in(VALUE self,
-                              VALUE bucket,
-                              VALUE collection,
-                              VALUE id,
-                              VALUE timeout,
-                              VALUE access_deleted,
-                              VALUE specs,
-                              VALUE options)
+cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE specs, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -1680,8 +1746,39 @@ cb_Backend_document_mutate_in(VALUE self,
                     req.durability_timeout = FIX2UINT(durability_timeout);
                 }
             }
+            VALUE access_deleted = rb_hash_aref(options, rb_id2sym(rb_intern("access_deleted")));
+            if (!NIL_P(access_deleted)) {
+                req.access_deleted = RTEST(access_deleted);
+            }
+            VALUE store_semantics = rb_hash_aref(options, rb_id2sym(rb_intern("store_semantics")));
+            if (!NIL_P(store_semantics)) {
+                Check_Type(store_semantics, T_SYMBOL);
+                ID semantics = rb_sym2id(store_semantics);
+                if (semantics == rb_intern("replace")) {
+                    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::replace;
+                } else if (semantics == rb_intern("insert")) {
+                    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::insert;
+                } else if (semantics == rb_intern("upsert")) {
+                    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
+                }
+            }
+            VALUE expiration = rb_hash_aref(options, rb_id2sym(rb_intern("expiration")));
+            if (!NIL_P(expiration)) {
+                Check_Type(expiration, T_FIXNUM);
+                req.expiration = FIX2UINT(expiration);
+            }
+            VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
+            if (!NIL_P(cas)) {
+                switch (TYPE(cas)) {
+                    case T_FIXNUM:
+                    case T_BIGNUM:
+                        req.cas = NUM2ULL(cas);
+                        break;
+                    default:
+                        rb_raise(rb_eArgError, "CAS must be an Integer");
+                }
+            }
         }
-        req.access_deleted = RTEST(access_deleted);
         auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
         req.specs.entries.reserve(entries_size);
         for (size_t i = 0; i < entries_size; ++i) {
@@ -1709,11 +1806,13 @@ cb_Backend_document_mutate_in(VALUE self,
                 opcode = couchbase::protocol::subdoc_opcode::array_add_unique;
             } else if (operation_id == rb_intern("counter")) {
                 opcode = couchbase::protocol::subdoc_opcode::counter;
+            } else if (operation_id == rb_intern("set_doc")) {
+                opcode = couchbase::protocol::subdoc_opcode::set_doc;
             } else {
                 rb_raise(rb_eArgError, "Unsupported operation for subdocument mutation: %+" PRIsVALUE, operation);
             }
             bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
-            bool create_parents = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("create_parents"))));
+            bool create_path = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("create_path"))));
             bool expand_macros = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("expand_macros"))));
             VALUE path = rb_hash_aref(entry, rb_id2sym(rb_intern("path")));
             Check_Type(path, T_STRING);
@@ -1724,7 +1823,7 @@ cb_Backend_document_mutate_in(VALUE self,
                 Check_Type(param, T_FIXNUM);
                 req.specs.add_spec(opcode,
                                    xattr,
-                                   create_parents,
+                                   create_path,
                                    expand_macros,
                                    std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))),
                                    FIX2LONG(param));
@@ -1732,7 +1831,7 @@ cb_Backend_document_mutate_in(VALUE self,
                 Check_Type(param, T_STRING);
                 req.specs.add_spec(opcode,
                                    xattr,
-                                   create_parents,
+                                   create_path,
                                    expand_macros,
                                    std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))),
                                    std::string(RSTRING_PTR(param), static_cast<size_t>(RSTRING_LEN(param))));
@@ -1744,7 +1843,7 @@ cb_Backend_document_mutate_in(VALUE self,
         backend->cluster->execute(req, [barrier](couchbase::operations::mutate_in_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to mutate {}", doc_id));
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to mutate {} (opaque={})", doc_id, resp.opaque));
             break;
         }
 
@@ -1756,16 +1855,22 @@ cb_Backend_document_mutate_in(VALUE self,
         rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
         for (size_t i = 0; i < resp.fields.size(); ++i) {
             VALUE entry = rb_hash_new();
+            rb_hash_aset(entry, rb_id2sym(rb_intern("index")), ULL2NUM(i));
             rb_hash_aset(
               entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
-            if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::counter) {
-                rb_hash_aset(entry, rb_id2sym(rb_intern("value")), LONG2NUM(std::stoll(resp.fields[i].value)));
-            } else {
-                rb_hash_aset(entry,
-                             rb_id2sym(rb_intern("value")),
-                             rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+            if (resp.fields[i].status == couchbase::protocol::status::success ||
+                resp.fields[i].status == couchbase::protocol::status::subdoc_success_deleted) {
+                if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::counter) {
+                    if (resp.fields[i].value.size() > 0) {
+                        rb_hash_aset(entry, rb_id2sym(rb_intern("value")), LONG2NUM(std::stoll(resp.fields[i].value)));
+                    }
+                } else {
+                    rb_hash_aset(entry,
+                                 rb_id2sym(rb_intern("value")),
+                                 rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+                }
             }
-            rb_hash_aset(entry, rb_id2sym(rb_intern("status")), cb__map_subdoc_status(resp.fields[i].status));
+            cb__map_subdoc_status(resp.fields[i].status, i, resp.fields[i].path, entry);
             rb_hash_aset(entry, rb_id2sym(rb_intern("type")), cb__map_subdoc_opcode(resp.fields[i].opcode));
             rb_ary_store(fields, static_cast<long>(i), entry);
         }
@@ -5248,7 +5353,7 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 7);
     rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 5);
     rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 6);
-    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 7);
+    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 6);
     rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
     rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 5);
     rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 4);
@@ -5316,17 +5421,25 @@ init_backend(VALUE mCouchbase)
     rb_define_singleton_method(cBackend, "parse_connection_string", VALUE_FUNC(cb_Backend_parse_connection_string), 1);
 }
 
-extern "C" {
 void
-Init_libcouchbase(void)
+init_logger()
 {
-    auto env_val = spdlog::details::os::getenv("SPDLOG_LEVEL");
+    spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %v");
+
+    auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
     if (env_val.empty()) {
         spdlog::set_level(spdlog::level::critical);
     } else {
-        spdlog::cfg::load_env_levels();
+        auto levels = spdlog::cfg::helpers::extract_levels(env_val);
+        spdlog::details::registry::instance().update_levels(std::move(levels));
     }
-    spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %v");
+}
+
+extern "C" {
+void
+Init_libcouchbase(void)
+{
+    init_logger();
 
     VALUE mCouchbase = rb_define_module("Couchbase");
     init_versions(mCouchbase);