kcenon::monitoring::statsd_exporter Class Reference

StatsD metric exporter implementation. More...

#include <metric_exporters.h>

Inheritance diagram for kcenon::monitoring::statsd_exporter:

Collaboration diagram for kcenon::monitoring::statsd_exporter:

Public Member Functions
	statsd_exporter (const metric_export_config &config)
	Construct StatsD exporter with default UDP transport.
	statsd_exporter (const metric_export_config &config, std::unique_ptr< udp_transport > transport)
	Construct StatsD exporter with custom UDP transport.
std::vector< statsd_metric_data >	convert_monitoring_data (const monitoring_data &data) const
	Convert monitoring_data to StatsD format.
std::vector< statsd_metric_data >	convert_snapshot (const metrics_snapshot &snapshot) const
	Convert metrics_snapshot to StatsD format.
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
common::VoidResult	send_udp_batch (const std::vector< std::string > &lines)
std::string	sanitize_metric_name (const std::string &name) const
metric_type	infer_metric_type (const std::string &name, double) const

Private Attributes
metric_export_config	config_
std::unique_ptr< udp_transport >	transport_
std::atomic< std::size_t >	exported_metrics_ {0}
std::atomic< std::size_t >	failed_exports_ {0}
std::atomic< std::size_t >	sent_packets_ {0}
bool	started_ {false}

Detailed Description

StatsD metric exporter implementation.

Exports metrics to StatsD-compatible backends via UDP. Supports both plain StatsD and DataDog extension formats.

Definition at line 505 of file metric_exporters.h.

Constructor & Destructor Documentation

statsd_exporter() [1/2]

kcenon::monitoring::statsd_exporter::statsd_exporter ( const metric_export_config & config )

inlineexplicit

Construct StatsD exporter with default UDP transport.

Parameters

config

Export configuration with endpoint and port

Definition at line 519 of file metric_exporters.h.

        : config_(config)
        , transport_(create_default_udp_transport()) {}

statsd_exporter() [2/2]

kcenon::monitoring::statsd_exporter::statsd_exporter ( const metric_export_config & config, std::unique_ptr< udp_transport > transport )

inline

Construct StatsD exporter with custom UDP transport.

Parameters

config	Export configuration
transport	Custom UDP transport implementation

Definition at line 528 of file metric_exporters.h.

        : config_(config)
        , transport_(std::move(transport)) {}

Member Function Documentation

convert_monitoring_data()

std::vector< statsd_metric_data > kcenon::monitoring::statsd_exporter::convert_monitoring_data ( const monitoring_data & data ) const

inline

Convert monitoring_data to StatsD format.

Definition at line 536 of file metric_exporters.h.

                                                                                             {
        std::vector<statsd_metric_data> statsd_metrics;
        
        for (const auto& [name, value] : data.get_metrics()) {
            statsd_metric_data metric;
            metric.name = sanitize_metric_name(name);
            metric.type = infer_metric_type(name, value);
            metric.value = value;
            metric.sample_rate = 1.0;
            
            // Add component as tag
            metric.tags["component"] = data.get_component_name();
            
            // Add custom tags from config
            for (const auto& [key, tag_value] : config_.labels) {
                metric.tags[key] = tag_value;
            }
            
            // Add tags from data
            for (const auto& [key, tag_value] : data.get_tags()) {
                metric.tags[key] = tag_value;
            }
            
            if (!config_.instance_id.empty()) {
                metric.tags["instance"] = config_.instance_id;
            }
            
            statsd_metrics.push_back(std::move(metric));
        }
        
        return statsd_metrics;
    }

References config_, kcenon::monitoring::monitoring_data::get_component_name(), kcenon::monitoring::monitoring_data::get_metrics(), kcenon::monitoring::monitoring_data::get_tags(), infer_metric_type(), kcenon::monitoring::metric_export_config::instance_id, kcenon::monitoring::metric_export_config::labels, kcenon::monitoring::metric::name, sanitize_metric_name(), kcenon::monitoring::metric::tags, kcenon::monitoring::metric::type, and kcenon::monitoring::metric::value.

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

Here is the call graph for this function:

Here is the caller graph for this function:

convert_snapshot()

std::vector< statsd_metric_data > kcenon::monitoring::statsd_exporter::convert_snapshot ( const metrics_snapshot & snapshot ) const

inline

Convert metrics_snapshot to StatsD format.

