kcenon::monitoring::otlp_metrics_exporter Class Reference

OpenTelemetry Protocol (OTLP) metrics exporter implementation. More...

#include <metric_exporters.h>

Inheritance diagram for kcenon::monitoring::otlp_metrics_exporter:

Collaboration diagram for kcenon::monitoring::otlp_metrics_exporter:

Public Member Functions
	otlp_metrics_exporter (const metric_export_config &config, const otel_resource &resource)
	Construct OTLP exporter with default transports.
	otlp_metrics_exporter (const metric_export_config &config, const otel_resource &resource, std::unique_ptr< http_transport > http_transport, std::unique_ptr< grpc_transport > grpc_transport)
	Construct OTLP exporter with custom transports.
common::VoidResult	export_metrics (const std::vector< monitoring_data > &metrics) override
	Export a batch of metrics.
common::VoidResult	export_snapshot (const metrics_snapshot &snapshot) override
	Export a single metrics snapshot.
common::VoidResult	start () override
	Start the exporter (for pull-based systems)
common::VoidResult	stop () override
	Stop the exporter.
common::VoidResult	flush () override
	Flush any pending metrics.
common::VoidResult	shutdown () override
	Shutdown the exporter.
std::unordered_map< std::string, std::size_t >	get_stats () const override
	Get exporter statistics.
Public Member Functions inherited from kcenon::monitoring::metric_exporter_interface
virtual	~metric_exporter_interface ()=default

Private Member Functions
bool	is_grpc_protocol () const
bool	is_http_protocol () const
std::string	get_content_type () const
common::VoidResult	send_otlp_batch (const std::vector< otel_metric_data > &metrics)
common::VoidResult	send_via_http (const std::vector< otel_metric_data > &metrics)
common::VoidResult	send_via_grpc (const std::vector< otel_metric_data > &metrics)
std::vector< uint8_t >	serialize_metrics (const std::vector< otel_metric_data > &metrics) const

Private Attributes
metric_export_config	config_
std::unique_ptr< opentelemetry_metrics_adapter >	otel_adapter_
std::unique_ptr< http_transport >	http_transport_
std::unique_ptr< grpc_transport >	grpc_transport_
std::atomic< std::size_t >	exported_metrics_ {0}
std::atomic< std::size_t >	failed_exports_ {0}
bool	started_ {false}

Detailed Description

OpenTelemetry Protocol (OTLP) metrics exporter implementation.

Exports metrics to OTLP-compatible backends via gRPC or HTTP. Supports OTLP/gRPC, OTLP/HTTP JSON, and OTLP/HTTP Protobuf formats.

Definition at line 795 of file metric_exporters.h.

Constructor & Destructor Documentation

otlp_metrics_exporter() [1/2]

kcenon::monitoring::otlp_metrics_exporter::otlp_metrics_exporter ( const metric_export_config & config, const otel_resource & resource )

inlineexplicit

Construct OTLP exporter with default transports.

Parameters

config	Export configuration with endpoint and protocol
resource	OpenTelemetry resource attributes

Definition at line 811 of file metric_exporters.h.

        : config_(config)
        , otel_adapter_(std::make_unique<opentelemetry_metrics_adapter>(resource))
        , http_transport_(create_default_transport())
        , grpc_transport_(create_default_grpc_transport()) {}

otlp_metrics_exporter() [2/2]

kcenon::monitoring::otlp_metrics_exporter::otlp_metrics_exporter ( const metric_export_config & config, const otel_resource & resource, std::unique_ptr< http_transport > http_transport, std::unique_ptr< grpc_transport > grpc_transport )

inline

Construct OTLP exporter with custom transports.

Parameters

config	Export configuration
resource	OpenTelemetry resource attributes
http_transport	Custom HTTP transport (for OTLP/HTTP)
grpc_transport	Custom gRPC transport (for OTLP/gRPC)

Definition at line 824 of file metric_exporters.h.

        : config_(config)
        , otel_adapter_(std::make_unique<opentelemetry_metrics_adapter>(resource))
        , http_transport_(std::move(http_transport))
        , grpc_transport_(std::move(grpc_transport)) {}

Member Function Documentation

export_metrics()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::export_metrics ( const std::vector< monitoring_data > & metrics )

inlineoverridevirtual

