couchbase 3.5.1 → 3.5.2

data/ext/couchbase/couchbase/metrics/otel_meter.hxx

@@ -36,96 +36,108 @@ namespace couchbase::metrics
 
 class otel_sync_histogram
 {
-  public:
-    otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter)
-      : histogram_counter_(histogram_counter)
-    {
-    }
-    void record(uint64_t value, const opentelemetry::common::KeyValueIterable& tags, opentelemetry::context::Context& ctx)
-    {
-        // overflow
-        if (value > LONG_MAX) {
-            value = LONG_MAX;
-        }
-        long lvalue = static_cast<long>(value);
-        histogram_counter_->Record(lvalue, tags, ctx);
+public:
+  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter)
+    : histogram_counter_(histogram_counter)
+  {
+  }
+  void record(uint64_t value,
+              const opentelemetry::common::KeyValueIterable& tags,
+              opentelemetry::context::Context& ctx)
+  {
+    // overflow
+    if (value > LONG_MAX) {
+      value = LONG_MAX;
     }
+    long lvalue = static_cast<long>(value);
+    histogram_counter_->Record(lvalue, tags, ctx);
+  }
 
-  private:
-    nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
-    std::mutex mutex_;
+private:
+  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  std::mutex mutex_;
 };
 
 class otel_value_recorder : public couchbase::metrics::value_recorder
 {
-  public:
-    explicit otel_value_recorder(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter,
-                                 const std::map<std::string, std::string>& tags)
-      : histogram_counter_(histogram_counter)
-      , tags_(tags)
-    {
-    }
-    void record_value(std::int64_t value) override
-    {
-        if (value > LONG_MAX) {
-            value = LONG_MAX;
-        }
-        long lvalue = static_cast<long>(value);
-        histogram_counter_->Record(value, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
+public:
+  explicit otel_value_recorder(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter,
+                               const std::map<std::string, std::string>& tags)
+    : histogram_counter_(histogram_counter)
+    , tags_(tags)
+  {
+  }
+  void record_value(std::int64_t value) override
+  {
+    if (value > LONG_MAX) {
+      value = LONG_MAX;
     }
+    long lvalue = static_cast<long>(value);
+    histogram_counter_->Record(
+      value, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
+  }
 
-    const std::map<std::string, std::string> tags()
-    {
-        return tags_;
-    }
+  const std::map<std::string, std::string> tags()
+  {
+    return tags_;
+  }
 
-    nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter()
-    {
-        return histogram_counter_;
-    }
+  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter()
+  {
+    return histogram_counter_;
+  }
 
-  private:
-    nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
-    const std::map<std::string, std::string> tags_;
-    opentelemetry::context::Context context_{};
-    std::mutex mutex_;
+private:
+  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  const std::map<std::string, std::string> tags_;
+  opentelemetry::context::Context context_{};
+  std::mutex mutex_;
 };
 
 class otel_meter : public couchbase::metrics::meter
 {
-  public:
-    explicit otel_meter(nostd::shared_ptr<metrics_api::Meter> meter)
-      : meter_(meter)
-    {
-    }
+public:
+  explicit otel_meter(nostd::shared_ptr<metrics_api::Meter> meter)
+    : meter_(meter)
+  {
+  }
 
-    std::shared_ptr<value_recorder> get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags) override
-    {
-        // first look up the histogram, in case we already have it...
-        std::scoped_lock<std::mutex> lock(mutex_);
-        auto it = recorders_.equal_range(name);
-        if (it.first == it.second) {
-            // this name isn't associated with any histogram, so make one and return it.
-            // Note we'd like to make one with more buckets than default, given the range of
-            // response times we'd like to display (queries vs kv for instance), but otel
-            // api doesn't seem to allow this.
-            return recorders_.insert({ name, std::make_shared<otel_value_recorder>(meter_->CreateLongHistogram(name, "", "us"), tags) })
-              ->second;
-        }
-        // so it is already, lets see if we already have one with those tags, or need
-        // to make a new one (using the histogram we already have).
-        for (auto itr = it.first; itr != it.second; itr++) {
-            if (tags == itr->second->tags()) {
-                return itr->second;
-            }
-        }
-        // if you are here, we need to add one with these tags and the histogram associated with the name.
-        return recorders_.insert({ name, std::make_shared<otel_value_recorder>(it.first->second->histogram_counter(), tags) })->second;
+  auto get_value_recorder(const std::string& name, const std::map<std::string, std::string>& tags)
+    -> std::shared_ptr<value_recorder> override
+  {
+    // first look up the histogram, in case we already have it...
+    std::scoped_lock<std::mutex> lock(mutex_);
+    auto it = recorders_.equal_range(name);
+    if (it.first == it.second) {
+      // this name isn't associated with any histogram, so make one and return it.
+      // Note we'd like to make one with more buckets than default, given the range of
+      // response times we'd like to display (queries vs kv for instance), but otel
+      // api doesn't seem to allow this.
+      return recorders_
+        .insert({ name,
+                  std::make_shared<otel_value_recorder>(meter_->CreateLongHistogram(name, "", "us"),
+                                                        tags) })
+        ->second;
+    }
+    // so it is already, lets see if we already have one with those tags, or need
+    // to make a new one (using the histogram we already have).
+    for (auto itr = it.first; itr != it.second; itr++) {
+      if (tags == itr->second->tags()) {
+        return itr->second;
+      }
     }
+    // if you are here, we need to add one with these tags and the histogram associated with the
+    // name.
+    return recorders_
+      .insert(
+        { name,
+          std::make_shared<otel_value_recorder>(it.first->second->histogram_counter(), tags) })
+      ->second;
+  }
 
-  private:
-    nostd::shared_ptr<metrics_api::Meter> meter_;
-    std::mutex mutex_;
-    std::multimap<std::string, std::shared_ptr<otel_value_recorder>> recorders_;
+private:
+  nostd::shared_ptr<metrics_api::Meter> meter_;
+  std::mutex mutex_;
+  std::multimap<std::string, std::shared_ptr<otel_value_recorder>> recorders_;
 };
 } // namespace couchbase::metrics

data/ext/couchbase/couchbase/metrics_options.hxx

@@ -27,45 +27,45 @@ namespace couchbase
 {
 class metrics_options
 {
-  public:
-    static constexpr std::chrono::milliseconds default_emit_interval{ std::chrono::minutes{ 10 } };
+public:
+  static constexpr std::chrono::milliseconds default_emit_interval{ std::chrono::minutes{ 10 } };
 
-    auto enable(bool enable) -> metrics_options&
-    {
-        enabled_ = enable;
-        return *this;
-    }
+  auto enable(bool enable) -> metrics_options&
+  {
+    enabled_ = enable;
+    return *this;
+  }
 
-    auto emit_interval(std::chrono::milliseconds interval) -> metrics_options&
-    {
-        emit_interval_ = interval;
-        return *this;
-    }
+  auto emit_interval(std::chrono::milliseconds interval) -> metrics_options&
+  {
+    emit_interval_ = interval;
+    return *this;
+  }
 
-    auto meter(std::shared_ptr<metrics::meter> custom_meter) -> metrics_options&
-    {
-        meter_ = std::move(custom_meter);
-        return *this;
-    }
+  auto meter(std::shared_ptr<metrics::meter> custom_meter) -> metrics_options&
+  {
+    meter_ = std::move(custom_meter);
+    return *this;
+  }
 
-    struct built {
-        bool enabled;
-        std::chrono::milliseconds emit_interval;
-        std::shared_ptr<metrics::meter> meter;
-    };
+  struct built {
+    bool enabled;
+    std::chrono::milliseconds emit_interval;
+    std::shared_ptr<metrics::meter> meter;
+  };
 
-    [[nodiscard]] auto build() const -> built
-    {
-        return {
-            enabled_,
-            emit_interval_,
-            meter_,
-        };
-    }
+  [[nodiscard]] auto build() const -> built
+  {
+    return {
+      enabled_,
+      emit_interval_,
+      meter_,
+    };
+  }
 
-  private:
-    bool enabled_{ true };
-    std::chrono::milliseconds emit_interval_{ default_emit_interval };
-    std::shared_ptr<metrics::meter> meter_{ nullptr };
+private:
+  bool enabled_{ true };
+  std::chrono::milliseconds emit_interval_{ default_emit_interval };
+  std::shared_ptr<metrics::meter> meter_{ nullptr };
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/mutate_in_options.hxx

@@ -21,10 +21,10 @@
 
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/common_durability_options.hxx>
+#include <couchbase/error.hxx>
 #include <couchbase/expiry.hxx>
 #include <couchbase/mutate_in_result.hxx>
 #include <couchbase/store_semantics.hxx>
-#include <couchbase/subdocument_error_context.hxx>
 
 #include <chrono>
 #include <functional>
@@ -42,161 +42,172 @@ namespace couchbase
  * @committed
  */
 struct mutate_in_options : public common_durability_options<mutate_in_options> {
-    /**
-     * Immutable value object representing consistent options.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    struct built : public common_durability_options<mutate_in_options>::built {
-        const std::uint32_t expiry;
-        const bool preserve_expiry;
-        const couchbase::store_semantics store_semantics;
-        const couchbase::cas cas;
-        const bool access_deleted;
-        const bool create_as_deleted;
-    };
+  /**
+   * Immutable value object representing consistent options.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  struct built : public common_durability_options<mutate_in_options>::built {
+    const std::uint32_t expiry;
+    const bool preserve_expiry;
+    const couchbase::store_semantics store_semantics;
+    const couchbase::cas cas;
+    const bool access_deleted;
+    const bool create_as_deleted;
+  };
 
-    /**
-     * Validates options and returns them as an immutable value.
-     *
-     * @return consistent options as an immutable value
-     *
-     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    [[nodiscard]] auto build() const -> built
-    {
-        auto base = build_common_durability_options();
-        return { base, expiry_, preserve_expiry_, store_semantics_, cas_, access_deleted_, create_as_deleted_ };
-    }
+  /**
+   * Validates options and returns them as an immutable value.
+   *
+   * @return consistent options as an immutable value
+   *
+   * @exception std::system_error with code errc::common::invalid_argument if the options are not
+   * valid
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  [[nodiscard]] auto build() const -> built
+  {
+    auto base = build_common_durability_options();
+    return { base, expiry_,         preserve_expiry_,  store_semantics_,
+             cas_, access_deleted_, create_as_deleted_ };
+  }
 
-    /**
-     * Specifies whether an existing document's expiry should be preserved. Defaults to false.
-     *
-     * If true, and the document exists, its expiry will not be modified. Otherwise the document's expiry is determined by
-     * {@link #expiry(std::chrono::seconds)} or {@link #expiry(std::chrono::system_clock::time_point)}.
-     *
-     * Requires Couchbase Server 7.0 or later.
-     *
-     * @param preserve `true` to preserve expiry, `false` to set new expiry
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto preserve_expiry(bool preserve) -> mutate_in_options&
-    {
-        preserve_expiry_ = preserve;
-        return self();
-    }
+  /**
+   * Specifies whether an existing document's expiry should be preserved. Defaults to false.
+   *
+   * If true, and the document exists, its expiry will not be modified. Otherwise the document's
+   * expiry is determined by
+   * {@link #expiry(std::chrono::seconds)} or {@link
+   * #expiry(std::chrono::system_clock::time_point)}.
+   *
+   * Requires Couchbase Server 7.0 or later.
+   *
+   * @param preserve `true` to preserve expiry, `false` to set new expiry
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto preserve_expiry(bool preserve) -> mutate_in_options&
+  {
+    preserve_expiry_ = preserve;
+    return self();
+  }
 
-    /**
-     * Sets the expiry for the document. By default the document will never expire.
-     *
-     * The duration must be less than 50 years. For expiry further in the future, use
-     * {@link #expiry(std::chrono::system_clock::time_point)}.
-     *
-     * @param duration the duration after which the document will expire (zero duration means never expire).
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto expiry(std::chrono::seconds duration) -> mutate_in_options&
-    {
-        expiry_ = core::impl::expiry_relative(duration);
-        return self();
-    }
+  /**
+   * Sets the expiry for the document. By default the document will never expire.
+   *
+   * The duration must be less than 50 years. For expiry further in the future, use
+   * {@link #expiry(std::chrono::system_clock::time_point)}.
+   *
+   * @param duration the duration after which the document will expire (zero duration means never
+   * expire).
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto expiry(std::chrono::seconds duration) -> mutate_in_options&
+  {
+    expiry_ = core::impl::expiry_relative(duration);
+    return self();
+  }
 
-    /**
-     * Sets the expiry for the document. By default the document will never expire.
-     *
-     * @param time_point the point in time when the document will expire (epoch second zero means never expire).
-     * @return this options class for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto expiry(std::chrono::system_clock::time_point time_point) -> mutate_in_options&
-    {
-        expiry_ = core::impl::expiry_absolute(time_point);
-        return self();
-    }
+  /**
+   * Sets the expiry for the document. By default the document will never expire.
+   *
+   * @param time_point the point in time when the document will expire (epoch second zero means
+   * never expire).
+   * @return this options class for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto expiry(std::chrono::system_clock::time_point time_point) -> mutate_in_options&
+  {
+    expiry_ = core::impl::expiry_absolute(time_point);
+    return self();
+  }
 
-    /**
-     * Specifies a CAS value that will be taken into account on the server side for optimistic concurrency.
-     *
-     * The CAS value is an opaque identifier which is associated with a specific state of the document on the server. The
-     * CAS value is received on read operations (or after mutations) and can be used during a subsequent mutation to
-     * make sure that the document has not been modified in the meantime.
-     *
-     * If document on the server has been modified in the meantime the SDK will raise a {@link errc::common::cas_mismatch}. In
-     * this case the caller is expected to re-do the whole "fetch-modify-update" cycle again. Please refer to the
-     * SDK documentation for more information on CAS mismatches and subsequent retries.
-     *
-     * @param cas the opaque CAS identifier to use for this operation.
-     * @return the {@link mutate_in_options} for chaining purposes.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto cas(couchbase::cas cas) -> mutate_in_options&
-    {
-        cas_ = cas;
-        return self();
-    }
-    /**
-     * Changes the storing semantics of the outer/enclosing document.
-     *
-     * While each individual {@link mutate_in_specs} describes the semantics of the respective sub-document section, the
-     * {@link store_semantics} are applied to the outer enclosing document as a whole. You can think of using the same
-     * verb for a {@link couchbase::store_semantics store_semantics} aligns with the corresponding full document. So for example a
-     * {@link store_semantics::insert} works semantically similar to a {@link collection#insert()} and will fail if the document as a whole
-     * already exists.
-     *
-     * @param semantics the store semantics to apply to the document.
-     * @return this {@link mutate_in_options} for chaining purposes.
-     */
-    auto store_semantics(couchbase::store_semantics semantics) -> mutate_in_options&
-    {
-        store_semantics_ = semantics;
-        return self();
-    }
+  /**
+   * Specifies a CAS value that will be taken into account on the server side for optimistic
+   * concurrency.
+   *
+   * The CAS value is an opaque identifier which is associated with a specific state of the document
+   * on the server. The CAS value is received on read operations (or after mutations) and can be
+   * used during a subsequent mutation to make sure that the document has not been modified in the
+   * meantime.
+   *
+   * If document on the server has been modified in the meantime the SDK will raise a {@link
+   * errc::common::cas_mismatch}. In this case the caller is expected to re-do the whole
+   * "fetch-modify-update" cycle again. Please refer to the SDK documentation for more information
+   * on CAS mismatches and subsequent retries.
+   *
+   * @param cas the opaque CAS identifier to use for this operation.
+   * @return the {@link mutate_in_options} for chaining purposes.
+   *
+   * @since 1.0.0
+   * @committed
+   */
+  auto cas(couchbase::cas cas) -> mutate_in_options&
+  {
+    cas_ = cas;
+    return self();
+  }
+  /**
+   * Changes the storing semantics of the outer/enclosing document.
+   *
+   * While each individual {@link mutate_in_specs} describes the semantics of the respective
+   * sub-document section, the
+   * {@link store_semantics} are applied to the outer enclosing document as a whole. You can think
+   * of using the same verb for a {@link couchbase::store_semantics store_semantics} aligns with the
+   * corresponding full document. So for example a
+   * {@link store_semantics::insert} works semantically similar to a {@link collection#insert()} and
+   * will fail if the document as a whole already exists.
+   *
+   * @param semantics the store semantics to apply to the document.
+   * @return this {@link mutate_in_options} for chaining purposes.
+   */
+  auto store_semantics(couchbase::store_semantics semantics) -> mutate_in_options&
+  {
+    store_semantics_ = semantics;
+    return self();
+  }
 
-    /**
-     * For internal use only: allows access to deleted documents that are in 'tombstone' form.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    auto access_deleted(bool value) -> mutate_in_options&
-    {
-        access_deleted_ = value;
-        return self();
-    }
+  /**
+   * For internal use only: allows access to deleted documents that are in 'tombstone' form.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  auto access_deleted(bool value) -> mutate_in_options&
+  {
+    access_deleted_ = value;
+    return self();
+  }
 
-    /**
-     * For internal use only: allows creating documents in 'tombstone' form.
-     *
-     * @since 1.0.0
-     * @internal
-     */
-    auto create_as_deleted(bool value) -> mutate_in_options&
-    {
-        create_as_deleted_ = value;
-        return self();
-    }
+  /**
+   * For internal use only: allows creating documents in 'tombstone' form.
+   *
+   * @since 1.0.0
+   * @internal
+   */
+  auto create_as_deleted(bool value) -> mutate_in_options&
+  {
+    create_as_deleted_ = value;
+    return self();
+  }
 
-  private:
-    couchbase::store_semantics store_semantics_{ couchbase::store_semantics::replace };
-    couchbase::cas cas_{};
-    std::uint32_t expiry_{ 0 };
-    bool preserve_expiry_{ false };
-    bool access_deleted_{ false };
-    bool create_as_deleted_{ false };
+private:
+  couchbase::store_semantics store_semantics_{ couchbase::store_semantics::replace };
+  couchbase::cas cas_{};
+  std::uint32_t expiry_{ 0 };
+  bool preserve_expiry_{ false };
+  bool access_deleted_{ false };
+  bool create_as_deleted_{ false };
 };
 
 /**
@@ -205,5 +216,5 @@ struct mutate_in_options : public common_durability_options<mutate_in_options> {
  * @since 1.0.0
  * @uncommitted
  */
-using mutate_in_handler = std::function<void(couchbase::subdocument_error_context, mutate_in_result)>;
+using mutate_in_handler = std::function<void(error, mutate_in_result)>;
 } // namespace couchbase