couchbase 3.0.0.alpha.3 → 3.0.1

data/ext/extconf.rb

@@ -1,47 +1,95 @@
+#    Copyright 2020 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.
+
 require "mkmf"
-require "fileutils"
 require "tempfile"
 
-unless find_executable("cmake")
-  abort "ERROR: CMake is required to build couchbase extension."
+require_relative "../lib/couchbase/version"
+SDK_VERSION = Couchbase::VERSION[:sdk]
+
+cmake = find_executable("cmake")
+if `#{cmake} --version`[/cmake version (\d+\.\d+)/, 1].to_f < 3.15
+  cmake = find_executable("cmake3")
 end
+abort "ERROR: CMake is required to build couchbase extension." unless cmake
+puts "-- #{`#{cmake} --version`.split("\n").first}"
 
 def sys(*cmd)
   puts "-- #{Dir.pwd}"
-  puts "-- #{cmd.join(" ")}"
+  puts "-- #{cmd.join(' ')}"
   system(*cmd)
 end
 
-
 build_type = ENV["DEBUG"] ? "Debug" : "RelWithDebInfo"
-cmake_flags = [
-  "-DCMAKE_BUILD_TYPE=#{build_type}",
-  "-DRUBY_HDR_DIR=#{RbConfig::CONFIG["rubyhdrdir"]}",
-  "-DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG["rubyarchhdrdir"]}",
-  "-DTAOCPP_JSON_BUILD_TESTS=OFF",
-  "-DTAOCPP_JSON_BUILD_EXAMPLES=OFF",
-  "-DSNAPPY_BUILD_TESTS=OFF",
-  "-DSNAPPY_INSTALL=OFF",
+cmake_flags = %W[
+  -DCMAKE_BUILD_TYPE=#{build_type}
+  -DRUBY_HDR_DIR=#{RbConfig::CONFIG['rubyhdrdir']}
+  -DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG['rubyarchhdrdir']}
 ]
-openssl_root = `brew --prefix openssl 2> /dev/null`.strip
-unless openssl_root.empty?
-  cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}"
+
+cmake_flags << "-DCMAKE_C_COMPILER=#{ENV['CB_CC']}" if ENV["CB_CC"]
+cmake_flags << "-DCMAKE_CXX_COMPILER=#{ENV['CB_CXX']}" if ENV["CB_CXX"]
+cmake_flags << "-DSTATIC_STDLIB=ON" << "-DSTATIC_OPENSSL=ON" if ENV["CB_STATIC"]
+cmake_flags << "-DENABLE_SANITIZER_ADDRESS=ON" if ENV["CB_ASAN"]
+cmake_flags << "-DENABLE_SANITIZER_LEAK=ON" if ENV["CB_LSAN"]
+cmake_flags << "-DENABLE_SANITIZER_MEMORY=ON" if ENV["CB_MSAN"]
+cmake_flags << "-DENABLE_SANITIZER_THREAD=ON" if ENV["CB_TSAN"]
+cmake_flags << "-DENABLE_SANITIZER_UNDEFINED_BEHAVIOUR=ON" if ENV["CB_UBSAN"]
+
+case RbConfig::CONFIG["target_os"]
+when /darwin/
+  openssl_root = `brew --prefix openssl 2> /dev/null`.strip
+  cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}" unless openssl_root.empty?
+when /linux/
+  openssl_root = ["/usr/lib64/openssl11", "/usr/include/openssl11"]
+  cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root.join(';')}" if openssl_root.all? { |path| File.directory?(path) }
 end
 
 project_path = File.expand_path(File.join(__dir__))
-build_dir = File.join(Dir.tmpdir, "couchbase-rubygem-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}")
-FileUtils.mkdir_p(build_dir)
+build_dir = ENV['CB_EXT_BUILD_DIR'] ||
+            File.join(Dir.tmpdir, "cb-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}-#{SDK_VERSION}")
+FileUtils.rm_rf(build_dir, verbose: true) unless ENV['CB_PRESERVE_BUILD_DIR']
+FileUtils.mkdir_p(build_dir, verbose: true)
 Dir.chdir(build_dir) do