Export a batch of metrics.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 833 of file metric_exporters.h.

                                                                                        {
        try {
            for (const auto& data : metrics) {
                // Convert to OpenTelemetry format
                auto otel_result = otel_adapter_->convert_monitoring_data(data);
                if (otel_result.is_err()) {
                    failed_exports_++;
                    return common::VoidResult::err(error_info(monitoring_error_code::processing_failed,
                                     "Failed to convert metrics to OTEL format: " + otel_result.error().message, "monitoring_system").to_common_error());
                }
                
                const auto& otel_metrics = otel_result.value();
                
                // Send via appropriate OTLP protocol
                auto send_result = send_otlp_batch(otel_metrics);
                if (send_result.is_err()) {
                    failed_exports_++;
                    return send_result;
                }
            }
            
            exported_metrics_ += metrics.size();
            return common::ok();
 
        } catch (const std::exception& e) {
            failed_exports_++;
            return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
                             "OTLP metrics export failed: " + std::string(e.what()), "monitoring_system").to_common_error());
        }
    }

References exported_metrics_, failed_exports_, kcenon::monitoring::operation_failed, otel_adapter_, kcenon::monitoring::processing_failed, send_otlp_batch(), and kcenon::monitoring::error_info::to_common_error().

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

export_snapshot()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::export_snapshot ( const metrics_snapshot & snapshot )

inlineoverridevirtual

Export a single metrics snapshot.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 864 of file metric_exporters.h.

                                                                                {
        try {
            // Convert to OpenTelemetry format
            auto otel_result = otel_adapter_->convert_metrics(snapshot);
            if (otel_result.is_err()) {
                failed_exports_++;
                return common::VoidResult::err(error_info(monitoring_error_code::processing_failed,
                                 "Failed to convert snapshot to OTEL format: " + otel_result.error().message, "monitoring_system").to_common_error());
            }
            
            const auto& otel_metrics = otel_result.value();
            
            // Send via appropriate OTLP protocol
            auto send_result = send_otlp_batch(otel_metrics);
            if (send_result.is_err()) {
                failed_exports_++;
                return send_result;
            }
            
            exported_metrics_++;
            return common::ok();
 
        } catch (const std::exception& e) {
            failed_exports_++;
            return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
                             "OTLP snapshot export failed: " + std::string(e.what()), "monitoring_system").to_common_error());
        }
    }

References exported_metrics_, failed_exports_, kcenon::monitoring::operation_failed, otel_adapter_, kcenon::monitoring::processing_failed, send_otlp_batch(), and kcenon::monitoring::error_info::to_common_error().

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

flush()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::flush ( )

inlineoverridevirtual

Flush any pending metrics.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 917 of file metric_exporters.h.

                                      {
        // OTLP exporter typically sends immediately, so flush is a no-op
        return common::ok();
    }

Referenced by TEST_F().

Here is the caller graph for this function:

get_content_type()

std::string kcenon::monitoring::otlp_metrics_exporter::get_content_type ( ) const

inlineprivate

Definition at line 953 of file metric_exporters.h.

                                       {
        switch (config_.format) {
            case metric_export_format::otlp_http_json:
                return "application/json";
            case metric_export_format::otlp_http_protobuf:
                return "application/x-protobuf";
            default:
                return "application/json";
        }
    }

References config_, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::otlp_http_json, and kcenon::monitoring::otlp_http_protobuf.

Referenced by send_via_http().

Here is the caller graph for this function:

get_stats()

std::unordered_map< std::string, std::size_t > kcenon::monitoring::otlp_metrics_exporter::get_stats ( ) const

inlineoverridevirtual

Get exporter statistics.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 926 of file metric_exporters.h.

                                                                      {
        std::unordered_map<std::string, std::size_t> stats = {
            {"exported_metrics", exported_metrics_.load()},
            {"failed_exports", failed_exports_.load()}
        };
 
        // Add transport statistics based on protocol
        if (is_grpc_protocol() && grpc_transport_) {
            auto transport_stats = grpc_transport_->get_statistics();
            stats["transport_requests_sent"] = transport_stats.requests_sent;
            stats["transport_bytes_sent"] = transport_stats.bytes_sent;
            stats["transport_send_failures"] = transport_stats.send_failures;
        }
 
        return stats;
    }

References exported_metrics_, failed_exports_, grpc_transport_, and is_grpc_protocol().

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

is_grpc_protocol()

bool kcenon::monitoring::otlp_metrics_exporter::is_grpc_protocol ( ) const

inlineprivate

Definition at line 944 of file metric_exporters.h.

                                  {
        return config_.format == metric_export_format::otlp_grpc;
    }

References config_, kcenon::monitoring::metric_export_config::format, and kcenon::monitoring::otlp_grpc.

Referenced by get_stats(), and send_otlp_batch().

Here is the caller graph for this function:

is_http_protocol()

bool kcenon::monitoring::otlp_metrics_exporter::is_http_protocol ( ) const

inlineprivate

