couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/mcbp/packet.cxx

@@ -20,73 +20,87 @@
 #include "../protocol/client_opcode_fmt.hxx"
 #include "../protocol/magic_fmt.hxx"
 
-#include <couchbase/fmt/key_value_status_code.hxx>
+#include "core/fmt/key_value_status_code.hxx"
 
 #include <fmt/core.h>
 #include <spdlog/fmt/bin_to_hex.h>
 
 namespace couchbase::core::mcbp
 {
-std::string
-packet::debug_string() const
+auto
+packet::debug_string() const -> std::string
 {
-    std::vector<char> out;
-    fmt::format_to(std::back_insert_iterator(out),
-                   "mcbp::packet{{magic:{:02x}({}), command:{:02x}({}), datatype:{:02x}, status:{:02x}({}), vbucket:{}({:04x}), "
-                   "opaque:{:08x}, cas:{:08x}, collection_id:{}({:08x})\nkey: {:a}\nvalue: {:a}\nextras: {:a}",
-                   static_cast<std::uint8_t>(magic_),
-                   magic_,
-                   static_cast<std::uint8_t>(command_),
-                   command_,
-                   datatype_,
-                   static_cast<std::uint16_t>(status_),
-                   status_,
-                   vbucket_,
-                   vbucket_,
-                   opaque_,
-                   cas_,
-                   collection_id_,
-                   collection_id_,
-                   spdlog::to_hex(key_),
-                   spdlog::to_hex(value_),
-                   spdlog::to_hex(extras_));
+  std::vector<char> out;
+  fmt::format_to(
+    std::back_insert_iterator(out),
+    "mcbp::packet{{magic:{:02x}({}), command:{:02x}({}), datatype:{:02x}, status:{:02x}({}), "
+    "vbucket:{}({:04x}), "
+    "opaque:{:08x}, cas:{:08x}, collection_id:{}({:08x})\nkey: {:a}\nvalue: {:a}\nextras: {:a}",
+    static_cast<std::uint8_t>(magic_),
+    magic_,
+    static_cast<std::uint8_t>(command_),
+    command_,
+    datatype_,
+    static_cast<std::uint16_t>(status_),
+    status_,
+    vbucket_,
+    vbucket_,
+    opaque_,
+    cas_,
+    collection_id_,
+    collection_id_,
+    spdlog::to_hex(key_),
+    spdlog::to_hex(value_),
+    spdlog::to_hex(extras_));
 
-    if (durability_level_frame_) {
-        fmt::format_to(
-          std::back_insert_iterator(out), "\ndurability level: {:02x}", static_cast<std::uint8_t>(durability_level_frame_->level));
-        if (durability_timeout_frame_) {
-            fmt::format_to(std::back_insert_iterator(out), "\ndurability timeout: {}ms", durability_timeout_frame_->timeout.count());
-        }
+  if (durability_level_frame_) {
+    fmt::format_to(std::back_insert_iterator(out),
+                   "\ndurability level: {:02x}",
+                   static_cast<std::uint8_t>(durability_level_frame_->level));
+    if (durability_timeout_frame_) {
+      fmt::format_to(std::back_insert_iterator(out),
+                     "\ndurability timeout: {}ms",
+                     durability_timeout_frame_->timeout.count());
     }
+  }
 
-    if (preserve_expiry_frame_) {
-        fmt::format_to(std::back_insert_iterator(out), "\npreserve expiry: true");
-    }
+  if (preserve_expiry_frame_) {
+    fmt::format_to(std::back_insert_iterator(out), "\npreserve expiry: true");
+  }
 
-    if (stream_id_frame_) {
-        fmt::format_to(std::back_insert_iterator(out), "\nstream id: {}", stream_id_frame_->stream_id);
-    }
+  if (stream_id_frame_) {
+    fmt::format_to(std::back_insert_iterator(out), "\nstream id: {}", stream_id_frame_->stream_id);
+  }
 
-    if (open_tracing_frame_) {
-        fmt::format_to(std::back_insert_iterator(out), "\ntrace context: {:a}", spdlog::to_hex(open_tracing_frame_->trace_context));
-    }
+  if (open_tracing_frame_) {
+    fmt::format_to(std::back_insert_iterator(out),
+                   "\ntrace context: {:a}",
+                   spdlog::to_hex(open_tracing_frame_->trace_context));
+  }
 
-    if (server_duration_frame_) {
-        fmt::format_to(std::back_insert_iterator(out), "\nserver duration: {}ms", server_duration_frame_->server_duration.count());
-    }
+  if (server_duration_frame_) {
+    fmt::format_to(std::back_insert_iterator(out),
+                   "\nserver duration: {}ms",
+                   server_duration_frame_->server_duration.count());
+  }
 
-    if (user_impersonation_frame_) {
-        fmt::format_to(std::back_insert_iterator(out), "\nuser: {:a}", spdlog::to_hex(user_impersonation_frame_->user));
-    }
+  if (user_impersonation_frame_) {
+    fmt::format_to(std::back_insert_iterator(out),
+                   "\nuser: {:a}",
+                   spdlog::to_hex(user_impersonation_frame_->user));
+  }
 
-    if (!unsupported_frames_.empty()) {
-        fmt::format_to(std::back_insert_iterator(out), "\nunsupported frames:");
-        for (const auto& frame : unsupported_frames_) {
-            fmt::format_to(std::back_insert_iterator(out), "\nframe type: {}, data: {:n}", frame.type, spdlog::to_hex(frame.data));
-        }
+  if (!unsupported_frames_.empty()) {
+    fmt::format_to(std::back_insert_iterator(out), "\nunsupported frames:");
+    for (const auto& frame : unsupported_frames_) {
+      fmt::format_to(std::back_insert_iterator(out),
+                     "\nframe type: {}, data: {:n}",
+                     frame.type,
+                     spdlog::to_hex(frame.data));
     }
+  }
 
-    fmt::format_to(std::back_insert_iterator(out), "}}");
-    return { out.begin(), out.end() };
+  fmt::format_to(std::back_insert_iterator(out), "}}");
+  return { out.begin(), out.end() };
 }
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/packet.hxx

@@ -40,32 +40,32 @@ namespace couchbase::core::mcbp
 {
 class packet
 {
-  public:
-    [[nodiscard]] std::string debug_string() const;
+public:
+  [[nodiscard]] auto debug_string() const -> std::string;
 
-    protocol::magic magic_;
-    protocol::client_opcode command_;
-    std::byte datatype_{};
-    std::uint16_t status_{ 0x00 };
-    key_value_status_code status_code_{ key_value_status_code::success };
-    std::uint16_t vbucket_{};
-    std::uint32_t opaque_{};
-    std::uint64_t cas_{};
-    std::uint32_t collection_id_{};
-    std::vector<std::byte> key_{};
-    std::vector<std::byte> extras_{};
-    std::vector<std::byte> value_{};
+  protocol::magic magic_;
+  protocol::client_opcode command_;
+  std::byte datatype_{};
+  std::uint16_t status_{ 0x00 };
+  key_value_status_code status_code_{ key_value_status_code::success };
+  std::uint16_t vbucket_{};
+  std::uint32_t opaque_{};
+  std::uint64_t cas_{};
+  std::uint32_t collection_id_{};
+  std::vector<std::byte> key_{};
+  std::vector<std::byte> extras_{};
+  std::vector<std::byte> value_{};
 
-    std::optional<barrier_frame> barrier_frame_{};
-    std::optional<durability_level_frame> durability_level_frame_{};
-    std::optional<durability_timeout_frame> durability_timeout_frame_{};
-    std::optional<stream_id_frame> stream_id_frame_{};
-    std::optional<open_tracing_frame> open_tracing_frame_{};
-    std::optional<server_duration_frame> server_duration_frame_{};
-    std::optional<user_impersonation_frame> user_impersonation_frame_{};
-    std::optional<preserve_expiry_frame> preserve_expiry_frame_{};
-    std::optional<read_units_frame> read_units_frame_{};
-    std::optional<write_units_frame> write_units_frame_{};
-    std::vector<unsupported_frame> unsupported_frames_{};
+  std::optional<barrier_frame> barrier_frame_{};
+  std::optional<durability_level_frame> durability_level_frame_{};
+  std::optional<durability_timeout_frame> durability_timeout_frame_{};
+  std::optional<stream_id_frame> stream_id_frame_{};
+  std::optional<open_tracing_frame> open_tracing_frame_{};
+  std::optional<server_duration_frame> server_duration_frame_{};
+  std::optional<user_impersonation_frame> user_impersonation_frame_{};
+  std::optional<preserve_expiry_frame> preserve_expiry_frame_{};
+  std::optional<read_units_frame> read_units_frame_{};
+  std::optional<write_units_frame> write_units_frame_{};
+  std::vector<unsupported_frame> unsupported_frames_{};
 };
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/preserve_expiry_frame.hxx

@@ -19,8 +19,10 @@
 
 namespace couchbase::core::mcbp
 {
-// preserve_expiry_frame is used to indicate that the server should preserve the expiry time for existing document.
+// preserve_expiry_frame is used to indicate that the server should preserve the expiry time for
+// existing document.
 struct preserve_expiry_frame {
-    // Preserve Expiry frames have no extra configuration, but their existence triggers the preserve expiry behaviour.
+  // Preserve Expiry frames have no extra configuration, but their existence triggers the preserve
+  // expiry behaviour.
 };
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/queue_callback.hxx

@@ -28,7 +28,8 @@ namespace couchbase::core::mcbp
 class queue_request;
 class queue_response;
 
-using queue_callback =
-  utils::movable_function<void(std::shared_ptr<queue_response> response, std::shared_ptr<queue_request> request, std::error_code error)>;
+using queue_callback = utils::movable_function<void(std::shared_ptr<queue_response> response,
+                                                    std::shared_ptr<queue_request> request,
+                                                    std::error_code error)>;
 
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/queue_request.cxx

@@ -27,148 +27,151 @@
 
 namespace couchbase::core::mcbp
 {
-queue_request::queue_request(protocol::magic magic, protocol::client_opcode opcode, queue_callback&& callback)
+queue_request::queue_request(protocol::magic magic,
+                             protocol::client_opcode opcode,
+                             queue_callback&& callback)
   : mcbp::packet{ magic, opcode }
   , callback_{ std::move(callback) }
 {
 }
 
-std::size_t
-queue_request::retry_attempts() const
+auto
+queue_request::retry_attempts() const -> std::size_t
 {
-    std::scoped_lock lock(retry_mutex_);
-    return retry_count_;
+  std::scoped_lock lock(retry_mutex_);
+  return retry_count_;
 }
 
-std::string
-queue_request::identifier() const
+auto
+queue_request::identifier() const -> std::string
 {
-    return std::to_string(opaque_);
+  return std::to_string(opaque_);
 }
 
-bool
-queue_request::idempotent() const
+auto
+queue_request::idempotent() const -> bool
 {
-    return mcbp::is_idempotent(command_);
+  return mcbp::is_idempotent(command_);
 }
 
-std::set<retry_reason>
-queue_request::retry_reasons() const
+auto
+queue_request::retry_reasons() const -> std::set<retry_reason>
 {
-    std::scoped_lock lock(retry_mutex_);
-    return retry_reasons_;
+  std::scoped_lock lock(retry_mutex_);
+  return retry_reasons_;
 }
 
 void
 queue_request::record_retry_attempt(retry_reason reason)
 {
-    std::scoped_lock lock(retry_mutex_);
-    ++retry_count_;
-    retry_reasons_.insert(reason);
+  std::scoped_lock lock(retry_mutex_);
+  ++retry_count_;
+  retry_reasons_.insert(reason);
 }
 
 auto
 queue_request::retries() const -> std::pair<std::size_t, std::set<retry_reason>>
 {
-    std::scoped_lock lock(retry_mutex_);
-    return { retry_count_, retry_reasons_ };
+  std::scoped_lock lock(retry_mutex_);
+  return { retry_count_, retry_reasons_ };
 }
 
 auto
 queue_request::connection_info() const -> queue_request_connection_info
 {
-    std::scoped_lock lock(connection_info_mutex_);
-    return connection_info_;
+  std::scoped_lock lock(connection_info_mutex_);
+  return connection_info_;
 }
 
 auto
 queue_request::is_cancelled() const -> bool
 {
-    return is_completed_.load();
+  return is_completed_.load();
 }
 
 static inline void
 cancel_timer(std::shared_ptr<asio::steady_timer> timer)
 {
-    if (auto t = std::move(timer); t) {
-        t->cancel();
-    }
+  if (auto t = std::move(timer); t) {
+    t->cancel();
+  }
 }
 
 auto
 queue_request::internal_cancel() -> bool
 {
-    std::scoped_lock lock(processing_mutex_);
+  std::scoped_lock lock(processing_mutex_);
 
-    if (bool expected_state{ false }; !is_completed_.compare_exchange_strong(expected_state, true)) {
-        // someone already completed this request
-        return false;
-    }
+  if (bool expected_state{ false }; !is_completed_.compare_exchange_strong(expected_state, true)) {
+    // someone already completed this request
+    return false;
+  }
 
-    cancel_timer(deadline_);
-    cancel_timer(retry_backoff_);
+  cancel_timer(deadline_);
+  cancel_timer(retry_backoff_);
 
-    if (auto* queued_with = queued_with_.load(); queued_with) {
-        queued_with->remove(shared_from_this());
-    }
-    if (auto* waiting_in = waiting_in_.load(); waiting_in) {
-        waiting_in->remove_request(shared_from_this());
-    }
+  if (auto* queued_with = queued_with_.load(); queued_with) {
+    queued_with->remove(shared_from_this());
+  }
+  if (auto* waiting_in = waiting_in_.load(); waiting_in) {
+    waiting_in->remove_request(shared_from_this());
+  }
 
-    return true;
+  return true;
 }
 
 void
 queue_request::cancel(std::error_code error)
 {
-    if (internal_cancel()) {
-        callback_({}, shared_from_this(), error);
-    }
+  if (internal_cancel()) {
+    callback_({}, shared_from_this(), error);
+  }
 }
 
 void
 queue_request::set_deadline(std::shared_ptr<asio::steady_timer> timer)
 {
-    deadline_ = std::move(timer);
+  deadline_ = std::move(timer);
 }
 
 void
 queue_request::set_retry_backoff(std::shared_ptr<asio::steady_timer> timer)
 {
-    retry_backoff_ = std::move(timer);
+  retry_backoff_ = std::move(timer);
 }
 
 void
 queue_request::try_callback(std::shared_ptr<queue_response> response, std::error_code error)
 {
-    cancel_timer(deadline_);
-    cancel_timer(retry_backoff_);
-
-    if (persistent_) {
-        if (error) {
-            if (internal_cancel()) {
-                return callback_(std::move(response), shared_from_this(), error);
-            }
-        } else if (!is_completed_) {
-            return callback_(std::move(response), shared_from_this(), error);
-        }
-        return;
-    }
-    if (bool expected_state{ false }; is_completed_.compare_exchange_strong(expected_state, true)) {
+  cancel_timer(deadline_);
+  cancel_timer(retry_backoff_);
+
+  if (persistent_) {
+    if (error) {
+      if (internal_cancel()) {
         return callback_(std::move(response), shared_from_this(), error);
+      }
+    } else if (!is_completed_) {
+      return callback_(std::move(response), shared_from_this(), error);
     }
+    return;
+  }
+  if (bool expected_state{ false }; is_completed_.compare_exchange_strong(expected_state, true)) {
+    return callback_(std::move(response), shared_from_this(), error);
+  }
 }
 
 void
 queue_request::cancel()
 {
-    // Try to perform the cancellation, if it succeeds, we call the callback immediately on the user's behalf.
-    return cancel(errc::common::request_canceled);
+  // Try to perform the cancellation, if it succeeds, we call the callback immediately on the user's
+  // behalf.
+  return cancel(errc::common::request_canceled);
 }
 
 auto
 queue_request::retry_strategy() const -> std::shared_ptr<couchbase::retry_strategy>
 {
-    return retry_strategy_;
+  return retry_strategy_;
 }
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/queue_request.hxx

@@ -46,75 +46,77 @@ class queue_request
   , public retry_request
   , public pending_operation
 {
-  public:
-    queue_request(protocol::magic magic, protocol::client_opcode opcode, queue_callback&& callback);
-    ~queue_request() override = default;
+public:
+  queue_request(protocol::magic magic, protocol::client_opcode opcode, queue_callback&& callback);
+  ~queue_request() override = default;
 
-    [[nodiscard]] auto retry_attempts() const -> std::size_t override;
-    [[nodiscard]] auto identifier() const -> std::string override;
-    [[nodiscard]] auto idempotent() const -> bool override;
-    [[nodiscard]] auto retry_reasons() const -> std::set<retry_reason> override;
+  [[nodiscard]] auto retry_attempts() const -> std::size_t override;
+  [[nodiscard]] auto identifier() const -> std::string override;
+  [[nodiscard]] auto idempotent() const -> bool override;
+  [[nodiscard]] auto retry_reasons() const -> std::set<retry_reason> override;
 
-    [[nodiscard]] auto retries() const -> std::pair<std::size_t, std::set<retry_reason>>;
-    [[nodiscard]] auto connection_info() const -> queue_request_connection_info;
+  [[nodiscard]] auto retries() const -> std::pair<std::size_t, std::set<retry_reason>>;
+  [[nodiscard]] auto connection_info() const -> queue_request_connection_info;
 
-    void record_retry_attempt(retry_reason reason) override;
-    [[nodiscard]] auto retry_strategy() const -> std::shared_ptr<retry_strategy>;
+  void record_retry_attempt(retry_reason reason) override;
+  [[nodiscard]] auto retry_strategy() const -> std::shared_ptr<retry_strategy>;
 
-    [[nodiscard]] auto is_cancelled() const -> bool;
-    void cancel() override;
-    void cancel(std::error_code error);
-    void try_callback(std::shared_ptr<queue_response> response, std::error_code error);
-    auto internal_cancel() -> bool;
+  [[nodiscard]] auto is_cancelled() const -> bool;
+  void cancel() override;
+  void cancel(std::error_code error);
+  void try_callback(std::shared_ptr<queue_response> response, std::error_code error);
+  auto internal_cancel() -> bool;
 
-    void set_deadline(std::shared_ptr<asio::steady_timer> timer);
-    void set_retry_backoff(std::shared_ptr<asio::steady_timer> timer);
+  void set_deadline(std::shared_ptr<asio::steady_timer> timer);
+  void set_retry_backoff(std::shared_ptr<asio::steady_timer> timer);
 
-    std::string collection_name_{};
-    std::string scope_name_{};
-    std::size_t replica_index_{ 0 };
-    // This tracks when the request was dispatched so that we can properly prioritize older requests to try and meet timeout requirements.
-    std::chrono::steady_clock::time_point dispatched_time_{};
-    bool persistent_{ false };
+  std::string collection_name_{};
+  std::string scope_name_{};
+  std::size_t replica_index_{ 0 };
+  // This tracks when the request was dispatched so that we can properly prioritize older requests
+  // to try and meet timeout requirements.
+  std::chrono::steady_clock::time_point dispatched_time_{};
+  bool persistent_{ false };
 
-    // This stores a pointer to the operation_map that currently is holding this request.  This allows us to remove it form that list
-    // whenever the request is cancelled
-    std::atomic<operation_map*> waiting_in_{ nullptr };
+  // This stores a pointer to the operation_map that currently is holding this request.  This allows
+  // us to remove it form that list whenever the request is cancelled
+  std::atomic<operation_map*> waiting_in_{ nullptr };
 
-    // This is used to determine what, if any, retry strategy to use when deciding whether to retry the request and calculating any back-off
-    // time period.
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy_{};
+  // This is used to determine what, if any, retry strategy to use when deciding whether to retry
+  // the request and calculating any back-off time period.
+  std::shared_ptr<couchbase::retry_strategy> retry_strategy_{};
 
-  private:
-    // Static routing properties
-    queue_callback callback_;
+private:
+  // Static routing properties
+  queue_callback callback_;
 
-    // This stores a pointer to the server that currently own this request.  This allows us to remove it from that list whenever the request
-    // is cancelled.
-    std::atomic<operation_queue*> queued_with_{ nullptr };
+  // This stores a pointer to the server that currently own this request.  This allows us to remove
+  // it from that list whenever the request is cancelled.
+  std::atomic<operation_queue*> queued_with_{ nullptr };
 
-    // This keeps track of whether the request has been 'completed' which is synonymous with the callback having been invoked. This is an
-    // integer to allow us to atomically control it.
-    std::atomic_bool is_completed_{ false };
+  // This keeps track of whether the request has been 'completed' which is synonymous with the
+  // callback having been invoked. This is an integer to allow us to atomically control it.
+  std::atomic_bool is_completed_{ false };
 
-    // This is used to lock access to the request when processing a timeout, a response or spans
-    mutable std::mutex processing_mutex_{};
+  // This is used to lock access to the request when processing a timeout, a response or spans
+  mutable std::mutex processing_mutex_{};
 
-    // This stores the number of times that the item has been retried. It is used for various non-linear retry algorithms.
-    std::size_t retry_count_{ 0 };
+  // This stores the number of times that the item has been retried. It is used for various
+  // non-linear retry algorithms.
+  std::size_t retry_count_{ 0 };
 
-    // This is the set of reasons why this request has been retried.
-    std::set<retry_reason> retry_reasons_{};
+  // This is the set of reasons why this request has been retried.
+  std::set<retry_reason> retry_reasons_{};
 
-    // This is used to lock access to the request when processing retry reasons or attempts.
-    mutable std::mutex retry_mutex_{};
+  // This is used to lock access to the request when processing retry reasons or attempts.
+  mutable std::mutex retry_mutex_{};
 
-    queue_request_connection_info connection_info_{};
-    mutable std::mutex connection_info_mutex_{};
+  queue_request_connection_info connection_info_{};
+  mutable std::mutex connection_info_mutex_{};
 
-    std::shared_ptr<asio::steady_timer> deadline_{};
-    std::shared_ptr<asio::steady_timer> retry_backoff_{};
+  std::shared_ptr<asio::steady_timer> deadline_{};
+  std::shared_ptr<asio::steady_timer> retry_backoff_{};
 
-    friend operation_queue;
+  friend operation_queue;
 };
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/queue_request_connection_info.hxx

@@ -22,8 +22,8 @@
 namespace couchbase::core::mcbp
 {
 struct queue_request_connection_info {
-    std::string last_dispatched_to{};
-    std::string last_dispatched_from{};
-    std::string last_connection_id{};
+  std::string last_dispatched_to{};
+  std::string last_dispatched_from{};
+  std::string last_connection_id{};
 };
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/queue_response.hxx

@@ -25,13 +25,13 @@ namespace couchbase::core::mcbp
 {
 class queue_response : public packet
 {
-  public:
-    explicit queue_response(packet&& pkt)
-      : packet{ pkt }
-    {
-    }
+public:
+  explicit queue_response(packet&& pkt)
+    : packet{ pkt }
+  {
+  }
 
-    std::string source_address_{};
-    std::string source_connection_id_{};
+  std::string source_address_{};
+  std::string source_connection_id_{};
 };
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/read_units_frame.hxx

@@ -21,8 +21,9 @@
 
 namespace couchbase::core::mcbp
 {
-// read_units_frame allows the server to return information about the number of read units used by a command.
+// read_units_frame allows the server to return information about the number of read units used by a
+// command.
 struct read_units_frame {
-    std::uint16_t read_units;
+  std::uint16_t read_units;
 };
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/server_duration.cxx

@@ -24,17 +24,17 @@ namespace couchbase::core::mcbp
 auto
 encode_server_duration(std::chrono::microseconds duration) -> std::uint16_t
 {
-    auto encoded = std::pow(static_cast<double>(duration.count()) * 2, 1.0 / 1.74);
-    if (encoded > 65535) {
-        return 65535;
-    }
-    return static_cast<std::uint16_t>(encoded);
+  auto encoded = std::pow(static_cast<double>(duration.count()) * 2, 1.0 / 1.74);
+  if (encoded > 65535) {
+    return 65535;
+  }
+  return static_cast<std::uint16_t>(encoded);
 }
 
 auto
 decode_server_duration(std::uint16_t encoded) -> std::chrono::microseconds
 {
-    auto decoded = std::pow(static_cast<double>(encoded), 1.74) / 2;
-    return std::chrono::microseconds{ static_cast<std::uint64_t>(decoded) };
+  auto decoded = std::pow(static_cast<double>(encoded), 1.74) / 2;
+  return std::chrono::microseconds{ static_cast<std::uint64_t>(decoded) };
 }
 } // namespace couchbase::core::mcbp

data/ext/couchbase/core/mcbp/server_duration_frame.hxx

@@ -21,8 +21,9 @@
 
 namespace couchbase::core::mcbp
 {
-// server_duration_frame allows the server to return information about the period of time an operation took to complete.
+// server_duration_frame allows the server to return information about the period of time an
+// operation took to complete.
 struct server_duration_frame {
-    std::chrono::microseconds server_duration;
+  std::chrono::microseconds server_duration;
 };
 } // namespace couchbase::core::mcbp