couchbase 4.6.1 → 4.7.0-dev.1

package/scripts/prebuilds.js

@@ -277,7 +277,7 @@ function getLinuxType(platform) {
   if (platform !== 'linux') {
     return ''
   }
-   return `linux${familySync() === MUSL ? 'musl' : ''}`
+  return `linux${familySync() === MUSL ? 'musl' : ''}`
 }
 
 function getNodeMajorVersion(version) {

package/scripts/updateVersion.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+// 1. Define the paths relative to this script
+const packageJsonPath = path.join(__dirname, '../package.json')
+const versionTsPath = path.join(__dirname, '../lib/version.ts')
+
+// 2. Read and parse package.json
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+const version = packageJson.version;
+const name = packageJson.name;
+
+// 3. Generate the TypeScript content
+const tsContent = `// This file is auto-generated by scripts/updateVersion.js during the build process.
+// DO NOT EDIT DIRECTLY.
+
+export const SDK_VERSION = '${version}';
+export const SDK_NAME = '${name}';
+`;
+
+// 4. Write it to the lib directory
+fs.writeFileSync(versionTsPath, tsContent, 'utf8');
+
+console.log(`[Build] Wrote ${name} v${version} to lib/version.ts`);

package/src/connection.cpp

@@ -4,8 +4,9 @@
 #include "jstocbpp.hpp"
 #include "mutationtoken.hpp"
 #include "scan_iterator.hpp"
-#include "transcoder.hpp"
 #include <core/agent_group.hxx>
+#include <core/cluster.hxx>
+#include <core/cluster_label_listener.hxx>
 #include <core/operations/management/freeform.hxx>
 #include <core/range_scan_orchestrator.hxx>
 #include <core/utils/connection_string.hxx>
@@ -35,11 +36,14 @@ void Connection::Init(Napi::Env env, Napi::Object exports)
         env, "Connection",
         {
             InstanceMethod<&Connection::jsConnect>("connect"),
+            InstanceMethod<&Connection::jsUpdateCredentials>(
+                "updateCredentials"),
             InstanceMethod<&Connection::jsShutdown>("shutdown"),
             InstanceMethod<&Connection::jsOpenBucket>("openBucket"),
             InstanceMethod<&Connection::jsDiagnostics>("diagnostics"),
             InstanceMethod<&Connection::jsPing>("ping"),
             InstanceMethod<&Connection::jsScan>("scan"),
+            InstanceMethod<&Connection::jsGetClusterLabels>("getClusterLabels"),
 
             //#region Autogenerated Method Registration
 
@@ -279,7 +283,7 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
 {
     auto connstr = info[0].ToString().Utf8Value();
     auto credentialsJsObj = info[1].As<Napi::Object>();
-    auto callbackJsFn = info[7].As<Napi::Function>();
+    auto callbackJsFn = info[6].As<Napi::Function>();
 
     auto connstrInfo = couchbase::core::utils::parse_connection_string(connstr);
     auto creds =
@@ -343,121 +347,51 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
         }
     }
 
-    couchbase::core::tracing::threshold_logging_options tracing_options{};
-    bool has_tracing_options = false;
-
-    if (!info[4].IsNull()) {
-        auto jsTracingConfigObj = info[4].As<Napi::Object>();
-        auto jsEnableTracing = jsTracingConfigObj.Get("enableTracing");
-        if (!(jsEnableTracing.IsNull() || jsEnableTracing.IsUndefined())) {
-            connstrInfo.options.enable_tracing =
-                js_to_cbpp<bool>(jsEnableTracing);
-        }
-        auto jsEmitInterval = jsTracingConfigObj.Get("emitInterval");
-        if (!(jsEmitInterval.IsNull() || jsEmitInterval.IsUndefined())) {
-            tracing_options.threshold_emit_interval =
-                js_to_cbpp<std::chrono::milliseconds>(jsEmitInterval);
-            has_tracing_options = true;
-        }
-        auto jsSampleSize = jsTracingConfigObj.Get("sampleSize");
-        if (!(jsSampleSize.IsNull() || jsSampleSize.IsUndefined())) {
-            tracing_options.threshold_sample_size =
-                js_to_cbpp<std::size_t>(jsSampleSize);
-            has_tracing_options = true;
-        }
-        auto jsKvThreshold = jsTracingConfigObj.Get("kvThreshold");
-        if (!(jsKvThreshold.IsNull() || jsKvThreshold.IsUndefined())) {
-            tracing_options.key_value_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsKvThreshold);
-            has_tracing_options = true;
-        }
-        auto jsQueryThreshold = jsTracingConfigObj.Get("queryThreshold");
-        if (!(jsQueryThreshold.IsNull() || jsQueryThreshold.IsUndefined())) {
-            tracing_options.query_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsQueryThreshold);
-            has_tracing_options = true;
-        }
-        auto jsSearchThreshold = jsTracingConfigObj.Get("searchThreshold");
-        if (!(jsSearchThreshold.IsNull() || jsSearchThreshold.IsUndefined())) {
-            tracing_options.search_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsSearchThreshold);
-            has_tracing_options = true;
-        }
-        auto jsAnalyticsThreshold =
-            jsTracingConfigObj.Get("analyticsThreshold");
-        if (!(jsAnalyticsThreshold.IsNull() ||
-              jsAnalyticsThreshold.IsUndefined())) {
-            tracing_options.analytics_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsAnalyticsThreshold);
-            has_tracing_options = true;
-        }
-        auto jsManagementThreshold =
-            jsTracingConfigObj.Get("managementThreshold");
-        if (!(jsManagementThreshold.IsNull() ||
-              jsManagementThreshold.IsUndefined())) {
-            tracing_options.management_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsManagementThreshold);
-            has_tracing_options = true;
-        }
-        auto jsEventingThreshold = jsTracingConfigObj.Get("eventingThreshold");
-        if (!(jsEventingThreshold.IsNull() ||
-              jsEventingThreshold.IsUndefined())) {
-            tracing_options.eventing_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsEventingThreshold);
-            has_tracing_options = true;
-        }
-        auto jsViewsThreshold = jsTracingConfigObj.Get("viewsThreshold");
-        if (!(jsViewsThreshold.IsNull() || jsViewsThreshold.IsUndefined())) {
-            tracing_options.view_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsViewsThreshold);
-            has_tracing_options = true;
-        }
+    // Always disable tracing, this will be ignored if we set the tracer
+    connstrInfo.options.enable_tracing = false;
+    auto setup_sdk_tracing = info[4].ToBoolean().Value();
+    if (setup_sdk_tracing) {
+        connstrInfo.options.tracer =
+            std::make_shared<couchbase::core::tracing::wrapper_sdk_tracer>();
     }
