test_metric_exporters.cpp File Reference

#include <gtest/gtest.h>
#include <kcenon/monitoring/exporters/metric_exporters.h>
#include <kcenon/monitoring/exporters/udp_transport.h>
#include <kcenon/monitoring/exporters/http_transport.h>
#include <kcenon/monitoring/exporters/grpc_transport.h>
#include <kcenon/monitoring/interfaces/monitorable_interface.h>
#include <kcenon/monitoring/interfaces/monitoring_core.h>
#include <kcenon/monitoring/exporters/opentelemetry_adapter.h>
#include <thread>
#include <chrono>

Include dependency graph for test_metric_exporters.cpp:

Go to the source code of this file.

Classes
class	MetricExportersTest

Functions
	TEST_F (MetricExportersTest, MetricExportConfigValidation)
	TEST_F (MetricExportersTest, PrometheusMetricConversion)
	TEST_F (MetricExportersTest, PrometheusTextFormat)
	TEST_F (MetricExportersTest, PrometheusExporterBasicFunctionality)
	TEST_F (MetricExportersTest, StatsDMetricConversion)
	TEST_F (MetricExportersTest, StatsDTextFormat)
	TEST_F (MetricExportersTest, StatsDExporterBasicFunctionality)
	TEST_F (MetricExportersTest, OtlpMetricsExporterBasicFunctionality)
	TEST_F (MetricExportersTest, MetricExporterFactory)
	TEST_F (MetricExportersTest, SupportedFormatsQuery)
	TEST_F (MetricExportersTest, HelperFunctions)
	TEST_F (MetricExportersTest, EmptyMetricsHandling)
	TEST_F (MetricExportersTest, LargeMetricBatch)
	TEST_F (MetricExportersTest, MetricNameSanitization)
	TEST_F (MetricExportersTest, MetricTypeInference)
	TEST (UdpTransportTest, StubTransportBasicFunctionality)
	TEST (UdpTransportTest, StubTransportSimulateFailure)
	TEST (UdpTransportTest, StubTransportStatisticsReset)
	TEST (UdpTransportTest, DefaultTransportCreation)
	TEST (GrpcTransportTest, StubTransportBasicFunctionality)
	TEST (GrpcTransportTest, StubTransportCustomResponseHandler)
	TEST (GrpcTransportTest, StubTransportSimulateFailure)
	TEST (GrpcTransportTest, DefaultTransportCreation)
	TEST_F (MetricExportersTest, StatsDExporterWithCustomTransport)
	TEST_F (MetricExportersTest, StatsDExporterTransportFailure)
	TEST_F (MetricExportersTest, OtlpExporterWithCustomHttpTransport)
	TEST (HttpTransportTest, SimpleHttpClientValidUrls)
	TEST (HttpTransportTest, SimpleHttpClientInvalidUrls)
	TEST (HttpTransportTest, SimpleHttpClientPortDefaults)
	TEST (HttpTransportTest, SimpleHttpClientNameAndAvailability)
	TEST (HttpTransportTest, StubHttpTransportIsAvailableAndName)
	TEST (GrpcTransportTest, StubTransportResetStatistics)
	TEST (GrpcTransportTest, StubTransportDisconnectedState)
	TEST (UdpTransportTest, StubTransportStringSendDelegation)
	TEST_F (MetricExportersTest, OtlpExporterWithCustomGrpcTransport)

Function Documentation

TEST() [1/16]

TEST	(	GrpcTransportTest	,
		DefaultTransportCreation	)

Definition at line 696 of file test_metric_exporters.cpp.

                                                  {
    auto transport = create_default_grpc_transport();
    ASSERT_TRUE(transport);
    EXPECT_TRUE(transport->is_available());
}

References kcenon::monitoring::create_default_grpc_transport().

Here is the call graph for this function:

TEST() [2/16]

TEST	(	GrpcTransportTest	,
		StubTransportBasicFunctionality	)

Definition at line 611 of file test_metric_exporters.cpp.

                                                         {
    auto transport = create_stub_grpc_transport();
    ASSERT_TRUE(transport);
    EXPECT_TRUE(transport->is_available());
    EXPECT_EQ(transport->name(), "stub");
    EXPECT_FALSE(transport->is_connected());
 
    // Test connection
    auto connect_result = transport->connect("localhost", 4317);
    EXPECT_TRUE(connect_result.is_ok());
    EXPECT_TRUE(transport->is_connected());
    EXPECT_EQ(transport->get_host(), "localhost");
    EXPECT_EQ(transport->get_port(), 4317);
 
    // Test send
    grpc_request request;
    request.service = "test.Service";
    request.method = "TestMethod";
    request.body = {0x01, 0x02, 0x03, 0x04};
    request.timeout = std::chrono::milliseconds(5000);
 
    auto send_result = transport->send(request);
    EXPECT_TRUE(send_result.is_ok());
 
    const auto& response = send_result.value();
    EXPECT_EQ(response.status_code, 0); // gRPC OK
    EXPECT_EQ(response.status_message, "OK");
 
    // Check statistics
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.requests_sent, 1);
    EXPECT_EQ(stats.bytes_sent, 4);
    EXPECT_EQ(stats.send_failures, 0);
 
    // Test disconnect
    transport->disconnect();
    EXPECT_FALSE(transport->is_connected());
}

References kcenon::monitoring::grpc_request::body, kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::grpc_request::method, kcenon::monitoring::grpc_request::service, and kcenon::monitoring::grpc_request::timeout.

Here is the call graph for this function:

TEST() [3/16]

TEST	(	GrpcTransportTest	,
		StubTransportCustomResponseHandler	)

