Define observability interface between core SDK and the wrapper

Author: avsej

CMakeLists.txt

@@ -393,6 +393,10 @@ set(couchbase_cxx_client_FILES
     core/scan_result.cxx
     core/search_query_options.cxx
     core/seed_config.cxx
+    core/signal_bridge.cxx
+    core/signal_data.cxx
+    core/metric_measurement.cxx
+    core/chrono_utils.cxx
     core/topology/capabilities.cxx
     core/topology/configuration.cxx
     core/tracing/threshold_logging_tracer.cxx

core/chrono_utils.cxx

@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Current 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 "chrono_utils.hxx"
+
+#include <array>
+#include <chrono>
+#include <stdexcept>
+
+namespace couchbase::core
+{
+auto
+to_iso8601_utc(std::time_t time_in_seconds, std::int64_t microseconds) -> std::string
+{
+  std::tm tm{};
+#if defined(_MSC_VER)
+  gmtime_s(&tm, &time_in_seconds);
+#else
+  gmtime_r(&time_in_seconds, &tm);
+#endif
+
+  std::array<char, 100> buffer{};
+  auto rc = std::snprintf(buffer.data(),
+                          buffer.size(),
+                          "%04d-%02d-%02dT%02d:%02d:%02d.%06lldZ",
+                          tm.tm_year + 1900,
+                          tm.tm_mon + 1,
+                          tm.tm_mday,
+                          tm.tm_hour,
+                          tm.tm_min,
+                          tm.tm_sec,
+                          static_cast<long long>(microseconds));
+  auto bytes_written = static_cast<std::size_t>(rc);
+  if (rc < 0 || bytes_written >= buffer.size()) {
+    throw std::range_error("unable to format date: not enough memory in the buffer");
+  }
+  return { buffer.data(), bytes_written };
+}
+
+auto
+to_iso8601_utc(const std::chrono::system_clock::time_point& time_point) -> std::string
+{
+  const auto duration{ time_point.time_since_epoch() };
+  const auto seconds{ std::chrono::duration_cast<std::chrono::seconds>(duration) };
+  const auto micros{ std::chrono::duration_cast<std::chrono::microseconds>(duration - seconds) };
+
+  return to_iso8601_utc(std::chrono::system_clock::to_time_t(time_point), micros.count());
+}
+} // namespace couchbase::core

core/chrono_utils.hxx

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Current 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 <chrono>
+#include <string>
+
+namespace couchbase::core
+{
+auto
+to_iso8601_utc(std::time_t time_in_seconds, std::int64_t microseconds = 0) -> std::string;
+
+auto
+to_iso8601_utc(const std::chrono::system_clock::time_point& time_point) -> std::string;
+} // namespace couchbase::core

core/log_entry.hxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Current 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 "signal_attribute.hxx"
+
+#include <string>
+#include <vector>
+
+namespace couchbase::core
+{
+struct log_entry {
+  std::string timestamp;
+  std::string severity;
+  std::string message;
+
+  struct {
+    std::string trace_id{};
+    std::string span_id{};
+  } context{};
+
+  std::vector<signal_attribute> attributes{};
+};
+
+inline auto
+operator==(const log_entry& lhs, const log_entry& rhs) -> bool
+{
+  return lhs.timestamp == rhs.timestamp &&               //
+         lhs.severity == rhs.severity &&                 //
+         lhs.message == rhs.message &&                   //
+         lhs.context.trace_id == rhs.context.trace_id && //
+         lhs.context.span_id == rhs.context.span_id &&   //
+         lhs.attributes == rhs.attributes;
+}
+
+inline auto
+operator!=(const log_entry& lhs, const log_entry& rhs) -> bool
+{
+  return !(lhs == rhs);
+}
+} // namespace couchbase::core

core/metric_measurement.cxx

@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Current 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 "metric_measurement.hxx"
+
+namespace couchbase::core
+{
+
+[[nodiscard]] auto
+metric_measurement::is_double() const noexcept -> bool
+{
+  return std::holds_alternative<double>(value_);
+}
+
+[[nodiscard]] auto
+metric_measurement::as_double() const -> double
+{
+  return std::get<double>(value_);
+}
+
+[[nodiscard]] auto
+metric_measurement::try_as_double() && -> std::optional<double>
+{
+  if (auto* ptr = std::get_if<double>(&value_)) {
+    return *ptr;
+  }
+  return std::nullopt;
+}
+
+[[nodiscard]] auto
+metric_measurement::is_int64() const noexcept -> bool
+{
+  return std::holds_alternative<std::int64_t>(value_);
+}
+
+[[nodiscard]] auto
+metric_measurement::as_int64() const -> std::int64_t
+{
+  return std::get<std::int64_t>(value_);
+}
+
+[[nodiscard]] auto
+metric_measurement::try_as_int64() && -> std::optional<std::int64_t>
+{
+  if (auto* ptr = std::get_if<std::int64_t>(&value_)) {
+    return *ptr;
+  }
+  return std::nullopt;
+}
+
+} // namespace couchbase::core

core/metric_measurement.hxx

@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Current 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 <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
+namespace couchbase::core
+{
+class metric_measurement
+{
+public:
+  template<typename Float, std::enable_if_t<std::is_floating_point_v<Float>, int> = 0>
+  metric_measurement(std::string name, Float value)
+    : name_{ std::move(name) }
+    , value_{ value }
+  {
+  }
+
+  template<
+    typename Integer,
+    std::enable_if_t<std::is_integral_v<Integer> && std::is_signed_v<Integer> &&
+                       !std::is_same_v<Integer, bool> && sizeof(Integer) <= sizeof(std::int64_t),
+                     int> = 0>
+  metric_measurement(std::string name, Integer value)
+    : name_{ std::move(name) }
+    , value_{ value }
+  {
+  }
+
+  metric_measurement(const metric_measurement&) = default;
+  metric_measurement(metric_measurement&&) = default;
+  ~metric_measurement() = default;
+  auto operator=(const metric_measurement&) -> metric_measurement& = default;
+  auto operator=(metric_measurement&&) -> metric_measurement& = default;
+
+  [[nodiscard]] auto is_double() const noexcept -> bool;
+  [[nodiscard]] auto as_double() const -> double;
+  [[nodiscard]] auto try_as_double() && -> std::optional<double>;
+  explicit operator double() const
+  {
+    return as_double();
+  }
+
+  [[nodiscard]] auto is_int64() const noexcept -> bool;
+  [[nodiscard]] auto as_int64() const -> std::int64_t;
+  [[nodiscard]] auto try_as_int64() && -> std::optional<std::int64_t>;
+  explicit operator std::int64_t() const
+  {
+    return as_int64();
+  }
+
+  friend auto operator==(const metric_measurement& lhs, const metric_measurement& rhs) -> bool;
+
+private:
+  std::string name_;
+  std::variant<double, std::int64_t> value_;
+};
+
+inline auto
+operator==(const metric_measurement& lhs, const metric_measurement& rhs) -> bool
+{
+  return lhs.name_ == rhs.name_ && //
+         lhs.value_ == rhs.value_;
+}
+
+inline auto
+operator!=(const metric_measurement& lhs, const metric_measurement& rhs) -> bool
+{
+  return !(lhs == rhs);
+}
+} // namespace couchbase::core

core/signal_attribute.hxx

@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025-Current 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 <string>
+
+namespace couchbase::core
+{
+struct signal_attribute {
+  std::string name;
+  std::string value;
+};
+
+inline auto
+operator==(const signal_attribute& lhs, const signal_attribute& rhs) -> bool
+{
+  return lhs.name == rhs.name && //
+         lhs.value == rhs.value;
+}
+
+inline auto
+operator!=(const signal_attribute& lhs, const signal_attribute& rhs) -> bool
+{
+  return !(lhs == rhs);
+}
+
+} // namespace couchbase::core