-  sys("cmake", *cmake_flags, project_path)
+  puts "-- build #{build_type} extension #{SDK_VERSION} for ruby #{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}"
+  sys(cmake, *cmake_flags, project_path)
   sys("make -j4 VERBOSE=1")
 end
-extension_name = "libcouchbase.#{RbConfig::CONFIG["SOEXT"]}"
+extension_name = "libcouchbase.#{RbConfig::CONFIG['SOEXT'] || RbConfig::CONFIG['DLEXT']}"
 extension_path = File.expand_path(File.join(build_dir, extension_name))
-unless File.file?(extension_path)
-  abort "ERROR: failed to build extension in #{extension_path}"
-end
+abort "ERROR: failed to build extension in #{extension_path}" unless File.file?(extension_path)
 extension_name.gsub!(/\.dylib/, '.bundle')
 install_path = File.expand_path(File.join(__dir__, "..", "lib", "couchbase", extension_name))
 puts "-- copy extension to #{install_path}"
-FileUtils.cp(extension_path, install_path)
+FileUtils.cp(extension_path, install_path, verbose: true)
+ext_directory = File.expand_path(__dir__)
 create_makefile("libcouchbase")
+if ENV["CB_REMOVE_EXT_DIRECTORY"]
+  puts "-- CB_REMOVE_EXT_DIRECTORY is set, remove #{ext_directory}"
+  Dir
+    .glob("#{ext_directory}/*", File::FNM_DOTMATCH)
+    .reject { |path| %w[. .. extconf.rb].include?(File.basename(path)) || File.basename(path).start_with?(".gem") }
+    .each do |entry|
+    puts "-- remove #{entry}"
+    FileUtils.rm_rf(entry, verbose: true)
+  end
+  File.truncate("#{ext_directory}/extconf.rb", 0)
+  puts "-- truncate #{ext_directory}/extconf.rb"
+  File.write("#{ext_directory}/Makefile", <<~MAKEFILE)
+    .PHONY: all clean install
+    all:
+    clean:
+    install:
+  MAKEFILE
+end

data/ext/test/test_helper.hxx

@@ -0,0 +1,141 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <test_config.hxx>
+
+#include <string>
+#include <regex>
+#include <cstdlib>
+
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+struct test_server_version {
+    unsigned long major;
+    unsigned long minor;
+    unsigned long micro{ 0 };
+    unsigned long build{ 0 };
+    bool developer_preview{ false };
+
+    static test_server_version parse(const std::string& str)
+    {
+        std::regex version_regex(R"((\d+).(\d+).(\d+(-(\d+))?)?)");
+        std::smatch version_match;
+        test_server_version ver{};
+        if (std::regex_match(str, version_match, version_regex) && version_match.ready()) {
+            ver.major = std::stoul(version_match[1]);
+            ver.minor = std::stoul(version_match[2]);
+            if (version_match.length(3) > 0) {
+                ver.micro = std::stoul(version_match[3]);
+                if (version_match.length(5) > 0) {
+                    ver.build = std::stoul(version_match[5]);
+                }
+            }
+        } else {
+            ver.major = 6;
+            ver.minor = 6;
+            ver.micro = 0;
+        }
+        return ver;
+    }
+
+    [[nodiscard]] bool is_alice() const
+    {
+        // [6.0.0, 6.5.0)
+        return major == 6 && minor < 5;
+    }
+
+    [[nodiscard]] bool is_mad_hatter() const
+    {
+        // [6.5.0, 7.0.0)
+        return major == 6 && minor >= 5;
+    }
+
+    [[nodiscard]] bool is_cheshire_cat() const
+    {
+        // [7.0.0, inf)
+        return major >= 7;
+    }
+
+    [[nodiscard]] bool supports_gcccp() const
+    {
+        return is_mad_hatter() || is_cheshire_cat();
+    }
+
+    [[nodiscard]] bool supports_sync_replication() const
+    {
+        return is_mad_hatter() || is_cheshire_cat();
+    }
+
+    [[nodiscard]] bool supports_scoped_queries() const
+    {
+        return is_cheshire_cat();
+    }
+
+    [[nodiscard]] bool supports_collections() const
+    {
+        return (is_mad_hatter() && developer_preview) || is_cheshire_cat();
+    }
+};
+
+struct test_context {
+    std::string connection_string{ "couchbase://127.0.0.1" };
+    std::string username{ "Administrator" };
+    std::string password{ "password" };
+    std::string bucket{ "default" };
+    test_server_version version{ 6, 6, 0 };
+
+    static test_context load_from_environment()
+    {
+        test_context ctx{};
+
+        const char* var = nullptr;
+
+        var = getenv("TEST_CONNECTION_STRING");
+        if (var != nullptr) {
+            ctx.connection_string = var;
+        }
+        var = getenv("TEST_USERNAME");
+        if (var != nullptr) {
+            ctx.username = var;
+        }
+        var = getenv("TEST_PASSWORD");
+        if (var != nullptr) {
+            ctx.password = var;
+        }
+        var = getenv("TEST_BUCKET");
+        if (var != nullptr) {
+            ctx.bucket = var;
+        }
+        var = getenv("TEST_SERVER_VERSION");
+        if (var != nullptr) {
+            ctx.bucket = var;
+        }
+        var = getenv("TEST_DEVELOPER_PREVIEW");
+        if (var != nullptr) {
+            if (strcmp(var, "true") == 0 || strcmp(var, "yes") == 0 || strcmp(var, "1") == 0) {
+                ctx.version.developer_preview = true;
+            } else if (strcmp(var, "false") == 0 || strcmp(var, "no") == 0 || strcmp(var, "0") == 0) {
+                ctx.version.developer_preview = false;
+            }
+        }
+
+        return ctx;
+    }
+};