Definition at line 650 of file test_metric_exporters.cpp.

                                                            {
    auto transport = create_stub_grpc_transport();
    transport->connect("localhost", 4317);
 
    // Set custom response handler
    transport->set_response_handler([](const grpc_request& req) {
        grpc_response response;
        response.status_code = 0;
        response.status_message = "Custom response for " + req.method;
        response.body = {0xAB, 0xCD};
        return response;
    });
 
    grpc_request request;
    request.method = "CustomMethod";
    request.body = {0x01};
 
    auto result = transport->send(request);
    EXPECT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().status_message, "Custom response for CustomMethod");
    EXPECT_EQ(result.value().body.size(), 2);
}

References kcenon::monitoring::grpc_request::body, kcenon::monitoring::grpc_response::body, kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::grpc_request::method, kcenon::monitoring::grpc_response::status_code, and kcenon::monitoring::grpc_response::status_message.

Here is the call graph for this function:

TEST() [4/16]

TEST	(	GrpcTransportTest	,
		StubTransportDisconnectedState	)

Definition at line 893 of file test_metric_exporters.cpp.

                                                        {
    auto transport = create_stub_grpc_transport();
    transport->connect("localhost", 4317);
    EXPECT_TRUE(transport->is_connected());
 
    transport->disconnect();
    EXPECT_FALSE(transport->is_connected());
 
    // Send should fail after disconnect
    grpc_request request;
    request.body = {0x01};
    auto result = transport->send(request);
    EXPECT_TRUE(result.is_err());
 
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.send_failures, 1);
}

References kcenon::monitoring::grpc_request::body, and kcenon::monitoring::create_stub_grpc_transport().

Here is the call graph for this function:

TEST() [5/16]

TEST	(	GrpcTransportTest	,
		StubTransportResetStatistics	)

Definition at line 873 of file test_metric_exporters.cpp.

                                                      {
    auto transport = create_stub_grpc_transport();
    transport->connect("localhost", 4317);
 
    grpc_request request;
    request.body = {0x01, 0x02, 0x03};
    transport->send(request);
    transport->send(request);
 
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.requests_sent, 2);
    EXPECT_EQ(stats.bytes_sent, 6);
 
    transport->reset_statistics();
    auto reset_stats = transport->get_statistics();
    EXPECT_EQ(reset_stats.requests_sent, 0);
    EXPECT_EQ(reset_stats.bytes_sent, 0);
    EXPECT_EQ(reset_stats.send_failures, 0);
}

References kcenon::monitoring::grpc_request::body, and kcenon::monitoring::create_stub_grpc_transport().

Here is the call graph for this function:

TEST() [6/16]

TEST	(	GrpcTransportTest	,
		StubTransportSimulateFailure	)

Definition at line 673 of file test_metric_exporters.cpp.

                                                      {
    auto transport = create_stub_grpc_transport();
    transport->set_simulate_success(false);
 
    // Connection should fail
    auto connect_result = transport->connect("localhost", 4317);
    EXPECT_TRUE(connect_result.is_err());
 
    // Re-enable and connect
    transport->set_simulate_success(true);
    transport->connect("localhost", 4317);
 
    // Simulate send failure
    transport->set_simulate_success(false);
    grpc_request request;
    request.body = {0x01};
    auto send_result = transport->send(request);
    EXPECT_TRUE(send_result.is_err());
 
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.send_failures, 1);
}

References kcenon::monitoring::grpc_request::body, and kcenon::monitoring::create_stub_grpc_transport().

Here is the call graph for this function:

TEST() [7/16]

TEST	(	HttpTransportTest	,
		SimpleHttpClientInvalidUrls	)

