couchbase 4.2.3 → 4.2.4

package/deps/couchbase-cxx-client/tools/pillowfight.cxx

@@ -33,6 +33,7 @@
 #include <csignal>
 #include <numeric>
 #include <random>
+#include <thread>
 
 namespace cbc
 {
@@ -46,11 +47,14 @@ usage() -> std::string
     static const std::size_t default_number_of_worker_threads{ 1 };
     static const double default_chance_of_get{ 0.6 };
     static const double default_hit_chance_for_get{ 1.0 };
-    static const double default_hit_chance_for_upsert{ 0.5 };
+    static const double default_hit_chance_for_upsert{ 1 };
     static const double default_chance_of_query{ 0.0 };
     static const std::string default_query_statement{ "SELECT COUNT(*) FROM `{bucket_name}` WHERE type = \"fake_profile\"" };
     static const std::size_t default_document_body_size{ 0 };
     static const std::size_t default_operation_limit{ 0 };
+    static const std::size_t default_batch_size{ 100 };
+    static const std::chrono::milliseconds default_batch_wait{ 0 };
+    static const std::size_t default_number_of_keys_to_populate{ 1'000 };
 
     static const std::string usage_string = fmt::format(
       R"(Run workload generator.
@@ -60,20 +64,24 @@ Usage:
   cbc pillowfight (-h|--help)
 
 Options:
-  -h --help                           Show this screen.
-  --bucket-name=STRING                Name of the bucket. [default: {bucket_name}]
-  --scope-name=STRING                 Name of the scope. [default: {scope_name}]
-  --collection-name=STRING            Name of the collection. [default: {collection_name}]
-  --number-of-io-threads=INTEGER      Number of the IO threads. [default: {number_of_io_threads}]
-  --number-of-worker-threads=INTEGER  Number of the IO threads. [default: {number_of_worker_threads}]
-  --chance-of-get=FLOAT               The probability of get operation (where 1 means only get, and 0 - only upsert). [default: {chance_of_get}]
-  --hit-chance-for-get=FLOAT          The probability of using existing ID for get operation. [default: {hit_chance_for_get}]
-  --hit-chance-for-upsert=FLOAT       The probability of using existing ID for upsert operation. [default: {hit_chance_for_upsert}]
-  --chance-of-query=FLOAT             The probability of N1QL query will be send on after get/upsert. [default: {chance_of_query}]
-  --query-statement=STRING            The N1QL query statement to use ({{bucket_name}}, {{scope_name}} and {{collection_name}} will be substituted). [default: {query_statement}]
-  --incompressible-body               Use random characters to fill generated document value (by default uses 'x' to fill the body).
-  --document-body-size=INTEGER        Size of the body (if zero, it will use predefined document). [default: {document_body_size}]
-  --operations-limit=INTEGER          Stop and exit after the number of the operations reaches this limit. (zero for running indefinitely) [default: {operation_limit}]
+  -h --help                             Show this screen.
+  --verbose                             Include more context and information where it is applicable.
+  --bucket-name=STRING                  Name of the bucket. [default: {bucket_name}]
+  --scope-name=STRING                   Name of the scope. [default: {scope_name}]
+  --collection-name=STRING              Name of the collection. [default: {collection_name}]
+  --batch-size=INTEGER                  Number of the operations in single batch. [default: {batch_size}]
+  --batch-wait=DURATION                 Time to wait after the batch. [default: {batch_wait}]
+  --number-of-io-threads=INTEGER        Number of the IO threads. [default: {number_of_io_threads}]
+  --number-of-worker-threads=INTEGER    Number of the IO threads. [default: {number_of_worker_threads}]
+  --chance-of-get=FLOAT                 The probability of get operation (where 1 means only get, and 0 - only upsert). [default: {chance_of_get}]
+  --hit-chance-for-get=FLOAT            The probability of using existing ID for get operation. [default: {hit_chance_for_get}]
+  --hit-chance-for-upsert=FLOAT         The probability of using existing ID for upsert operation. [default: {hit_chance_for_upsert}]
+  --chance-of-query=FLOAT               The probability of N1QL query will be send on after get/upsert. [default: {chance_of_query}]
+  --query-statement=STRING              The N1QL query statement to use ({{bucket_name}}, {{scope_name}} and {{collection_name}} will be substituted). [default: {query_statement}]
+  --incompressible-body                 Use random characters to fill generated document value (by default uses 'x' to fill the body).
+  --document-body-size=INTEGER          Size of the body (if zero, it will use predefined document). [default: {document_body_size}]
+  --number-of-keys-to-populate=INTEGER  Preload keys before running workload, so that the worker will not generate new keys afterwards. [default: {number_of_keys_to_populate}]
+  --operations-limit=INTEGER            Stop and exit after the number of the operations reaches this limit. (zero for running indefinitely) [default: {operation_limit}]
 
 {logger_options}{cluster_options}
 )",
@@ -89,6 +97,9 @@ Options:
       fmt::arg("query_statement", default_query_statement),
       fmt::arg("document_body_size", default_document_body_size),
       fmt::arg("operation_limit", default_operation_limit),
+      fmt::arg("batch_size", default_batch_size),
+      fmt::arg("batch_wait", default_batch_wait),
+      fmt::arg("number_of_keys_to_populate", default_number_of_keys_to_populate),
       fmt::arg("logger_options", usage_block_for_logger()),
       fmt::arg("cluster_options", usage_block_for_cluster_options()));
 
@@ -140,8 +151,11 @@ struct command_options {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
+    std::size_t batch_size;
+    std::chrono::milliseconds batch_wait;
     std::size_t number_of_io_threads;
     std::size_t number_of_worker_threads;
+    std::size_t number_of_keys_to_populate;
     double chance_of_get;
     double hit_chance_for_get;
     double hit_chance_for_upsert;
@@ -149,6 +163,12 @@ struct command_options {
     std::string query_statement;
     bool incompressible_body;
     std::size_t document_body_size;
+    bool verbose{ false };
+
+    void set_batch_wait(std::chrono::milliseconds val)
+    {
+        batch_wait = val;
+    }
 };
 
 enum class operation {
@@ -166,8 +186,9 @@ std::map<std::error_code, std::size_t> errors{};
 std::mutex errors_mutex{};
 
 void
-sigint_handler(int /* signal */)
+sigint_handler(int signal)
 {
+    fmt::print(stderr, "\nrequested stop, signal={}\n", signal);
     running.clear();
 }
 
@@ -179,9 +200,11 @@ dump_stats(asio::steady_timer& timer, std::chrono::system_clock::time_point star
         if (ec == asio::error::operation_aborted) {
             return;
         }
-        auto diff = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - start_time).count();
+        auto uptime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - start_time);
+        auto diff = uptime.count();
         const std::uint64_t ops = total;
-        fmt::print(stderr, "\rrate: {} ops/s, total: {}", diff == 0 ? ops : ops / static_cast<std::uint64_t>(diff), ops);
+        fmt::print(
+          stderr, "\r\033[Kuptime: {}, rate: {} ops/s, total: {}\r", uptime, diff == 0 ? ops : ops / static_cast<std::uint64_t>(diff), ops);
         return dump_stats(timer, start_time);
     });
 }
