couchbase 3.0.0.alpha.5 → 3.0.3

data/ext/couchbase/platform/backtrace.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 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 <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+typedef void (*write_cb_t)(void* ctx, const char* frame);
+
+/**
+ * Prints a backtrace from the current thread. For each frame, the
+ * `write_cb` function is called with `context` and a string describing
+ * the frame.
+ */
+void
+print_backtrace(write_cb_t write_cb, void* context);
+
+/**
+ * Convenience function - prints a backtrace to the specified FILE.
+ */
+void
+print_backtrace_to_file(FILE* stream);
+
+/**
+ * print a backtrace to a buffer
+ *
+ * @param indent the indent used for each entry in the callstack
+ * @param buffer the buffer to populate with the backtrace
+ * @param size the size of the input buffer
+ */
+bool
+print_backtrace_to_buffer(const char* indent, char* buffer, size_t size);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

data/ext/couchbase/platform/terminate_handler.cc

@@ -0,0 +1,130 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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 <platform/terminate_handler.h>
+
+#include <cstdlib>
+#include <exception>
+
+#include <spdlog/spdlog.h>
+#include <platform/backtrace.h>
+
+#include <version.hxx>
+
+namespace couchbase::platform
+{
+static bool should_include_backtrace = true;
+static std::terminate_handler default_terminate_handler = nullptr;
+
+// Logs details on the handled exception. Attempts to log to
+// `terminate_logger` if non-null; otherwise prints to stderr.
+static void
+log_handled_exception()
+{
+#ifdef WIN32
+    // Windows doesn't like us re-throwing the exception in the handler (and
+    // seems to result in immediate process termination). As such skip logging
+    // the exception here.
+    return;
+#else
+    // Attempt to get the exception's what() message.
+    try {
+        static int tried_throw = 0;
+        // try once to re-throw currently active exception (so we can print
+        // its what() message).
+        if (tried_throw++ == 0) {
+            throw;
+        }
+    } catch (const std::exception& e) {
+        spdlog::critical("Caught unhandled std::exception-derived exception. what(): {}", e.what());
+    } catch (...) {
+        spdlog::critical("Caught unknown/unhandled exception.");
+    }
+#endif
+}
+
+// Log the symbolified backtrace to this point.
+static void
+log_backtrace()
+{
+    static const char format_str[] = "Call stack:\n%s";
+
+    char buffer[8192];
+    if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
+        spdlog::critical("Call stack:\n{}", buffer);
+    } else {
+        // Exceeded buffer space - print directly to stderr FD (requires no
+        // buffering, but has the disadvantage that we don't get it in the log).
+        fprintf(stderr, format_str, "");
+        print_backtrace_to_file(stderr);
+        fflush(stderr);
+        spdlog::critical("Call stack exceeds 8k, rendered to STDERR");
+    }
+}
+
+// Replacement terminate_handler which prints the exception's what() and a
+// backtrace of the current stack before chaining to the default handler.
+static void
+backtrace_terminate_handler()
+{
+    static bool meta_reported = false;
+    if (!meta_reported) {
+        spdlog::critical(R"(*** Fatal error encountered during exception handling (rev="{}", compiler="{}", system="{}", date="{}") ***)",
+                         BACKEND_GIT_REVISION,
+                         BACKEND_CXX_COMPILER,
+                         BACKEND_SYSTEM,
+                         BACKEND_BUILD_TIMESTAMP);
+        meta_reported = true;
+    }
+    log_handled_exception();
+
+    if (should_include_backtrace) {
+        log_backtrace();
+    }
+
+    // Chain to the default handler if available (as it may be able to print
+    // other useful information on why we were told to terminate).
+    if (default_terminate_handler != nullptr && default_terminate_handler != backtrace_terminate_handler) {
+        default_terminate_handler();
+    }
+
+#if !defined(HAVE_BREAKPAD)
+    // Shut down the logger (and flush everything). If breakpad is installed
+    // then we'll let it do it.
+    spdlog::shutdown();
+#endif
+
+    std::abort();
+}
+
+void
+install_backtrace_terminate_handler()
+{
+    if (default_terminate_handler != nullptr) {
+        // restore the previously saved one before (re)installing ours.
+        std::set_terminate(default_terminate_handler);
+    }
+    default_terminate_handler = std::set_terminate(backtrace_terminate_handler);
+}
+
+void
+set_terminate_handler_print_backtrace(bool print)
+{
+    should_include_backtrace = print;
+}
+
+} // namespace couchbase::platform

