couchbase 4.4.2 → 4.4.4

package/deps/couchbase-cxx-client/couchbase/common_options.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/retry_strategy.hxx>
+#include <couchbase/tracing/request_span.hxx>
 
 #include <chrono>
 #include <memory>
@@ -69,6 +70,18 @@ public:
     return self();
   }
 
+  /**
+   * @param span
+   *
+   * @since 1.0.4
+   * @volatile
+   */
+  auto parent_span(std::shared_ptr<tracing::request_span> span) -> derived_class&
+  {
+    parent_span_ = std::move(span);
+    return self();
+  }
+
   /**
    * Immutable value object representing consistent options.
    *
@@ -78,6 +91,7 @@ public:
   struct built {
     const std::optional<std::chrono::milliseconds> timeout;
     const std::shared_ptr<couchbase::retry_strategy> retry_strategy;
+    const std::shared_ptr<tracing::request_span> parent_span;
   };
 
 protected:
@@ -88,7 +102,7 @@ protected:
    */
   [[nodiscard]] auto build_common_options() const -> built
   {
-    return { timeout_, retry_strategy_ };
+    return { timeout_, retry_strategy_, parent_span_ };
   }
 
   /**
@@ -107,6 +121,7 @@ protected:
 private:
   std::optional<std::chrono::milliseconds> timeout_{};
   std::shared_ptr<couchbase::retry_strategy> retry_strategy_{ nullptr };
+  std::shared_ptr<tracing::request_span> parent_span_{ nullptr };
 };
 
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/metrics/otel_meter.hxx

@@ -20,6 +20,7 @@
 #include "opentelemetry/sdk/metrics/meter.h"
 #include <couchbase/metrics/meter.hxx>
 
+#include <algorithm>
 #include <iostream>
 #include <thread>
 #include <utility>
@@ -37,44 +38,39 @@ namespace couchbase::metrics
 class otel_sync_histogram
 {
 public:
-  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter)
+  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter)
     : histogram_counter_(histogram_counter)
   {
   }
-  void record(uint64_t value,
+
+  void record(std::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);
+    histogram_counter_->Record(value, tags, ctx);
   }
 
 private:
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> 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)
+  explicit otel_value_recorder(
+    nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> 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);
+    value = std::max<int64_t>(value, 0);
+    auto uvalue = static_cast<std::uint64_t>(value);
     histogram_counter_->Record(
-      value, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
+      uvalue, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
   }
 
   const std::map<std::string, std::string> tags()
@@ -82,13 +78,13 @@ public:
     return tags_;
   }
 
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter()
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter()
   {
     return histogram_counter_;
   }
 
 private:
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter_;
   const std::map<std::string, std::string> tags_;
   opentelemetry::context::Context context_{};
   std::mutex mutex_;
@@ -115,8 +111,8 @@ public:
       // api doesn't seem to allow this.
       return recorders_
         .insert({ name,
-                  std::make_shared<otel_value_recorder>(meter_->CreateLongHistogram(name, "", "us"),
-                                                        tags) })
+                  std::make_shared<otel_value_recorder>(
+                    meter_->CreateUInt64Histogram(name, "", "us"), tags) })
         ->second;
     }
     // so it is already, lets see if we already have one with those tags, or need

package/deps/couchbase-cxx-client/couchbase/mutate_in_specs.hxx

@@ -235,7 +235,7 @@ public:
   template<typename Value, typename Transcoder = codec::default_json_transcoder>
   static auto upsert(std::string path, const Value& value) -> subdoc::upsert
   {
-    return { std::move(path), std::move(Transcoder::template encode(value).data) };
+    return { std::move(path), std::move(Transcoder::template encode<const Value&>(value).data) };
   }
 
   /**
@@ -453,7 +453,7 @@ public:
   template<typename Value, typename Transcoder = codec::default_json_transcoder>
   static auto array_add_unique(std::string path, const Value& value) -> subdoc::array_add_unique
   {
-    return { std::move(path), std::move(Transcoder::template encode(value).data) };
+    return { std::move(path), std::move(Transcoder::template encode<Value>(value).data) };
   }
 
   /**

package/deps/couchbase-cxx-client/couchbase/query_options.hxx

@@ -445,7 +445,7 @@ struct query_options : public common_options<query_options> {
            std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto raw(std::string name, const Value& value) -> query_options&
   {
-    raw_[std::move(name)] = std::move(Serializer::template serialize(value));
+    raw_[std::move(name)] = std::move(Serializer::template serialize<const Value&>(value));
     return self();
   }
 
@@ -563,7 +563,8 @@ private:
            std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   void encode_positional_parameters(const Parameter& parameter, Rest... args)
   {
-    positional_parameters_.emplace_back(std::move(Serializer::template serialize(parameter)));
+    positional_parameters_.emplace_back(
+      std::move(Serializer::template serialize<const Parameter&>(parameter)));
     if constexpr (sizeof...(args) > 0) {
       encode_positional_parameters<Serializer>(args...);
     }
@@ -577,7 +578,7 @@ private:
   void encode_named_parameters(const std::pair<Name, Parameter>& parameter, Rest... args)
   {
     named_parameters_[parameter.first] =
-      std::move(Serializer::template serialize(parameter.second));
+      std::move(Serializer::template serialize<Parameter>(parameter.second));
     if constexpr (sizeof...(args) > 0) {
       encode_named_parameters<Serializer>(args...);
     }

package/deps/couchbase-cxx-client/couchbase/search_options.hxx

@@ -192,7 +192,7 @@ struct search_options : public common_options<search_options> {
            std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto raw(std::string name, const Value& value) -> search_options&
   {
-    raw_[std::move(name)] = std::move(Serializer::template serialize(value));
+    raw_[std::move(name)] = std::move(Serializer::template serialize<Value>(value));
     return self();
   }
 

package/dist/analyticsindexmanager.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { Cluster } from './cluster';
+import { CppManagementAnalyticsCouchbaseRemoteLink, CppManagementAnalyticsS3ExternalLink, CppManagementAnalyticsAzureBlobExternalLink } from './binding';
 import { NodeCallback } from './utilities';
 /**
  * Represents the type of an analytics link.
@@ -155,6 +156,14 @@ export interface IAnalyticsLink {
      * Specifies what type of analytics link this represents.
      */
     linkType: AnalyticsLinkType;