@@ -205,6 +228,19 @@ random_text(std::size_t length)
     return text;
 }
 
+auto
+generate_document_body(const command_options& options)
+{
+    if (options.document_body_size > 0) {
+        return couchbase::core::utils::json::generate_binary({
+          { "size", options.document_body_size },
+          { "text", options.incompressible_body ? random_text(options.document_body_size) : std::string(options.document_body_size, 'x') },
+        });
+    } else {
+        return couchbase::core::utils::to_binary(default_json_doc);
+    }
+}
+
 void
 worker(couchbase::cluster connected_cluster, command_options cmd_options, std::vector<std::string>& known_keys)
 {
@@ -216,71 +252,128 @@ worker(couchbase::cluster connected_cluster, command_options cmd_options, std::v
 
     auto collection = cluster.bucket(options.bucket_name).scope(options.scope_name).collection(options.collection_name);
 
-    std::vector<std::byte> json_doc{};
-    if (options.document_body_size > 0) {
-        json_doc = couchbase::core::utils::json::generate_binary({
-          { "size", options.document_body_size },
-          { "text", options.incompressible_body ? random_text(options.document_body_size) : std::string(options.document_body_size, 'x') },
-        });
-    } else {
-        json_doc = couchbase::core::utils::to_binary(default_json_doc);
-    }
+    std::vector<std::byte> json_doc = generate_document_body(options);
 
     while (running.test_and_set()) {
-        auto opcode = (dist(gen) <= options.chance_of_get) ? operation::get : operation::upsert;
-        if (opcode == operation::get && known_keys.empty()) {
-            opcode = operation::upsert;
+        std::list<std::variant<std::future<std::pair<couchbase::key_value_error_context, couchbase::mutation_result>>,
+                               std::future<std::pair<couchbase::key_value_error_context, couchbase::get_result>>,
+                               std::future<std::pair<couchbase::query_error_context, couchbase::query_result>>>>
+          futures;
+        for (std::size_t i = 0; i < options.batch_size; ++i) {
+            auto opcode = (dist(gen) <= options.chance_of_get) ? operation::get : operation::upsert;
+            if (opcode == operation::get && known_keys.empty()) {
+                opcode = operation::upsert;
+            }
+            bool should_check_known_keys{ false };
+            switch (opcode) {
+                case operation::get:
+                    should_check_known_keys = options.hit_chance_for_get > dist(gen);
+                    break;
+                case operation::upsert:
+                    should_check_known_keys = options.hit_chance_for_upsert > dist(gen);
+                    break;
+            }
+            std::string document_id = uniq_id("id");
+            if (should_check_known_keys && !known_keys.empty()) {
+                auto key_index = std::uniform_int_distribution<std::size_t>(0, known_keys.size() - 1)(gen);
+                document_id = known_keys[key_index];
+            }
+
+            switch (opcode) {
+                case operation::upsert:
+                    futures.emplace_back(collection.upsert<raw_json_transcoder>(document_id, json_doc));
+                    break;
+                case operation::get:
+                    futures.emplace_back(collection.get(document_id));
+                    break;
+            }
+            if (options.chance_of_query > 0 && dist(gen) <= options.chance_of_query) {
+                futures.emplace_back(cluster.query(options.query_statement, couchbase::query_options{}));
+            }
+            if (operations_limit > 0 && total >= operations_limit) {
+                running.clear();
+            }
         }
-        bool should_check_known_keys{ false };
-        switch (opcode) {
-            case operation::get:
-                should_check_known_keys = options.hit_chance_for_get > dist(gen);
-                break;
-            case operation::upsert:
-                should_check_known_keys = options.hit_chance_for_upsert > dist(gen);
-                break;
+
+        for (auto&& future : futures) {
+            std::visit(
+              [&options, &known_keys](auto f) mutable {
+                  using T = std::decay_t<decltype(f)>;
+
+                  auto [ctx, resp] = f.get();
+                  ++total;
+                  if (ctx.ec()) {
+                      const std::scoped_lock lock(errors_mutex);
+                      ++errors[ctx.ec()];
+                      if (options.verbose) {
+                          fmt::print(stderr, "\r\033[K{}\n", ctx.to_json());
+                      }
+                  } else if constexpr (std::is_same_v<
+                                         T,
+                                         std::future<std::pair<couchbase::key_value_error_context, couchbase::mutation_result>>>) {
+                      known_keys.emplace_back(ctx.id());
+                  }
+              },
+              std::move(future));
         }
-        std::string document_id = uniq_id("id");
-        if (should_check_known_keys && !known_keys.empty()) {
-            auto key_index = std::uniform_int_distribution<std::size_t>(0, known_keys.size() - 1)(gen);
-            document_id = known_keys[key_index];
-        } else {
-            known_keys.emplace_back(document_id);
+        if (options.batch_wait != std::chrono::milliseconds::zero()) {
+            std::this_thread::sleep_for(options.batch_wait);
         }
+    }
+}
 
-        switch (opcode) {
-            case operation::upsert: {
-                const couchbase::upsert_options operation_options{};
-                auto [ctx, resp] = collection.upsert<raw_json_transcoder>(document_id, json_doc, operation_options).get();
-                ++total;
-                if (ctx.ec()) {
-                    const std::scoped_lock lock(errors_mutex);
-                    ++errors[ctx.ec()];
-                }
-            } break;
-            case operation::get: {
-                const couchbase::get_options operation_options{};
-                auto [ctx, resp] = collection.get(document_id, operation_options).get();
-                ++total;
+void
+populate_keys(const couchbase::cluster& cluster, const command_options& options, std::vector<std::vector<std::string>>& known_keys)
+{
+    const std::size_t total_keys{ options.number_of_worker_threads * options.number_of_keys_to_populate };
+
+    auto collection = cluster.bucket(options.bucket_name).scope(options.scope_name).collection(options.collection_name);
+
+    const auto json_doc = generate_document_body(options);
+    const auto start_time = std::chrono::system_clock::now();
+
+    std::size_t stored_keys{ 0 };
+    std::size_t retried_keys{ 0 };
+    for (std::size_t i = 0; i < options.number_of_worker_threads; ++i) {
+        auto keys_left = options.number_of_keys_to_populate;
+
+        while (keys_left > 0) {
+            fmt::print(stderr,
+                       "\r\033[K{:02.2f}% {} of {}, {}\r",
+                       static_cast<double>(stored_keys) / gsl::narrow_cast<double>(total_keys) * 100,
+                       stored_keys,
+                       total_keys,
+                       std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start_time));
+
+            auto batch_size = std::min(keys_left, options.batch_size);
+
+            std::vector<std::future<std::pair<couchbase::key_value_error_context, couchbase::mutation_result>>> futures;
+            futures.reserve(batch_size);
+            for (std::size_t k = 0; k < batch_size; ++k) {
+                const std::string document_id = uniq_id("id");
+                futures.emplace_back(collection.upsert<raw_json_transcoder>(document_id, json_doc));
+            }
+
+            for (auto&& future : futures) {
+                auto [ctx, res] = future.get();
                 if (ctx.ec()) {
-                    const std::scoped_lock lock(errors_mutex);
-                    ++errors[ctx.ec()];
+                    ++retried_keys;
+                } else {
+                    ++stored_keys;
+                    --keys_left;
                 }
-            } break;
-        }
-        if (options.chance_of_query > 0 && dist(gen) <= options.chance_of_query) {
-            const couchbase::query_options operation_options{};
-            auto [ctx, resp] = cluster.query(options.query_statement, operation_options).get();
-            ++total;
-            if (ctx.ec()) {
-                const std::scoped_lock lock(errors_mutex);
-                ++errors[ctx.ec()];
             }
         }
-        if (operations_limit > 0 && total >= operations_limit) {
-            running.clear();
-        }
     }
+    const auto finish_time = std::chrono::system_clock::now();
+    const auto total_time = finish_time - start_time;
+
+    fmt::print(stderr,
+               "\r\033[K{} keys populated in {}s ({}ms) with {} retries\n",
+               stored_keys,
+               std::chrono::duration_cast<std::chrono::seconds>(total_time).count(),
+               std::chrono::duration_cast<std::chrono::milliseconds>(total_time).count(),
+               retried_keys);
 }
 
 void
@@ -309,13 +402,16 @@ do_work(const std::string& connection_string, const couchbase::cluster_options&
         throw std::system_error(ec, "unable to connect to the cluster in time");
     }
 
+    std::vector<std::vector<std::string>> known_keys(cmd_options.number_of_worker_threads);
+    if (cmd_options.number_of_keys_to_populate > 0) {
+        populate_keys(cluster, cmd_options, known_keys);
+    }
+
     const auto start_time = std::chrono::system_clock::now();
 
     asio::steady_timer stats_timer(io);
     dump_stats(stats_timer, start_time);
 
-    std::vector<std::vector<std::string>> known_keys(cmd_options.number_of_worker_threads);
-
     std::vector<std::thread> worker_pool{};
     worker_pool.reserve(cmd_options.number_of_worker_threads);
     for (std::size_t i = 0; i < cmd_options.number_of_worker_threads; ++i) {
@@ -343,7 +439,7 @@ do_work(const std::string& connection_string, const couchbase::cluster_options&
         if (!errors.empty()) {
             fmt::print("error stats:\n");
             for (auto [e, count] : errors) {
-                fmt::print("    {}: {}\n", ec.message(), count);
+                fmt::print("    {}: {}\n", e.message(), count);
             }
         }
     }
@@ -373,9 +469,13 @@ cbc::pillowfight::execute(const std::vector<std::string>& argv)
     cbc::fill_cluster_options(options, cluster_options, connection_string);
 
     command_options cmd_options{};
+    cmd_options.verbose = options["--verbose"].asBool();
     cmd_options.bucket_name = options["--bucket-name"].asString();
     cmd_options.scope_name = options["--scope-name"].asString();
     cmd_options.collection_name = options["--collection-name"].asString();
+    cmd_options.batch_size = options["--batch-size"].asLong();
+    parse_duration_option(cmd_options.set_batch_wait, "--batch-wait");
+    cmd_options.number_of_keys_to_populate = options["--number-of-keys-to-populate"].asLong();
     cmd_options.number_of_io_threads = options["--number-of-io-threads"].asLong();
     cmd_options.number_of_worker_threads = options["--number-of-worker-threads"].asLong();
     cmd_options.chance_of_get = get_double_option(options, "--chance-of-get");

package/deps/couchbase-cxx-client/tools/version.cxx

@@ -49,9 +49,11 @@ cbc::version::execute(const std::vector<std::string>& argv)
         if (options["--json"].asBool()) {
             tao::json::value info;
             for (const auto& [name, value] : couchbase::core::meta::sdk_build_info()) {
-                if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build") {
+                if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build" ||
+                    name == "mozilla_ca_bundle_size") {
                     info[name] = std::stoi(value);
-                } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl") {
+                } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl" ||
+                           name == "mozilla_ca_bundle_embedded") {
                     info[name] = value == "true";
                 } else {
                     info[name] = value;

package/dist/binding.d.ts

@@ -831,7 +831,7 @@ export interface CppSearchRequest {
     query: CppJsonString;
     limit?: number;
     skip?: number;
-    explain: boolean;
+    explain?: boolean;
     disable_scoring: boolean;
     include_locations: boolean;
     highlight_style?: CppSearchHighlightStyle;

package/package.json

@@ -1 +1 @@
-{"bugs":{"url":"http://www.couchbase.com/issues/browse/JSCBC"},"description":"The official Couchbase Node.js Client Library.","engines":{"node":">=12.0.0"},"homepage":"http://www.couchbase.com/communities/nodejs","keywords":["couchbase","libcouchbase","memcached","nosql","json","document"],"main":"dist/couchbase.js","types":"dist/couchbase.d.ts","license":"Apache-2.0","name":"couchbase","dependencies":{"bindings":"^1.5.0","cmake-js":"^6.3.2","node-addon-api":"^5.0.0","prebuild-install":"^7.1.1"},"devDependencies":{"@trivago/prettier-plugin-sort-imports":"^4.1.0","@tsconfig/node12":"^1.0.11","@types/bindings":"^1.5.1","@types/debug":"^4.1.7","@types/node":"^20.1.0","@typescript-eslint/eslint-plugin":"^5.32.0","@typescript-eslint/parser":"^5.32.0","chai":"^4.3.6","eslint":"^8.21.0","eslint-config-prettier":"^8.5.0","eslint-plugin-jsdoc":"^41.1.0","eslint-plugin-mocha":"^10.1.0","eslint-plugin-node":"^11.1.0","expose-gc":"^1.0.0","mocha":"^10.0.0","npm-check-updates":"^16.0.5","nyc":"^15.1.0","prebuild":"^11.0.4","prettier":"^2.7.1","segfault-handler":"^1.3.0","semver":"^7.3.7","ts-mocha":"^10.0.0","ts-node":"^10.9.1","typedoc":"^0.24.1","typescript":"^4.7.4","uuid":"^9.0.0"},"repository":{"type":"git","url":"http://github.com/couchbase/couchnode.git"},"version":"4.2.3","config":{"native":false},"scripts":{"install":"prebuild-install -r napi || cmake-js compile","build":"cmake-js build && tsc","rebuild":"cmake-js rebuild && tsc","prebuild":"prebuild --backend cmake-js --verbose --strip","prepare":"tsc","build-docs":"typedoc","test":"ts-mocha test/*.test.*","test-fast":"ts-mocha test/*.test.* -ig '(slow)'","cover":"nyc ts-mocha test/*.test.*","cover-fast":"nyc ts-mocha test/*.test.* -ig '(slow)'","lint":"eslint ./lib/ ./test/","check-deps":"ncu"},"binary":{"napi_versions":[6]}}
+{"bugs":{"url":"http://www.couchbase.com/issues/browse/JSCBC"},"description":"The official Couchbase Node.js Client Library.","engines":{"node":">=12.0.0"},"homepage":"http://www.couchbase.com/communities/nodejs","keywords":["couchbase","libcouchbase","memcached","nosql","json","document"],"main":"dist/couchbase.js","types":"dist/couchbase.d.ts","license":"Apache-2.0","name":"couchbase","dependencies":{"bindings":"^1.5.0","cmake-js":"^6.3.2","node-addon-api":"^5.0.0","prebuild-install":"^7.1.1"},"devDependencies":{"@trivago/prettier-plugin-sort-imports":"^4.1.0","@tsconfig/node12":"^1.0.11","@types/bindings":"^1.5.1","@types/debug":"^4.1.7","@types/node":"^20.1.0","@typescript-eslint/eslint-plugin":"^5.32.0","@typescript-eslint/parser":"^5.32.0","chai":"^4.3.6","eslint":"^8.21.0","eslint-config-prettier":"^8.5.0","eslint-plugin-jsdoc":"^41.1.0","eslint-plugin-mocha":"^10.1.0","eslint-plugin-node":"^11.1.0","expose-gc":"^1.0.0","mocha":"^10.0.0","npm-check-updates":"^16.0.5","nyc":"^15.1.0","prebuild":"^11.0.4","prettier":"^2.7.1","segfault-handler":"^1.3.0","semver":"^7.3.7","ts-mocha":"^10.0.0","ts-node":"^10.9.1","typedoc":"^0.24.1","typescript":"^4.7.4","uuid":"^9.0.0"},"repository":{"type":"git","url":"http://github.com/couchbase/couchnode.git"},"version":"4.2.4","config":{"native":false},"scripts":{"install":"prebuild-install -r napi || cmake-js compile","build":"cmake-js build && tsc","rebuild":"cmake-js rebuild && tsc","prebuild":"prebuild --backend cmake-js --verbose --strip","prepare":"tsc","build-docs":"typedoc","test":"ts-mocha test/*.test.*","test-fast":"ts-mocha test/*.test.* -ig '(slow)'","cover":"nyc ts-mocha test/*.test.*","cover-fast":"nyc ts-mocha test/*.test.* -ig '(slow)'","lint":"eslint ./lib/ ./test/","check-deps":"ncu"},"binary":{"napi_versions":[6]}}

package/src/jstocbpp_autogen.hpp

@@ -3723,7 +3723,7 @@ struct js_to_cbpp_t<couchbase::core::operations::search_request> {
                                                  jsObj.Get("limit"));
         js_to_cbpp<std::optional<std::uint32_t>>(cppObj.skip,
                                                  jsObj.Get("skip"));
-        js_to_cbpp<bool>(cppObj.explain, jsObj.Get("explain"));
+        js_to_cbpp<std::optional<bool>>(cppObj.explain, jsObj.Get("explain"));
         js_to_cbpp<bool>(cppObj.disable_scoring, jsObj.Get("disable_scoring"));
         js_to_cbpp<bool>(cppObj.include_locations,
                          jsObj.Get("include_locations"));
@@ -3767,7 +3767,8 @@ struct js_to_cbpp_t<couchbase::core::operations::search_request> {
                    cbpp_to_js<std::optional<std::uint32_t>>(env, cppObj.limit));
         resObj.Set("skip",
                    cbpp_to_js<std::optional<std::uint32_t>>(env, cppObj.skip));
-        resObj.Set("explain", cbpp_to_js<bool>(env, cppObj.explain));
+        resObj.Set("explain",
+                   cbpp_to_js<std::optional<bool>>(env, cppObj.explain));
         resObj.Set("disable_scoring",
                    cbpp_to_js<bool>(env, cppObj.disable_scoring));
         resObj.Set("include_locations",