couchbase 3.7.0 → 3.8.0

data/ext/couchbase/cmake/Packaging.cmake

@@ -84,6 +84,12 @@ add_custom_command(
 set(COUCHBASE_CXX_TARBALL_THIRD_PARTY_GLOB_FILE ${PROJECT_SOURCE_DIR}/cmake/tarball_glob.txt)
 
 if(COUCHBASE_CXX_RECORD_BUILD_INFO_FOR_TARBALL)
+  if(CPM_USE_NAMED_CACHE_DIRECTORIES)
+    get_filename_component(opentelemetry_SOURCE_DIR_PARENT "${opentelemetry_SOURCE_DIR}" DIRECTORY)
+    get_filename_component(opentelemetry_CPM_HASH "${opentelemetry_SOURCE_DIR_PARENT}" NAME)
+  else()
+    get_filename_component(opentelemetry_CPM_HASH "${opentelemetry_SOURCE_DIR}" NAME)
+  endif()
   file(
     WRITE "${CMAKE_SOURCE_DIR}/cmake/TarballRelease.cmake"
     "
@@ -91,6 +97,7 @@ set(CPM_DOWNLOAD_ALL OFF CACHE BOOL \"\" FORCE)
 set(CPM_USE_NAMED_CACHE_DIRECTORIES ON CACHE BOOL \"\" FORCE)
 set(CPM_USE_LOCAL_PACKAGES OFF CACHE BOOL \"\" FORCE)
 set(CPM_SOURCE_CACHE \"\${PROJECT_SOURCE_DIR}/third_party_cache\" CACHE STRING \"\" FORCE)
+set(OTELCPP_PROTO_PATH \"\${PROJECT_SOURCE_DIR}/third_party_cache/opentelemetry/${opentelemetry_CPM_HASH}/opentelemetry/third_party/opentelemetry-proto\" CACHE STRING \"\" FORCE)
 set(COUCHBASE_CXX_CLIENT_GIT_REVISION \"${COUCHBASE_CXX_CLIENT_GIT_REVISION}\")
 set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE \"${COUCHBASE_CXX_CLIENT_GIT_DESCRIBE}\")
 set(COUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP \"${COUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP}\")
@@ -112,16 +119,36 @@ add_custom_command(
     -DCPM_SOURCE_CACHE="${PROJECT_BINARY_DIR}/packaging/${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/cache"
     -DCOUCHBASE_CXX_CLIENT_EMBED_MOZILLA_CA_BUNDLE_ROOT="${PROJECT_BINARY_DIR}/packaging/${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/cache"
     -DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=OFF -DCOUCHBASE_CXX_CLIENT_BUILD_TOOLS=ON -DCOUCHBASE_CXX_CLIENT_BUILD_DOCS=OFF
+    -DCOUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY=ON
     -DCOUCHBASE_CXX_CLIENT_STATIC_BORINGSSL=ON -DCPM_DOWNLOAD_ALL=ON -DCPM_USE_NAMED_CACHE_DIRECTORIES=ON
     -DCPM_USE_LOCAL_PACKAGES=OFF -DCOUCHBASE_CXX_CLIENT_BUILD_STATIC=ON -DCOUCHBASE_CXX_CLIENT_BUILD_SHARED=ON
     -DCOUCHBASE_CXX_CLIENT_INSTALL=ON -DCOUCHBASE_CXX_RECORD_BUILD_INFO_FOR_TARBALL=ON
   COMMAND
-    ${XARGS} --arg-file=${COUCHBASE_CXX_TARBALL_THIRD_PARTY_GLOB_FILE} -I {} find
+    ${XARGS} -a ${COUCHBASE_CXX_TARBALL_THIRD_PARTY_GLOB_FILE} -I {} find
     "${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/cache" -wholename "${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/cache/{}"
-    -type f | grep -v "crypto_test_data\\|googletest" | uniq >
+    -type f
+    | grep -v
+        -e "/benchmark"
+        -e "/opentelemetry.*/functional"
+        -e "/opentelemetry.*/install"
+        -e "/opentelemetry.*/test"
+        -e "/opentelemetry/examples"
+        -e "/opentelemetry/docker"
+        -e "/opentelemetry/exporters/elasticsearch"
+        -e "/opentelemetry/exporters/etw"
+        -e "/opentelemetry/exporters/prometheus"
+        -e "/opentelemetry/exporters/zipkin"
+        -e "/opentelemetry/opentracing-.*"
+        -e "/opentelemetry/third_party/ms-gsl"
+        -e "/opentelemetry/third_party/nlohmann-json"
+        -e "/opentelemetry/third_party/prometheus-cpp"
+        -e "/opentelemetry/tools"
+        -e "crypto_test_data"
+        -e "googletest"
+    | uniq >
     "${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/third_party_manifest.txt"
   COMMAND ${CMAKE_COMMAND} -E make_directory "${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/filtered_cache"
-  COMMAND ${XARGS} --arg-file="${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/third_party_manifest.txt" -I {} ${CP} --parents
+  COMMAND ${XARGS} -a "${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/third_party_manifest.txt" -I {} ${CP} --parents
           {} "${COUCHBASE_CXX_CLIENT_TARBALL_NAME}/tmp/filtered_cache"
   COMMAND
     ${CMAKE_COMMAND} -E rename
@@ -263,7 +290,7 @@ if(COUCHBASE_CXX_CLIENT_RPM_TARGETS)
   set(COUCHBASE_CXX_CLIENT_SPEC "${PROJECT_BINARY_DIR}/packaging/couchbase-cxx-client.spec")
   configure_file(${PROJECT_SOURCE_DIR}/cmake/couchbase-cxx-client.spec.in "${COUCHBASE_CXX_CLIENT_SPEC}" @ONLY)
 
-  set(COUCHBASE_CXX_CLIENT_DEFAULT_ROOT "rocky-9-${CMAKE_SYSTEM_PROCESSOR}")
+  set(COUCHBASE_CXX_CLIENT_DEFAULT_ROOT "rocky+epel-9-${CMAKE_SYSTEM_PROCESSOR}")
   set(COUCHBASE_CXX_CLIENT_RPM_NAME
       "couchbase-cxx-client-${COUCHBASE_CXX_CLIENT_PACKAGE_VERSION}-${COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE}")
   set(COUCHBASE_CXX_CLIENT_SRPM "${PROJECT_BINARY_DIR}/packaging/srpm/${COUCHBASE_CXX_CLIENT_RPM_NAME}.el9.src.rpm")
@@ -282,9 +309,9 @@ if(COUCHBASE_CXX_CLIENT_RPM_TARGETS)
     APPEND
     COUCHBASE_CXX_CLIENT_SUPPORTED_ROOTS
     "opensuse-leap-15.6-${CMAKE_SYSTEM_PROCESSOR}"
-    "rocky-10-${CMAKE_SYSTEM_PROCESSOR}"
-    "rocky-9-${CMAKE_SYSTEM_PROCESSOR}"
-    "rocky-8-${CMAKE_SYSTEM_PROCESSOR}"
+    "rocky+epel-10-${CMAKE_SYSTEM_PROCESSOR}"
+    "rocky+epel-9-${CMAKE_SYSTEM_PROCESSOR}"
+    "rocky+epel-8-${CMAKE_SYSTEM_PROCESSOR}"
     "amazonlinux-2023-${CMAKE_SYSTEM_PROCESSOR}"
     "fedora-43-${CMAKE_SYSTEM_PROCESSOR}"
     "fedora-42-${CMAKE_SYSTEM_PROCESSOR}"
@@ -327,8 +354,21 @@ if(COUCHBASE_CXX_CLIENT_APK_TARGETS)
   set(COUCHBASE_CXX_CLIENT_TARBALL_ALPINE
       "${PROJECT_BINARY_DIR}/packaging/${COUCHBASE_CXX_CLIENT_TARBALL_NAME_ALPINE}.tar.gz")
   if(${COUCHBASE_CXX_CLIENT_NUMBER_OF_COMMITS} GREATER 0)
+    # Encode commit count and git hash into _p version for uniqueness
+    # Extract first 3 bytes from git hash (7-char short hash), convert to decimal
+    # Map each byte mod 100 to create 6-digit suffix
+    # Formula: p = commits × 10_000_000 + (byte1%100)*10000 + (byte2%100)*100 + (byte3%100)
+    # Example: 1.2.0-75-gfeb729b2 → 1.2.0_p750548341
+    string(SUBSTRING "${COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT}" 0 2 _b1_hex)
+    string(SUBSTRING "${COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT}" 2 2 _b2_hex)
+    string(SUBSTRING "${COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT}" 4 2 _b3_hex)
+    math(EXPR _b1 "0x${_b1_hex}")
+    math(EXPR _b2 "0x${_b2_hex}")
+    math(EXPR _b3 "0x${_b3_hex}")
+    math(EXPR _sha_pack "(${_b1} % 100) * 10000 + (${_b2} % 100) * 100 + (${_b3} % 100)")
+    math(EXPR _p_version "${COUCHBASE_CXX_CLIENT_NUMBER_OF_COMMITS} * 10000000 + ${_sha_pack}")
     set(COUCHBASE_CXX_CLIENT_TARBALL_NAME_ALPINE
-        "couchbase-cxx-client-${COUCHBASE_CXX_CLIENT_PACKAGE_VERSION}_p${COUCHBASE_CXX_CLIENT_NUMBER_OF_COMMITS}")
+        "couchbase-cxx-client-${COUCHBASE_CXX_CLIENT_PACKAGE_VERSION}_p${_p_version}")
     set(COUCHBASE_CXX_CLIENT_TARBALL_ALPINE
         "${PROJECT_BINARY_DIR}/packaging/${COUCHBASE_CXX_CLIENT_TARBALL_NAME_ALPINE}.tar.gz")
   endif()

data/ext/couchbase/cmake/ThirdPartyDependencies.cmake

@@ -39,6 +39,46 @@ if(NOT TARGET spdlog::spdlog)
     "SPDLOG_FMT_EXTERNAL OFF")
 endif()
 
+if(COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY)
+  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
+    
+    # https://github.com/open-telemetry/opentelemetry-cpp/releases
+    cpmaddpackage(
+      NAME
+      opentelemetry
+      VERSION
+      1.23.0
+      GITHUB_REPOSITORY
+      "open-telemetry/opentelemetry-cpp"
+      EXCLUDE_FROM_ALL ON
+      OPTIONS
+      "protobuf_MSVC_STATIC_RUNTIME OFF"
+      "OPENTELEMETRY_INSTALL OFF"
+      "WITH_ABI_VERSION_1 OFF"
+      "WITH_ABI_VERSION_2 ON"
+      "WITH_BENCHMARK OFF"
+      "WITH_EXAMPLES OFF"
+      "WITH_FUNC_TESTS OFF"
+      "WITH_OTLP_GRPC OFF"
+      "WITH_OTLP_HTTP ON"
+      "WITH_HTTP_CLIENT_CURL OFF"
+      "WITH_PROMETHEUS OFF"
+      "WITH_OPENTRACING OFF"
+      "WITH_STL CXX17"
+      "BUILD_TESTING OFF"
+      "BUILD_SHARED_LIBS OFF"
+      "CMAKE_C_VISIBILITY_PRESET hidden"
+      "CMAKE_CXX_VISIBILITY_PRESET hidden"
+      "CMAKE_POSITION_INDEPENDENT_CODE ON")
+  endif()
+
+  declare_system_library(opentelemetry_exporter_otlp_http)
+  declare_system_library(opentelemetry_exporter_otlp_http_metric)
+endif()
+
 if(NOT TARGET Microsoft.GSL::GSL)
   # https://github.com/microsoft/GSL/releases
   cpmaddpackage(
@@ -185,8 +225,9 @@ if(asio_ADDED)
   target_link_libraries(asio PRIVATE Threads::Threads)
   if(COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL)
     target_link_libraries(asio PUBLIC $<TARGET_OBJECTS:ssl> $<TARGET_OBJECTS:crypto>)
+    # Add BoringSSL include directories before asio's own include directories.
     target_include_directories(
-      asio SYSTEM PRIVATE $<BUILD_INTERFACE:$<TARGET_PROPERTY:ssl,INTERFACE_INCLUDE_DIRECTORIES>>
+      asio BEFORE PRIVATE $<BUILD_INTERFACE:$<TARGET_PROPERTY:ssl,INTERFACE_INCLUDE_DIRECTORIES>>
                           $<BUILD_INTERFACE:$<TARGET_PROPERTY:crypto,INTERFACE_INCLUDE_DIRECTORIES>>)
   elseif(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
     target_link_libraries(asio PRIVATE OpenSSL::SSL OpenSSL::Crypto)
@@ -264,3 +305,4 @@ declare_system_library(Microsoft.GSL::GSL)
 declare_system_library(spdlog::spdlog)
 declare_system_library(asio)
 declare_system_library(taocpp::json)
+declare_system_library(snappy)

data/ext/couchbase/cmake/build_config.hxx.in

@@ -24,3 +24,5 @@
 #cmakedefine COUCHBASE_CXX_CLIENT_BORINGSSL_SHA "@COUCHBASE_CXX_CLIENT_BORINGSSL_SHA@"
 #cmakedefine COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL
 #cmakedefine COUCHBASE_CXX_CLIENT_COLUMNAR
+#cmakedefine COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
+#cmakedefine COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY

data/ext/couchbase/cmake/couchbase-cxx-client.spec.in

@@ -12,6 +12,19 @@ BuildRequires: gcc13, gcc13-c++
 BuildRequires: gcc, gcc-c++
 %endif
 BuildRequires: cmake >= 3.19
+%if 0%{?suse_version} > 0
+BuildRequires: libcurl-devel
+BuildRequires: protobuf-devel
+BuildRequires: nlohmann_json-devel
+%else
+%if 0%{?amzn} == 0 && (0%{?rhel} >= 9 || 0%{?fedora} > 0)
+BuildRequires: curl-devel
+BuildRequires: protobuf-devel
+BuildRequires: json-devel
+%else
+# CentOS 8 / Rocky 8 - skip these packages (no OpenTelemetry)
+%endif
+%endif
 Source0: @COUCHBASE_CXX_CLIENT_TARBALL_NAME@.tar.gz
 
 %if 0%{?amzn}
@@ -50,6 +63,11 @@ Development files for the Couchbase C++ SDK.
     -DCOUCHBASE_CXX_CLIENT_STATIC_BORINGSSL=ON \
     -DCOUCHBASE_CXX_CLIENT_BUILD_EXAMPLES=OFF \
     -DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=OFF \
+%if 0%{?amzn} == 0 && (0%{?rhel} >= 9 || 0%{?fedora} > 0 || 0%{?suse_version} > 0)
+    -DCOUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY=ON \
+%else
+    -DCOUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY=OFF \
+%endif
     -DCOUCHBASE_CXX_CLIENT_BUILD_TOOLS=ON \
     -DCOUCHBASE_CXX_CLIENT_BUILD_STATIC=ON \
     -DCOUCHBASE_CXX_CLIENT_BUILD_SHARED=ON

data/ext/couchbase/cmake/tarball_glob.txt

@@ -90,3 +90,13 @@ spdlog/*/spdlog/include/*
 spdlog/*/spdlog/include/**/*
 spdlog/*/spdlog/src/*
 spdlog/*/spdlog/src/**/*
+opentelemetry/*/opentelemetry/CMakeLists.txt
+opentelemetry/*/opentelemetry/CMakeSettings.json
+opentelemetry/*/opentelemetry/LICENSE
+opentelemetry/*/opentelemetry/*/CMakeLists.txt
+opentelemetry/*/opentelemetry/cmake/*
+opentelemetry/*/opentelemetry/**/CMakeLists.txt
+opentelemetry/*/opentelemetry/**/LICENSE
+opentelemetry/*/opentelemetry/**/*.h
+opentelemetry/*/opentelemetry/**/*.cc
+opentelemetry/*/opentelemetry/third_party/opentelemetry-proto/opentelemetry/proto/**/*.proto

data/ext/couchbase/core/app_telemetry_meter.cxx

@@ -18,6 +18,7 @@
 #include "logger/logger.hxx"
 #include "meta/version.hxx"
 #include "topology/configuration.hxx"
+#include "utils/binary.hxx"
 #include "utils/json.hxx"
 
 #include <spdlog/fmt/bin_to_hex.h>

data/ext/couchbase/core/app_telemetry_reporter.cxx

@@ -83,7 +83,7 @@ public:
   static auto dial(app_telemetry_address address,
                    cluster_options options,
                    asio::io_context& ctx,
-                   asio::ssl::context& tls,
+                   tls_context_provider& tls,
                    std::shared_ptr<connection_state_listener>&& handler)
     -> std::shared_ptr<telemetry_dialer>
   {
@@ -96,7 +96,7 @@ public:
   telemetry_dialer(app_telemetry_address address,
                    cluster_options options,
                    asio::io_context& ctx,
-                   asio::ssl::context& tls,
+                   tls_context_provider& tls,
                    std::shared_ptr<connection_state_listener>&& handler)
     : address_{ std::move(address) }
     , options_{ std::move(options) }
@@ -223,7 +223,7 @@ private:
   app_telemetry_address address_;
   cluster_options options_;
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
   asio::steady_timer resolve_deadline_;
   asio::steady_timer connect_deadline_;
   asio::ip::tcp::resolver resolver_;
@@ -426,9 +426,17 @@ public:
 private:
   auto build_handshake_message() -> std::vector<std::byte>
   {
-    auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
+    std::string auth{};
+    if (credentials_.uses_jwt()) {
+      auth = fmt::format("Bearer {}", credentials_.jwt_token);
+    } else {
+      auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
+      auth = fmt::format(
+        "Basic {}",
+        base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
+    }
     auto message = fmt::format("GET {} HTTP/1.1\r\n"
-                               "Authorization: Basic {}\r\n"
+                               "Authorization: {}\r\n"
                                "Upgrade: websocket\r\n"
                                "Connection: Upgrade\r\n"
                                "Host: {}:{}\r\n"
@@ -436,10 +444,7 @@ private:
                                "Sec-WebSocket-Key: {}\r\n"
                                "\r\n",
                                address_.path,
-                               base64::encode(gsl::as_bytes(gsl::span{
-                                 credentials.data(),
-                                 credentials.size(),
-                               })),
+                               auth,
                                address_.hostname,
                                address_.service,
                                codec_.session_key());
@@ -671,30 +676,29 @@ class app_telemetry_reporter_impl
 {
 public:
   app_telemetry_reporter_impl(std::shared_ptr<app_telemetry_meter> meter,
-                              cluster_options options,
-                              cluster_credentials credentials,
+                              origin& origin,
                               asio::io_context& ctx,
-                              asio::ssl::context& tls)
+                              tls_context_provider& tls)
     : meter_{ std::move(meter) }
-    , options_{ std::move(options) }
-    , credentials_{ std::move(credentials) }
+    , origin_{ origin }
     , ctx_{ ctx }
     , tls_{ tls }
     , backoff_{ ctx }
     , exponential_backoff_calculator_{
       std::chrono::milliseconds{ 100 },
-      options_.app_telemetry_backoff_interval,
+      origin_.options().app_telemetry_backoff_interval,
       2 /* backoff factor */,
       0.5 /* jitter factor */,
     }
   {
-    if (options_.enable_app_telemetry) {
-      if (!options_.app_telemetry_endpoint.empty()) {
-        auto url = couchbase::core::utils::string_codec::url_parse(options_.app_telemetry_endpoint);
+    if (origin_.options().enable_app_telemetry) {
+      if (!origin_.options().app_telemetry_endpoint.empty()) {
+        auto url =
+          couchbase::core::utils::string_codec::url_parse(origin_.options().app_telemetry_endpoint);
         if (url.host.empty() || url.scheme != "ws") {
           CB_LOG_WARNING(
             "unable to use \"{}\" as a app telemetry endpoint (expected ws:// and hostname)",
-            options_.app_telemetry_endpoint);
+            origin_.options().app_telemetry_endpoint);
           return;
         }
         addresses_.push_back({
@@ -743,19 +747,19 @@ public:
     }
 
     websocket_state_ = connection_state::connected;
-    CB_LOG_WARNING("connected app telemetry endpoint.  {}",
-                   tao::json::to_string(tao::json::value{
-                     { "stream", stream->id() },
-                     { "hostname", address.hostname },
-                   }));
+    CB_LOG_DEBUG("connected app telemetry endpoint.  {}",
+                 tao::json::to_string(tao::json::value{
+                   { "stream", stream->id() },
+                   { "hostname", address.hostname },
+                 }));
     websocket_session_ = websocket_session::start(ctx_,
                                                   address,
-                                                  credentials_,
+                                                  origin_.credentials(),
                                                   std::move(stream),
                                                   meter_,
                                                   shared_from_this(),
-                                                  options_.app_telemetry_ping_interval,
-                                                  options_.app_telemetry_ping_timeout);
+                                                  origin_.options().app_telemetry_ping_interval,
+                                                  origin_.options().app_telemetry_ping_timeout);
     retry_backoff_calculator_ = &no_backoff_calculator_;
     ++next_address_index_;
   }
@@ -813,25 +817,27 @@ public:
           return;
         }
         if (self->websocket_state_ == connection_state::disconnected) {
-          self->dialer_ =
-            telemetry_dialer::dial(next_address, self->options_, self->ctx_, self->tls_, self);
+          self->dialer_ = telemetry_dialer::dial(
+            next_address, self->origin_.options(), self->ctx_, self->tls_, self);
         }
       });
       return;
     }
-    dialer_ = telemetry_dialer::dial(next_address, options_, ctx_, tls_, shared_from_this());
+    dialer_ =
+      telemetry_dialer::dial(next_address, origin_.options(), ctx_, tls_, shared_from_this());
   }
 
   void update_config(topology::configuration&& config)
   {
-    if (!options_.enable_app_telemetry) {
+    if (!origin_.options().enable_app_telemetry) {
       meter_->disable();
       return;
     }
     meter_->update_config(config);
 
-    if (options_.app_telemetry_endpoint.empty()) {
-      addresses_ = get_app_telemetry_addresses(config, options_.enable_tls, options_.network);
+    if (origin_.options().app_telemetry_endpoint.empty()) {
+      addresses_ = get_app_telemetry_addresses(
+        config, origin_.options().enable_tls, origin_.options().network);
       next_address_index_ = 0;
     }
 
@@ -841,17 +847,16 @@ public:
       meter_->enable();
       if (websocket_state_ == connection_state::disconnected) {
         dialer_ = telemetry_dialer::dial(
-          addresses_[next_address_index_], options_, ctx_, tls_, shared_from_this());
+          addresses_[next_address_index_], origin_.options(), ctx_, tls_, shared_from_this());
       }
     }
   }
 
 private:
   std::shared_ptr<app_telemetry_meter> meter_;
-  cluster_options options_;
-  cluster_credentials credentials_;
+  origin& origin_;
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
   asio::steady_timer backoff_;
   const exponential_backoff_with_jitter exponential_backoff_calculator_;
 
@@ -868,13 +873,10 @@ private:
 };
 
 app_telemetry_reporter::app_telemetry_reporter(std::shared_ptr<app_telemetry_meter> meter,
-                                               const cluster_options& options,
-                                               const cluster_credentials& credentials,
+                                               origin& origin,
                                                asio::io_context& ctx,
-                                               asio::ssl::context& tls)
-  : impl_{
-    std::make_shared<app_telemetry_reporter_impl>(std::move(meter), options, credentials, ctx, tls)
-  }
+                                               tls_context_provider& tls)
+  : impl_{ std::make_shared<app_telemetry_reporter_impl>(std::move(meter), origin, ctx, tls) }
 {
 }
 

data/ext/couchbase/core/app_telemetry_reporter.hxx

@@ -15,7 +15,9 @@
 
 #pragma once
 
+#include "cluster.hxx"
 #include "config_listener.hxx"
+#include "tls_context_provider.hxx"
 
 #include <memory>
 
@@ -45,10 +47,9 @@ public:
   auto operator=(const app_telemetry_reporter&) -> app_telemetry_reporter& = delete;
 
   app_telemetry_reporter(std::shared_ptr<app_telemetry_meter> meter,
-                         const cluster_options& options,
-                         const cluster_credentials& credentials,
+                         origin& origin,
                          asio::io_context& ctx,
-                         asio::ssl::context& tls);
+                         tls_context_provider& tls);
   ~app_telemetry_reporter() override;
   void update_config(topology::configuration config) override;
   void stop();