Definition at line 572 of file metric_exporters.h.

                                                                                           {
        std::vector<statsd_metric_data> statsd_metrics;
        
        for (const auto& metric_val : snapshot.metrics) {
            statsd_metric_data metric;
            metric.name = sanitize_metric_name(metric_val.name);
            metric.type = infer_metric_type(metric_val.name, metric_val.value);
            metric.value = metric_val.value;
            metric.sample_rate = 1.0;
            
            // Add source as tag
            if (!snapshot.source_id.empty()) {
                metric.tags["source"] = snapshot.source_id;
            }
            
            // Add custom tags from config
            for (const auto& [key, tag_value] : config_.labels) {
                metric.tags[key] = tag_value;
            }
            
            // Add tags from metric
            for (const auto& [key, tag_value] : metric_val.tags) {
                metric.tags[key] = tag_value;
            }
            
            if (!config_.instance_id.empty()) {
                metric.tags["instance"] = config_.instance_id;
            }
            
            statsd_metrics.push_back(std::move(metric));
        }
        
        return statsd_metrics;
    }

References config_, infer_metric_type(), kcenon::monitoring::metric_export_config::instance_id, kcenon::monitoring::metric_export_config::labels, kcenon::monitoring::metrics_snapshot::metrics, kcenon::monitoring::metric::name, sanitize_metric_name(), kcenon::monitoring::metrics_snapshot::source_id, kcenon::monitoring::metric::tags, kcenon::monitoring::metric::type, and kcenon::monitoring::metric::value.

Referenced by export_snapshot(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

export_metrics()

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

inlineoverridevirtual

Export a batch of metrics.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 607 of file metric_exporters.h.

                                                                                        {
        try {
            std::vector<std::string> statsd_lines;
            
            for (const auto& data : metrics) {
                auto statsd_metrics = convert_monitoring_data(data);
                for (const auto& metric : statsd_metrics) {
                    bool datadog_format = (config_.format == metric_export_format::statsd_datadog);
                    statsd_lines.push_back(metric.to_statsd_format(datadog_format));
                }
            }
            
            // Send via UDP (simulated)
            auto send_result = send_udp_batch(statsd_lines);
            if (send_result.is_ok()) {
                exported_metrics_ += metrics.size();
                sent_packets_++;
            } else {
                failed_exports_++;
                return send_result;
            }
 
            return common::ok();
 
        } catch (const std::exception& e) {
            failed_exports_++;
            return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
                             "StatsD export failed: " + std::string(e.what()), "monitoring_system").to_common_error());
        }
    }

References config_, convert_monitoring_data(), exported_metrics_, failed_exports_, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::operation_failed, send_udp_batch(), sent_packets_, kcenon::monitoring::statsd_datadog, and kcenon::monitoring::error_info::to_common_error().

Referenced by TEST_F(), 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::statsd_exporter::export_snapshot ( const metrics_snapshot & snapshot )

inlineoverridevirtual

Export a single metrics snapshot.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 638 of file metric_exporters.h.

                                                                                {
        try {
            auto statsd_metrics = convert_snapshot(snapshot);
            std::vector<std::string> statsd_lines;
            
            for (const auto& metric : statsd_metrics) {
                bool datadog_format = (config_.format == metric_export_format::statsd_datadog);
                statsd_lines.push_back(metric.to_statsd_format(datadog_format));
            }
            
            // Send via UDP (simulated)
            auto send_result = send_udp_batch(statsd_lines);
            if (send_result.is_ok()) {
                exported_metrics_++;
                sent_packets_++;
            } else {
                failed_exports_++;
                return send_result;
            }
 
            return common::ok();
 
        } catch (const std::exception& e) {
            failed_exports_++;
            return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
                             "StatsD snapshot export failed: " + std::string(e.what()), "monitoring_system").to_common_error());
        }
    }

References config_, convert_snapshot(), exported_metrics_, failed_exports_, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::operation_failed, send_udp_batch(), sent_packets_, kcenon::monitoring::statsd_datadog, 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::statsd_exporter::flush ( )

inlineoverridevirtual

Flush any pending metrics.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 703 of file metric_exporters.h.

                                      {
        // StatsD is push-based and sends immediately, so flush is a no-op
        return common::ok();
    }

Referenced by TEST_F().

Here is the caller graph for this function:

get_stats()

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

inlineoverridevirtual

Get exporter statistics.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 712 of file metric_exporters.h.

                                                                      {
        std::unordered_map<std::string, std::size_t> stats = {
            {"exported_metrics", exported_metrics_.load()},
            {"failed_exports", failed_exports_.load()},
            {"sent_packets", sent_packets_.load()}
        };
 
        // Add transport statistics if available
        if (transport_) {
            auto transport_stats = transport_->get_statistics();
            stats["transport_packets_sent"] = transport_stats.packets_sent;
            stats["transport_bytes_sent"] = transport_stats.bytes_sent;
            stats["transport_send_failures"] = transport_stats.send_failures;
        }
 
        return stats;
    }

References exported_metrics_, failed_exports_, sent_packets_, and transport_.

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

Here is the caller graph for this function:

infer_metric_type()

metric_type kcenon::monitoring::statsd_exporter::infer_metric_type ( const std::string & name, double  ) const