+    /**
+     * The dataverse that this link belongs to.
+     */
+    dataverse: string;
+    /**
+     * The name of this link.
+     */
+    name: string;
 }
 /**
  * This is a base class for specific link configurations for the analytics service.
@@ -168,6 +177,18 @@ export declare abstract class AnalyticsLink implements IAnalyticsLink {
      * Specifies what type of analytics link this represents.
      */
     linkType: AnalyticsLinkType;
+    /**
+     * The dataverse that this link belongs to.
+     */
+    dataverse: string;
+    /**
+     * The name of this link.
+     */
+    name: string;
+    /**
+     * Validates the link.
+     */
+    abstract validate(): void;
     /**
      * @internal
      */
@@ -250,18 +271,22 @@ export declare class CouchbaseRemoteAnalyticsLink extends AnalyticsLink implemen
      * (@see ICouchbaseAnalyticsEncryptionSettings.clientCertificate) is being used.
      */
     password?: string;
+    /**
+     * Validates the CouchbaseRemoteAnalyticsLink.
+     */
+    validate(): void;
     /**
      * @internal
      */
-    constructor(data: CouchbaseRemoteAnalyticsLink);
+    constructor(data: ICouchbaseRemoteAnalyticsLink);
     /**
      * @internal
      */
-    static _toHttpData(data: ICouchbaseRemoteAnalyticsLink): any;
+    static _toCppData(data: CouchbaseRemoteAnalyticsLink): CppManagementAnalyticsCouchbaseRemoteLink;
     /**
      * @internal
      */
-    static _fromHttpData(data: any): CouchbaseRemoteAnalyticsLink;
+    static _fromCppData(data: CppManagementAnalyticsCouchbaseRemoteLink): CouchbaseRemoteAnalyticsLink;
 }
 /**
  * Provides options for configuring an analytics remote S3 link.
@@ -341,15 +366,19 @@ export declare class S3ExternalAnalyticsLink extends AnalyticsLink implements IS
     /**
      * @internal
      */
-    constructor(data: S3ExternalAnalyticsLink);
+    constructor(data: IS3ExternalAnalyticsLink);
+    /**
+     * Validates the S3ExternalAnalyticsLink.
+     */
+    validate(): void;
     /**
      * @internal
      */