data/ext/couchbase/platform/terminate_handler.h

@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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
+
+namespace couchbase::platform
+{
+/**
+ * Interposes our own C++ terminate handler to print backtrace upon failures.
+ * Chains to the default handler (if exists) after printing the backtrace,
+ * then calls std::abort().
+ */
+void
+install_backtrace_terminate_handler();
+
+/**
+ * Control if our C++ terminate handler should include a backtrace or not.
+ */
+void
+set_terminate_handler_print_backtrace(bool print);
+
+} // namespace couchbase::platform

data/ext/couchbase/protocol/client_opcode.hxx

@@ -29,20 +29,199 @@ enum class client_opcode : uint8_t {
     remove = 0x04,
     increment = 0x05,
     decrement = 0x06,
+    noop = 0x0a,
+    version = 0x0b,
+    append = 0x0e,
+    prepend = 0x0f,
+    stat = 0x10,
+    verbosity = 0x1b,
     touch = 0x1c,
     get_and_touch = 0x1d,
     hello = 0x1f,
     sasl_list_mechs = 0x20,
     sasl_auth = 0x21,
     sasl_step = 0x22,
+    get_all_vbucket_seqnos = 0x48,
+
+    /**
+     * Open connection
+     * Sent by an external entity to a producer or a consumer to create a logical channel.
+     */
+    dcp_open = 0x50,
+
+    /**
+     * Add Stream
+     * Sent to the consumer to tell the consumer to initiate a stream request with the producer.
+     */
+    dcp_add_stream = 0x51,
+
+    /**
+     * Close Stream
+     * Sent to server controling an DCP stream to close the stream for a named vbucket as soon as possible.
+     */
+    dcp_close_stream = 0x52,
+
+    /**
+     * Stream Request
+     * Sent by the consumer side to the producer specifying that the consumer wants to create a vbucket stream
+     */
+    dcp_stream_request = 0x53,
+
+    /**
+     * Failover Log Request
+     * The Failover log request is used by the consumer to request all known failover ids a client may use to continue from.
+     */
+    dcp_get_failover_log = 0x54,
+
+    /**
+     * Stream End
+     * Sent to the consumer to indicate that the producer has no more messages to stream for the specified vbucket.
+     */
+    dcp_stream_end = 0x55,
+
+    /**
+     * Snapshot Marker
+     * Sent by the producer to tell the consumer that a new snapshot is being sent.
+     */
+    dcp_snapshot_marker = 0x56,
+
+    /**
+     * Mutation
+     * Tells the consumer that the message contains a key mutation.
+     */
+    dcp_mutation = 0x57,
+
+    /**
+     * Deletion
+     * Tells the consumer that the message contains a key deletion.
+     */
+    dcp_deletion = 0x58,
+
+    /**
+     * Expiration
+     * Tells the consumer that the message contains a key expiration
+     */
+    dcp_expiration = 0x59,
+
+    /**
+     * Set VBucket State
+     * The Set VBucket message is used during the VBucket takeover process to hand off ownership of a VBucket between two nodes
+     */
+    dcp_set_vbucket_state = 0x5b,
+
+    /**
+     * No-Op
+     * A No-Op message is sent by the Producer to the Consumer if the Producer has not sent any messages for a given interval of time
+     */
+    dcp_noop = 0x5c,
+
+    /**
+     * Buffer Acknowledgement
+     * Sent to by the Consumer to the Producer in order to inform the Producer that the Consumer has consumed some or all of the data the
+     * the Producer has sent and that the Consumer is ready for more data
+     */
+    dcp_buffer_acknowledgement = 0x5d,
+
+    /**
+     * Control
+     * Sent by the Consumer to the Producer in order to configure connection settings.
+     */
+    dcp_control = 0x5e,
+
+    /**
+     * System Event
+     * Tells the consumer that the message contains a system event.
+     */
+    dcp_system_event = 0x5f,
+
+    dcp_prepare = 0x60,
+    dcp_seqno_acknowledged = 0x61,
+    dcp_commit = 0x62,
+    dcp_abort = 0x63,
+
+    /**
+     * Seqno Advanced
+     * Sent by the producer to tell the consumer that the vbucket seqno has advanced due to an event that the consumer is not subscribed
+     * too.
+     */
+    dcp_seqno_advanced = 0x64,
+
+    /**
+     * OSO Snapshot
+     * Sent by the producer to tell the consumer that a Out of Sequence Order snapshot is to be transmitted or has now been completed.
+     */
+    dcp_oso_snapshot = 0x65,
+
+    get_replica = 0x83,
+    list_buckets = 0x87,
     select_bucket = 0x89,
+    observe_seqno = 0x91,
     observe = 0x92,
+    evict_key = 0x93,
     get_and_lock = 0x94,
     unlock = 0x95,
+    get_failover_log = 0x96,
+
+    /**
+     * Return the last closed checkpoint Id for a given VBucket.
+     */
+    last_closed_checkpoint = 0x97,
+
+    get_meta = 0xa0,
+    upsert_with_meta = 0xa2,
+    insert_with_meta = 0xa4,
+    remove_with_meta = 0xa8,
+
+    /**
+     * Command to create a new checkpoint on a given vbucket by force
+     */
+    create_checkpoint = 0xaa,
+
+    /**
+     * Command to wait for the checkpoint persistence
+     */
+    checkpoint_persistence = 0xb1,
+
+    /**
+     * Command that returns meta data for typical memcached ops
+     */
+    return_meta = 0xb2,
+
+    get_random_key = 0xb6,
+
+    /**
+     * Command to wait for the dcp sequence number persistence
+     */
+    seqno_persistence = 0xb7,
+
+    /**
+     * Command to get all keys
+     */
+    get_keys = 0xb8,
+
+    /**
+     * Command to set collections manifest
+     */
+    set_collections_manifest = 0xb9,
+
+    /**
+     * Command to get collections manifest
+     */
     get_collections_manifest = 0xba,
+
+    /**
+     * Command to get a collection ID
+     */
     get_collection_id = 0xbb,
+
+    /**
+     * Command to get a scope ID
+     */
+    get_scope_id = 0xbc,
+
     subdoc_multi_lookup = 0xd0,
     subdoc_multi_mutation = 0xd1,
+
     get_cluster_config = 0xb5,
     get_error_map = 0xfe,
     invalid = 0xff,
@@ -66,6 +245,7 @@ enum class subdoc_opcode : uint8_t {
     array_add_unique = 0xce,
     counter = 0xcf,
     get_count = 0xd2,
+    replace_body_with_xattr = 0xd3,
 };
 
 constexpr inline bool
@@ -96,6 +276,52 @@ is_valid_client_opcode(uint8_t code)
         case client_opcode::increment:
         case client_opcode::decrement:
         case client_opcode::get_collection_id:
+        case client_opcode::noop:
+        case client_opcode::version:
+        case client_opcode::append:
+        case client_opcode::prepend:
+        case client_opcode::stat:
+        case client_opcode::verbosity:
+        case client_opcode::get_all_vbucket_seqnos:
+        case client_opcode::dcp_open:
+        case client_opcode::dcp_add_stream:
+        case client_opcode::dcp_close_stream:
+        case client_opcode::dcp_stream_request:
+        case client_opcode::dcp_get_failover_log:
+        case client_opcode::dcp_stream_end:
+        case client_opcode::dcp_snapshot_marker:
+        case client_opcode::dcp_mutation:
+        case client_opcode::dcp_deletion:
+        case client_opcode::dcp_expiration:
+        case client_opcode::dcp_set_vbucket_state:
+        case client_opcode::dcp_noop:
+        case client_opcode::dcp_buffer_acknowledgement:
+        case client_opcode::dcp_control:
+        case client_opcode::dcp_system_event:
+        case client_opcode::dcp_prepare:
+        case client_opcode::dcp_seqno_acknowledged:
+        case client_opcode::dcp_commit:
+        case client_opcode::dcp_abort:
+        case client_opcode::dcp_seqno_advanced:
+        case client_opcode::dcp_oso_snapshot:
+        case client_opcode::get_replica:
+        case client_opcode::list_buckets:
+        case client_opcode::observe_seqno:
+        case client_opcode::evict_key:
+        case client_opcode::get_failover_log:
+        case client_opcode::last_closed_checkpoint:
+        case client_opcode::get_meta:
+        case client_opcode::upsert_with_meta:
+        case client_opcode::insert_with_meta:
+        case client_opcode::remove_with_meta:
+        case client_opcode::create_checkpoint:
+        case client_opcode::checkpoint_persistence:
+        case client_opcode::return_meta:
+        case client_opcode::get_random_key:
+        case client_opcode::seqno_persistence:
+        case client_opcode::get_keys:
+        case client_opcode::set_collections_manifest:
+        case client_opcode::get_scope_id:
             return true;
     }
     return false;