inlineprivate

Definition at line 770 of file metric_exporters.h.

                                                                         {
        // Simple heuristics for StatsD metric type inference
        std::string lower_name = name;
        std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
        
        if (lower_name.find("count") != std::string::npos ||
            lower_name.find("total") != std::string::npos) {
            return metric_type::counter;
        } else if (lower_name.find("time") != std::string::npos ||
                  lower_name.find("duration") != std::string::npos ||
                  lower_name.find("latency") != std::string::npos) {
            return metric_type::timer;
        } else {
            return metric_type::gauge; // Default to gauge
        }
    }

References kcenon::monitoring::counter, kcenon::monitoring::gauge, and kcenon::monitoring::timer.

Referenced by convert_monitoring_data(), and convert_snapshot().

Here is the caller graph for this function:

sanitize_metric_name()

std::string kcenon::monitoring::statsd_exporter::sanitize_metric_name ( const std::string & name ) const

inlineprivate

Definition at line 762 of file metric_exporters.h.

                                                                {
        std::string sanitized = name;
        // Replace dots and spaces with underscores for StatsD
        std::regex invalid_chars("[.\\s]+");
        sanitized = std::regex_replace(sanitized, invalid_chars, "_");
        return sanitized;
    }

Referenced by convert_monitoring_data(), and convert_snapshot().

Here is the caller graph for this function:

send_udp_batch()

common::VoidResult kcenon::monitoring::statsd_exporter::send_udp_batch ( const std::vector< std::string > & lines )

inlineprivate

Definition at line 731 of file metric_exporters.h.

                                                                       {
        if (!transport_) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::dependency_missing,
                "UDP transport not available",
                "statsd_exporter"
            ).to_common_error());
        }
 
        // Auto-connect if not already connected
        if (!transport_->is_connected()) {
            auto connect_result = transport_->connect(config_.endpoint, config_.port);
            if (connect_result.is_err()) {
                return connect_result;
            }
        }
 
        // Combine lines into a single packet (newline-separated)
        // StatsD typically accepts multiple metrics per packet
        std::string batch;
        for (const auto& line : lines) {
            if (!batch.empty()) {
                batch += '\n';
            }
            batch += line;
        }
 
        // Send the batch
        return transport_->send(batch);
    }

References config_, kcenon::monitoring::dependency_missing, kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::port, and transport_.

Referenced by export_metrics(), and export_snapshot().

Here is the caller graph for this function:

shutdown()

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

inlineoverridevirtual

Shutdown the exporter.

Implements kcenon::monitoring::metric_exporter_interface.

Definition at line 708 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::statsd_exporter::start ( )

inlineoverridevirtual

Start the exporter (for pull-based systems)

Reimplemented from kcenon::monitoring::metric_exporter_interface.

Definition at line 667 of file metric_exporters.h.

                                      {
        if (started_) {
            return common::ok();
        }
 
        if (!transport_) {
            return common::VoidResult::err(error_info(
                monitoring_error_code::dependency_missing,
                "UDP transport not available",
                "statsd_exporter"
            ).to_common_error());
        }
 
        // Connect to StatsD endpoint
        auto connect_result = transport_->connect(config_.endpoint, config_.port);
        if (connect_result.is_err()) {
            return connect_result;
        }
 
        started_ = true;
        return common::ok();
    }

References config_, kcenon::monitoring::dependency_missing, kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::port, started_, and transport_.

Referenced by TEST_F().

Here is the caller graph for this function:

stop()

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

inlineoverridevirtual

Stop the exporter.

Reimplemented from kcenon::monitoring::metric_exporter_interface.

Definition at line 690 of file metric_exporters.h.

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

References started_, and transport_.

Referenced by shutdown(), and TEST_F().

Here is the caller graph for this function:

Member Data Documentation

config_

metric_export_config kcenon::monitoring::statsd_exporter::config_

private

Definition at line 507 of file metric_exporters.h.

Referenced by convert_monitoring_data(), convert_snapshot(), export_metrics(), export_snapshot(), send_udp_batch(), and start().

exported_metrics_

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

private

Definition at line 509 of file metric_exporters.h.

{0};

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

failed_exports_

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

private

Definition at line 510 of file metric_exporters.h.

{0};

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

sent_packets_

std::atomic<std::size_t> kcenon::monitoring::statsd_exporter::sent_packets_ {0}

private

Definition at line 511 of file metric_exporters.h.

{0};

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

started_

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

private

Definition at line 512 of file metric_exporters.h.

{false};

Referenced by start(), and stop().

transport_

std::unique_ptr<udp_transport> kcenon::monitoring::statsd_exporter::transport_

private

Definition at line 508 of file metric_exporters.h.

Referenced by get_stats(), send_udp_batch(), start(), and stop().

---

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

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