kcenon::monitoring::opentelemetry_compatibility_layer Class Reference

Main OpenTelemetry compatibility layer. More...

#include <opentelemetry_adapter.h>

Collaboration diagram for kcenon::monitoring::opentelemetry_compatibility_layer:

Classes
struct	compatibility_stats
	Get compatibility layer statistics. More...

Public Member Functions
	opentelemetry_compatibility_layer (const otel_resource &resource)
common::VoidResult	initialize ()
	Initialize the compatibility layer.
common::VoidResult	shutdown ()
	Shutdown the compatibility layer.
common::VoidResult	export_spans (const std::vector< trace_span > &spans)
	Export spans using OpenTelemetry format.
common::VoidResult	export_metrics (const monitoring_data &data)
	Export metrics using OpenTelemetry format.
common::VoidResult	flush ()
	Flush pending data to exporters.
compatibility_stats	get_stats () const
const otel_resource &	get_resource () const
	Get resource information.

Private Attributes
otel_resource	resource_
opentelemetry_tracer_adapter	tracer_adapter_
opentelemetry_metrics_adapter	metrics_adapter_
std::mutex	mutex_
bool	initialized_ {false}
std::vector< otel_span_data >	pending_spans_
std::vector< otel_metric_data >	pending_metrics_
std::size_t	spans_exported_ {0}
std::size_t	metrics_exported_ {0}
std::chrono::system_clock::time_point	last_export_
std::size_t	export_errors_ {0}

Detailed Description

Main OpenTelemetry compatibility layer.

Definition at line 380 of file opentelemetry_adapter.h.

Constructor & Destructor Documentation

opentelemetry_compatibility_layer()

kcenon::monitoring::opentelemetry_compatibility_layer::opentelemetry_compatibility_layer ( const otel_resource & resource )

inlineexplicit

Definition at line 382 of file opentelemetry_adapter.h.

        : resource_(resource)
        , tracer_adapter_(resource)
        , metrics_adapter_(resource) {}

Member Function Documentation

export_metrics()

common::VoidResult kcenon::monitoring::opentelemetry_compatibility_layer::export_metrics ( const monitoring_data & data )

inline

Export metrics using OpenTelemetry format.

Definition at line 445 of file opentelemetry_adapter.h.

                                                                 {
        if (!initialized_) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_state,
                                    "Compatibility layer not initialized", "monitoring_system").to_common_error());
        }
 
        auto convert_result = metrics_adapter_.convert_monitoring_data(data);
        if (convert_result.is_err()) {
            return common::VoidResult::err(error_info(monitoring_error_code::processing_failed,
                                    "Failed to convert metrics: " + convert_result.error().message).to_common_error());
        }
 
        // Store converted metrics for batching
        std::lock_guard<std::mutex> lock(mutex_);
        const auto& otel_metrics = convert_result.value();
        pending_metrics_.insert(pending_metrics_.end(), otel_metrics.begin(), otel_metrics.end());
 
        return common::ok();
    }

References kcenon::monitoring::opentelemetry_metrics_adapter::convert_monitoring_data(), initialized_, kcenon::monitoring::invalid_state, metrics_adapter_, mutex_, pending_metrics_, kcenon::monitoring::processing_failed, and kcenon::monitoring::error_info::to_common_error().

Here is the call graph for this function:

export_spans()

common::VoidResult kcenon::monitoring::opentelemetry_compatibility_layer::export_spans ( const std::vector< trace_span > & spans )

inline

Export spans using OpenTelemetry format.

Definition at line 422 of file opentelemetry_adapter.h.

                                                                      {
        if (!initialized_) {
            return common::VoidResult::err(error_info(monitoring_error_code::invalid_state,
                                    "Compatibility layer not initialized", "monitoring_system").to_common_error());
        }
 
        auto convert_result = tracer_adapter_.convert_spans(spans);
        if (convert_result.is_err()) {
            return common::VoidResult::err(error_info(monitoring_error_code::processing_failed,
                                    "Failed to convert spans: " + convert_result.error().message).to_common_error());
        }
 
        // Store converted spans for batching
        std::lock_guard<std::mutex> lock(mutex_);
        const auto& otel_spans = convert_result.value();
        pending_spans_.insert(pending_spans_.end(), otel_spans.begin(), otel_spans.end());
 
        return common::ok();
    }

References kcenon::monitoring::opentelemetry_tracer_adapter::convert_spans(), initialized_, kcenon::monitoring::invalid_state, mutex_, pending_spans_, kcenon::monitoring::processing_failed, kcenon::monitoring::error_info::to_common_error(), and tracer_adapter_.

Here is the call graph for this function:

flush()

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

inline

Flush pending data to exporters.

Definition at line 468 of file opentelemetry_adapter.h.

                             {
        std::lock_guard<std::mutex> lock(mutex_);
        
        // In a real implementation, this would send data to OpenTelemetry collectors
        // For now, we'll just clear the pending data
        pending_spans_.clear();
        pending_metrics_.clear();
        
        return common::ok();
    }

References mutex_, pending_metrics_, and pending_spans_.

get_resource()

const otel_resource & kcenon::monitoring::opentelemetry_compatibility_layer::get_resource ( ) const

