couchbase 4.6.1 → 4.7.0-dev.1

package/src/jstocbpp_basic.hpp

@@ -10,6 +10,7 @@
 #include <core/json_string.hxx>
 #include <core/management/eventing_function.hxx>
 #include <core/query_context.hxx>
+#include <core/tracing/wrapper_sdk_tracer.hxx>
 #include <couchbase/codec/encoded_value.hxx>
 
 namespace couchnode
@@ -41,6 +42,7 @@ struct js_to_cbpp_t<couchbase::core::cluster_credentials> {
         js_to_cbpp(cppObj.password, jsObj.Get("password"));
         js_to_cbpp(cppObj.certificate_path, jsObj.Get("certificate_path"));
         js_to_cbpp(cppObj.key_path, jsObj.Get("key_path"));
+        js_to_cbpp(cppObj.jwt_token, jsObj.Get("jwt_token"));
         js_to_cbpp(cppObj.allowed_sasl_mechanisms,
                    jsObj.Get("allowed_sasl_mechanisms"));
         return cppObj;
@@ -157,4 +159,75 @@ struct js_to_cbpp_t<couchbase::codec::encoded_value> {
     }
 };
 
+template <>
+struct js_to_cbpp_t<
+    std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>> {
+    static inline Napi::Value cbpp_wrapper_span_to_js(
+        Napi::Env env,
+        std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapperSpan)
+    {
+        if (nullptr == wrapperSpan || wrapperSpan->children().empty()) {
+            return env.Undefined();
+        }
+        auto spanObj = Napi::Object::New(env);
+        auto jsAttributesObj = Napi::Object::New(env);
+        for (const auto &[key, value] : wrapperSpan->uint_tags()) {
+            jsAttributesObj.Set(key, cbpp_to_js(env, value));
+        }
+        for (const auto &[key, value] : wrapperSpan->string_tags()) {
+            jsAttributesObj.Set(key, cbpp_to_js(env, value));
+        }
+        spanObj.Set("attributes", jsAttributesObj);
+        spanObj.Set(
+            "children",
+            cbpp_to_js<std::vector<
+                std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>>>(
+                env, wrapperSpan->children()));
+        return spanObj;
+    }
+    static inline Napi::Value to_js(
+        Napi::Env env,
+        std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapperSpan)
+    {
+        if (nullptr == wrapperSpan) {
+            return env.Undefined();
+        }
+        auto resObj = Napi::Object::New(env);
+        resObj.Set("name", cbpp_to_js(env, wrapperSpan->name()));
+        constexpr int64_t NANOS_PER_SEC = 1'000'000'000;
+        auto start_time_since_epoch =
+            wrapperSpan->start_time().time_since_epoch();
+        auto start_time_ns =
+            std::chrono::duration_cast<std::chrono::nanoseconds>(
+                start_time_since_epoch)
+                .count();
+        resObj.Set("start", cbpp_to_js<std::array<int64_t, 2>>(
+                                env, {start_time_ns / NANOS_PER_SEC,
+                                      start_time_ns % NANOS_PER_SEC}));
+        auto end_time_since_epoch = wrapperSpan->end_time().time_since_epoch();
+        auto end_time_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                               end_time_since_epoch)
+                               .count();
+        resObj.Set("end", cbpp_to_js<std::array<int64_t, 2>>(
+                              env, {end_time_ns / NANOS_PER_SEC,
+                                    end_time_ns % NANOS_PER_SEC}));
+        auto jsAttributesObj = Napi::Object::New(env);
+        for (const auto &[key, value] : wrapperSpan->uint_tags()) {
+            jsAttributesObj.Set(key, cbpp_to_js(env, value));
+        }
+        for (const auto &[key, value] : wrapperSpan->string_tags()) {
+            jsAttributesObj.Set(key, cbpp_to_js(env, value));
+        }
+        resObj.Set("attributes", jsAttributesObj);
+        // some operations in the C++ core handle sub-operations (e.g. replicas, etc.)
+        if (!wrapperSpan->children().empty()) {
+            resObj.Set("children",
+                       cbpp_to_js<std::vector<std::shared_ptr<
+                           couchbase::core::tracing::wrapper_sdk_span>>>(
+                           env, wrapperSpan->children()));
+        }
+        return resObj;
+    }
+};
+
 } // namespace couchnode

