couchbase 4.2.2 → 4.2.3

package/deps/couchbase-cxx-client/core/bucket.hxx

@@ -106,6 +106,8 @@ class bucket
         } else {
             auto [partition, server] = map_id(cmd->request.id);
             if (!server.has_value()) {
+                CB_LOG_TRACE(
+                  R"({} unable to map key=\"{}\" to the node, id={}, partition={})", log_prefix(), cmd->request.id, cmd->id_, partition);
                 return io::retry_orchestrator::maybe_retry(
                   cmd->manager_, cmd, retry_reason::node_not_available, errc::common::request_canceled);
             }
@@ -114,9 +116,16 @@ class bucket
         }
         auto session = find_session_by_index(index);
         if (!session || !session->has_config()) {
+            CB_LOG_TRACE(R"({} defer operation id={}, session={}, has_config={})",
+                         log_prefix(),
+                         cmd->id_,
+                         session.has_value(),
+                         session.has_value() && session->has_config());
             return defer_command([self = shared_from_this(), cmd]() { self->map_and_send(cmd); });
         }
         if (session->is_stopped()) {
+            CB_LOG_TRACE(
+              R"({} the session has been found, but it is stopped, retrying id={}, session={})", log_prefix(), cmd->id_, session->id());
             return io::retry_orchestrator::maybe_retry(
               cmd->manager_, cmd, retry_reason::node_not_available, errc::common::request_canceled);
         }

package/deps/couchbase-cxx-client/core/cluster_options.cxx

@@ -16,7 +16,7 @@
  */
 
 #include "cluster_options.hxx"
-#include "config_profile.hxx"
+#include "config_profiles.hxx"
 #include <stdexcept>
 
 namespace couchbase::core
@@ -45,6 +45,6 @@ cluster_options::default_timeout_for(service_type type) const
 void
 cluster_options::apply_profile(std::string profile_name)
 {
-    couchbase::core::known_profiles().apply(profile_name, *this);
+    known_profiles().apply(profile_name, *this);
 }
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/cluster_options.hxx

@@ -25,6 +25,7 @@
 #include "core/transactions/cleanup_testing_hooks.hxx"
 #include "service_type.hxx"
 #include "timeout_defaults.hxx"
+#include "tls_verify_mode.hxx"
 
 #include <couchbase/best_effort_retry_strategy.hxx>
 #include <couchbase/metrics/meter.hxx>
@@ -32,16 +33,10 @@
 #include <couchbase/transactions/transactions_config.hxx>
 
 #include <chrono>