+    // For now, always disable metrics in the core
+    connstrInfo.options.enable_metrics = false;
 
     if (!info[5].IsNull()) {
+        couchbase::core::orphan_reporter_options orphan_options{};
+        bool has_orphan_options = false;
         auto jsOrphanReporterConfigObj = info[5].As<Napi::Object>();
-        // TODO(JSCBC-1364):  Migrate to orphan reporting config when available in C++ core
+        auto jsEnableOrphanReporting =
+            jsOrphanReporterConfigObj.Get("enableOrphanReporting");
+        if (!(jsEnableOrphanReporting.IsNull() ||
+              jsEnableOrphanReporting.IsUndefined())) {
+            connstrInfo.options.enable_orphan_reporting =
+                js_to_cbpp<bool>(jsEnableOrphanReporting);
+        }
         auto jsOrphanEmitInterval =
             jsOrphanReporterConfigObj.Get("emitInterval");
         if (!(jsOrphanEmitInterval.IsNull() ||
               jsOrphanEmitInterval.IsUndefined())) {
-            tracing_options.orphaned_emit_interval =
+            orphan_options.emit_interval =
                 js_to_cbpp<std::chrono::milliseconds>(jsOrphanEmitInterval);
-            has_tracing_options = true;
+            has_orphan_options = true;
         }
         auto jsOrphanSampleSize = jsOrphanReporterConfigObj.Get("sampleSize");
         if (!(jsOrphanSampleSize.IsNull() ||
               jsOrphanSampleSize.IsUndefined())) {
-            tracing_options.orphaned_sample_size =
+            orphan_options.sample_size =
                 js_to_cbpp<std::size_t>(jsOrphanSampleSize);
-            has_tracing_options = true;
+            has_orphan_options = true;
         }
-    }
 