@@ -119,6 +345,7 @@ is_valid_subdoc_opcode(uint8_t code)
         case subdoc_opcode::get_count:
         case subdoc_opcode::get_doc:
         case subdoc_opcode::set_doc:
+        case subdoc_opcode::replace_body_with_xattr:
             return true;
     }
     return false;
@@ -133,76 +360,214 @@ struct fmt::formatter<couchbase::protocol::client_opcode> : formatter<string_vie
         string_view name = "unknown";
         switch (opcode) {
             case couchbase::protocol::client_opcode::get:
-                name = "get";
+                name = "get (0x00)";
                 break;
             case couchbase::protocol::client_opcode::upsert:
-                name = "upsert";
+                name = "upsert (0x01)";
                 break;
             case couchbase::protocol::client_opcode::insert:
-                name = "insert";
+                name = "insert (0x02)";
                 break;
             case couchbase::protocol::client_opcode::replace:
-                name = "replace";
+                name = "replace (0x03)";
                 break;
             case couchbase::protocol::client_opcode::remove:
-                name = "remove";
+                name = "remove (0x04)";
                 break;
             case couchbase::protocol::client_opcode::hello:
-                name = "hello";
+                name = "hello (0x1f)";
                 break;
             case couchbase::protocol::client_opcode::sasl_list_mechs:
-                name = "sasl_list_mechs";
+                name = "sasl_list_mechs (0x20)";
                 break;
             case couchbase::protocol::client_opcode::sasl_auth:
-                name = "sasl_auth";
+                name = "sasl_auth (0x21)";
                 break;
             case couchbase::protocol::client_opcode::sasl_step:
-                name = "sasl_step";
+                name = "sasl_step (0x22)";
                 break;
             case couchbase::protocol::client_opcode::select_bucket:
-                name = "select_bucket";
+                name = "select_bucket (0x89)";
                 break;
             case couchbase::protocol::client_opcode::subdoc_multi_lookup:
-                name = "subdoc_multi_lookup";
+                name = "subdoc_multi_lookup (0xd0)";
                 break;
             case couchbase::protocol::client_opcode::subdoc_multi_mutation:
-                name = "subdoc_multi_mutation";
+                name = "subdoc_multi_mutation (0xd1)";
                 break;
             case couchbase::protocol::client_opcode::get_cluster_config:
-                name = "get_cluster_config";
+                name = "get_cluster_config (0xb5)";
                 break;
             case couchbase::protocol::client_opcode::get_error_map:
-                name = "get_error_map";
+                name = "get_error_map (0xfe)";
                 break;
             case couchbase::protocol::client_opcode::invalid:
-                name = "invalid";
+                name = "invalid (0xff)";
                 break;
             case couchbase::protocol::client_opcode::get_collections_manifest:
-                name = "get_collections_manifest";
+                name = "get_collections_manifest (0xba)";
                 break;
             case couchbase::protocol::client_opcode::touch:
-                name = "touch";
+                name = "touch (0x1c)";
                 break;
             case couchbase::protocol::client_opcode::observe:
-                name = "observe";
+                name = "observe (0x92)";
                 break;
             case couchbase::protocol::client_opcode::get_and_lock:
-                name = "get_and_lock";
+                name = "get_and_lock (0x94)";
                 break;
             case couchbase::protocol::client_opcode::unlock:
-                name = "unlock";
+                name = "unlock (0x95)";
                 break;
             case couchbase::protocol::client_opcode::get_and_touch:
-                name = "get_and_touch";
+                name = "get_and_touch (0x1d)";
                 break;
             case couchbase::protocol::client_opcode::increment:
-                name = "increment";
+                name = "increment (0x05)";
                 break;
             case couchbase::protocol::client_opcode::decrement:
-                name = "decrement";
+                name = "decrement (0x06)";
                 break;
             case couchbase::protocol::client_opcode::get_collection_id:
-                name = "get_collection_uid";
+                name = "get_collection_uid (0xbb)";
+                break;
+            case couchbase::protocol::client_opcode::noop:
+                name = "noop (0x0a)";
+                break;
+            case couchbase::protocol::client_opcode::version:
+                name = "version (0x0b)";
+                break;
+            case couchbase::protocol::client_opcode::append:
+                name = "append (0x0e)";
+                break;
+            case couchbase::protocol::client_opcode::prepend:
+                name = "prepend (0x0f)";
+                break;
+            case couchbase::protocol::client_opcode::stat:
+                name = "stat (0x10)";
+                break;
+            case couchbase::protocol::client_opcode::verbosity:
+                name = "verbosity (0x1b)";
+                break;
+            case couchbase::protocol::client_opcode::get_all_vbucket_seqnos:
+                name = "get_all_vbucket_seqnos (0x48)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_open:
+                name = "dcp_open (0x50)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_add_stream:
+                name = "dcp_add_stream (0x51)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_close_stream:
+                name = "dcp_add_stream (0x52)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_stream_request:
+                name = "dcp_stream_request (0x53)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_get_failover_log:
+                name = "dcp_get_failover_log (0x54)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_stream_end:
+                name = "dcp_stream_end (0x55)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_snapshot_marker:
+                name = "dcp_snapshot_marker (0x56)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_mutation:
+                name = "dcp_mutation (0x57)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_deletion:
+                name = "dcp_deletion (0x58)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_expiration:
+                name = "dcp_expiration (0x59)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_set_vbucket_state:
+                name = "dcp_expiration (0x5b)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_noop:
+                name = "dcp_noop (0x5c)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_buffer_acknowledgement:
+                name = "dcp_buffer_acknowledgement (0x5d)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_control:
+                name = "dcp_control (0x5e)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_system_event:
+                name = "dcp_system_event (0x5f)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_prepare:
+                name = "dcp_prepare (0x60)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_seqno_acknowledged:
+                name = "dcp_seqno_acknowledged (0x61)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_commit:
+                name = "dcp_commit (0x62)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_abort:
+                name = "dcp_abort (0x63)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_seqno_advanced:
+                name = "dcp_seqno_advanced (0x64)";
+                break;
+            case couchbase::protocol::client_opcode::dcp_oso_snapshot:
+                name = "dcp_oso_snapshot (0x65)";
+                break;
+            case couchbase::protocol::client_opcode::get_replica:
+                name = "dcp_get_replica (0x83)";
+                break;
+            case couchbase::protocol::client_opcode::list_buckets:
+                name = "list_buckets (0x87)";
+                break;
+            case couchbase::protocol::client_opcode::observe_seqno:
+                name = "observe_seqno (0x91)";
+                break;
+            case couchbase::protocol::client_opcode::evict_key:
+                name = "evict_key (0x93)";
+                break;
+            case couchbase::protocol::client_opcode::get_failover_log:
+                name = "get_failover_log (0x96)";
+                break;
+            case couchbase::protocol::client_opcode::last_closed_checkpoint:
+                name = "last_closed_checkpoint (0x97)";
+                break;
+            case couchbase::protocol::client_opcode::get_meta:
+                name = "get_meta (0xa0)";
+                break;
+            case couchbase::protocol::client_opcode::upsert_with_meta:
+                name = "upsert_with_meta (0xa2)";
+                break;
+            case couchbase::protocol::client_opcode::insert_with_meta:
+                name = "insert_with_meta (0xa4)";
+                break;
+            case couchbase::protocol::client_opcode::remove_with_meta:
+                name = "remove_with_meta (0xa8)";
+                break;
+            case couchbase::protocol::client_opcode::create_checkpoint:
+                name = "create_checkpoint (0xaa)";
+                break;
+            case couchbase::protocol::client_opcode::checkpoint_persistence:
+                name = "checkpoint_persistence (0xb1)";
+                break;
+            case couchbase::protocol::client_opcode::return_meta:
+                name = "return_meta (0xb2)";
+                break;
+            case couchbase::protocol::client_opcode::get_random_key:
+                name = "get_random_key (0xb6)";
+                break;
+            case couchbase::protocol::client_opcode::seqno_persistence:
+                name = "seqno_persistence (0xb7)";
+                break;
+            case couchbase::protocol::client_opcode::get_keys:
+                name = "get_keys (0xb8)";
+                break;
+            case couchbase::protocol::client_opcode::set_collections_manifest:
+                name = "set_collections_manifest (0xb9)";
+                break;
+            case couchbase::protocol::client_opcode::get_scope_id:
+                name = "get_scope_id (0xbc)";
                 break;
         }
         return formatter<string_view>::format(name, ctx);