data/ext/test/test_helper_native.hxx

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 "test_helper.hxx"
+
+#include <build_config.hxx>
+
+#include <asio/version.hpp>
+
+#include <spdlog/spdlog.h>
+#include <spdlog/cfg/env.h>
+
+#include <http_parser.h>
+
+#include <snappy.h>
+
+#include <version.hxx>
+
+#include <cluster.hxx>
+#include <operations.hxx>
+
+#include <io/dns_client.hxx>
+#include <utils/connection_string.hxx>
+
+void
+native_init_logger()
+{
+    static bool initialized = false;
+
+    if (!initialized) {
+        spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v");
+
+        auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
+        if (env_val.empty()) {
+            spdlog::set_level(spdlog::level::warn);
+        } else {
+            auto levels = spdlog::cfg::helpers::extract_levels(env_val);
+            spdlog::details::registry::instance().update_levels(std::move(levels));
+        }
+
+        initialized = true;
+    }
+}

data/ext/test/test_helper_ruby.hxx

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 "test_helper.hxx"
+#include <optional>
+
+#include <ruby.h>
+
+extern "C" {
+void
+rb_encdb_declare(const char* name);
+int
+rb_encdb_alias(const char* alias, const char* orig);
+}
+
+struct ruby_context {
+    ruby_context()
+    {
+        ruby_init();
+        ruby_init_loadpath();
+
+        rb_encdb_declare("ASCII-8BIT");
+        rb_encdb_declare("US-ASCII");
+        rb_encdb_declare("UTF-8");
+        rb_encdb_alias("BINARY", "ASCII-8BIT");
+        rb_encdb_alias("ASCII", "US-ASCII");
+        rb_require("rubygems");
+        rb_require("json");
+        rb_require(LIBCOUCHBASE_EXT_PATH);
+    }
+
+    ~ruby_context()
+    {
+        ruby_cleanup(0);
+    }
+
+    std::optional<std::string> eval_script(test_context& ctx, const std::string& input)
+    {
+        int status = 0;
+        std::string script = input;
+        script = std::regex_replace(script, std::regex("CONNECTION_STRING"), '"' + ctx.connection_string + '"');
+        script = std::regex_replace(script, std::regex("USERNAME"), '"' + ctx.username + '"');
+        script = std::regex_replace(script, std::regex("PASSWORD"), '"' + ctx.password + '"');
+        script = std::regex_replace(script, std::regex("BUCKET"), '"' + ctx.bucket + '"');
+        rb_eval_string_protect(script.c_str(), &status);
+        if (status != 0) {
+            VALUE rbError = rb_funcall(rb_gv_get("$!"), rb_intern("message"), 0);
+            return std::string(StringValuePtr(rbError));
+        }
+        return {};
+    }
+};
+
+#define TEST_PREAMBLE_RUBY                                                                                                                 \
+    RUBY_INIT_STACK;                                                                                                                       \
+    ruby_context ruby{};