package/src/jstocbpp_defs.hpp

@@ -1,7 +1,9 @@
 #pragma once
 #include <napi.h>
 
-#include "transcoder.hpp"
+#include <core/error_context/key_value.hxx>
+#include <core/error_context/query_error_context.hxx>
+#include <core/tracing/wrapper_sdk_tracer.hxx>
 
 namespace couchnode
 {
@@ -27,11 +29,13 @@ static inline Napi::Value cbpp_to_js(Napi::Env env, const T &cppObj)
     return js_to_cbpp_t<T>::to_js(env, cppObj);
 }
 
+// used w/in connection.hpp -> executeOp()
 template <typename T>
-static inline Napi::Value cbpp_to_js(Napi::Env env, const T &cppObj,
-                                     const Transcoder &transcoder)
+static inline Napi::Value cbpp_to_js(
+    Napi::Env env, const T &cppObj,
+    std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapperSpan)
 {
-    return js_to_cbpp_t<T>::to_js(env, cppObj, transcoder);
+    return js_to_cbpp_t<T>::to_js(env, cppObj, wrapperSpan);
 }
 
 template <typename T>
@@ -40,10 +44,13 @@ static inline T jsToCbpp(Napi::Value jsVal)
     return js_to_cbpp_t<T>::from_js(jsVal);
 }
 
+// used w/ methods in connection_autogen.cpp (jsGet(), etc.)
 template <typename T>
-static inline T jsToCbpp(Napi::Value jsVal, const Transcoder &transcoder)
+static inline T jsToCbpp(
+    Napi::Value jsVal,
+    std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapperSpan)
 {
-    return js_to_cbpp_t<T>::from_js(jsVal, transcoder);
+    return js_to_cbpp_t<T>::from_js(jsVal, wrapperSpan);
 }
 
 template <typename T>
@@ -52,11 +59,32 @@ Napi::Value cbppToJs(Napi::Env env, const T &cppObj)
     return js_to_cbpp_t<T>::to_js(env, cppObj);
 }
 
+// tracing additions
+// used w/ jstocbpp_autogen.cpp response objects & jscbpp_errors.hpp
 template <typename T>
-Napi::Value cbppToJs(Napi::Env env, const T &cppObj,
-                     const Transcoder &transcoder)
+static inline Napi::Value cbpp_wrapper_span_to_js(Napi::Env env, T wrapperSpan)
 {
-    return js_to_cbpp_t<T>::to_js(env, cppObj, transcoder);
+    return js_to_cbpp_t<T>::cbpp_wrapper_span_to_js(env, wrapperSpan);
+}
+template <typename T>
+static inline size_t get_cbpp_retries(const T &ctx)
+{
+    return ctx.retry_attempts;
+}
+template <>
+size_t get_cbpp_retries(const couchbase::core::key_value_error_context &ctx)
+{
+    return ctx.retry_attempts();
+}
+template <>
+size_t get_cbpp_retries(const couchbase::core::subdocument_error_context &ctx)
+{
+    return ctx.retry_attempts();
+}
+template <>
+size_t get_cbpp_retries(const couchbase::core::query_error_context &ctx)
+{
+    return ctx.retry_attempts();
 }
 
 } // namespace couchnode

package/src/jstocbpp_errors.hpp

@@ -5,8 +5,9 @@
 #include "jstocbpp_cpptypes.hpp"
 
 #include <core/cluster.hxx>
-#include <core/operations/management/error_utils.hxx>
 #include <core/error_context/query_error_context.hxx>