@@ -217,46 +582,49 @@ struct fmt::formatter<couchbase::protocol::subdoc_opcode> : formatter<string_vie
         string_view name = "unknown";
         switch (opcode) {
             case couchbase::protocol::subdoc_opcode::get:
-                name = "get";
+                name = "get (0xc5)";
                 break;
             case couchbase::protocol::subdoc_opcode::exists:
-                name = "exists";
+                name = "exists (0xc6)";
                 break;
             case couchbase::protocol::subdoc_opcode::dict_add:
-                name = "dict_add";
+                name = "dict_add (0xc7)";
                 break;
             case couchbase::protocol::subdoc_opcode::dict_upsert:
-                name = "dict_upsert";
+                name = "dict_upsert (0xc8)";
                 break;
             case couchbase::protocol::subdoc_opcode::remove:
-                name = "remove";
+                name = "remove (0xc9)";
                 break;
             case couchbase::protocol::subdoc_opcode::replace:
-                name = "replace";
+                name = "replace (0xca)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_push_last:
-                name = "array_push_last";
+                name = "array_push_last (0xcb)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_push_first:
-                name = "array_push_first";
+                name = "array_push_first (0xcc)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_insert:
-                name = "array_insert";
+                name = "array_insert (0xcd)";
                 break;
             case couchbase::protocol::subdoc_opcode::array_add_unique:
-                name = "array_add_unique";
+                name = "array_add_unique (0xce)";
                 break;
             case couchbase::protocol::subdoc_opcode::counter:
-                name = "counter";
+                name = "counter (0xcf)";
                 break;
             case couchbase::protocol::subdoc_opcode::get_count:
-                name = "get_count";
+                name = "get_count (0xd2)";
                 break;
             case couchbase::protocol::subdoc_opcode::get_doc:
-                name = "get_doc";
+                name = "get_doc (0x00)";
                 break;
             case couchbase::protocol::subdoc_opcode::set_doc:
-                name = "set_doc";
+                name = "set_doc (0x01)";
+                break;
+            case couchbase::protocol::subdoc_opcode::replace_body_with_xattr:
+                name = "replace_body_with_xattr (0xd3)";
                 break;
         }
         return formatter<string_view>::format(name, ctx);