-#include <list>
 #include <string>
 
 namespace couchbase::core
 {
-enum class tls_verify_mode {
-    none,
-    peer,
-};
-
 struct cluster_options {
     std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
     std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
@@ -53,7 +48,6 @@ struct cluster_options {
     std::chrono::milliseconds analytics_timeout = timeout_defaults::analytics_timeout;
     std::chrono::milliseconds search_timeout = timeout_defaults::search_timeout;
     std::chrono::milliseconds management_timeout = timeout_defaults::management_timeout;
-    std::chrono::milliseconds dns_srv_timeout = timeout_defaults::dns_srv_timeout;
 
     bool enable_tls{ false };
     std::string trust_certificate{};
@@ -87,6 +81,8 @@ struct cluster_options {
     couchbase::transactions::transactions_config::built transactions{};
 
     [[nodiscard]] std::chrono::milliseconds default_timeout_for(service_type type) const;
+
+    bool dump_configuration{ false };
     void apply_profile(std::string profile_name);
 };
 

package/deps/couchbase-cxx-client/core/cluster_options_fwd.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+namespace couchbase
+{
+namespace core
+{
+struct cluster_options;
+} // namespace core
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/config_profile.hxx

@@ -16,13 +16,7 @@
  */
 #pragma once
 
-#include "cluster_options.hxx"
-#include <chrono>
-#include <fmt/core.h>
-#include <map>
-#include <mutex>
-#include <stdexcept>
-#include <string>
+#include "cluster_options_fwd.hxx"
 
 namespace couchbase::core
 {
@@ -32,61 +26,4 @@ class config_profile
     virtual ~config_profile() = default;
     virtual void apply(cluster_options&) = 0;
 };
-
-class development_profile : public config_profile
-{
-  public:
-    void apply(couchbase::core::cluster_options& opts) override
-    {
-        opts.key_value_timeout = std::chrono::milliseconds(20000); // 20 sec kv timeout.
-        opts.key_value_durable_timeout = std::chrono::milliseconds(20000); // 20 sec durable kv timeout.
-        opts.connect_timeout = std::chrono::milliseconds(20000);           // 20 sec connect timeout.
-        opts.view_timeout = std::chrono::milliseconds(120000);             // 2 minute view timeout
-        opts.query_timeout = std::chrono::milliseconds(120000);            // 2 minute query timeout
-        opts.analytics_timeout = std::chrono::milliseconds(120000);        // 2 minute analytics timeout
-        opts.search_timeout = std::chrono::milliseconds(120000);           // 2 minute search timeout
-        opts.management_timeout = std::chrono::milliseconds(120000);       // 2 minute management timeout
-    }
-};
-
-// this class just registers the known profiles defined above, and allows access to them.
-class config_profiles
-{
-  private:
-    std::map<std::string, std::shared_ptr<couchbase::core::config_profile>> profiles_;
-    std::mutex mut_;
-
-  public:
-    config_profiles() noexcept
-    {
-        // add all known profiles (above) to the map
-        register_profile<development_profile>("wan_development");
-    }
-
-    void apply(const std::string& profile_name, couchbase::core::cluster_options& opts)
-    {
-        std::lock_guard<std::mutex> lock(mut_);
-        auto it = profiles_.find(profile_name);
-        if (it != profiles_.end()) {
-            it->second->apply(opts);
-        } else {
-            throw std::invalid_argument(fmt::format("unknown profile '{}'", profile_name));
-        }
-    }
-
-    template<typename T, typename... Args>
-    void register_profile(const std::string& name, Args... args)
-    {
-        // This will just add it, doesn't look to see if it is overwriting an existing profile.
-        // TODO: perhaps add a template Args param?
-        // TODO: should we make this thread-safe?   Easy enough here, but we'd need to make the
-        //   singleton thread-safe too.
-        std::lock_guard<std::mutex> lock(mut_);
-        profiles_.emplace(std::make_pair(name, std::make_shared<T>(args...)));
-    }
-};
-
-config_profiles&
-known_profiles();
-
-} // namespace couchbase::core
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/config_profiles.cxx

@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "config_profiles.hxx"
+
+#include "cluster_options.hxx"
+
+#include <fmt/core.h>
+
+#include <chrono>
+#include <stdexcept>
+
+namespace couchbase::core
+{
+class development_profile : public config_profile
+{
+  public:
+    void apply(couchbase::core::cluster_options& opts) override
+    {
+        opts.key_value_timeout = std::chrono::seconds(20);
+        opts.key_value_durable_timeout = std::chrono::seconds(20);
+        opts.connect_timeout = std::chrono::seconds(20);
+        opts.view_timeout = std::chrono::minutes(2);
+        opts.query_timeout = std::chrono::minutes(2);
+        opts.analytics_timeout = std::chrono::minutes(2);
+        opts.search_timeout = std::chrono::minutes(2);
+        opts.management_timeout = std::chrono::minutes(2);
+
+        // C++SDK specific
+        opts.dns_config = couchbase::core::io::dns::dns_config{
+            opts.dns_config.nameserver(),
+            opts.dns_config.port(),
+            std::chrono::seconds(20), // timeout to make DNS-SRV query
+        };
+        opts.resolve_timeout = std::chrono::seconds(20);  // timeout to resolve hostnames
+        opts.bootstrap_timeout = std::chrono::minutes(2); // overall timeout to bootstrap
+    }
+};
+
+config_profiles::config_profiles() noexcept
+{
+    // add all known profiles (above) to the map
+    register_profile<development_profile>("wan_development");
+}
+
+void
+config_profiles::apply(const std::string& profile_name, couchbase::core::cluster_options& opts)
+{
+    std::lock_guard<std::mutex> lock(mut_);
+    auto it = profiles_.find(profile_name);
+    if (it != profiles_.end()) {
+        it->second->apply(opts);
+    } else {
+        throw std::invalid_argument(fmt::format("unknown profile '{}'", profile_name));
+    }
+}
+
+config_profiles&
+known_profiles()
+{
+    static config_profiles profiles{};
+    return profiles;
+}
+
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/config_profiles.hxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+#pragma once
+
+#include "cluster_options_fwd.hxx"
+#include "config_profile.hxx"
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace couchbase::core
+{
+// this class just registers the known profiles defined above, and allows access to them.
+class config_profiles
+{
+  private:
+    std::map<std::string, std::shared_ptr<config_profile>, std::less<>> profiles_;
+    mutable std::mutex mut_;
+
+  public:
+    config_profiles() noexcept;
+
+    void apply(const std::string& profile_name, couchbase::core::cluster_options& opts);
+
+    template<typename T, typename... Args>
+    void register_profile(const std::string& name, Args... args)
+    {
+        // This will just add it, doesn't look to see if it is overwriting an existing profile.
+        // TODO: perhaps add a template Args param?
+        // TODO: should we make this thread-safe?   Easy enough here, but we'd need to make the
+        //   singleton thread-safe too.
+        const std::scoped_lock lock(mut_);
+        profiles_.emplace(std::make_pair(name, std::make_shared<T>(args...)));
+    }
+};
+
+config_profiles&
+known_profiles();
+
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/crypto/CMakeLists.txt

@@ -4,7 +4,11 @@ target_link_libraries(couchbase_crypto PRIVATE project_options project_warnings)
 target_include_directories(couchbase_crypto PRIVATE ../..)
 
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-  target_link_libraries(couchbase_crypto PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+    target_link_libraries(couchbase_crypto PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+  else()
+    target_link_libraries(couchbase_crypto PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  endif()
 endif()
 
 if(WIN32)

package/deps/couchbase-cxx-client/core/error_context/analytics.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 
 #include <couchbase/retry_reason.hxx>
 
+#include <cstdint>
 #include <optional>
 #include <set>
 #include <string>

package/deps/couchbase-cxx-client/core/error_context/http.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 
 #include <couchbase/retry_reason.hxx>
 
+#include <cstdint>
 #include <optional>
 #include <set>
 #include <string>

package/deps/couchbase-cxx-client/core/error_context/query.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 
 #include <couchbase/retry_reason.hxx>
 
+#include <cstdint>
 #include <optional>
 #include <set>
 #include <string>

package/deps/couchbase-cxx-client/core/error_context/search.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 
 #include <couchbase/retry_reason.hxx>
 
+#include <cstdint>
 #include <optional>
 #include <set>
 #include <string>

package/deps/couchbase-cxx-client/core/error_context/view.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@
 
 #include <couchbase/retry_reason.hxx>
 
+#include <cstdint>
 #include <optional>
 #include <set>
 #include <string>

package/deps/couchbase-cxx-client/core/impl/analytics.cxx

@@ -0,0 +1,236 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include <couchbase/cluster.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/document_analytics.hxx"
+
+namespace couchbase
+{
+static analytics_error_context
+build_context(core::operations::analytics_response& resp)
+{
+    return {
+        resp.ctx.ec,
+        resp.ctx.last_dispatched_to,
+        resp.ctx.last_dispatched_from,
+        resp.ctx.retry_attempts,
+        std::move(resp.ctx.retry_reasons),
+        resp.ctx.first_error_code,
+        std::move(resp.ctx.first_error_message),
+        std::move(resp.ctx.client_context_id),
+        std::move(resp.ctx.statement),
+        std::move(resp.ctx.parameters),
+        std::move(resp.ctx.method),
+        std::move(resp.ctx.path),
+        resp.ctx.http_status,
+        std::move(resp.ctx.http_body),
+        std::move(resp.ctx.hostname),
+        resp.ctx.port,
+    };
+}
+
+static analytics_status
+map_status(core::operations::analytics_response::analytics_status status)
+{
+    switch (status) {
+        case core::operations::analytics_response::running:
+            return analytics_status::running;
+        case core::operations::analytics_response::success:
+            return analytics_status::success;
+        case core::operations::analytics_response::errors:
+            return analytics_status::errors;
+        case core::operations::analytics_response::completed:
+            return analytics_status::completed;
+        case core::operations::analytics_response::stopped:
+            return analytics_status::stopped;
+        case core::operations::analytics_response::timedout:
+            return analytics_status::timeout;
+        case core::operations::analytics_response::closed:
+            return analytics_status::closed;
+        case core::operations::analytics_response::fatal:
+            return analytics_status::fatal;
+        case core::operations::analytics_response::aborted:
+            return analytics_status::aborted;
+        case core::operations::analytics_response::unknown:
+            return analytics_status::unknown;
+    }
+    return analytics_status::unknown;
+}
+
+static std::optional<couchbase::core::analytics_scan_consistency>
+map_scan_consistency(std::optional<couchbase::analytics_scan_consistency> consistency)
+{
+    if (consistency.has_value()) {
+        switch (consistency.value()) {
+            case analytics_scan_consistency::not_bounded:
+                return couchbase::core::analytics_scan_consistency::not_bounded;
+            case analytics_scan_consistency::request_plus:
+                return couchbase::core::analytics_scan_consistency::request_plus;
+        }
+    }
+    return {};
+}
+
+static std::vector<codec::binary>
+map_rows(const core::operations::analytics_response& resp)
+{
+    std::vector<codec::binary> rows;
+    rows.reserve(resp.rows.size());
+    for (const auto& row : resp.rows) {
+        rows.emplace_back(core::utils::to_binary(row));
+    }
+    return rows;
+}
+
+static std::vector<analytics_warning>
+map_warnings(core::operations::analytics_response& resp)
+{
+    if (resp.meta.warnings.empty()) {
+        return {};
+    }
+    std::vector<analytics_warning> warnings;
+    warnings.reserve(resp.meta.warnings.size());
+    for (auto& warning : resp.meta.warnings) {
+        warnings.emplace_back(warning.code, std::move(warning.message));
+    }
+    return warnings;
+}
+
+static analytics_metrics
+map_metrics(const core::operations::analytics_response& resp)
+{
+    return analytics_metrics{
+        resp.meta.metrics.elapsed_time,  resp.meta.metrics.execution_time,    resp.meta.metrics.result_count,
+        resp.meta.metrics.result_size,   resp.meta.metrics.processed_objects, resp.meta.metrics.error_count,
+        resp.meta.metrics.warning_count,
+    };
+}
+
+static std::optional<std::vector<std::byte>>
+map_signature(core::operations::analytics_response& resp)
+{
+    if (!resp.meta.signature) {
+        return {};
+    }
+    return core::utils::to_binary(resp.meta.signature.value());
+}
+
+static analytics_result
+build_result(core::operations::analytics_response& resp)
+{
+    return {
+        analytics_meta_data{
+          std::move(resp.meta.request_id),
+          std::move(resp.meta.client_context_id),
+          map_status(resp.meta.status),
+          map_warnings(resp),
+          map_metrics(resp),
+          map_signature(resp),
+        },
+        map_rows(resp),
+    };
+}
+
+static core::operations::analytics_request
+build_analytics_request(std::string statement,
+                        analytics_options::built options,
+                        std::optional<std::string> bucket_name,
+                        std::optional<std::string> scope_name)
+{
+    core::operations::analytics_request request{
+        std::move(statement),
+        options.readonly,
+        options.priority,
+        std::move(bucket_name),
+        std::move(scope_name),
+        {},
+        map_scan_consistency(options.scan_consistency),
+        {},
+        {},
+        {},
+        {},
+        std::move(options.client_context_id),
+        options.timeout,
+    };
+    if (!options.raw.empty()) {
+        for (auto& [name, value] : options.raw) {
+            request.raw[name] = std::move(value);
+        }
+    }
+    if (!options.positional_parameters.empty()) {
+        for (auto& value : options.positional_parameters) {
+            request.positional_parameters.emplace_back(std::move(value));
+        }
+    }
+    if (!options.named_parameters.empty()) {
+        for (auto& [name, value] : options.named_parameters) {
+            request.named_parameters[name] = std::move(value);
+        }
+    }
+    return request;
+}
+
+void
+cluster::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    auto request = build_analytics_request(std::move(statement), options.build(), {}, {});
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
+        auto r = std::move(resp);
+        return handler(build_context(r), build_result(r));
+    });
+}
+
+auto
+cluster::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+void
+scope::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+{
+    auto request = build_analytics_request(std::move(statement), options.build(), bucket_name_, name_);
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::analytics_response resp) mutable {
+        auto r = std::move(resp);
+        return handler(build_context(r), build_result(r));
+    });
+}
+
+auto
+scope::analytics_query(std::string statement, const analytics_options& options) const
+  -> std::future<std::pair<analytics_error_context, analytics_result>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
+    auto future = barrier->get_future();
+    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
+        barrier->set_value({ std::move(ctx), std::move(result) });
+    });
+    return future;
+}
+
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/cluster.cxx

@@ -95,10 +95,10 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
     if (opts.dns.nameserver) {
         user_options.dns_config =
           io::dns::dns_config(opts.dns.nameserver.value(), opts.dns.port.value_or(io::dns::dns_config::default_port), opts.dns.timeout);
-        user_options.dns_srv_timeout = opts.dns.timeout;
     }
     user_options.enable_clustermap_notification = opts.behavior.enable_clustermap_notification;
     user_options.show_queries = opts.behavior.show_queries;
+    user_options.dump_configuration = opts.behavior.dump_configuration;
     user_options.enable_mutation_tokens = opts.behavior.enable_mutation_tokens;
     user_options.enable_unordered_execution = opts.behavior.enable_unordered_execution;
     user_options.user_agent_extra = opts.behavior.user_agent_extra;