+#include <core/operations/management/error_utils.hxx>
+#include <core/tracing/wrapper_sdk_tracer.hxx>
 
 namespace couchnode
 {
@@ -43,7 +44,8 @@ struct js_to_cbpp_t<std::error_code> {
 template <>
 struct js_to_cbpp_t<couchbase::core::key_value_extended_error_info> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::key_value_extended_error_info &cppObj)
+    to_js(Napi::Env env,
+          const couchbase::core::key_value_extended_error_info &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("reference", cbpp_to_js(env, cppObj.reference()));
@@ -55,7 +57,9 @@ struct js_to_cbpp_t<couchbase::core::key_value_extended_error_info> {
 template <>
 struct js_to_cbpp_t<couchbase::core::key_value_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::key_value_error_context &ctx)
+    to_js(Napi::Env env, const couchbase::core::key_value_error_context &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec()) {
             return env.Null();
@@ -76,6 +80,7 @@ struct js_to_cbpp_t<couchbase::core::key_value_error_context> {
                 cbpp_to_js(env, ctx.last_dispatched_from()));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts()));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons()));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
@@ -83,7 +88,9 @@ struct js_to_cbpp_t<couchbase::core::key_value_error_context> {
 template <>
 struct js_to_cbpp_t<couchbase::core::subdocument_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::subdocument_error_context &ctx)
+    to_js(Napi::Env env, const couchbase::core::subdocument_error_context &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec()) {
             return env.Null();
@@ -107,6 +114,7 @@ struct js_to_cbpp_t<couchbase::core::subdocument_error_context> {
         err.Set("first_error_path", cbpp_to_js(env, ctx.first_error_path()));
         err.Set("first_error_index", cbpp_to_js(env, ctx.first_error_index()));
         err.Set("deleted", cbpp_to_js(env, ctx.deleted()));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
@@ -114,7 +122,9 @@ struct js_to_cbpp_t<couchbase::core::subdocument_error_context> {
 template <>
 struct js_to_cbpp_t<couchbase::core::error_context::view> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::error_context::view &ctx)
+    to_js(Napi::Env env, const couchbase::core::error_context::view &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -140,6 +150,7 @@ struct js_to_cbpp_t<couchbase::core::error_context::view> {
                 cbpp_to_js(env, ctx.last_dispatched_from));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
@@ -147,7 +158,9 @@ struct js_to_cbpp_t<couchbase::core::error_context::view> {
 template <>
 struct js_to_cbpp_t<couchbase::core::error_context::query> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::error_context::query &ctx)
+    to_js(Napi::Env env, const couchbase::core::error_context::query &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -184,14 +197,17 @@ struct js_to_cbpp_t<couchbase::core::error_context::query> {
                 cbpp_to_js(env, ctx.last_dispatched_from));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
 
 template <>
 struct js_to_cbpp_t<couchbase::core::query_error_context> {
-    static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::core::query_error_context &ctx)
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::core::query_error_context &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec()) {
             return env.Null();
@@ -219,6 +235,7 @@ struct js_to_cbpp_t<couchbase::core::query_error_context> {
                 cbpp_to_js(env, ctx.last_dispatched_from()));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts()));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons()));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
@@ -226,7 +243,9 @@ struct js_to_cbpp_t<couchbase::core::query_error_context> {
 template <>
 struct js_to_cbpp_t<couchbase::core::error_context::search> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::error_context::search &ctx)
+    to_js(Napi::Env env, const couchbase::core::error_context::search &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -260,6 +279,7 @@ struct js_to_cbpp_t<couchbase::core::error_context::search> {
                 cbpp_to_js(env, ctx.last_dispatched_from));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
@@ -267,7 +287,9 @@ struct js_to_cbpp_t<couchbase::core::error_context::search> {
 template <>
 struct js_to_cbpp_t<couchbase::core::error_context::analytics> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::error_context::analytics &ctx)
+    to_js(Napi::Env env, const couchbase::core::error_context::analytics &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -304,6 +326,7 @@ struct js_to_cbpp_t<couchbase::core::error_context::analytics> {
                 cbpp_to_js(env, ctx.last_dispatched_from));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };
@@ -311,7 +334,9 @@ struct js_to_cbpp_t<couchbase::core::error_context::analytics> {
 template <>
 struct js_to_cbpp_t<couchbase::core::error_context::http> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::error_context::http &ctx)
+    to_js(Napi::Env env, const couchbase::core::error_context::http &ctx,
+          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+              wrapperSpan = nullptr)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -332,6 +357,7 @@ struct js_to_cbpp_t<couchbase::core::error_context::http> {
                 cbpp_to_js(env, ctx.last_dispatched_from));
         err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts));
         err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons));