Definition at line 818 of file test_metric_exporters.cpp.

                                                     {
    simple_http_client client;
 
    // Missing scheme
    http_request req;
    req.url = "example.com/api";
    auto result = client.send(req);
    EXPECT_TRUE(result.is_err());
 
    // Empty host after scheme
    req.url = "http://";
    result = client.send(req);
    EXPECT_TRUE(result.is_err());
 
    // No URL at all
    req.url = "";
    result = client.send(req);
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::client, and kcenon::monitoring::http_request::url.

TEST() [8/16]

TEST	(	HttpTransportTest	,
		SimpleHttpClientNameAndAvailability	)

Definition at line 852 of file test_metric_exporters.cpp.

                                                             {
    simple_http_client client;
    EXPECT_EQ(client.name(), "stub");
    EXPECT_FALSE(client.is_available());
}

References kcenon::monitoring::client.

TEST() [9/16]

TEST	(	HttpTransportTest	,
		SimpleHttpClientPortDefaults	)

Definition at line 838 of file test_metric_exporters.cpp.

                                                      {
    simple_http_client client;
 
    // Stub transport returns error (no real HTTP client) — URL parsing still works
    http_request req;
    req.url = "http://example.com/path";
    auto result = client.send(req);
    EXPECT_TRUE(result.is_err());
 
    req.url = "https://example.com/path";
    result = client.send(req);
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::client, and kcenon::monitoring::http_request::url.

TEST() [10/16]

TEST	(	HttpTransportTest	,
		SimpleHttpClientValidUrls	)

Definition at line 796 of file test_metric_exporters.cpp.

                                                   {
    simple_http_client client;
 
    // Stub transport returns error for all valid URLs (no real HTTP client)
    http_request req;
    req.url = "http://example.com/api/v1/traces";
    auto result = client.send(req);
    EXPECT_TRUE(result.is_err());
 
    req.url = "https://collector.example.com:4318/v1/metrics";
    result = client.send(req);
    EXPECT_TRUE(result.is_err());
 
    req.url = "http://localhost:9090";
    result = client.send(req);
    EXPECT_TRUE(result.is_err());
 
    req.url = "http://prometheus";
    result = client.send(req);
    EXPECT_TRUE(result.is_err());
}

References kcenon::monitoring::client, and kcenon::monitoring::http_request::url.

TEST() [11/16]

TEST	(	HttpTransportTest	,
		StubHttpTransportIsAvailableAndName	)

Definition at line 862 of file test_metric_exporters.cpp.

                                                             {
    auto transport = create_stub_transport();
    ASSERT_TRUE(transport);
    EXPECT_TRUE(transport->is_available());
    EXPECT_EQ(transport->name(), "stub");
}

References kcenon::monitoring::create_stub_transport().

Here is the call graph for this function:

TEST() [12/16]

TEST	(	UdpTransportTest	,
		DefaultTransportCreation	)

Definition at line 600 of file test_metric_exporters.cpp.

                                                 {
    auto transport = create_default_udp_transport();
    ASSERT_TRUE(transport);
    EXPECT_TRUE(transport->is_available());
    // Default transport should work (either stub or network)
}

References kcenon::monitoring::create_default_udp_transport().

Here is the call graph for this function:

TEST() [13/16]

TEST	(	UdpTransportTest	,
		StubTransportBasicFunctionality	)

Definition at line 525 of file test_metric_exporters.cpp.

                                                        {
    auto transport = create_stub_udp_transport();
    ASSERT_TRUE(transport);
    EXPECT_TRUE(transport->is_available());
    EXPECT_EQ(transport->name(), "stub");
    EXPECT_FALSE(transport->is_connected());
 
    // Test connection
    auto connect_result = transport->connect("localhost", 8125);
    EXPECT_TRUE(connect_result.is_ok());
    EXPECT_TRUE(transport->is_connected());
    EXPECT_EQ(transport->get_host(), "localhost");
    EXPECT_EQ(transport->get_port(), 8125);
 
    // Test send
    std::string metric = "test_metric:100|c";
    auto send_result = transport->send(metric);
    EXPECT_TRUE(send_result.is_ok());
 
    // Check statistics
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.packets_sent, 1);
    EXPECT_EQ(stats.bytes_sent, metric.size());
    EXPECT_EQ(stats.send_failures, 0);
 
    // Test disconnect
    transport->disconnect();
    EXPECT_FALSE(transport->is_connected());
 
    // Send should fail after disconnect
    auto fail_result = transport->send(metric);
    EXPECT_TRUE(fail_result.is_err());
 
    auto stats_after = transport->get_statistics();
    EXPECT_EQ(stats_after.send_failures, 1);
}

References kcenon::monitoring::create_stub_udp_transport().

Here is the call graph for this function:

TEST() [14/16]

TEST	(	UdpTransportTest	,
		StubTransportSimulateFailure	)

Definition at line 562 of file test_metric_exporters.cpp.

                                                     {
    auto transport = create_stub_udp_transport();
    transport->set_simulate_success(false);
 
    // Connection should fail
    auto connect_result = transport->connect("localhost", 8125);
    EXPECT_TRUE(connect_result.is_err());
    EXPECT_FALSE(transport->is_connected());
 
    // Re-enable success and connect
    transport->set_simulate_success(true);
    auto retry_result = transport->connect("localhost", 8125);
    EXPECT_TRUE(retry_result.is_ok());
 
    // Now simulate send failure
    transport->set_simulate_success(false);
    auto send_result = transport->send("test:1|c");
    EXPECT_TRUE(send_result.is_err());
}

References kcenon::monitoring::create_stub_udp_transport().

Here is the call graph for this function:

TEST() [15/16]

TEST	(	UdpTransportTest	,
		StubTransportStatisticsReset	)

Definition at line 582 of file test_metric_exporters.cpp.

                                                     {
    auto transport = create_stub_udp_transport();
    transport->connect("localhost", 8125);
    transport->send("metric1:1|c");
    transport->send("metric2:2|c");
    transport->send("metric3:3|c");
 
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.packets_sent, 3);
    EXPECT_GT(stats.bytes_sent, 0);
 
    transport->reset_statistics();
    auto reset_stats = transport->get_statistics();
    EXPECT_EQ(reset_stats.packets_sent, 0);
    EXPECT_EQ(reset_stats.bytes_sent, 0);
    EXPECT_EQ(reset_stats.send_failures, 0);
}

References kcenon::monitoring::create_stub_udp_transport().

Here is the call graph for this function:

TEST() [16/16]

TEST	(	UdpTransportTest	,
		StubTransportStringSendDelegation	)

Definition at line 915 of file test_metric_exporters.cpp.

                                                          {
    auto transport = create_stub_udp_transport();
    transport->connect("localhost", 8125);
 
    // Send using the string overload (inherited from udp_transport base class)
    std::string metric_line = "test.metric:42|g";
    auto result = transport->send(metric_line);
    EXPECT_TRUE(result.is_ok());
 
    auto stats = transport->get_statistics();
    EXPECT_EQ(stats.packets_sent, 1);
    EXPECT_EQ(stats.bytes_sent, metric_line.size());
}

References kcenon::monitoring::create_stub_udp_transport().

Here is the call graph for this function:

TEST_F() [1/19]

TEST_F	(	MetricExportersTest	,
		EmptyMetricsHandling	)

Definition at line 414 of file test_metric_exporters.cpp.

                                                  {
    std::vector<monitoring_data> empty_data;
    metrics_snapshot empty_snapshot;
    
    metric_export_config config;
    config.endpoint = "http://test:1234";
    config.format = metric_export_format::prometheus_text;
    
    prometheus_exporter exporter(config);
    
    auto data_result = exporter.export_metrics(empty_data);
    EXPECT_TRUE(data_result.is_ok());
    
    auto snapshot_result = exporter.export_snapshot(empty_snapshot);
    EXPECT_TRUE(snapshot_result.is_ok());
    
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_metrics"], 1); // Empty snapshot counts as 1
    EXPECT_EQ(stats["failed_exports"], 0);
}

References kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::prometheus_exporter::export_metrics(), kcenon::monitoring::prometheus_exporter::export_snapshot(), kcenon::monitoring::metric_export_config::format, and kcenon::monitoring::prometheus_exporter::get_stats().

Here is the call graph for this function:

TEST_F() [2/19]

TEST_F	(	MetricExportersTest	,
		HelperFunctions	)

Definition at line 399 of file test_metric_exporters.cpp.

                                             {
    // Test Prometheus helper
    auto prometheus_exporter = create_prometheus_exporter(9090, "test_job");
    EXPECT_TRUE(prometheus_exporter);
    
    // Test StatsD helper
    auto statsd_exporter = create_statsd_exporter("localhost", 8125, true);
    EXPECT_TRUE(statsd_exporter);
    
    // Test OTLP helper
    auto otlp_exporter = create_otlp_metrics_exporter("http://otlp:4317", otel_resource_, 
                                                     metric_export_format::otlp_http_json);
    EXPECT_TRUE(otlp_exporter);
}

References kcenon::monitoring::create_otlp_metrics_exporter(), kcenon::monitoring::create_prometheus_exporter(), and kcenon::monitoring::create_statsd_exporter().

Here is the call graph for this function:

TEST_F() [3/19]

TEST_F	(	MetricExportersTest	,
		LargeMetricBatch	)

Definition at line 435 of file test_metric_exporters.cpp.

                                              {
    // Create a large batch of monitoring data
    std::vector<monitoring_data> large_batch;
    for (int i = 0; i < 100; ++i) {
        monitoring_data data("service_" + std::to_string(i));
        data.add_metric("requests_total", i * 10.0);
        data.add_metric("response_time", i * 0.1);
        data.add_tag("instance", std::to_string(i));
        large_batch.push_back(data);
    }
    
    metric_export_config config;
    config.endpoint = "http://test:1234";
    config.format = metric_export_format::statsd_plain;
    config.max_batch_size = 50; // Smaller than batch size
    
    statsd_exporter exporter(config);
    auto result = exporter.export_metrics(large_batch);
    EXPECT_TRUE(result.is_ok());
    
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_metrics"], 100);
}