-    static _toHttpData(data: IS3ExternalAnalyticsLink): any;
+    static _toCppData(data: S3ExternalAnalyticsLink): CppManagementAnalyticsS3ExternalLink;
     /**
      * @internal
      */
-    static _fromHttpData(data: any): S3ExternalAnalyticsLink;
+    static _fromCppData(data: CppManagementAnalyticsS3ExternalLink): S3ExternalAnalyticsLink;
 }
 /**
  * Provides options for configuring an analytics remote Azure link.
@@ -435,15 +464,19 @@ export declare class AzureExternalAnalyticsLink extends AnalyticsLink implements
     /**
      * @internal
      */
-    constructor(data: AzureExternalAnalyticsLink);
+    constructor(data: IAzureExternalAnalyticsLink);
+    /**
+     * Validates the AzureExternalAnalyticsLink.
+     */
+    validate(): void;
     /**
      * @internal
      */
-    static _toHttpData(data: IAzureExternalAnalyticsLink): any;
+    static _toCppData(data: AzureExternalAnalyticsLink): CppManagementAnalyticsAzureBlobExternalLink;
     /**
      * @internal
      */
-    static _fromHttpData(data: any): AzureExternalAnalyticsLink;
+    static _fromCppData(data: CppManagementAnalyticsAzureBlobExternalLink): AzureExternalAnalyticsLink;
 }
 /**
  * @category Management
@@ -571,6 +604,18 @@ export interface GetAllAnalyticsIndexesOptions {
  * @category Management
  */
 export interface ConnectAnalyticsLinkOptions {
+    /**
+     * Whether or not the call should attempt to force the link connection.
+     */
+    force?: boolean;
+    /**
+     * The name of the dataverse the link belongs to.
+     */
+    dataverseName?: string;
+    /**
+     * The name of the link to connect.
+     */
+    linkName?: string;
     /**
      * The timeout for this operation, represented in milliseconds.
      */
@@ -580,6 +625,14 @@ export interface ConnectAnalyticsLinkOptions {
  * @category Management
  */
 export interface DisconnectAnalyticsLinkOptions {
+    /**
+     * The name of the dataverse the link belongs to.
+     */
+    dataverseName?: string;
+    /**
+     * The name of the link to connect.
+     */
+    linkName?: string;
     /**
      * The timeout for this operation, represented in milliseconds.
      */
@@ -654,7 +707,6 @@ export declare class AnalyticsIndexManager {
      * @internal
      */
     constructor(cluster: Cluster);
-    private get _http();
     /**
      * Creates a new dataverse.
      *
@@ -726,19 +778,51 @@ export declare class AnalyticsIndexManager {
     /**
      * Connects a not yet connected link.
      *
-     * @param linkName The name of the link to connect.
+     * @param linkStr The name of the link to connect.
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     * @deprecated Use the other overload instead.
+     */
+    connectLink(linkStr: string, options?: ConnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Connects a not yet connected link.
+     *
+     * @param options Optional parameters for this operation.
+     * @param callback A node-style callback to be invoked after execution.
+     */
+    connectLink(options?: ConnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * @internal
+     */
+    _connectLinkDeprecated(linkStr: string, options?: ConnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * @internal
+     */
+    _connectLink(options?: ConnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * Disconnects a previously connected link.
+     *
+     * @param linkStr The name of the link to disconnect.
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
+     * @deprecated Use the other overload instead.
      */
-    connectLink(linkName: string, options?: ConnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    disconnectLink(linkStr: string, options?: DisconnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
     /**
      * Disconnects a previously connected link.
      *
-     * @param linkName The name of the link to disconnect.
      * @param options Optional parameters for this operation.
      * @param callback A node-style callback to be invoked after execution.
      */
-    disconnectLink(linkName: string, options?: DisconnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    disconnectLink(options?: DisconnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * @internal
+     */
+    _disconnectLinkDeprecated(linkStr: string, options?: DisconnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
+    /**
+     * @internal
+     */
+    _disconnectLink(options?: DisconnectAnalyticsLinkOptions, callback?: NodeCallback<void>): Promise<void>;
     /**
      * Returns a list of all pending mutations.
      *