Definition at line 948 of file metric_exporters.h.

                                  {
        return config_.format == metric_export_format::otlp_http_json ||
               config_.format == metric_export_format::otlp_http_protobuf;
    }

References config_, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::otlp_http_json, and kcenon::monitoring::otlp_http_protobuf.

send_otlp_batch()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::send_otlp_batch ( const std::vector< otel_metric_data > & metrics )

inlineprivate

Definition at line 964 of file metric_exporters.h.

                                                                                 {
        if (is_grpc_protocol()) {
            return send_via_grpc(metrics);
        } else {
            return send_via_http(metrics);
        }
    }

References is_grpc_protocol(), send_via_grpc(), and send_via_http().

Referenced by export_metrics(), and export_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

send_via_grpc()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::send_via_grpc ( const std::vector< otel_metric_data > & metrics )

inlineprivate

Definition at line 1024 of file metric_exporters.h.

                                                                               {
        if (!grpc_transport_) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::dependency_missing,
                "gRPC transport not available",
                "otlp_metrics_exporter"
            ).to_common_error());
        }
 
        // Connect if not already connected
        if (!grpc_transport_->is_connected()) {
            auto connect_result = grpc_transport_->connect(config_.endpoint, config_.port);
            if (connect_result.is_err()) {
                return connect_result;
            }
        }
 
        // Serialize metrics to protobuf
        std::vector<uint8_t> body = serialize_metrics(metrics);
 
        grpc_request request;
        request.service = "opentelemetry.proto.collector.metrics.v1.MetricsService";
        request.method = "Export";
        request.body = std::move(body);
        request.timeout = config_.timeout;
 
        auto result = grpc_transport_->send(request);
        if (result.is_err()) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::network_error,
                "gRPC send failed: " + result.error().message,
                "otlp_metrics_exporter"
            ).to_common_error());
        }
 
        const auto& response = result.value();
        if (response.status_code != 0) { // gRPC OK is 0
            return common::VoidResult::err(error_info(
                monitoring_error_code::operation_failed,
                "OTLP gRPC request failed: " + response.status_message,
                "otlp_metrics_exporter"
            ).to_common_error());
        }
 
        return common::ok();
    }

References kcenon::monitoring::grpc_request::body, config_, kcenon::monitoring::dependency_missing, kcenon::monitoring::metric_export_config::endpoint, grpc_transport_, kcenon::monitoring::grpc_request::method, kcenon::monitoring::network_error, kcenon::monitoring::operation_failed, kcenon::monitoring::metric_export_config::port, serialize_metrics(), kcenon::monitoring::grpc_request::service, kcenon::monitoring::grpc_request::timeout, kcenon::monitoring::metric_export_config::timeout, and kcenon::monitoring::error_info::to_common_error().

Referenced by send_otlp_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

send_via_http()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::send_via_http ( const std::vector< otel_metric_data > & metrics )

inlineprivate

Definition at line 972 of file metric_exporters.h.

                                                                               {
        if (!http_transport_) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::dependency_missing,
                "HTTP transport not available",
                "otlp_metrics_exporter"
            ).to_common_error());
        }
 
        // Build OTLP HTTP endpoint
        std::string endpoint = config_.endpoint;
        if (config_.port != 0) {
            endpoint += ":" + std::to_string(config_.port);
        }
        endpoint += "/v1/metrics";
 
        // Serialize metrics to JSON or Protobuf
        std::vector<uint8_t> body = serialize_metrics(metrics);
 
        http_request request;
        request.url = endpoint;
        request.method = "POST";
        request.headers["Content-Type"] = get_content_type();
        request.body = std::move(body);
        request.timeout = config_.timeout;
 
        // Add custom headers
        for (const auto& [key, value] : config_.headers) {
            request.headers[key] = value;
        }
 
        auto result = http_transport_->send(request);
        if (result.is_err()) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::network_error,
                "HTTP send failed: " + result.error().message,
                "otlp_metrics_exporter"
            ).to_common_error());
        }
 
        const auto& response = result.value();
        if (response.status_code < 200 || response.status_code >= 300) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::operation_failed,
                "OTLP HTTP request failed with status " + std::to_string(response.status_code),
                "otlp_metrics_exporter"
            ).to_common_error());
        }
 
        return common::ok();
    }

References kcenon::monitoring::http_request::body, config_, kcenon::monitoring::dependency_missing, kcenon::monitoring::metric_export_config::endpoint, get_content_type(), kcenon::monitoring::http_request::headers, kcenon::monitoring::metric_export_config::headers, http_transport_, kcenon::monitoring::http_request::method, kcenon::monitoring::network_error, kcenon::monitoring::operation_failed, kcenon::monitoring::metric_export_config::port, serialize_metrics(), kcenon::monitoring::http_request::timeout, kcenon::monitoring::metric_export_config::timeout, kcenon::monitoring::error_info::to_common_error(), and kcenon::monitoring::http_request::url.

