couchbase 3.8.1 → 3.9.0

data/ext/couchbase/cmake/TestFramework.cmake

@@ -0,0 +1,283 @@
+# The shared test framework: the runner, the common main(), the registration helpers, and the
+# framework's own self-test.
+#
+# Hand-rolled (CXXCBC-885), deliberately NOT Catch2. It lives outside either test subdirectory
+# because both test trees link it. See test/cng/README.md to build and run the CNG tests.
+
+find_package(Threads REQUIRED)
+
+# Each test executable links this and provides its own tests(). fmt comes from spdlog's bundled
+# copy (header include dirs only). ${PROJECT_SOURCE_DIR}/test is PUBLIC so every test spells its
+# includes from one root: "framework/test_runner.hxx", "cng/fixtures/live_fixture.hxx".
+add_library(
+  test_framework_main STATIC
+  ${PROJECT_SOURCE_DIR}/test/framework/context.cxx
+  ${PROJECT_SOURCE_DIR}/test/framework/requirement.cxx
+  ${PROJECT_SOURCE_DIR}/test/framework/test_runner.cxx
+  ${PROJECT_SOURCE_DIR}/test/framework/test_main.cxx)
+target_include_directories(test_framework_main PUBLIC ${PROJECT_SOURCE_DIR}/test
+                                                      ${PROJECT_SOURCE_DIR})
+# spdlog is linked, not merely included, so the framework compiles bundled fmt in the same mode as
+# the client library. Borrowing only spdlog's include directories left SPDLOG_COMPILED_LIB undefined
+# here, and spdlog/fmt/fmt.h responds by defining FMT_HEADER_ONLY, which emits definitions of
+# fmt::v11::vformat, report_error, is_printable, write_loc and friends into test_runner.obj and
+# test_main.obj. A test that also links the client then puts those next to the compiled spdlog's
+# copies of the same symbols. ld folds that silently; link.exe does not, and fails with LNK2005.
+# declare_system_library() already marks spdlog's includes SYSTEM, so linking it keeps its headers
+# out of /W4 /WX without the manual BEFORE override.
+target_link_libraries(test_framework_main PUBLIC Threads::Threads spdlog::spdlog)
+set_project_options(test_framework_main)
+set_project_warnings(test_framework_main)
+# Sanitized like test_utils, for the reason test/utils/CMakeLists.txt gives.
+enable_sanitizers(test_framework_main)
+
+# The shared cluster helpers. Promoted out of test/CMakeLists.txt because the framework's cluster
+# probes are built on them, so they have to exist whenever either suite is built rather than only
+# when the Catch2 suite is.
+if(NOT TARGET test_utils)
+  add_subdirectory(test/utils)
+endif()
+
+# Exactly one of these provides make_probe_backend(), and couchbase_add_test() picks which by
+# whether the test links the client library. OBJECT rather than STATIC so the definition is always
+# contributed: an archive is only searched when something already references what it holds, and the
+# reference here comes from the framework's own main().
+#
+# The null one answers every probe with "I cannot ask", which the runner reports as undetermined and
+# therefore as a failure. A test that asks about the server from a binary with no way to reach one
+# is a registration mistake, and skipping it would hide the mistake for as long as it existed.
+add_library(test_framework_null_probes OBJECT ${PROJECT_SOURCE_DIR}/test/framework/null_probes.cxx)
+target_include_directories(test_framework_null_probes PRIVATE ${PROJECT_SOURCE_DIR}/test)
+target_include_directories(
+  test_framework_null_probes SYSTEM BEFORE
+  PRIVATE $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>)
+set_target_properties(test_framework_null_probes PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_project_options(test_framework_null_probes)
+set_project_warnings(test_framework_null_probes)
+enable_sanitizers(test_framework_null_probes)
+
+# The real one drives a connection through test::utils::integration_test_guard, so it is the only
+# part of the framework that includes core headers -- and it is a .cxx, which is what keeps
+# context.hxx lean.
+add_library(test_framework_cluster_probes OBJECT
+            ${PROJECT_SOURCE_DIR}/test/framework/cluster_probes.cxx)
+target_include_directories(
+  test_framework_cluster_probes PRIVATE ${PROJECT_SOURCE_DIR}/test ${PROJECT_SOURCE_DIR}
+                                       ${PROJECT_BINARY_DIR}/generated
+                                       ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
+target_include_directories(
+  test_framework_cluster_probes SYSTEM BEFORE
+  PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
+          $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>
+          $<BUILD_INTERFACE:$<TARGET_PROPERTY:asio,INTERFACE_INCLUDE_DIRECTORIES>>)
+propagate_public_compile_definitions(test_framework_cluster_probes spdlog::spdlog asio)
+target_link_libraries(test_framework_cluster_probes PRIVATE $<BUILD_INTERFACE:Microsoft.GSL::GSL>
+                                                            $<BUILD_INTERFACE:taocpp::json>)
+set_target_properties(test_framework_cluster_probes PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_project_options(test_framework_cluster_probes)
+set_project_warnings(test_framework_cluster_probes)
+enable_sanitizers(test_framework_cluster_probes)
+
+# couchbase_discover_tests(<target> PROPERTIES <prop> <value>...)
+#
+# Registers one ctest entry per case, named <target>.<case>, the way catch_discover_tests does for
+# the Catch2 suites. Per-executable registration would be coarser than what the suite already
+# depends on: bin/run-integration-tests shards the valgrind leg with `ctest -I i,,n`, whose stride
+# runs over ctest entries, and --output-junit builds the CI report from one row per entry.
+#
+# The list is produced at post-build by running the executable with --list-tests, which reports
+# every case regardless of what the environment satisfies -- so the registered set does not depend
+# on the machine that built it.
+#
+# NAMING RULE, which the whole scheme relies on: a case name is the name of the function that
+# implements it -- the CASE macro in test/framework/test_registry.hxx stringifies the identifier, so
+# the two cannot drift -- and is therefore a C++ identifier, [A-Za-z_][A-Za-z0-9_]* and nothing
+# else, lower_snake_case by convention rather than by enforcement. No spaces, no punctuation, no
+# colons. A Catch2 case is
+# converted to one ONCE, when it is migrated: the category prefix is dropped because the target's
+# ctest label and the case's own requirements already carry it, and the remaining words are joined
+# with underscores. So
+# "integration: cluster remains usable in a forked child" is migrated as the function
+# cluster_remains_usable_in_a_forked_child.
+#
+# Keep that rule and nothing here needs quoting or escaping: the name is safe as a CMake list
+# element, as a ctest -R pattern, and as an argv entry in bash, zsh, cmd and PowerShell alike. Break
+# it and the fix is the name, never an escaping scheme in this file.
+function(couchbase_discover_tests target)
+  cmake_parse_arguments(ARG "" "" "PROPERTIES" ${ARGN})
+
+  get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+  if(is_multi_config)
+    set(ctest_file "${CMAKE_CURRENT_BINARY_DIR}/${target}_tests_$<CONFIG>.cmake")
+    set(ctest_file_at_test_time "${CMAKE_CURRENT_BINARY_DIR}/${target}_tests_\${CTEST_CONFIGURATION_TYPE}.cmake")
+    # No BYPRODUCTS here. It accepts a generator expression only from CMake 3.20, and this project
+    # declares 3.19, so a multi-config generate would break on the minimum version this repository
+    # claims to support. The declaration only tells the build graph that the command writes this
+    # file -- it is a `clean` and dependency-tracking hint, not a correctness requirement, and the
+    # per-config file name is worth more than the hint. catch_discover_tests() avoids the question
+    # by keying its file on an argument hash rather than the configuration, which is why one file
+    # there serves every config.
+    set(byproducts "")
+  else()
+    set(ctest_file "${CMAKE_CURRENT_BINARY_DIR}/${target}_tests.cmake")
+    set(ctest_file_at_test_time "${ctest_file}")
+    set(byproducts BYPRODUCTS "${ctest_file}")
+  endif()
+
+  add_custom_command(
+    TARGET ${target}
+    POST_BUILD
+    ${byproducts}
+    COMMAND
+      "${CMAKE_COMMAND}" -D "TEST_TARGET=${target}" -D "TEST_EXECUTABLE=$<TARGET_FILE:${target}>" -D
+      "TEST_PROPERTIES=${ARG_PROPERTIES}" -D "CTEST_FILE=${ctest_file}" -P
+      "${PROJECT_SOURCE_DIR}/cmake/TestFrameworkAddTests.cmake"
+    COMMENT "Enumerating test cases in ${target}"
+    VERBATIM)
+
+  # ctest reads TEST_INCLUDE_FILES at the start of a run, when the generated file may not exist --
+  # a fresh configure, or a build that never got as far as linking this target. Registering a test
+  # that cannot pass is the point: an unbuilt binary must not read as a binary with no failures.
+  #
+  # The placeholder runs cmake -E false rather than a command named after the target: a missing
+  # command fails with a different message on every platform ("command not found", "file not
+  # found", a Windows error box), and one of them has to be recognisable as the intended failure.
+  set(include_file "${CMAKE_CURRENT_BINARY_DIR}/${target}_include.cmake")
+  file(
+    WRITE "${include_file}"
+    "if(EXISTS \"${ctest_file_at_test_time}\")\n"
+    "  include(\"${ctest_file_at_test_time}\")\n"
+    "else()\n"
+    # Positional, not add_test(NAME ... COMMAND ...): the keyword signature is a CMakeLists
+    # feature. Meeting one in an include file, ctest takes the first argument as the test name and
+    # the rest as the command, so it registers an entry literally called "NAME" that reports Not
+    # Run. The positional form is what makes the entry carry the target's name and fail for the
+    # reason it was registered.
+    "  add_test([==[${target}_NOT_BUILT]==] [==[${CMAKE_COMMAND}]==] -E false)\n"
+    # The placeholder carries the same labels as the real cases would. Without them a labelled run
+    # -- which is how CI runs everything -- would filter the placeholder out, and an unbuilt binary
+    # would once again read as a binary with no failures.
+    "  set(properties [==[${ARG_PROPERTIES}]==])\n"
+    "  set_tests_properties(${target}_NOT_BUILT PROPERTIES \${properties})\n"
+    "endif()\n")
+  set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES "${include_file}")
+endfunction()
+
+# Which client library a LINK_CLIENT test links. test/cng/CMakeLists.txt narrows this for the
+# couchbase2 tests, which also link the generated protobuf stubs directly.
+set(couchbase_cxx_client_test_library ${couchbase_cxx_client_DEFAULT_LIBRARY})
+
+# couchbase_add_test(<relpath> LABEL <label> [LINK_CLIENT] [LIBS <lib>...])
+#
+# relpath is under test/ without the extension (e.g. cng/protostellar/dispatcher). The target name
+# is that path with the separators flattened, which makes it unique by construction: keying on the
+# file stem instead would collide the moment two subsystems each have a parser.cxx. LINK_CLIENT
+# links the client library and its core header include set, for tests that exercise core code.
+function(couchbase_add_test relpath)
+  cmake_parse_arguments(ARG "LINK_CLIENT" "LABEL" "LIBS" ${ARGN})
+
+  # Every entry is a label some leg in bin/ or .github/workflows/ selects with --label-regex. A
+  # label no runner selects is worse than a typo: it configures, builds and links, and the cases
+  # are then never executed by anything. Do not add one here without the leg that runs it.
+  set(known_labels unit integration transaction benchmark cng)
+  if(NOT ARG_LABEL IN_LIST known_labels)
+    # A typo here is invisible at build time and then quietly drops the binary out of the CI leg
+    # that was supposed to run it.
+    message(FATAL_ERROR "couchbase_add_test(${relpath}): LABEL must be one of ${known_labels}, "
+                        "got \"${ARG_LABEL}\"")
+  endif()
+
+  string(REPLACE "/" "_" target "${relpath}")
+  add_executable(${target} ${PROJECT_SOURCE_DIR}/test/${relpath}.cxx)
+  # The suite name in the run's own output, taken from the path rather than written out again in
+  # the file: a hand-written one drifts the moment the file is renamed and nothing notices.
+  target_compile_definitions(${target} PRIVATE COUCHBASE_TEST_SUITE_NAME="${target}")
+  target_include_directories(${target} PRIVATE ${PROJECT_SOURCE_DIR})
+  target_include_directories(
+    ${target} SYSTEM BEFORE
+    PRIVATE $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>)
+  target_link_libraries(${target} PRIVATE test_framework_main Threads::Threads)
+  if(ARG_LINK_CLIENT)
+    target_include_directories(${target} PRIVATE ${PROJECT_BINARY_DIR}/generated
+                                                 ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
+    target_include_directories(
+      ${target} SYSTEM BEFORE
+      PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
+              $<BUILD_INTERFACE:$<TARGET_PROPERTY:asio,INTERFACE_INCLUDE_DIRECTORIES>>)
+    propagate_public_compile_definitions(${target} spdlog::spdlog asio)
+    target_link_libraries(
+      ${target}
+      PRIVATE ${couchbase_cxx_client_test_library} test_framework_cluster_probes test_utils
+              $<BUILD_INTERFACE:Microsoft.GSL::GSL> $<BUILD_INTERFACE:taocpp::json>)
+    # The TLS backend the tree settled on, named the way test/utils/CMakeLists.txt names it:
+    # cmake/OpenSSL.cmake switches to the pkg-config target where find_package(OpenSSL) is absent
+    # or fails its usability probe, and creates neither under
+    # COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL, where the application supplies the symbols.
+    # Naming OpenSSL::SSL unconditionally fails to generate in both of those configurations.
+    if(TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+      target_link_libraries(${target} PRIVATE PkgConfig::PKG_CONFIG_OPENSSL)
+    elseif(TARGET OpenSSL::SSL)
+      target_link_libraries(${target} PRIVATE OpenSSL::SSL)
+    endif()
+    if(COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL AND WIN32)
+      # Ignore the `LNK4099: PDB ['crypto.pdb'|'ssl.pdb'] was not found` warnings: the BoringSSL
+      # build's *.PDB files are not kept. bin/build-tests.rb configures every Windows test build
+      # with STATIC_BORINGSSL, and cmake/Testing.cmake carries the same line for each Catch2
+      # target, so without this a migrated test is the only executable in the tree that reports it.
+      set_target_properties(${target} PROPERTIES LINK_FLAGS "/ignore:4099")
+    endif()
+  else()
+    target_link_libraries(${target} PRIVATE test_framework_null_probes)
+  endif()
+  if(ARG_LIBS)
+    target_link_libraries(${target} PRIVATE ${ARG_LIBS})
+  endif()
+  set_project_options(${target})
+  set_project_warnings(${target})
+
+  # Join the aggregate that build_<suite>_tests depends on. bin/build-tests builds that aggregate
+  # rather than `all` whenever CB_TEST_SUITE is set, and a target missing from it is not built --
+  # which leaves the discovery file absent and the case registered as the _NOT_BUILT placeholder.
+  #
+  # cmake/Testing.cmake blanks these properties, and it is included after this file, so an append
+  # made while this file is being read is discarded. Only calls from test/CMakeLists.txt, which
+  # Testing.cmake reads later, survive -- which is why a framework test that needs to be in an
+  # aggregate is registered there and not here. cng has no aggregate; it is built only by `all`.
+  if(ARG_LABEL STREQUAL "unit")
+    set_property(GLOBAL APPEND PROPERTY COUCHBASE_UNIT_TESTS ${target})
+  elseif(ARG_LABEL STREQUAL "integration")
+    set_property(GLOBAL APPEND PROPERTY COUCHBASE_INTEGRATION_TESTS ${target})
+  elseif(ARG_LABEL STREQUAL "transaction")
+    set_property(GLOBAL APPEND PROPERTY COUCHBASE_TRANSACTION_TESTS ${target})
+  elseif(ARG_LABEL STREQUAL "benchmark")
+    set_property(GLOBAL APPEND PROPERTY COUCHBASE_BENCHMARKS ${target})
+  endif()
+
+  # The harness returns 77 when every case was skipped; map that to ctest's "Skipped".
+  set(properties SKIP_RETURN_CODE 77 LABELS "${ARG_LABEL}")
+  # Sanitizers are applied per target (cmake/Sanitizers.cmake), so dependencies fetched and built
+  # as ordinary packages -- gRPC and abseil among them -- carry no instrumentation, and TSan cannot
+  # see the happens-before edges inside their event-engine and futex code. Without
+  # ignore_noninstrumented_modules it reports those as races: the dispatcher tests drive real gRPC
+  # threads and produced 54 such reports. Set on the test rather than in CI so a local `ctest` under
+  # TSan behaves the same way.
+  if(DEFINED COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS AND EXISTS "${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+    list(
+      APPEND
+      properties
+      ENVIRONMENT
+      "TSAN_OPTIONS=halt_on_error=0,second_deadlock_stack=1,ignore_noninstrumented_modules=1,suppressions=${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}"
+    )
+  endif()
+  couchbase_discover_tests(${target} PROPERTIES ${properties})
+
+endfunction()
+
+# cng, because that is the leg whose steps deliberately do not apply --test-action memcheck: the
+# inner suites here assert on absolute millisecond budgets, which valgrind would blow with no
+# multiplier able to reach them.
+couchbase_add_test(framework/selftest LABEL cng)
+
+# What assert_success prints. It needs couchbase::error, and therefore the client library, but no
+# server: every value it asserts on is constructed by hand. cng for the same reason as above.
+couchbase_add_test(framework/errors_selftest LABEL cng LINK_CLIENT)

data/ext/couchbase/cmake/TestFrameworkAddTests.cmake

@@ -0,0 +1,51 @@
+# Post-build enumerator for couchbase_discover_tests(). Runs the freshly linked test executable
+# with --list-tests and writes one add_test() per case, so ctest sees the same granularity
+# catch_discover_tests gives the Catch2 suites: `ctest -I i,,n` can shard a binary, `-R` can select
+# a single case, and --output-junit carries one row per case.
+#
+# Driven by cmake -P with TEST_TARGET, TEST_EXECUTABLE, TEST_PROPERTIES and CTEST_FILE defined.
+
+execute_process(
+  COMMAND "${TEST_EXECUTABLE}" --list-tests
+  OUTPUT_VARIABLE listing
+  ERROR_VARIABLE listing_error
+  RESULT_VARIABLE listing_result)
+
+if(NOT listing_result EQUAL 0)
+  message(FATAL_ERROR "${TEST_EXECUTABLE} --list-tests failed (${listing_result}):\n${listing_error}")
+endif()
+
+# Splitting on newlines below makes ";" the list separator, so any semicolon already in the text
+# has to be escaped first or one line becomes two entries. Case names cannot contain one -- they are
+# C++ identifiers, see the naming rule in couchbase_discover_tests() -- so this guards whatever else
+# the listing carries beside the name.
+string(REPLACE ";" "\\;" listing "${listing}")
+string(REPLACE "\n" ";" listing "${listing}")
+
+# Bracket-quoted once, then expanded unquoted at ctest time: interpolating the list straight into
+# the file splits it on any space inside a value -- a TSan suppressions path containing one would
+# have silently truncated the ENVIRONMENT property rather than failing.
+set(script "set(properties [==[${TEST_PROPERTIES}]==])\n")
+set(case_count 0)
+foreach(line IN LISTS listing)
+  # Each line is "<case name>\t<what it requires>". Only the name is registered; the requirements
+  # are there for whoever runs --list-tests by hand.
+  string(REGEX REPLACE "\t.*$" "" case_name "${line}")
+  string(STRIP "${case_name}" case_name)
+  if(case_name STREQUAL "")
+    continue()
+  endif()
+  math(EXPR case_count "${case_count} + 1")
+  set(test_name "${TEST_TARGET}.${case_name}")
+  string(APPEND script "add_test([==[${test_name}]==] [==[${TEST_EXECUTABLE}]==] [==[${case_name}]==])\n")
+  string(APPEND script "set_tests_properties([==[${test_name}]==] PROPERTIES \${properties})\n")
+endforeach()
+
+# A binary that reports no cases has to break the build. Writing an empty file instead would leave
+# ctest green with nothing registered, which is the failure this whole scheme exists to make
+# impossible.
+if(case_count EQUAL 0)
+  message(FATAL_ERROR "${TEST_EXECUTABLE} --list-tests reported no test cases")
+endif()
+
+file(WRITE "${CTEST_FILE}" "${script}")

data/ext/couchbase/cmake/Testing.cmake

@@ -14,8 +14,12 @@ if(COUCHBASE_CXX_CLIENT_ENABLE_VALGRIND)
   find_program(VALGRIND valgrind)
   if(VALGRIND)
     set(VALGRIND_COMMAND "${VALGRIND}")
+    # --run-libc-freeres=no: at exit, memcheck runs glibc's __libc_freeres on the last thread after
+    # exit_group has killed the others. Its stdio cleanup takes every FILE lock, so a thread killed
+    # while writing a log line to stderr leaves that lock held and the process waits on it forever.
+    # A fork child that leaves through _Exit() while the SDK's threads still log is such a process.
     set(VALGRIND_COMMAND_OPTIONS
-        "-v --tool=memcheck --leak-check=full --track-fds=yes --num-callers=50 --show-reachable=yes --track-origins=yes --malloc-fill=0xff --free-fill=0xfe --suppressions=${PROJECT_SOURCE_DIR}/.valgrind_suppressions.txt"
+        "-v --tool=memcheck --leak-check=full --track-fds=yes --num-callers=50 --show-reachable=yes --track-origins=yes --malloc-fill=0xff --free-fill=0xfe --run-libc-freeres=no --suppressions=${PROJECT_SOURCE_DIR}/.valgrind_suppressions.txt"
     )
     set(MEMORYCHECK_COMMAND "${VALGRIND}")
     set(MEMORYCHECK_COMMAND_OPTIONS "${VALGRIND_COMMAND_OPTIONS}")
@@ -43,8 +47,7 @@ macro(integration_test name)
                                                               ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
   target_include_directories(
     test_integration_${name} SYSTEM BEFORE
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cxx_function>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
+    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:asio,INTERFACE_INCLUDE_DIRECTORIES>>)
   propagate_public_compile_definitions(test_integration_${name} spdlog::spdlog asio)
@@ -63,9 +66,15 @@ macro(integration_test name)
     # *.PDB from the BoringSSL build
     set_target_properties(test_integration_${name} PROPERTIES LINK_FLAGS "/ignore:4099")
   endif()
+  set(_catch_extra_args "")
+  if(DEFINED COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS AND EXISTS "${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+    set(_catch_extra_args ENVIRONMENT
+                          "TSAN_OPTIONS=halt_on_error=0,second_deadlock_stack=1,ignore_noninstrumented_modules=1,suppressions=${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+  endif()
   catch_discover_tests(
     test_integration_${name}
     PROPERTIES
+    ${_catch_extra_args}
     SKIP_REGULAR_EXPRESSION
     "SKIP"
     LABELS
@@ -86,8 +95,7 @@ macro(transaction_test name)
                                                               ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
   target_include_directories(
     test_transaction_${name} SYSTEM BEFORE
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cxx_function>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
+    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:asio,INTERFACE_INCLUDE_DIRECTORIES>>)
   propagate_public_compile_definitions(test_transaction_${name} spdlog::spdlog asio)
@@ -106,9 +114,15 @@ macro(transaction_test name)
     # *.PDB from the BoringSSL build
     set_target_properties(test_transaction_${name} PROPERTIES LINK_FLAGS "/ignore:4099")
   endif()
+  set(_catch_extra_args "")
+  if(DEFINED COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS AND EXISTS "${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+    set(_catch_extra_args ENVIRONMENT
+                          "TSAN_OPTIONS=halt_on_error=0,second_deadlock_stack=1,ignore_noninstrumented_modules=1,suppressions=${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+  endif()
   catch_discover_tests(
     test_transaction_${name}
     PROPERTIES
+    ${_catch_extra_args}
     SKIP_REGULAR_EXPRESSION
     "SKIP"
     LABELS
@@ -128,8 +142,7 @@ macro(unit_test name)
                                                        ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
   target_include_directories(
     test_unit_${name} SYSTEM BEFORE
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cxx_function>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
+    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:asio,INTERFACE_INCLUDE_DIRECTORIES>>)
   propagate_public_compile_definitions(test_unit_${name} spdlog::spdlog asio)
@@ -148,9 +161,15 @@ macro(unit_test name)
     # *.PDB from the BoringSSL build
     set_target_properties(test_unit_${name} PROPERTIES LINK_FLAGS "/ignore:4099")
   endif()
+  set(_catch_extra_args "")
+  if(DEFINED COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS AND EXISTS "${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+    set(_catch_extra_args ENVIRONMENT
+                          "TSAN_OPTIONS=halt_on_error=0,second_deadlock_stack=1,ignore_noninstrumented_modules=1,suppressions=${COUCHBASE_CXX_CLIENT_TSAN_SUPPRESSIONS}")
+  endif()
   catch_discover_tests(
     test_unit_${name}
     PROPERTIES
+    ${_catch_extra_args}
     SKIP_REGULAR_EXPRESSION
     "SKIP"
     LABELS
@@ -171,8 +190,7 @@ macro(integration_benchmark name)
                                           ${PROJECT_BINARY_DIR}/generated_$<CONFIG>)
   target_include_directories(
     benchmark_integration_${name} SYSTEM BEFORE
-    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cxx_function>
-            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
+    PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>
             $<BUILD_INTERFACE:$<TARGET_PROPERTY:asio,INTERFACE_INCLUDE_DIRECTORIES>>)
   propagate_public_compile_definitions(benchmark_integration_${name} spdlog::spdlog asio)

data/ext/couchbase/cmake/ThirdPartyDependencies.cmake

@@ -16,6 +16,11 @@ function(declare_system_library target)
                                              $<TARGET_PROPERTY:${target},INTERFACE_INCLUDE_DIRECTORIES>)
 endfunction()
 
+# Vendored dependencies that declare install rules no option can switch off send them here instead,
+# and the packaging install step deletes this one directory. Defined before any of them is added so
+# gRPC and curl share it.
+set(COUCHBASE_CXX_CLIENT_VENDORED_INSTALL_JUNK_DIR "vendored-not-installed")
+
 include(cmake/OpenSSL.cmake)
 
 if(NOT TARGET spdlog::spdlog)
@@ -39,12 +44,125 @@ if(NOT TARGET spdlog::spdlog)
     "SPDLOG_FMT_EXTERNAL OFF")
 endif()
 
+if((COUCHBASE_CXX_CLIENT_BUILD_TOOLS AND COUCHBASE_CXX_CLIENT_BUILD_FIT_PERFORMER)
+   OR COUCHBASE_CXX_CLIENT_BUILD_COUCHBASE2)
+  # gRPC/Protobuf are pulled in only for gRPC-based components (the FIT performer and the
+  # couchbase2:// transport). This MUST come before OpenTelemetry so OTel reuses these targets.
+  include(cmake/GrpcProtobuf.cmake)
+endif()
+
 if(COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY)
+  # OpenTelemetry's OTLP/HTTP exporter needs libcurl, and its cmake/curl.cmake takes the platform's
+  # copy when find_package(CURL) succeeds. That copy is linked against the platform's OpenSSL, so it
+  # puts a second TLS implementation into every process loading the SDK next to the BoringSSL linked
+  # here -- visible as libssl/libcrypto among cbc's dependencies.
+  #
+  # Declaring curl first is what avoids it. OpenTelemetry declares curl under the name "curl" and
+  # then calls FetchContent_MakeAvailable(curl), which does nothing when the name is already
+  # populated, and its own alias step is skipped because CURL::libcurl already exists. Its fetch
+  # branch is also the wrong shape for packaging: it forces BUILD_SHARED_LIBS ON, producing a
+  # libcurl.so this project would have to ship.
+  #
+  # CMAKE_DISABLE_FIND_PACKAGE_CURL stops it preferring a system libcurl over this one; both of its
+  # call sites are QUIET and not REQUIRED, so disabling the search is safe.
+  if(COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL AND NOT TARGET CURL::libcurl)
+    set(CMAKE_DISABLE_FIND_PACKAGE_CURL ON)
+
+    # Keep the tag in step with the one OpenTelemetry pins in its third_party_release, so the
+    # version it expects is the version it gets.
+    cpmaddpackage(
+      NAME
+      curl
+      GITHUB_REPOSITORY
+      "curl/curl"
+      GIT_TAG
+      curl-8_12_0
+      OPTIONS
+      # curl asks find_package(OpenSSL REQUIRED) and then links OpenSSL::SSL and OpenSSL::Crypto by
+      # target. Those targets are already BoringSSL aliases, so the only thing missing is a
+      # find_package that succeeds without an OpenSSL installation: see
+      # cmake/vendored_openssl/FindOpenSSL.cmake. curl appends its own CMake directory to
+      # CMAKE_MODULE_PATH, so replacing it here costs nothing.
+      "CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/vendored_openssl"
+      "COUCHBASE_CXX_CLIENT_BORINGSSL_INCLUDE_DIR ${boringssl_SOURCE_DIR}/src/include"
+      "CURL_USE_OPENSSL ON"
+      # curl identifies the TLS library, and probes for a few functions, with check_symbol_exists.
+      # Those compile a TryCompile project which does NOT inherit ALIAS targets, so the probes
+      # cannot resolve OpenSSL::SSL -> BoringSSL and fail outright ("Target links to OpenSSL::SSL
+      # but the target was not found"). Every one of them is guarded by if(NOT DEFINED ...), so
+      # answering in advance skips them. The answers describe BoringSSL: it is not AWS-LC or
+      # LibreSSL, and it does provide SSL_set0_wbio. SRP is not probed at all because
+      # CURL_DISABLE_SRP is on below.
+      "HAVE_BORINGSSL 1"
+      "HAVE_AWSLC 0"
+      "HAVE_LIBRESSL 0"
+      "HAVE_SSL_SET0_WBIO 1"
+      # TLS-SRP probes against <openssl/ssl.h> and would find the platform OpenSSL's declarations
+      # while compiling against BoringSSL headers, which omit SRP: curl then fails on implicit
+      # declarations of SSL_CTX_set_srp_username. Nothing here uses TLS-SRP.
+      "CURL_DISABLE_SRP ON"
+      # curl's install(TARGETS libcurl_static EXPORT ...) fails because the BoringSSL targets it
+      # links belong to no export set, and nothing here consumes curl's export files.
+      "CURL_ENABLE_EXPORT_TARGET OFF"
+      # CURL_ENABLE_EXPORT_TARGET only suppresses the CMake export file: curl still installs its
+      # archive, its headers, curl-config and libcurl.pc. Send them where gRPC's go, so the single
+      # cleanup in the packaging install step covers both.
+      "CMAKE_INSTALL_BINDIR ${COUCHBASE_CXX_CLIENT_VENDORED_INSTALL_JUNK_DIR}/bin"
+      "CMAKE_INSTALL_LIBDIR ${COUCHBASE_CXX_CLIENT_VENDORED_INSTALL_JUNK_DIR}/lib"
+      "CMAKE_INSTALL_INCLUDEDIR ${COUCHBASE_CXX_CLIENT_VENDORED_INSTALL_JUNK_DIR}/include"
+      "CMAKE_INSTALL_DATADIR ${COUCHBASE_CXX_CLIENT_VENDORED_INSTALL_JUNK_DIR}/share"
+      "CMAKE_INSTALL_DATAROOTDIR ${COUCHBASE_CXX_CLIENT_VENDORED_INSTALL_JUNK_DIR}/share"
+      "BUILD_SHARED_LIBS OFF"
+      "BUILD_STATIC_LIBS ON"
+      "BUILD_CURL_EXE OFF"
+      "BUILD_LIBCURL_DOCS OFF"
+      "BUILD_MISC_DOCS OFF"
+      "ENABLE_CURL_MANUAL OFF"
+      "BUILD_TESTING OFF"
+      # Everything below is a dependency the exporter does not need and that would otherwise become
+      # a build requirement or another shared library in the package.
+      "CURL_USE_LIBPSL OFF"
+      "CURL_USE_LIBSSH2 OFF"
+      "CURL_USE_LIBSSH OFF"
+      "CURL_USE_GSSAPI OFF"
+      "USE_LIBIDN2 OFF"
+      "CURL_BROTLI OFF"
+      "CURL_ZSTD OFF"
+      "USE_NGHTTP2 OFF"
+      "CURL_DISABLE_LDAP ON"
+      "CURL_DISABLE_LDAPS ON"
+      "CMAKE_C_VISIBILITY_PRESET hidden"
+      "CMAKE_POSITION_INDEPENDENT_CODE ON")
+
+    if(TARGET libcurl_static AND NOT TARGET CURL::libcurl)
+      add_library(CURL::libcurl ALIAS libcurl_static)
+    endif()
+    if(NOT TARGET CURL::libcurl)
+      message(FATAL_ERROR "Vendored curl did not provide CURL::libcurl")
+    endif()
+    declare_system_library(CURL::libcurl)
+  endif()
+
+  # The FIT driver gives the C++ performer an OTLP/gRPC collector endpoint, so the performer needs
+  # the gRPC exporters. OpenTelemetry finds the gRPC that GrpcProtobuf.cmake resolved: the cached
+  # gRPC_DIR for a platform package, CPM's grpc-config.cmake redirect for a source build.
+  set(_couchbase_otel_protobuf_option)
+  if(COUCHBASE_CXX_CLIENT_BUILD_TOOLS AND COUCHBASE_CXX_CLIENT_BUILD_FIT_PERFORMER)
+    set(_couchbase_otel_with_otlp_grpc ON)
+    if(COUCHBASE_CXX_CLIENT_BUNDLED_PROTOBUF_DIR)
+      set(_couchbase_otel_protobuf_option "Protobuf_DIR ${COUCHBASE_CXX_CLIENT_BUNDLED_PROTOBUF_DIR}")
+    endif()
+  else()
+    set(_couchbase_otel_with_otlp_grpc OFF)
+  endif()
+
   if(NOT TARGET opentelemetry)
-    # Disable curl HTTP client to avoid curl downloading and linking to BoringSSL
-    # OpenTelemetry will fall back to using its own HTTP client implementation
-    # This avoids CMake export errors when curl tries to reference ssl/crypto targets
-    
+    # These curl settings apply to the configuration that does NOT vendor curl above, where
+    # OpenTelemetry resolves the platform's libcurl: they are no-ops against a system package, and
+    # they keep the from-source path working for a build that does not use BoringSSL.
+    set(CURL_ENABLE_EXPORT_TARGET OFF CACHE BOOL "" FORCE)
+    set(CURL_DISABLE_SRP ON CACHE BOOL "" FORCE)
+
     # https://github.com/open-telemetry/opentelemetry-cpp/releases
     cpmaddpackage(
       NAME
@@ -62,9 +180,9 @@ if(COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY)
       "WITH_BENCHMARK OFF"
       "WITH_EXAMPLES OFF"
       "WITH_FUNC_TESTS OFF"
-      "WITH_OTLP_GRPC OFF"
+      "WITH_OTLP_GRPC ${_couchbase_otel_with_otlp_grpc}"
+      ${_couchbase_otel_protobuf_option}
       "WITH_OTLP_HTTP ON"
-      "WITH_HTTP_CLIENT_CURL OFF"
       "WITH_PROMETHEUS OFF"
       "WITH_OPENTRACING OFF"
       "WITH_STL CXX17"
@@ -77,6 +195,10 @@ if(COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY)
 
   declare_system_library(opentelemetry_exporter_otlp_http)
   declare_system_library(opentelemetry_exporter_otlp_http_metric)
+  if(_couchbase_otel_with_otlp_grpc)
+    declare_system_library(opentelemetry_exporter_otlp_grpc)
+    declare_system_library(opentelemetry_exporter_otlp_grpc_metrics)
+  endif()
 endif()
 
 if(NOT TARGET Microsoft.GSL::GSL)
@@ -287,8 +409,19 @@ if(asio_ADDED)
 
     message(STATUS "Set _WIN32_WINNT=${_WIN32_WINNT}")
 
-    target_compile_definitions(asio INTERFACE _WIN32_WINNT=${_WIN32_WINNT} WIN32_LEAN_AND_MEAN)
-    target_compile_options(asio INTERFACE /bigobj)
+    # PUBLIC: asio.cpp and the code including asio's headers must see the same values. asio otherwise
+    # derives ASIO_HAS_THREADS per translation unit from predefined macros and earlier includes, and two
+    # translation units that disagree compile the same asio classes against different mutex and thread types.
+    target_compile_definitions(asio PUBLIC _WIN32_WINNT=${_WIN32_WINNT} WIN32_LEAN_AND_MEAN ASIO_HAS_THREADS=1)
+    if(MSVC)
+      target_compile_options(asio INTERFACE /bigobj)
+    else()
+      # MSVC gets these through asio's #pragma comment(lib); MinGW needs them on the link line.
+      target_link_libraries(asio PUBLIC ws2_32 mswsock bcrypt)
+      if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(asio INTERFACE -Wa,-mbig-obj)
+      endif()
+    endif()
   endif()
 
   add_library(asio::asio ALIAS asio)