data/ext/test/test_native_diagnostics.cxx

@@ -0,0 +1,385 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 "test_helper_native.hxx"
+
+#include <diagnostics.hxx>
+
+using namespace std::literals::chrono_literals;
+
+TEST_CASE("native: serializing diagnostics report", "[native]")
+{
+    couchbase::diag::diagnostics_result res{
+        "0xdeadbeef",
+        "ruby/1.0.0",
+        {
+          {
+            {
+              couchbase::service_type::search,
+              {
+                {
+                  couchbase::service_type::search,
+                  "0x1415F11",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8094",
+                  "127.0.0.1:54669",
+                  couchbase::diag::endpoint_state::connecting,
+                  std::nullopt,
+                  "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017",
+                },
+              },
+            },
+            {
+              couchbase::service_type::kv,
+              {
+                {
+                  couchbase::service_type::kv,
+                  "0x1415F12",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:11210",
+                  "127.0.0.1:54670",
+                  couchbase::diag::endpoint_state::connected,
+                  "bucketname",
+                },
+              },
+            },
+            {
+              couchbase::service_type::query,
+              {
+                {
+                  couchbase::service_type::query,
+                  "0x1415F13",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8093",
+                  "127.0.0.1:54671",
+                  couchbase::diag::endpoint_state::connected,
+                },
+                {
+                  couchbase::service_type::query,
+                  "0x1415F14",
+                  1182000us,
+                  "centos7-lx2.home.ingenthron.org:8095",
+                  "127.0.0.1:54682",
+                  couchbase::diag::endpoint_state::disconnected,
+                },
+              },
+            },
+            {
+              couchbase::service_type::analytics,
+              {
+                {
+                  couchbase::service_type::analytics,
+                  "0x1415F15",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8095",
+                  "127.0.0.1:54675",
+                  couchbase::diag::endpoint_state::connected,
+                },
+              },
+            },
+            {
+              couchbase::service_type::views,
+              {
+                {
+                  couchbase::service_type::views,
+                  "0x1415F16",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8092",
+                  "127.0.0.1:54672",
+                  couchbase::diag::endpoint_state::connected,
+                },
+              },
+            },
+          },
+        },
+    };
+
+    auto expected = tao::json::from_string(R"(
+{
+  "version": 2,
+  "id": "0xdeadbeef",
+  "sdk": "ruby/1.0.0",
+  "services": {
+    "kv": [
+      {
+        "id": "0x1415F12",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:11210",
+        "local": "127.0.0.1:54670",
+        "state": "connected",
+        "namespace": "bucketname"
+      }
+    ],
+    "search": [
+      {
+        "id": "0x1415F11",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8094",
+        "local": "127.0.0.1:54669",
+        "state": "connecting",
+        "details": "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017"
+      }
+    ],
+    "query": [
+      {
+        "id": "0x1415F13",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8093",
+        "local": "127.0.0.1:54671",
+        "state": "connected"
+      },
+      {
+        "id": "0x1415F14",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx2.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54682",
+        "state": "disconnected"
+      }
+    ],
+    "analytics": [
+      {
+        "id": "0x1415F15",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54675",
+        "state": "connected"
+      }
+    ],
+    "views": [
+      {
+        "id": "0x1415F16",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8092",
+        "local": "127.0.0.1:54672",
+        "state": "connected"
+      }
+    ]
+  }
+}
+)");
+    auto report = tao::json::value(res);
+    REQUIRE(report == expected);
+}
+
+TEST_CASE("native: serializing ping report", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    couchbase::diag::ping_result res{
+        "0xdeadbeef",
+        "ruby/1.0.0",
+        53,
+        {
+          {
+            {
+              couchbase::service_type::search,
+              {
+                {
+                  couchbase::service_type::search,
+                  "0x1415F11",
+                  877909us,
+                  "centos7-lx1.home.ingenthron.org:8094",
+                  "127.0.0.1:54669",
+                  couchbase::diag::ping_state::ok,
+                },
+              },
+            },
+            {
+              couchbase::service_type::kv,
+              {
+                {
+                  couchbase::service_type::kv,
+                  "0x1415F12",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:11210",
+                  "127.0.0.1:54670",
+                  couchbase::diag::ping_state::ok,
+                  "bucketname",
+                },
+              },
+            },
+            {
+              couchbase::service_type::query,
+              {
+                {
+                  couchbase::service_type::query,
+                  "0x1415F14",
+                  2213us,
+                  "centos7-lx2.home.ingenthron.org:8095",
+                  "127.0.0.1:54682",
+                  couchbase::diag::ping_state::timeout,
+                },
+              },
+            },
+            {
+              couchbase::service_type::analytics,
+              {
+                {
+                  couchbase::service_type::analytics,
+                  "0x1415F15",
+                  2213us,
+                  "centos7-lx1.home.ingenthron.org:8095",
+                  "127.0.0.1:54675",
+                  couchbase::diag::ping_state::error,
+                  std::nullopt,
+                  "endpoint returned HTTP code 500!",
+                },
+              },
+            },
+            {
+              couchbase::service_type::views,
+              {
+                {
+                  couchbase::service_type::views,
+                  "0x1415F16",
+                  45585us,
+                  "centos7-lx1.home.ingenthron.org:8092",
+                  "127.0.0.1:54672",
+                  couchbase::diag::ping_state::ok,
+                },
+              },
+            },
+          },
+        },
+    };
+
+    auto expected = tao::json::from_string(R"(
+{
+  "version": 2,
+  "id": "0xdeadbeef",
+  "config_rev": 53,
+  "sdk": "ruby/1.0.0",
+  "services": {
+    "search": [
+      {
+        "id": "0x1415F11",
+        "latency_us": 877909,
+        "remote": "centos7-lx1.home.ingenthron.org:8094",
+        "local": "127.0.0.1:54669",
+        "state": "ok"
+      }
+    ],
+    "kv": [
+      {
+        "id": "0x1415F12",
+        "latency_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:11210",
+        "local": "127.0.0.1:54670",
+        "state": "ok",
+        "namespace": "bucketname"
+      }
+    ],
+    "query": [
+      {
+        "id": "0x1415F14",
+        "latency_us": 2213,
+        "remote": "centos7-lx2.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54682",
+        "state": "timeout"
+      }
+    ],
+    "analytics": [
+      {
+        "id": "0x1415F15",
+        "latency_us": 2213,
+        "remote": "centos7-lx1.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54675",
+        "state": "error",
+        "error": "endpoint returned HTTP code 500!"
+      }
+    ],
+    "views": [
+      {
+        "id": "0x1415F16",
+        "latency_us": 45585,
+        "remote": "centos7-lx1.home.ingenthron.org:8092",
+        "local": "127.0.0.1:54672",
+        "state": "ok"
+      }
+    ]
+  }
+}
+)");
+    auto report = tao::json::value(res);
+    REQUIRE(report == expected);
+}
+
+TEST_CASE("native: fetch diagnostics after N1QL query", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(io);
+    auto io_thread = std::thread([&io]() { io.run(); });
+
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        couchbase::operations::query_request req{ "SELECT 'hello, couchbase' AS greetings" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
+        auto f = barrier->get_future();
+        cluster.execute_http(req, [barrier](couchbase::operations::query_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ec.message());
+        REQUIRE_FALSE(resp.ec);
+        INFO("rows.size() =" << resp.payload.rows.size());
+        REQUIRE(resp.payload.rows.size() == 1);
+        INFO("row=" << resp.payload.rows[0]);
+        REQUIRE(resp.payload.rows[0] == R"({"greetings":"hello, couchbase"})");
+    }
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::diagnostics_result>>();
+        auto f = barrier->get_future();
+        cluster.diagnostics("my_report_id", [barrier](couchbase::diag::diagnostics_result resp) mutable { barrier->set_value(resp); });
+        auto res = f.get();
+        REQUIRE(res.id == "my_report_id");
+        REQUIRE(res.sdk.find("ruby/") == 0);
+        REQUIRE(res.services[couchbase::service_type::kv].size() > 1);
+        REQUIRE(res.services[couchbase::service_type::query].size() == 1);
+        REQUIRE(res.services[couchbase::service_type::query][0].state == couchbase::diag::endpoint_state::connected);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}