-    if (has_tracing_options) {
-        connstrInfo.options.tracing_options = tracing_options;
-    }
-
-    if (!info[6].IsNull()) {
-        auto jsMetricsConfigObj = info[6].As<Napi::Object>();
-        auto jsEnableMetrics = jsMetricsConfigObj.Get("enableMetrics");
-        if (!(jsEnableMetrics.IsNull() || jsEnableMetrics.IsUndefined())) {
-            connstrInfo.options.enable_metrics =
-                js_to_cbpp<bool>(jsEnableMetrics);
-        }
-
-        auto jsEmitInterval = jsMetricsConfigObj.Get("emitInterval");
-        if (!(jsEmitInterval.IsNull() || jsEmitInterval.IsUndefined())) {
-            couchbase::core::metrics::logging_meter_options logging_options{};
-            logging_options.emit_interval =
-                js_to_cbpp<std::chrono::milliseconds>(jsEmitInterval);
-            connstrInfo.options.metrics_options = logging_options;
+        if (has_orphan_options) {
+            connstrInfo.options.orphan_options = orphan_options;
         }
     }
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "cbConnectCallback");
     this->_instance->_cluster.open(
-        couchbase::core::origin(creds, connstrInfo),
+        couchbase::core::origin(std::move(creds), std::move(connstrInfo)),
         [cookie = std::move(cookie)](std::error_code ec) mutable {
             cookie.invoke([ec](Napi::Env env, Napi::Function callback) {
                 callback.Call({cbpp_to_js(env, ec)});
@@ -467,6 +401,18 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
     return info.Env().Null();
 }
 
+Napi::Value Connection::jsUpdateCredentials(const Napi::CallbackInfo &info)
+{
+    auto credentialsJsObj = info[0].As<Napi::Object>();
+    auto creds =
+        jsToCbpp<couchbase::core::cluster_credentials>(credentialsJsObj);
+    auto err = this->_instance->_cluster.update_credentials(std::move(creds));
+    if (err.ec) {
+        return cbpp_to_js(info.Env(), err.ec);
+    }
+    return info.Env().Null();
+}
+
 Napi::Value Connection::jsShutdown(const Napi::CallbackInfo &info)
 {
     auto callbackJsFn = info[0].As<Napi::Function>();
@@ -606,8 +552,15 @@ Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
         couchbase::core::agent_group_config{{this->_instance->_cluster}});
     agentGroup.open_bucket(bucketName);
     auto agent = agentGroup.get_agent(bucketName);
-    auto options = js_to_cbpp<couchbase::core::range_scan_orchestrator_options>(
-        optionsObj);
+    std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapper_span;
+    auto span_name = jsToCbpp<std::string>(optionsObj.Get("wrapper_span_name"));
+    if (!span_name.empty()) {
+        wrapper_span =
+            std::make_shared<couchbase::core::tracing::wrapper_sdk_span>(
+                span_name);
+    }
+    auto options = jsToCbpp<couchbase::core::range_scan_orchestrator_options>(
+        optionsObj, wrapper_span);
 
     if (!agent.has_value()) {
         resObj.Set("cppErr", cbpp_to_js(env, agent.error()));
@@ -645,4 +598,32 @@ Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
     return resObj;
 }
 
+std::pair<std::optional<std::string>, std::optional<std::string>>
+Connection::getClusterLabels()
+{
+    auto labels = std::make_pair(std::optional<std::string>{},
+                                 std::optional<std::string>{});
+    auto cppLabels =
+        this->_instance->_cluster.cluster_label_listener()->cluster_labels();
+    if (cppLabels.cluster_name.has_value()) {
+        labels.first = cppLabels.cluster_name.value();
+    }
+    if (cppLabels.cluster_uuid.has_value()) {
+        labels.second = cppLabels.cluster_uuid.value();
+    }
+    return labels;
+}
+
+Napi::Value Connection::jsGetClusterLabels(const Napi::CallbackInfo &info)
+{
+    auto env = info.Env();
+    auto resObj = Napi::Object::New(env);
+    auto clusterLabels = this->getClusterLabels();
+    resObj.Set("clusterName", cbpp_to_js<std::optional<std::string>>(
+                                  env, clusterLabels.first));
+    resObj.Set("clusterUUID", cbpp_to_js<std::optional<std::string>>(
+                                  env, clusterLabels.second));
+    return resObj;
+}
+
 } // namespace couchnode

package/src/connection.hpp

@@ -2,7 +2,7 @@
 #include "addondata.hpp"
 #include "instance.hpp"
 #include "jstocbpp.hpp"
-#include "transcoder.hpp"
+#include <core/tracing/wrapper_sdk_tracer.hxx>
 #include <core/utils/movable_function.hxx>
 #include <napi.h>
 
@@ -64,12 +64,17 @@ public:
         return _instance->_cluster;
     }
 
+    std::pair<std::optional<std::string>, std::optional<std::string>>
+    getClusterLabels();
+
     Napi::Value jsConnect(const Napi::CallbackInfo &info);
     Napi::Value jsShutdown(const Napi::CallbackInfo &info);
+    Napi::Value jsUpdateCredentials(const Napi::CallbackInfo &info);
     Napi::Value jsOpenBucket(const Napi::CallbackInfo &info);
     Napi::Value jsDiagnostics(const Napi::CallbackInfo &info);
     Napi::Value jsPing(const Napi::CallbackInfo &info);
     Napi::Value jsScan(const Napi::CallbackInfo &info);
+    Napi::Value jsGetClusterLabels(const Napi::CallbackInfo &info);
 
     //#region Autogenerated Method Declarations
 
@@ -240,45 +245,48 @@ private:
 
     template <typename Request>
     void executeOp(const std::string &opName, const Request &req,
-                   Napi::Function jsCallback)
-    {
-        using response_type = typename Request::response_type;
-        executeOp(opName, req, jsCallback,
-                  [](Napi::Env env, Napi::Function callback,
-                     response_type resp) mutable {
-                      Napi::Value jsErr, jsRes;
-                      try {
-                          jsErr = cbpp_to_js(env, resp.ctx);
-                          jsRes = cbpp_to_js(env, resp);
-                      } catch (const Napi::Error &e) {
-                          jsErr = e.Value();
-                          jsRes = env.Null();
-                      }
-
-                      callback.Call({jsErr, jsRes});
-                  });
-    }
-
-    template <typename Request>
-    void executeOp(const std::string &opName, const Request &req,
-                   Napi::Function jsCallback, Transcoder &&transcoder)
+                   Napi::Function jsCallback,
+                   std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+                       wrapperSpan = nullptr)
     {
         using response_type = typename Request::response_type;
-        executeOp(opName, req, jsCallback,
-                  [transcoder = std::move(transcoder)](
-                      Napi::Env env, Napi::Function callback,
-                      response_type resp) mutable {
-                      Napi::Value jsErr, jsRes;
-                      try {
-                          jsErr = cbpp_to_js(env, resp.ctx);
-                          jsRes = cbpp_to_js(env, resp, transcoder);
-                      } catch (const Napi::Error &e) {
-                          jsErr = e.Value();
-                          jsRes = env.Null();
-                      }
-
-                      callback.Call({jsErr, jsRes});
-                  });
+        auto clusterLabels = wrapperSpan != nullptr
+                                 ? this->getClusterLabels()
+                                 : std::make_pair(std::optional<std::string>{},
+                                                  std::optional<std::string>{});
+        executeOp(
+            opName, req, jsCallback,
+            [wrapperSpan, clusterLabels = std::move(clusterLabels)](
+                Napi::Env env, Napi::Function callback,
+                response_type resp) mutable {
+                Napi::Value jsErr, jsRes;
+                try {
+                    if (auto retries = get_cbpp_retries(resp.ctx);
+                        retries > 0 && wrapperSpan) {
+                        wrapperSpan->add_tag("retries", retries);
+                    }
+                    if (wrapperSpan) {
+                        if (clusterLabels.first.has_value()) {
+                            wrapperSpan->add_tag("cluster_name",
+                                                 clusterLabels.first.value());
+                        }
+                        if (clusterLabels.second.has_value()) {
+                            wrapperSpan->add_tag("cluster_uuid",
+                                                 clusterLabels.second.value());
+                        }
+                    }
+                    jsErr = cbpp_to_js(env, resp.ctx, wrapperSpan);
+                    jsRes = cbpp_to_js(env, resp, wrapperSpan);
+                } catch (const Napi::Error &e) {
+                    Napi::Value err = e.Value();
+                    Napi::Object errObj = err.As<Napi::Object>();
+                    errObj.Set("cpp_core_span",
+                               cbpp_wrapper_span_to_js(env, wrapperSpan));
+                    jsErr = errObj;
+                    jsRes = env.Null();
+                }
+                callback.Call({jsErr, jsRes});
+            });
     }
 
     Instance *_instance;