References kcenon::monitoring::monitoring_data::add_metric(), kcenon::monitoring::monitoring_data::add_tag(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::statsd_exporter::export_metrics(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::statsd_exporter::get_stats(), and kcenon::monitoring::metric_export_config::max_batch_size.

Here is the call graph for this function:

TEST_F() [4/19]

TEST_F	(	MetricExportersTest	,
		MetricExportConfigValidation	)

Definition at line 72 of file test_metric_exporters.cpp.

                                                          {
    // Valid configuration
    metric_export_config valid_config;
    valid_config.endpoint = "http://prometheus:9090";
    valid_config.format = metric_export_format::prometheus_text;
    valid_config.push_interval = std::chrono::milliseconds(15000);
    valid_config.max_batch_size = 1000;
    valid_config.max_queue_size = 10000;
    
    auto validation = valid_config.validate();
    EXPECT_TRUE(validation.is_ok());
 
    // Valid configuration with port
    metric_export_config port_config;
    port_config.port = 8125;
    port_config.format = metric_export_format::statsd_plain;
    auto port_validation = port_config.validate();
    EXPECT_TRUE(port_validation.is_ok());
 
    // Invalid configuration (no endpoint or port)
    metric_export_config invalid_config;
    invalid_config.format = metric_export_format::prometheus_text;
    auto invalid_validation = invalid_config.validate();
    EXPECT_TRUE(invalid_validation.is_err());
 
    // Invalid push interval
    metric_export_config invalid_interval;
    invalid_interval.endpoint = "http://test";
    invalid_interval.push_interval = std::chrono::milliseconds(0);
    auto interval_validation = invalid_interval.validate();
    EXPECT_TRUE(interval_validation.is_err());
    
    // Invalid batch size
    metric_export_config invalid_batch;
    invalid_batch.endpoint = "http://test";
    invalid_batch.max_batch_size = 0;
    auto batch_validation = invalid_batch.validate();
    EXPECT_FALSE(batch_validation.is_ok());
 
    // Invalid queue size
    metric_export_config invalid_queue;
    invalid_queue.endpoint = "http://test";
    invalid_queue.max_batch_size = 1000;
    invalid_queue.max_queue_size = 500;
    auto queue_validation = invalid_queue.validate();
    EXPECT_FALSE(queue_validation.is_ok());
}

References kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::invalid_interval, kcenon::monitoring::metric_export_config::max_batch_size, kcenon::monitoring::metric_export_config::max_queue_size, kcenon::monitoring::metric_export_config::port, kcenon::monitoring::metric_export_config::push_interval, and kcenon::monitoring::metric_export_config::validate().

Here is the call graph for this function:

TEST_F() [5/19]

TEST_F	(	MetricExportersTest	,
		MetricExporterFactory	)

Definition at line 340 of file test_metric_exporters.cpp.

                                                   {
    // Test Prometheus factory
    metric_export_config prometheus_config;
    prometheus_config.endpoint = "http://prometheus:9090";
    prometheus_config.format = metric_export_format::prometheus_text;
    
    auto prometheus_exporter = metric_exporter_factory::create_exporter(prometheus_config, otel_resource_);
    EXPECT_TRUE(prometheus_exporter);
    
    // Test StatsD factory
    metric_export_config statsd_config;
    statsd_config.endpoint = "statsd.example.com";
    statsd_config.port = 8125;
    statsd_config.format = metric_export_format::statsd_datadog;
    
    auto statsd_exporter = metric_exporter_factory::create_exporter(statsd_config, otel_resource_);
    EXPECT_TRUE(statsd_exporter);
    
    // Test OTLP factory
    metric_export_config otlp_config;
    otlp_config.endpoint = "http://otlp-collector:4317";
    otlp_config.format = metric_export_format::otlp_http_json;
    
    auto otlp_exporter = metric_exporter_factory::create_exporter(otlp_config, otel_resource_);
    EXPECT_TRUE(otlp_exporter);
    
    // Test invalid format
    metric_export_config invalid_config;
    invalid_config.endpoint = "http://test";
    invalid_config.format = static_cast<metric_export_format>(999);
    
    auto invalid_exporter = metric_exporter_factory::create_exporter(invalid_config, otel_resource_);
    EXPECT_FALSE(invalid_exporter);
}

References kcenon::monitoring::metric_exporter_factory::create_exporter(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, and kcenon::monitoring::metric_export_config::port.

Here is the call graph for this function:

TEST_F() [6/19]

TEST_F	(	MetricExportersTest	,
		MetricNameSanitization	)

Definition at line 459 of file test_metric_exporters.cpp.

                                                    {
    metric_export_config config;
    config.endpoint = "http://prometheus:9090";
    config.format = metric_export_format::prometheus_text;
    
    prometheus_exporter exporter(config);
    
    // Create data with problematic metric names
    monitoring_data data("test_component");
    data.add_metric("http.requests-total", 100.0);  // Contains dots and dashes
    data.add_metric("123_invalid_start", 50.0);     // Starts with number
    data.add_metric("special@chars#metric", 75.0);   // Contains special characters
    
    auto prom_metrics = exporter.convert_monitoring_data(data);
    EXPECT_EQ(prom_metrics.size(), 3);
    
    // Check sanitized names exist
    std::vector<std::string> expected_names = {"http_requests_total", "_123_invalid_start", "special_chars_metric"};
    std::vector<std::string> actual_names;
    for (const auto& metric : prom_metrics) {
        actual_names.push_back(metric.name);
    }
    
    for (const auto& expected_name : expected_names) {
        EXPECT_NE(std::find(actual_names.begin(), actual_names.end(), expected_name), actual_names.end()) 
            << "Expected metric name '" << expected_name << "' not found";
    }
}

References kcenon::monitoring::monitoring_data::add_metric(), kcenon::monitoring::prometheus_exporter::convert_monitoring_data(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, and kcenon::monitoring::metric::name.

Here is the call graph for this function:

TEST_F() [7/19]

TEST_F	(	MetricExportersTest	,
		MetricTypeInference	)

Definition at line 488 of file test_metric_exporters.cpp.

                                                 {
    metric_export_config config;
    config.endpoint = "statsd.example.com";
    config.port = 8125;
    config.format = metric_export_format::statsd_plain;
    
    statsd_exporter exporter(config);
    
    monitoring_data data("test_service");
    data.add_metric("requests_count", 100.0);       // Should be counter
    data.add_metric("requests_total", 200.0);       // Should be counter
    data.add_metric("response_time_ms", 250.0);     // Should be timer
    data.add_metric("request_duration", 0.5);       // Should be timer
    data.add_metric("cpu_usage", 75.5);             // Should be gauge
    data.add_metric("memory_available", 1024.0);    // Should be gauge
    
    auto statsd_metrics = exporter.convert_monitoring_data(data);
    
    // Check inferred types by finding specific metrics
    auto find_metric = [&](const std::string& name) -> const statsd_metric_data* {
        auto it = std::find_if(statsd_metrics.begin(), statsd_metrics.end(),
            [&name](const statsd_metric_data& m) { return m.name == name; });
        return (it != statsd_metrics.end()) ? &(*it) : nullptr;
    };
    
    EXPECT_EQ(find_metric("requests_count")->type, metric_type::counter);
    EXPECT_EQ(find_metric("requests_total")->type, metric_type::counter);
    EXPECT_EQ(find_metric("response_time_ms")->type, metric_type::timer);
    EXPECT_EQ(find_metric("request_duration")->type, metric_type::timer);
    EXPECT_EQ(find_metric("cpu_usage")->type, metric_type::gauge);
    EXPECT_EQ(find_metric("memory_available")->type, metric_type::gauge);
}

References kcenon::monitoring::monitoring_data::add_metric(), kcenon::monitoring::statsd_exporter::convert_monitoring_data(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, and kcenon::monitoring::metric_export_config::port.

Here is the call graph for this function:

TEST_F() [8/19]

TEST_F	(	MetricExportersTest	,
		OtlpExporterWithCustomGrpcTransport	)

Definition at line 933 of file test_metric_exporters.cpp.

                                                                 {
    auto stub_http = create_stub_transport();
    auto stub_grpc = create_stub_grpc_transport();
    auto* grpc_ptr = stub_grpc.get();
 
    metric_export_config config;
    config.endpoint = "otlp-collector";
    config.port = 4317;
    config.format = metric_export_format::otlp_grpc;
 
    otlp_metrics_exporter exporter(config, otel_resource_,
                                   std::move(stub_http), std::move(stub_grpc));
 
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_ok());
 
    // Check gRPC transport was used
    auto transport_stats = grpc_ptr->get_statistics();
    EXPECT_GT(transport_stats.requests_sent, 0);
 
    auto stats = exporter.get_stats();
    EXPECT_GT(stats["transport_requests_sent"], 0);
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::create_stub_transport(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::otlp_metrics_exporter::export_metrics(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::otlp_metrics_exporter::get_stats(), and kcenon::monitoring::metric_export_config::port.

Here is the call graph for this function:

TEST_F() [9/19]

TEST_F	(	MetricExportersTest	,
		OtlpExporterWithCustomHttpTransport	)

Definition at line 765 of file test_metric_exporters.cpp.

                                                                 {
    auto stub_http = create_stub_transport();
    auto stub_grpc = create_stub_grpc_transport();
 
    metric_export_config config;
    config.endpoint = "http://otlp-collector";
    config.port = 4318;
    config.format = metric_export_format::otlp_http_json;
 
    otlp_metrics_exporter exporter(config, otel_resource_,
                                   std::move(stub_http), std::move(stub_grpc));
 
    // Start and export
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_ok());
 
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_ok());
 
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_metrics"], 1);
 
    auto stop_result = exporter.stop();
    EXPECT_TRUE(stop_result.is_ok());
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::create_stub_transport(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::otlp_metrics_exporter::export_metrics(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::otlp_metrics_exporter::get_stats(), kcenon::monitoring::metric_export_config::port, kcenon::monitoring::otlp_metrics_exporter::start(), and kcenon::monitoring::otlp_metrics_exporter::stop().

Here is the call graph for this function:

TEST_F() [10/19]

TEST_F	(	MetricExportersTest	,
		OtlpMetricsExporterBasicFunctionality	)

Definition at line 311 of file test_metric_exporters.cpp.

                                                                   {
    metric_export_config config;
    config.endpoint = "http://otlp-collector:4317";
    config.format = metric_export_format::otlp_grpc;
    
    otlp_metrics_exporter exporter(config, otel_resource_);
    
    // Export monitoring data
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_ok());
    
    // Export snapshot
    auto snapshot_result = exporter.export_snapshot(test_snapshot_);
    EXPECT_TRUE(snapshot_result.is_ok());
    
    // Check statistics
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_metrics"], 2); // 1 data + 1 snapshot
    EXPECT_EQ(stats["failed_exports"], 0);
    
    // Test flush and shutdown
    auto flush_result = exporter.flush();
    EXPECT_TRUE(flush_result.is_ok());
    
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
}

References kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::otlp_metrics_exporter::export_metrics(), kcenon::monitoring::otlp_metrics_exporter::export_snapshot(), kcenon::monitoring::otlp_metrics_exporter::flush(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::otlp_metrics_exporter::get_stats(), and kcenon::monitoring::otlp_metrics_exporter::shutdown().

Here is the call graph for this function:

TEST_F() [11/19]

TEST_F	(	MetricExportersTest	,
		PrometheusExporterBasicFunctionality	)

Definition at line 181 of file test_metric_exporters.cpp.

                                                                  {
    metric_export_config config;
    config.endpoint = "http://prometheus:9090";
    config.format = metric_export_format::prometheus_text;
    
    prometheus_exporter exporter(config);
    
    // Export monitoring data
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_ok());
    
    // Export snapshot
    auto snapshot_result = exporter.export_snapshot(test_snapshot_);
    EXPECT_TRUE(snapshot_result.is_ok());
    
    // Get metrics text
    std::string metrics_text = exporter.get_metrics_text();
    EXPECT_FALSE(metrics_text.empty());
    EXPECT_NE(metrics_text.find("http_requests_total"), std::string::npos);
    EXPECT_NE(metrics_text.find("system_load_1m"), std::string::npos);
    
    // Check statistics
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_metrics"], 2); // 1 data + 1 snapshot
    EXPECT_EQ(stats["failed_exports"], 0);
    EXPECT_EQ(stats["scrape_requests"], 1); // Called get_metrics_text once
    
    // Test flush and shutdown
    auto flush_result = exporter.flush();
    EXPECT_TRUE(flush_result.is_ok());
    
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
}

References kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::prometheus_exporter::export_metrics(), kcenon::monitoring::prometheus_exporter::export_snapshot(), kcenon::monitoring::prometheus_exporter::flush(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::prometheus_exporter::get_metrics_text(), kcenon::monitoring::prometheus_exporter::get_stats(), and kcenon::monitoring::prometheus_exporter::shutdown().

Here is the call graph for this function:

TEST_F() [12/19]

TEST_F	(	MetricExportersTest	,
		PrometheusMetricConversion	)

Definition at line 120 of file test_metric_exporters.cpp.

                                                        {
    metric_export_config config;
    config.endpoint = "http://prometheus:9090";
    config.format = metric_export_format::prometheus_text;
    config.instance_id = "test_instance";
    config.labels["datacenter"] = "dc1";
    
    prometheus_exporter exporter(config);
    
    // Test monitoring_data conversion
    auto prom_metrics = exporter.convert_monitoring_data(test_data_);
    EXPECT_EQ(prom_metrics.size(), 4); // 4 metrics in test data
    
    // Find http_requests_total metric
    auto it = std::find_if(prom_metrics.begin(), prom_metrics.end(),
        [](const prometheus_metric_data& m) { return m.name == "http_requests_total"; });
    ASSERT_NE(it, prom_metrics.end());
    
    const auto& requests_metric = *it;
    EXPECT_EQ(requests_metric.name, "http_requests_total");
    EXPECT_EQ(requests_metric.type, metric_type::counter);
    EXPECT_EQ(requests_metric.value, 1500.0);
    EXPECT_EQ(requests_metric.labels.at("component"), "web_server");
    EXPECT_EQ(requests_metric.labels.at("environment"), "production");
    EXPECT_EQ(requests_metric.labels.at("datacenter"), "dc1");
    EXPECT_EQ(requests_metric.labels.at("instance"), "test_instance");
    
    // Test snapshot conversion
    auto snapshot_metrics = exporter.convert_snapshot(test_snapshot_);
    EXPECT_EQ(snapshot_metrics.size(), 5); // 5 metrics in test snapshot
    
    // Check snapshot metric
    const auto& load_metric = snapshot_metrics[0];
    EXPECT_EQ(load_metric.name, "system_load_1m");
    EXPECT_EQ(load_metric.type, metric_type::gauge);
    EXPECT_EQ(load_metric.value, 2.1);
    EXPECT_EQ(load_metric.labels.at("source"), "system_monitor");
    EXPECT_EQ(load_metric.labels.at("host"), "server01");
}

References kcenon::monitoring::prometheus_exporter::convert_monitoring_data(), kcenon::monitoring::prometheus_exporter::convert_snapshot(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::metric_export_config::instance_id, and kcenon::monitoring::metric_export_config::labels.

Here is the call graph for this function:

TEST_F() [13/19]

TEST_F	(	MetricExportersTest	,
		PrometheusTextFormat	)

Definition at line 160 of file test_metric_exporters.cpp.

                                                  {
    prometheus_metric_data metric;
    metric.name = "http_requests_total";
    metric.type = metric_type::counter;
    metric.value = 1500.0;
    metric.help_text = "Total number of HTTP requests";
    metric.labels["method"] = "GET";
    metric.labels["status"] = "200";
    metric.timestamp = std::chrono::system_clock::from_time_t(1640995200); // Fixed timestamp: 2022-01-01 00:00:00 UTC
    
    std::string prometheus_text = metric.to_prometheus_text();
    
    // Check format components
    EXPECT_NE(prometheus_text.find("# HELP http_requests_total Total number of HTTP requests"), std::string::npos);
    EXPECT_NE(prometheus_text.find("# TYPE http_requests_total counter"), std::string::npos);
    EXPECT_NE(prometheus_text.find("http_requests_total{"), std::string::npos);
    EXPECT_NE(prometheus_text.find("method=\"GET\""), std::string::npos);
    EXPECT_NE(prometheus_text.find("status=\"200\""), std::string::npos);
    EXPECT_NE(prometheus_text.find("} 1500"), std::string::npos);
}

References kcenon::monitoring::metric::name, kcenon::monitoring::prometheus_text, kcenon::monitoring::metric::timestamp, kcenon::monitoring::metric::type, and kcenon::monitoring::metric::value.

TEST_F() [14/19]

TEST_F	(	MetricExportersTest	,
		StatsDExporterBasicFunctionality	)

Definition at line 280 of file test_metric_exporters.cpp.

                                                              {
    metric_export_config config;
    config.endpoint = "statsd.example.com";
    config.port = 8125;
    config.format = metric_export_format::statsd_plain;
    
    statsd_exporter exporter(config);
    
    // Export monitoring data
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_ok());
    
    // Export snapshot
    auto snapshot_result = exporter.export_snapshot(test_snapshot_);
    EXPECT_TRUE(snapshot_result.is_ok());
    
    // Check statistics
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_metrics"], 2); // 1 data + 1 snapshot
    EXPECT_EQ(stats["failed_exports"], 0);
    EXPECT_EQ(stats["sent_packets"], 2); // 2 UDP packets sent
    
    // Test flush and shutdown
    auto flush_result = exporter.flush();
    EXPECT_TRUE(flush_result.is_ok());
    
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
}

References kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::statsd_exporter::export_metrics(), kcenon::monitoring::statsd_exporter::export_snapshot(), kcenon::monitoring::statsd_exporter::flush(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::statsd_exporter::get_stats(), kcenon::monitoring::metric_export_config::port, and kcenon::monitoring::statsd_exporter::shutdown().

Here is the call graph for this function:

TEST_F() [15/19]

TEST_F	(	MetricExportersTest	,
		StatsDExporterTransportFailure	)

Definition at line 741 of file test_metric_exporters.cpp.

                                                            {
    auto stub_transport = create_stub_udp_transport();
    stub_transport->set_simulate_success(false);
 
    metric_export_config config;
    config.endpoint = "statsd.example.com";
    config.port = 8125;
    config.format = metric_export_format::statsd_plain;
 
    statsd_exporter exporter(config, std::move(stub_transport));
 
    // Export should fail due to transport failure
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_err());
 
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["failed_exports"], 1);
}

References kcenon::monitoring::create_stub_udp_transport(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::statsd_exporter::export_metrics(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::statsd_exporter::get_stats(), and kcenon::monitoring::metric_export_config::port.

Here is the call graph for this function:

TEST_F() [16/19]

TEST_F	(	MetricExportersTest	,
		StatsDExporterWithCustomTransport	)

Definition at line 706 of file test_metric_exporters.cpp.

                                                               {
    auto stub_transport = create_stub_udp_transport();
    auto* transport_ptr = stub_transport.get();
 
    metric_export_config config;
    config.endpoint = "statsd.example.com";
    config.port = 8125;
    config.format = metric_export_format::statsd_datadog;
 
    statsd_exporter exporter(config, std::move(stub_transport));
 
    // Start the exporter
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_ok());
 
    // Export metrics
    std::vector<monitoring_data> data_batch = {test_data_};
    auto export_result = exporter.export_metrics(data_batch);
    EXPECT_TRUE(export_result.is_ok());
 
    // Check transport was used
    auto transport_stats = transport_ptr->get_statistics();
    EXPECT_GT(transport_stats.packets_sent, 0);
    EXPECT_GT(transport_stats.bytes_sent, 0);
 
    // Get exporter stats (includes transport stats)
    auto stats = exporter.get_stats();
    EXPECT_GT(stats["transport_packets_sent"], 0);
    EXPECT_GT(stats["transport_bytes_sent"], 0);
 
    // Stop the exporter
    auto stop_result = exporter.stop();
    EXPECT_TRUE(stop_result.is_ok());
}

References kcenon::monitoring::create_stub_udp_transport(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::statsd_exporter::export_metrics(), kcenon::monitoring::metric_export_config::format, kcenon::monitoring::statsd_exporter::get_stats(), kcenon::monitoring::metric_export_config::port, kcenon::monitoring::statsd_exporter::start(), and kcenon::monitoring::statsd_exporter::stop().

Here is the call graph for this function:

TEST_F() [17/19]

TEST_F	(	MetricExportersTest	,
		StatsDMetricConversion	)

Definition at line 217 of file test_metric_exporters.cpp.

                                                    {
    metric_export_config config;
    config.endpoint = "statsd.example.com";
    config.port = 8125;
    config.format = metric_export_format::statsd_datadog;
    config.instance_id = "test_instance";
    config.labels["datacenter"] = "dc1";
    
    statsd_exporter exporter(config);
    
    // Test monitoring_data conversion
    auto statsd_metrics = exporter.convert_monitoring_data(test_data_);
    EXPECT_EQ(statsd_metrics.size(), 4); // 4 metrics in test data
    
    // Find http_requests_total metric
    auto it = std::find_if(statsd_metrics.begin(), statsd_metrics.end(),
        [](const statsd_metric_data& m) { return m.name == "http_requests_total"; });
    ASSERT_NE(it, statsd_metrics.end());
    
    const auto& requests_metric = *it;
    EXPECT_EQ(requests_metric.name, "http_requests_total");
    EXPECT_EQ(requests_metric.type, metric_type::counter);
    EXPECT_EQ(requests_metric.value, 1500.0);
    EXPECT_EQ(requests_metric.sample_rate, 1.0);
    EXPECT_EQ(requests_metric.tags.at("component"), "web_server");
    EXPECT_EQ(requests_metric.tags.at("environment"), "production");
    EXPECT_EQ(requests_metric.tags.at("datacenter"), "dc1");
    
    // Test snapshot conversion
    auto snapshot_metrics = exporter.convert_snapshot(test_snapshot_);
    EXPECT_EQ(snapshot_metrics.size(), 5); // 5 metrics in test snapshot
}

References kcenon::monitoring::statsd_exporter::convert_monitoring_data(), kcenon::monitoring::statsd_exporter::convert_snapshot(), kcenon::monitoring::metric_export_config::endpoint, kcenon::monitoring::metric_export_config::format, kcenon::monitoring::metric_export_config::instance_id, kcenon::monitoring::metric_export_config::labels, and kcenon::monitoring::metric_export_config::port.

Here is the call graph for this function:

TEST_F() [18/19]

TEST_F	(	MetricExportersTest	,
		StatsDTextFormat	)

Definition at line 250 of file test_metric_exporters.cpp.

                                              {
    statsd_metric_data counter_metric;
    counter_metric.name = "http_requests_total";
    counter_metric.type = metric_type::counter;
    counter_metric.value = 1500.0;
    counter_metric.sample_rate = 1.0;
    counter_metric.tags["method"] = "GET";
    counter_metric.tags["status"] = "200";
    
    // Test plain StatsD format
    std::string plain_statsd = counter_metric.to_statsd_format(false);
    EXPECT_EQ(plain_statsd, "http_requests_total:1500|c");
    
    // Test DataDog format with tags
    std::string datadog_statsd = counter_metric.to_statsd_format(true);
    EXPECT_NE(datadog_statsd.find("http_requests_total:1500|c|#"), std::string::npos);
    EXPECT_NE(datadog_statsd.find("method:GET"), std::string::npos);
    EXPECT_NE(datadog_statsd.find("status:200"), std::string::npos);
    
    // Test timer metric
    statsd_metric_data timer_metric;
    timer_metric.name = "request_duration";
    timer_metric.type = metric_type::timer;
    timer_metric.value = 250.0;
    timer_metric.sample_rate = 0.1;
    
    std::string timer_statsd = timer_metric.to_statsd_format(false);
    EXPECT_EQ(timer_statsd, "request_duration:250|ms|@0.1");
}

References kcenon::monitoring::statsd_metric_data::name, kcenon::monitoring::statsd_metric_data::sample_rate, kcenon::monitoring::statsd_metric_data::tags, kcenon::monitoring::statsd_metric_data::to_statsd_format(), kcenon::monitoring::statsd_metric_data::type, and kcenon::monitoring::statsd_metric_data::value.

Here is the call graph for this function:

TEST_F() [19/19]

TEST_F	(	MetricExportersTest	,
		SupportedFormatsQuery	)

Definition at line 375 of file test_metric_exporters.cpp.

                                                   {
    auto prometheus_formats = metric_exporter_factory::get_supported_formats("prometheus");
    EXPECT_EQ(prometheus_formats.size(), 2);
    EXPECT_TRUE(std::find(prometheus_formats.begin(), prometheus_formats.end(), 
                         metric_export_format::prometheus_text) != prometheus_formats.end());
    EXPECT_TRUE(std::find(prometheus_formats.begin(), prometheus_formats.end(), 
                         metric_export_format::prometheus_protobuf) != prometheus_formats.end());
    
    auto statsd_formats = metric_exporter_factory::get_supported_formats("statsd");
    EXPECT_EQ(statsd_formats.size(), 2);
    EXPECT_TRUE(std::find(statsd_formats.begin(), statsd_formats.end(), 
                         metric_export_format::statsd_plain) != statsd_formats.end());
    EXPECT_TRUE(std::find(statsd_formats.begin(), statsd_formats.end(), 
                         metric_export_format::statsd_datadog) != statsd_formats.end());
    
    auto otlp_formats = metric_exporter_factory::get_supported_formats("otlp");
    EXPECT_EQ(otlp_formats.size(), 3);
    EXPECT_TRUE(std::find(otlp_formats.begin(), otlp_formats.end(), 
                         metric_export_format::otlp_grpc) != otlp_formats.end());
    
    auto unknown_formats = metric_exporter_factory::get_supported_formats("unknown");
    EXPECT_EQ(unknown_formats.size(), 0);
}

References kcenon::monitoring::metric_exporter_factory::get_supported_formats().

Here is the call graph for this function: