Add OpenTelemetry lib and metric-interfaces

CMakeLists.txt

@@ -59,6 +59,10 @@ add_subdirectory(include/ydb-cpp-sdk/client)
 add_subdirectory(src)
 add_subdirectory(util)
 
+if (YDB_SDK_HAS_OPEN_TELEMETRY)
+  add_subdirectory(open_telemetry EXCLUDE_FROM_ALL)
+endif()
+
 #_ydb_sdk_validate_public_headers()
 
 if (YDB_SDK_EXAMPLES)

cmake/external_libs.cmake

@@ -13,6 +13,10 @@ find_package(base64 REQUIRED)
 find_package(Brotli 1.1.0 REQUIRED)
 find_package(jwt-cpp REQUIRED)
 find_package(double-conversion REQUIRED)
+find_package(opentelemetry-cpp QUIET)
+if (opentelemetry-cpp_FOUND)
+  set(YDB_SDK_HAS_OPEN_TELEMETRY ON)
+endif()
 
 # RapidJSON
 if (YDB_SDK_USE_RAPID_JSON)

include/ydb-cpp-sdk/client/metrics/metrics.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <ydb-cpp-sdk/client/extension_common/extension.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace NYdb::inline V3::NMetrics {
+
+using TLabels = std::map<std::string, std::string>;
+
+class ICounter {
+public:
+    virtual ~ICounter() = default;
+    virtual void Inc() = 0;
+};
+
+class IGauge {
+public:
+    virtual ~IGauge() = default;
+    virtual void Add(double delta) = 0;
+    virtual void Set(double value) = 0;
+};
+
+class IHistogram {
+public:
+    virtual ~IHistogram() = default;
+    virtual void Record(double value) = 0;
+};
+
+class IMetricRegistry {
+public:
+    virtual ~IMetricRegistry() = default;
+
+    virtual std::shared_ptr<ICounter> Counter(const std::string& name, const TLabels& labels = {}) = 0;
+    virtual std::shared_ptr<IGauge> Gauge(const std::string& name, const TLabels& labels = {}) = 0;
+    virtual std::shared_ptr<IHistogram> Histogram(const std::string& name, const std::vector<double>& buckets, const TLabels& labels = {}) = 0;
+};
+
+enum class ESpanKind {
+    INTERNAL,
+    SERVER,
+    CLIENT,
+    PRODUCER,
+    CONSUMER
+};
+
+class ISpan {
+public:
+    virtual ~ISpan() = default;
+    virtual void End() = 0;
+    virtual void SetAttribute(const std::string& key, const std::string& value) = 0;
+    virtual void SetAttribute(const std::string& key, int64_t value) = 0;
+};
+
+class ITracer {
+public:
+    virtual ~ITracer() = default;
+    virtual std::shared_ptr<ISpan> StartSpan(const std::string& name, ESpanKind kind = ESpanKind::INTERNAL) = 0;
+};
+
+class ITraceProvider {
+public:
+    virtual ~ITraceProvider() = default;
+    virtual std::shared_ptr<ITracer> GetTracer(const std::string& name) = 0;
+};
+
+class IMetricsApi : public IExtensionApi {
+public:
+    static IMetricsApi* Create(TDriver driver);
+public:
+    virtual ~IMetricsApi() = default;
+    virtual void SetMetricRegistry(std::shared_ptr<IMetricRegistry> registry) = 0;
+    virtual void SetTraceProvider(std::shared_ptr<ITraceProvider> provider) = 0;
+    virtual std::shared_ptr<IMetricRegistry> GetMetricRegistry() const = 0;
+    virtual std::shared_ptr<ITraceProvider> GetTraceProvider() const = 0;
+};
+
+} // namespace NYdb::NMetrics

open_telemetry/CMakeLists.txt

@@ -0,0 +1,20 @@
+_ydb_sdk_add_library(open_telemetry)
+
+target_sources(open_telemetry PRIVATE
+    src/otel.cpp
+)
+
+target_include_directories(open_telemetry PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(open_telemetry PUBLIC
+    client-metrics
+    opentelemetry-cpp::api
+    opentelemetry-cpp::metrics
+    opentelemetry-cpp::trace
+)
+
+_ydb_sdk_make_client_component(OpenTelemetry open_telemetry)
+_ydb_sdk_install_headers(${CMAKE_INSTALL_INCLUDEDIR} DIRECTORY include/)

open_telemetry/include/ydb-cpp-sdk/open_telemetry/extension.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <ydb-cpp-sdk/open_telemetry/otel.h>
+#include <ydb-cpp-sdk/client/extension_common/extension.h>
+
+namespace NYdb::inline V3::NMetrics {
+
+class TOtelExtension : public IExtension {
+public:
+    using IApi = IMetricsApi;
+
+    struct TParams {
+        opentelemetry::nostd::shared_ptr<opentelemetry::metrics::MeterProvider> MeterProvider;
+        opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> TracerProvider;
+    };
+
+    TOtelExtension(const TParams& params, IApi* api) {
+        if (params.MeterProvider) {
+            api->SetMetricRegistry(std::make_shared<TOtelMetricRegistry>(params.MeterProvider));
+        }
+        if (params.TracerProvider) {
+            api->SetTraceProvider(std::make_shared<TOtelTraceProvider>(params.TracerProvider));
+        }
+    }
+};
+
+inline void AddOpenTelemetry(TDriver& driver
+    , opentelemetry::nostd::shared_ptr<opentelemetry::metrics::MeterProvider> meterProvider
+    , opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> tracerProvider
+) {
+    driver.AddExtension<TOtelExtension>({meterProvider, tracerProvider});
+}
+
+} // namespace NYdb::NMetrics

open_telemetry/include/ydb-cpp-sdk/open_telemetry/otel.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <ydb-cpp-sdk/client/metrics/metrics.h>
+
+#include <opentelemetry/metrics/meter_provider.h>
+#include <opentelemetry/trace/tracer_provider.h>
+
+namespace NYdb::inline V3::NMetrics {
+
+class TOtelMetricRegistry : public IMetricRegistry {
+public:
+    TOtelMetricRegistry(opentelemetry::nostd::shared_ptr<opentelemetry::metrics::MeterProvider> meterProvider);
+
+    std::shared_ptr<ICounter> Counter(const std::string& name, const TLabels& labels = {}) override;
+    std::shared_ptr<IGauge> Gauge(const std::string& name, const TLabels& labels = {}) override;
+    std::shared_ptr<IHistogram> Histogram(const std::string& name, const std::vector<double>& buckets, const TLabels& labels = {}) override;
+
+private:
+    opentelemetry::nostd::shared_ptr<opentelemetry::metrics::MeterProvider> MeterProvider_;
+    opentelemetry::nostd::shared_ptr<opentelemetry::metrics::Meter> Meter_;
+};
+
+class TOtelTraceProvider : public ITraceProvider {
+public:
+    TOtelTraceProvider(opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> tracerProvider);
+
+    std::shared_ptr<ITracer> GetTracer(const std::string& name) override;
+
+private:
+    opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> TracerProvider_;
+};
+
+} // namespace NYdb::NMetrics

open_telemetry/src/otel.cpp

@@ -0,0 +1,153 @@
+#include <ydb-cpp-sdk/open_telemetry/otel.h>
+
+#include <opentelemetry/metrics/meter.h>
+#include <opentelemetry/metrics/sync_instruments.h>
+#include <opentelemetry/common/key_value_iterable_view.h>
+#include <opentelemetry/trace/tracer.h>
+#include <opentelemetry/context/runtime_context.h>
+
+namespace NYdb::inline V3::NMetrics {
+
+namespace {
+
+using namespace opentelemetry;
+
+common::KeyValueIterableView<TLabels> MakeAttributes(const TLabels& labels) {
+    return common::KeyValueIterableView<TLabels>(labels);
+}
+
+class TOtelCounter : public ICounter {
+public:
+    TOtelCounter(nostd::shared_ptr<metrics::Counter<uint64_t>> counter, const TLabels& labels)
+        : Counter_(std::move(counter))
+        , Labels_(labels)
+    {}
+
+    void Inc() override {
+        Counter_->Add(1, MakeAttributes(Labels_), context::RuntimeContext::GetCurrent());
+    }
+
+private:
+    nostd::shared_ptr<metrics::Counter<uint64_t>> Counter_;
+    TLabels Labels_;
+};
+
+class TOtelUpDownCounterGauge : public IGauge {
+public:
+    TOtelUpDownCounterGauge(nostd::shared_ptr<metrics::UpDownCounter<double>> counter, const TLabels& labels)
+        : Counter_(std::move(counter))
+        , Labels_(labels)
+    {}
+
+    void Add(double delta) override {
+        Counter_->Add(delta, MakeAttributes(Labels_), context::RuntimeContext::GetCurrent());
+        Value_ += delta;
+    }
+
+    void Set(double value) override {
+        Counter_->Add(value - Value_, MakeAttributes(Labels_), context::RuntimeContext::GetCurrent());
+        Value_ = value;
+    }
+
+private:
+    nostd::shared_ptr<metrics::UpDownCounter<double>> Counter_;
+    TLabels Labels_;
+    double Value_ = 0;
+};
+
+class TOtelHistogram : public IHistogram {
+public:
+    TOtelHistogram(nostd::shared_ptr<metrics::Histogram<double>> histogram, const TLabels& labels)
+        : Histogram_(std::move(histogram))
+        , Labels_(labels)
+    {}
+
+    void Record(double value) override {
+        Histogram_->Record(value, MakeAttributes(Labels_), context::RuntimeContext::GetCurrent());
+    }
+
+private:
+    nostd::shared_ptr<metrics::Histogram<double>> Histogram_;
+    TLabels Labels_;
+};
+
+trace::SpanKind MapSpanKind(ESpanKind kind) {
+    switch (kind) {
+        case ESpanKind::INTERNAL: return trace::SpanKind::kInternal;
+        case ESpanKind::SERVER:   return trace::SpanKind::kServer;
+        case ESpanKind::CLIENT:   return trace::SpanKind::kClient;
+        case ESpanKind::PRODUCER: return trace::SpanKind::kProducer;
+        case ESpanKind::CONSUMER: return trace::SpanKind::kConsumer;
+    }
+    return trace::SpanKind::kInternal;
+}
+
+class TOtelSpan : public ISpan {
+public:
+    TOtelSpan(nostd::shared_ptr<trace::Span> span)
+        : Span_(std::move(span))
+    {}
+
+    void End() override {
+        Span_->End();
+    }
+
+    void SetAttribute(const std::string& key, const std::string& value) override {
+        Span_->SetAttribute(key, value);
+    }
+
+    void SetAttribute(const std::string& key, int64_t value) override {
+        Span_->SetAttribute(key, value);
+    }
+
+private:
+    nostd::shared_ptr<trace::Span> Span_;
+};
+
+class TOtelTracer : public ITracer {
+public:
+    TOtelTracer(nostd::shared_ptr<trace::Tracer> tracer)
+        : Tracer_(std::move(tracer))
+    {}
+
+    std::shared_ptr<ISpan> StartSpan(const std::string& name, ESpanKind kind) override {
+        trace::StartSpanOptions options;
+        options.kind = MapSpanKind(kind);
+        return std::make_shared<TOtelSpan>(Tracer_->StartSpan(name, options));
+    }
+
+private:
+    nostd::shared_ptr<trace::Tracer> Tracer_;
+};
+
+} // namespace
+
+TOtelMetricRegistry::TOtelMetricRegistry(nostd::shared_ptr<metrics::MeterProvider> meterProvider)
+    : MeterProvider_(std::move(meterProvider))
+    , Meter_(MeterProvider_->GetMeter("ydb-cpp-sdk", "1.0.0"))
+{}
+
+std::shared_ptr<ICounter> TOtelMetricRegistry::Counter(const std::string& name, const TLabels& labels) {
+    auto counter = Meter_->CreateUInt64Counter(name);
+    return std::make_shared<TOtelCounter>(std::move(counter), labels);
+}
+
+std::shared_ptr<IGauge> TOtelMetricRegistry::Gauge(const std::string& name, const TLabels& labels) {
+    auto counter = Meter_->CreateDoubleUpDownCounter(name);
+    return std::make_shared<TOtelUpDownCounterGauge>(std::move(counter), labels);
+}
+
+std::shared_ptr<IHistogram> TOtelMetricRegistry::Histogram(const std::string& name, const std::vector<double>& buckets, const TLabels& labels) {
+    auto histogram = Meter_->CreateDoubleHistogram(name);
+    return std::make_shared<TOtelHistogram>(std::move(histogram), labels);
+}
+
+TOtelTraceProvider::TOtelTraceProvider(nostd::shared_ptr<trace::TracerProvider> tracerProvider)
+    : TracerProvider_(std::move(tracerProvider))
+{}
+
+std::shared_ptr<ITracer> TOtelTraceProvider::GetTracer(const std::string& name) {
+    return std::make_shared<TOtelTracer>(TracerProvider_->GetTracer(name));
+}
+
+} // namespace NYdb::NMetrics

src/CMakeLists.txt

@@ -1,3 +1,3 @@
 add_subdirectory(api)
 add_subdirectory(client)
-add_subdirectory(library)
+add_subdirectory(library)

src/client/CMakeLists.txt

@@ -12,6 +12,7 @@ add_subdirectory(iam)
 add_subdirectory(iam_private)
 add_subdirectory(impl)
 add_subdirectory(import)
+add_subdirectory(metrics)
 add_subdirectory(monitoring)
 add_subdirectory(operation)
 add_subdirectory(params)

src/client/impl/internal/grpc_connections/grpc_connections.h

@@ -581,6 +581,18 @@ class TGRpcConnectionsImpl
     ::NMonitoring::TMetricRegistry* GetMetricRegistry() override;
     void RegisterExtension(IExtension* extension);
     void RegisterExtensionApi(IExtensionApi* api);
+
+    template<typename T>
+    T* GetExtensionApi() {
+        std::lock_guard lock(ExtensionsLock_);
+        for (const auto& api : ExtensionApis_) {
+            if (auto ptr = dynamic_cast<T*>(api.get())) {
+                return ptr;
+            }
+        }
+        return nullptr;
+    }
+
     void SetDiscoveryMutator(IDiscoveryMutatorApi::TMutatorCb&& cb);
     const TLog& GetLog() const override;
 

src/client/metrics/CMakeLists.txt

@@ -0,0 +1,16 @@
+_ydb_sdk_add_library(client-metrics)
+
+target_sources(client-metrics PRIVATE
+    metrics.cpp
+)
+
+target_include_directories(client-metrics PUBLIC
+    $<BUILD_INTERFACE:${YDB_SDK_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(client-metrics PUBLIC
+    client-extension_common
+)
+
+_ydb_sdk_make_client_component(Metrics client-metrics)