inline

Get resource information.

Definition at line 506 of file opentelemetry_adapter.h.

                                              {
        return resource_;
    }

References resource_.

get_stats()

compatibility_stats kcenon::monitoring::opentelemetry_compatibility_layer::get_stats ( ) const

inline

Definition at line 491 of file opentelemetry_adapter.h.

                                          {
        std::lock_guard<std::mutex> lock(mutex_);
        compatibility_stats stats;
        stats.pending_spans = pending_spans_.size();
        stats.pending_metrics = pending_metrics_.size();
        stats.spans_exported = spans_exported_;
        stats.metrics_exported = metrics_exported_;
        stats.last_export = last_export_;
        stats.export_errors = export_errors_;
        return stats;
    }

References kcenon::monitoring::opentelemetry_compatibility_layer::compatibility_stats::export_errors, export_errors_, kcenon::monitoring::opentelemetry_compatibility_layer::compatibility_stats::last_export, last_export_, kcenon::monitoring::opentelemetry_compatibility_layer::compatibility_stats::metrics_exported, metrics_exported_, mutex_, kcenon::monitoring::opentelemetry_compatibility_layer::compatibility_stats::pending_metrics, pending_metrics_, kcenon::monitoring::opentelemetry_compatibility_layer::compatibility_stats::pending_spans, pending_spans_, kcenon::monitoring::opentelemetry_compatibility_layer::compatibility_stats::spans_exported, and spans_exported_.

initialize()

common::VoidResult kcenon::monitoring::opentelemetry_compatibility_layer::initialize ( )

inline

Initialize the compatibility layer.

Definition at line 390 of file opentelemetry_adapter.h.

                                  {
        std::lock_guard<std::mutex> lock(mutex_);
        if (initialized_) {
            return common::VoidResult::err(error_info(monitoring_error_code::already_exists,
                                    "Compatibility layer already initialized", "monitoring_system").to_common_error());
        }
 
        initialized_ = true;
        return common::ok();
    }

References kcenon::monitoring::already_exists, initialized_, and mutex_.

shutdown()

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

inline

Shutdown the compatibility layer.

Definition at line 404 of file opentelemetry_adapter.h.

                                {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!initialized_) {
            return common::ok();
        }
        
        // Flush any pending data without re-locking
        // In a real implementation, this would send data to OpenTelemetry collectors
        pending_spans_.clear();
        pending_metrics_.clear();
        
        initialized_ = false;
        return common::ok();
    }

References initialized_, mutex_, pending_metrics_, and pending_spans_.

Member Data Documentation

export_errors_

std::size_t kcenon::monitoring::opentelemetry_compatibility_layer::export_errors_ {0}

private

Definition at line 524 of file opentelemetry_adapter.h.

{0};

Referenced by get_stats().

initialized_

bool kcenon::monitoring::opentelemetry_compatibility_layer::initialized_ {false}

private

Definition at line 516 of file opentelemetry_adapter.h.

{false};

Referenced by export_metrics(), export_spans(), initialize(), and shutdown().

last_export_

std::chrono::system_clock::time_point kcenon::monitoring::opentelemetry_compatibility_layer::last_export_

private

Definition at line 523 of file opentelemetry_adapter.h.

Referenced by get_stats().

metrics_adapter_

opentelemetry_metrics_adapter kcenon::monitoring::opentelemetry_compatibility_layer::metrics_adapter_

private

Definition at line 513 of file opentelemetry_adapter.h.

Referenced by export_metrics().

metrics_exported_

std::size_t kcenon::monitoring::opentelemetry_compatibility_layer::metrics_exported_ {0}

private

Definition at line 522 of file opentelemetry_adapter.h.

{0};

Referenced by get_stats().

mutex_

std::mutex kcenon::monitoring::opentelemetry_compatibility_layer::mutex_

mutableprivate

Definition at line 515 of file opentelemetry_adapter.h.

Referenced by export_metrics(), export_spans(), flush(), get_stats(), initialize(), and shutdown().

pending_metrics_

std::vector<otel_metric_data> kcenon::monitoring::opentelemetry_compatibility_layer::pending_metrics_

private

Definition at line 519 of file opentelemetry_adapter.h.

Referenced by export_metrics(), flush(), get_stats(), and shutdown().

pending_spans_

std::vector<otel_span_data> kcenon::monitoring::opentelemetry_compatibility_layer::pending_spans_

private

Definition at line 518 of file opentelemetry_adapter.h.

Referenced by export_spans(), flush(), get_stats(), and shutdown().

resource_

otel_resource kcenon::monitoring::opentelemetry_compatibility_layer::resource_

private

Definition at line 511 of file opentelemetry_adapter.h.

Referenced by get_resource().

spans_exported_

std::size_t kcenon::monitoring::opentelemetry_compatibility_layer::spans_exported_ {0}

private

Definition at line 521 of file opentelemetry_adapter.h.

{0};

Referenced by get_stats().

tracer_adapter_

opentelemetry_tracer_adapter kcenon::monitoring::opentelemetry_compatibility_layer::tracer_adapter_

private

Definition at line 512 of file opentelemetry_adapter.h.

Referenced by export_spans().

---

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

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