Referenced by send_otlp_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_metrics()

std::vector< uint8_t > kcenon::monitoring::otlp_metrics_exporter::serialize_metrics ( const std::vector< otel_metric_data > & metrics ) const

inlineprivate

Definition at line 1071 of file metric_exporters.h.

                                                                                           {
        // Serialize metrics based on format
        // For JSON format, convert to JSON string
        // For protobuf format, serialize to protobuf bytes
        // This is a simplified implementation
        std::string json = "{\"resourceMetrics\":[";
 
        bool first = true;
        for (const auto& metric : metrics) {
            if (!first) json += ",";
            first = false;
 
            json += "{\"resource\":{},\"scopeMetrics\":[{\"metrics\":[{";
            json += "\"name\":\"" + metric.name + "\",";
            json += "\"gauge\":{\"dataPoints\":[{\"asDouble\":" +
                    std::to_string(metric.value) + "}]}";
            json += "}]}]}";
        }
 
        json += "]}";
 
        return std::vector<uint8_t>(json.begin(), json.end());
    }

References kcenon::monitoring::metric::name, and kcenon::monitoring::metric::value.

Referenced by send_via_grpc(), and send_via_http().

Here is the caller graph for this function:

shutdown()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::shutdown ( )

inlineoverridevirtual

Shutdown the exporter.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 922 of file metric_exporters.h.

                                         {
        return stop();
    }

References stop().

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

start()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::start ( )

inlineoverridevirtual

Start the exporter (for pull-based systems)

Reimplemented from kcenon::monitoring::metric_exporter_interface.

Definition at line 893 of file metric_exporters.h.

                                      {
        if (started_) {
            return common::ok();
        }
 
        // gRPC transport connection is managed per-request
        // HTTP transport is stateless
        started_ = true;
        return common::ok();
    }

References started_.

Referenced by TEST_F().

Here is the caller graph for this function:

stop()

common::VoidResult kcenon::monitoring::otlp_metrics_exporter::stop ( )

inlineoverridevirtual

Stop the exporter.

Reimplemented from kcenon::monitoring::metric_exporter_interface.

Definition at line 904 of file metric_exporters.h.

                                     {
        if (!started_) {
            return common::ok();
        }
 
        if (grpc_transport_) {
            grpc_transport_->disconnect();
        }
 
        started_ = false;
        return common::ok();
    }

References grpc_transport_, and started_.

Referenced by shutdown(), and TEST_F().

Here is the caller graph for this function:

Member Data Documentation

config_

metric_export_config kcenon::monitoring::otlp_metrics_exporter::config_

private

Definition at line 797 of file metric_exporters.h.

Referenced by get_content_type(), is_grpc_protocol(), is_http_protocol(), send_via_grpc(), and send_via_http().

exported_metrics_

std::atomic<std::size_t> kcenon::monitoring::otlp_metrics_exporter::exported_metrics_ {0}

private

Definition at line 801 of file metric_exporters.h.

{0};

Referenced by export_metrics(), export_snapshot(), and get_stats().

failed_exports_

std::atomic<std::size_t> kcenon::monitoring::otlp_metrics_exporter::failed_exports_ {0}

private

Definition at line 802 of file metric_exporters.h.

{0};

Referenced by export_metrics(), export_snapshot(), and get_stats().

grpc_transport_

std::unique_ptr<grpc_transport> kcenon::monitoring::otlp_metrics_exporter::grpc_transport_

private

Definition at line 800 of file metric_exporters.h.

Referenced by get_stats(), send_via_grpc(), and stop().

http_transport_

std::unique_ptr<http_transport> kcenon::monitoring::otlp_metrics_exporter::http_transport_

private

Definition at line 799 of file metric_exporters.h.

Referenced by send_via_http().

otel_adapter_

std::unique_ptr<opentelemetry_metrics_adapter> kcenon::monitoring::otlp_metrics_exporter::otel_adapter_

private

Definition at line 798 of file metric_exporters.h.

Referenced by export_metrics(), and export_snapshot().

started_

bool kcenon::monitoring::otlp_metrics_exporter::started_ {false}

private

Definition at line 803 of file metric_exporters.h.

{false};

Referenced by start(), and stop().

---

The documentation for this class was generated from the following file:

• include/kcenon/monitoring/exporters/metric_exporters.h