+        err.Set("cpp_core_span", cbpp_wrapper_span_to_js(env, wrapperSpan));
         return err.Value();
     }
 };

package/tools/gen-bindings-js.js

@@ -7,6 +7,7 @@ const CustomDefinedTypes = [
   'couchbase::mutation_token',
   'couchbase::retry_strategy',
   'couchbase::core::query_context',
+  'couchbase::core::wrapper_sdk_span',
 ]
 
 const handleJsVariant = {
@@ -17,6 +18,10 @@ const handleJsVariant = {
   fields: ['scan_type', 'auth'],
 }
 
+const otherObservableTypes = [
+  'couchbase::core::range_scan_orchestrator_options'
+]
+
 function getTsType(type, typeDb) {
   // special case for std::vector<std::byte> which is a Buffer
   if (type.name === 'std::vector' && type.of.name === 'std::byte') {
@@ -88,6 +93,8 @@ function getTsType(type, typeDb) {
     //  return 'CppJsonString'
     case 'couchbase::core::impl::subdoc::opcode':
       return 'number'
+    case 'couchbase::core::tracing::wrapper_sdk_span':
+      return getStructTsName(type.name)
   }
 
   const opsStructs = typeDb.op_structs
@@ -249,7 +256,7 @@ function isIgnoredField(st, fieldName) {
     fieldName === 'retry_strategy' ||
     fieldName === 'internal' ||
     fieldName === 'revive_document' ||
-    fieldName === 'num_vbuckets' ||
+    fieldName === 'cpp_core_span' ||
     (fieldName.endsWith('_') &&
       !StructsWithAllowedPrivateField.includes(st.name))
   ) {
@@ -259,6 +266,18 @@ function isIgnoredField(st, fieldName) {
   return false
 }
 
+function getOpReqName(name){
+  if (name.endsWith('_request')) {
+    return name.substr(0, name.length - 8)
+  }
+  if (name.endsWith('_with_legacy_durability')) {
+    return name
+  }
+  if (name.endsWith('>')) {
+    return name.replace('_request', '')
+  }
+}
+
 const FILE_WRITER_DEBUG = false
 class FileWriter {
   constructor(regionName) {
@@ -340,19 +359,28 @@ async function go() {
   )
 
   const opReqTypes = []
+  const opStructReqsWithTracing = []
+  const opStructRespsWithTracing = []
   opsStructs.forEach((opStruct) => {
-    if (opStruct.name.endsWith('_request')) {
-      const opReqName = opStruct.name.substr(0, opStruct.name.length - 8)
-      opReqTypes.push(opReqName)
+    const reqName = getOpReqName(opStruct.name)
+    if (reqName) {
+      opReqTypes.push(reqName)
     }
-    if (opStruct.name.endsWith('_with_legacy_durability')) {
-      opReqTypes.push(opStruct.name)
+    // handle tracing for requests
+    if (opStruct.fields.some((f) => f.name === 'parent_span')) {
+      opStructReqsWithTracing.push(opStruct.name)
     }
-    if (opStruct.name.endsWith('>')) {
-      opReqTypes.push(opStruct.name.replace('_request', ''))
+    // handle tracing for responses
+    if (opStruct.fields.some((f) => f.name === 'cpp_core_span')) {
+      opStructRespsWithTracing.push(opStruct.name)
     }
   })
 
+  for (const op of opStructRespsWithTracing) {
+    console.log(op)
+  }
+  
+
   // filter out the custom types
   opsStructs = opsStructs.filter(
     (x) =>
@@ -384,24 +412,30 @@ async function go() {
       ? getStructTsName(opStruct.name + '_request')
       : getStructTsName(opStruct.name)
 
-    outJsAll.write(`export interface ${jsTypeName} {`)
+    if (opStruct.fields.find(f => f.name === 'parent_span')) {
+      outJsAll.write(`export interface ${jsTypeName} extends CppObservableRequest {`)
+    } else if (opStruct.fields.find(f => f.name === 'cpp_core_span')) {
+      outJsAll.write(`export interface ${jsTypeName} extends CppObservableResponse {`)
+    } else {
+      outJsAll.write(`export interface ${jsTypeName} {`)
+    }
+
     opStruct.fields.forEach((field) => {
-      // ignnore the ctx and retries fields
-      if (isIgnoredField(opStruct, field.name)) {
+      // cpp_core_span is provided with the response interface extending the CppObservabelResponse interface
+      if (field.name === 'cpp_core_span') {
+        return
+      } else if (isIgnoredField(opStruct, field.name)) {
         outJsAll.write(`  // ${field.name}`)
         return
       }
 
       // special case for optional fields
       if (field.type.name === 'std::optional') {
-        const jsFieldName = field.name
         const jsFieldType = getTsType(field.type.of, ops)
-
-        outJsAll.write(`  ${jsFieldName}?: ${jsFieldType}`)
+        outJsAll.write(`  ${field.name}?: ${jsFieldType}`)
       } else if (field.type.name === 'template') {
         const jsFieldName = field.name
         const jsFieldType = getStructTsName(field.type.of.name)
-
         outJsAll.write(`  ${jsFieldName}: ${jsFieldType}`)
       } else {
         const jsFieldName = field.name
@@ -484,6 +518,17 @@ async function go() {
   outJsAll.write('}')
   outJsAll.write('')
 
+  // Create CppObservableRequests union type
+  const observableRequestTypes = []
+  opReqTypes.forEach((x) => {
+    const jsReqName = getStructTsName(x + '_request')
+    if (opStructReqsWithTracing.find(r => getOpReqName(r) === x)) {
+      observableRequestTypes.push(jsReqName)
+    }
+  })
+  outJsAll.write(`export type CppObservableRequests = ${observableRequestTypes.join(" | ")}`)
+  outJsAll.write('')
+
   //outJsAll.write('//#endregion Autogen Code')
   //await outJsAll.save('./out/js_all.ts')
   await outJsAll.saveToRegion('../lib/binding.ts')
@@ -526,18 +571,34 @@ async function go() {
     outCppFuncDefs.write(
       `    auto callbackJsFn = info[1].As<Napi::Function>();`
     )
+    const reqArgs = ['optsJsObj']
+    const reqHasTracing = opStructReqsWithTracing.find(r => getOpReqName(r) === x)
+    if (reqHasTracing) {
+      outCppFuncDefs.write(``)
+      outCppFuncDefs.write(`    std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapper_span;`)
+      outCppFuncDefs.write(`    auto span_name = jsToCbpp<std::string>(optsJsObj.Get("wrapper_span_name"));`)
+      outCppFuncDefs.write(`    if (!span_name.empty()) {`)
+      outCppFuncDefs.write(`        wrapper_span = std::make_shared<couchbase::core::tracing::wrapper_sdk_span>(span_name);`)
+      outCppFuncDefs.write(`    }`)
+      reqArgs.push('wrapper_span')
+    }
     outCppFuncDefs.write(``)
     outCppFuncDefs.write(`    executeOp("${cppBaseOpName}",`)
     if (x.endsWith('_with_legacy_durability')) {
-      outCppFuncDefs.write(`              jsToCbpp<${x}>(optsJsObj),`)
+      outCppFuncDefs.write(`              jsToCbpp<${x}>(${reqArgs.join(", ")}),`)
     } else if (x.endsWith('>')) {
       const reqTokens = x.split('<')
       const cppReqName = reqTokens[0] + '_request<' + reqTokens[1]
-      outCppFuncDefs.write(`              jsToCbpp<${cppReqName}>(optsJsObj),`)
+      outCppFuncDefs.write(`              jsToCbpp<${cppReqName}>(${reqArgs.join(", ")}),`)
+    } else {
+      outCppFuncDefs.write(`              jsToCbpp<${x}_request>(${reqArgs.join(", ")}),`)
+    }
+    if (reqHasTracing) {
+      outCppFuncDefs.write(`              callbackJsFn,`)
+      outCppFuncDefs.write(`              wrapper_span);`)
     } else {
-      outCppFuncDefs.write(`              jsToCbpp<${x}_request>(optsJsObj),`)
+      outCppFuncDefs.write(`              callbackJsFn);`)
     }
-    outCppFuncDefs.write(`              callbackJsFn);`)
     outCppFuncDefs.write(``)
     outCppFuncDefs.write(`    return info.Env().Null();`)
     outCppFuncDefs.write(`}`)
@@ -619,7 +680,12 @@ async function go() {
     outCppStructDefs.write(`struct js_to_cbpp_t<${st.name}> {`)
 
     outCppStructDefs.write(`    static inline ${st.name}`)
-    outCppStructDefs.write(`    from_js(Napi::Value jsVal)`)
+    if (opStructReqsWithTracing.includes(st.name)) {
+      outCppStructDefs.write(`    from_js(Napi::Value jsVal,`)
+      outCppStructDefs.write(`            std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapperSpan)`)
+    } else {
+      outCppStructDefs.write(`    from_js(Napi::Value jsVal)`)
+    }
     outCppStructDefs.write(`    {`)
     outCppStructDefs.write(`        auto jsObj = jsVal.ToObject();`)
     const variantFields = st.fields.filter((field) => {
@@ -663,7 +729,9 @@ async function go() {
     })
     outCppStructDefs.write(`        ${st.name} cppObj;`)
     st.fields.forEach((field) => {
-      if (isIgnoredField(st, field.name)) {
+      if (opStructReqsWithTracing.includes(st.name) && field.name == 'parent_span' ) {
+        outCppStructDefs.write(`        cppObj.${field.name} = wrapperSpan;`)
+      } else if (isIgnoredField(st, field.name)) {
         outCppStructDefs.write(`        // ${field.name}`)
       } else if (
         handleJsVariant.names.includes(st.name) &&
@@ -681,7 +749,13 @@ async function go() {
     outCppStructDefs.write(`    }`)
 
     outCppStructDefs.write(`    static inline Napi::Value`)
-    outCppStructDefs.write(`    to_js(Napi::Env env, const ${st.name} &cppObj)`)
+    if (st.name.endsWith('response') || otherObservableTypes.includes(st.name)) {
+      outCppStructDefs.write(`    to_js(Napi::Env env,`)
+      outCppStructDefs.write(`          const ${st.name} &cppObj,`)
+      outCppStructDefs.write(`          std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapperSpan = nullptr)`)
+    } else {
+      outCppStructDefs.write(`    to_js(Napi::Env env, const ${st.name} &cppObj)`)
+    }
     outCppStructDefs.write(`    {`)
     outCppStructDefs.write(`        auto resObj = Napi::Object::New(env);`)
     variantFields.forEach((field) => {
@@ -708,6 +782,10 @@ async function go() {
       return
     })
     st.fields.forEach((field) => {
+      if (field.name == 'cpp_core_span' && opStructRespsWithTracing.includes(st.name)) {
+        outCppStructDefs.write(`        resObj.Set("${field.name}", cbpp_wrapper_span_to_js(env, wrapperSpan));`)
+        return
+      }
       if (isIgnoredField(st, field.name)) {
         outCppStructDefs.write(`        // ${field.name}`)
         return

package/tools/gen-bindings-json.py

@@ -72,6 +72,7 @@ FILE_LIST = [
     "core/view_scan_consistency.hxx",
     "core/view_sort_order.hxx",
     "core/operations/*",
+    "core/operations/document_view.hxx",
     "core/operations/management/*",
     "couchbase/durability_level.hxx",
     "couchbase/cas.hxx",
@@ -308,10 +309,11 @@ class BindingsGenerator:
         for headerPath in self._full_file_list:
             print("processing " + headerPath)
             index = clang.cindex.Index.create()
+            suppress_warnings = ['-Wno-nullability-completeness', '-Wno-deprecated-literal-operator']
             if self._verbose is True:
-                args = ['-std=c++17', '-v', f'-isysroot{os.getcwd()}'] + self._include_paths
+                args = ['-std=c++17', '-v', f'-isysroot{os.getcwd()}'] + self._include_paths + suppress_warnings
             else:
-                args = ['-std=c++17', f'-isysroot{os.getcwd()}'] + self._include_paths
+                args = ['-std=c++17', f'-isysroot{os.getcwd()}'] + self._include_paths + suppress_warnings
             translation_unit = index.parse(headerPath, args=args)
 
             # output clang compiler diagnostics information (for debugging)
@@ -322,6 +324,8 @@ class BindingsGenerator:
 
             self.traverse(translation_unit.cursor, [], headerPath)
 
+        self.process_observability()
+
         jsonData = json.dumps({
             'op_structs': self._op_types,
             'op_enums': self._op_enums
@@ -331,6 +335,32 @@ class BindingsGenerator:
         f.write(jsonData)
         f.close()
 
+    def process_observability(self) -> None:
+        cpp_spans_response = {
+            'name': 'cpp_core_span',
+            'type': {
+                'name': 'std::optional', 
+                'of': {'name': 'std::vector', 'of': {'name':'couchbase::core::tracing::wrapper_sdk_span'}}
+            }
+        }
+        special_ops = ['couchbase::core::operations::management::analytics_link_create_response',
+                       'couchbase::core::operations::management::analytics_link_replace_response']
+
+        for op_type in self._op_types:
+            if op_type.get('name') in special_ops:
+                op_type['fields'].append(cpp_spans_response)
+                continue
+
+            parent_span = next((f for f in op_type.get('fields') if f.get('name') == 'parent_span'), None)
+            if not parent_span:
+                continue
+            parent_span['type']['name'] = 'std::optional'
+            parent_span['type']['of']['name'] = 'std::string'
+            resp_name = op_type.get('name').replace('request', 'response')
+            resp_op = next((op for op in self._op_types if op.get('name') == resp_name), None)
+            if resp_op:
+                resp_op['fields'].append(cpp_spans_response)
+
     def set_file_list(self) -> None:
         for file_path in FILE_LIST:
             if "*" in file_path:
@@ -482,10 +512,14 @@ class BindingsGenerator:
     @staticmethod
     def set_cxx_deps_include_paths(dep, includes):
         cpm_path = os.path.join(CXX_CLIENT_CACHE, dep)
-        dir_pattern = r'[0-9a-z]{40}'
-        cpm_hash_dir = next((d for d in os.listdir(cpm_path)
-                            if os.path.isdir(os.path.join(cpm_path, d)) and re.match(dir_pattern, d)),
-                            None)
+        dir_patterns = [r'[0-9a-z]{40}', r'[0-9a-z]{4}']
+        cpm_hash_dir = None
+        for dir_pattern in dir_patterns:
+            cpm_hash_dir = next((d for d in os.listdir(cpm_path)
+                                if os.path.isdir(os.path.join(cpm_path, d)) and re.match(dir_pattern, d)),
+                                None)
+            if cpm_hash_dir:
+                break
         if not cpm_hash_dir:
             raise Exception(f'Unable to find CPM hash directory for path: {cpm_path}.')
         return list(map(lambda p: p.format(CXX_CLIENT_CACHE, cpm_hash_dir), includes))