kcenon::logger::network_writer Class Reference

Sends logs over network (TCP/UDP) More...

#include <network_writer.h>

Inheritance diagram for kcenon::logger::network_writer:

Collaboration diagram for kcenon::logger::network_writer:

Classes
struct	connection_stats
	Get connection statistics. More...

Public Types
enum class	protocol_type { tcp , udp }

Public Member Functions
	network_writer (const std::string &host, uint16_t port, protocol_type protocol=protocol_type::tcp, size_t buffer_size=8192, std::chrono::seconds reconnect_interval=std::chrono::seconds(5))
	Constructor.
	~network_writer () override
	Destructor.
common::VoidResult	write (const log_entry &entry) override
	Write log entry.
common::VoidResult	flush () override
	Flush pending logs.
std::string	get_name () const override
	Get writer name.
bool	is_connected () const
	Check if connected.
connection_stats	get_stats () const
void	set_integrity_policy (std::shared_ptr< security::integrity_policy > policy)
	Enable tamper-evident integrity signing for outbound frames.
Public Member Functions inherited from kcenon::logger::base_writer
	base_writer (std::unique_ptr< log_formatter_interface > formatter=nullptr)
	Constructor with optional formatter.
virtual	~base_writer ()=default
virtual void	set_use_color (bool use_color)
	Set whether to use color output (if supported)
bool	use_color () const
	Get current color output setting.
virtual bool	is_healthy () const override
	Check if the writer is healthy and operational.
log_formatter_interface *	get_formatter () const
	Get the current formatter.
Public Member Functions inherited from kcenon::logger::log_writer_interface
virtual	~log_writer_interface ()=default
virtual common::VoidResult	close ()
	Close the writer and release resources.
virtual auto	is_open () const -> bool
	Check if writer is open and ready.

Private Member Functions
bool	connect ()
void	disconnect ()
bool	send_data (const std::string &data)
void	process_buffer ()
void	attempt_reconnect ()
std::string	format_for_network (const log_entry &entry)
std::string	escape_json (const std::string &str) const

Private Attributes
std::string	host_
uint16_t	port_
protocol_type	protocol_
size_t	buffer_size_
std::chrono::seconds	reconnect_interval_
int	socket_fd_
std::atomic< bool >	connected_ {false}
std::atomic< bool >	running_ {false}
std::queue< log_entry >	buffer_
std::mutex	buffer_mutex_
std::condition_variable	buffer_cv_
std::unique_ptr< network_send_jthread_worker >	send_worker_
std::unique_ptr< network_reconnect_jthread_worker >	reconnect_worker_
std::mutex	stats_mutex_
connection_stats	stats_ {}
std::shared_ptr< security::integrity_policy >	integrity_policy_

Additional Inherited Members
Static Public Attributes inherited from kcenon::logger::async_writer_tag
static constexpr writer_category	category = writer_category::asynchronous
Protected Member Functions inherited from kcenon::logger::base_writer
std::string	format_log_entry (const log_entry &entry) const
	Format a log entry using the current formatter.

Detailed Description

Sends logs over network (TCP/UDP)

Category: Asynchronous (non-blocking network I/O with background threads)

Since

1.4.0 Added async_writer_tag for category classification

Definition at line 43 of file network_writer.h.

Member Enumeration Documentation

protocol_type

enum class kcenon::logger::network_writer::protocol_type

strong

Enumerator
tcp
udp

Definition at line 45 of file network_writer.h.

                             {
        tcp,
        udp
    };

Constructor & Destructor Documentation

network_writer()

kcenon::logger::network_writer::network_writer	(	const std::string &	host,
		uint16_t	port,
		protocol_type	protocol = protocol_type::tcp,
		size_t	buffer_size = 8192,
		std::chrono::seconds	reconnect_interval = std::chrono::seconds(5) )

Constructor.

Parameters

host	Remote host address
port	Remote port
protocol	Network protocol (TCP/UDP)
buffer_size	Internal buffer size
reconnect_interval	Reconnection interval in seconds

Definition at line 199 of file network_writer.cpp.

    : host_(host)
    , port_(port)
    , protocol_(protocol)
    , buffer_size_(buffer_size)
    , reconnect_interval_(reconnect_interval)
    , socket_fd_(-1) {
 
#ifdef _WIN32
    // Initialize Winsock
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        throw std::runtime_error("Failed to initialize Winsock");
    }
#endif
 
    running_ = true;
 
    // Create and start send worker
    send_worker_ = std::make_unique<network_send_jthread_worker>(
        [this] { process_buffer(); });
    send_worker_->start();
 
    // Create and start reconnect worker for TCP
    if (protocol_ == protocol_type::tcp) {
        reconnect_worker_ = std::make_unique<network_reconnect_jthread_worker>(
            [this] { attempt_reconnect(); }, reconnect_interval_);
        reconnect_worker_->start();
    }
 
    // Initial connection attempt
    connect();
}

References attempt_reconnect(), connect(), process_buffer(), protocol_, reconnect_interval_, reconnect_worker_, running_, send_worker_, and tcp.

Here is the call graph for this function:

~network_writer()

kcenon::logger::network_writer::~network_writer ( )

override

Destructor.

Definition at line 237 of file network_writer.cpp.

                                {
    running_ = false;
 
    // Stop workers with error handling
    // IMPORTANT: Reset workers after stop to join their threads before accessing any members
    utils::safe_destructor_operation("send_worker_stop", [this]() {
        if (send_worker_) {
            send_worker_->stop();
            send_worker_.reset();
        }
    });
 
    utils::safe_destructor_operation("reconnect_worker_stop", [this]() {
        if (reconnect_worker_) {
            reconnect_worker_->stop();
            reconnect_worker_.reset();
        }
    });
 
    // Disconnect with error handling
    utils::safe_destructor_operation("network_disconnect", [this]() {
        disconnect();
    });
 
#ifdef _WIN32
    // Cleanup Winsock with error handling
    utils::safe_destructor_operation("winsock_cleanup", []() {
        WSACleanup();
    });
#endif
}

References disconnect(), reconnect_worker_, running_, kcenon::logger::utils::safe_destructor_operation(), and send_worker_.

Here is the call graph for this function:

Member Function Documentation

attempt_reconnect()

void kcenon::logger::network_writer::attempt_reconnect ( )

private

Definition at line 436 of file network_writer.cpp.

                                       {
    if (!connected_ && running_) {
        connect();
    }
}

References connect(), connected_, and running_.

Referenced by network_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

connect()

bool kcenon::logger::network_writer::connect ( )

private

Definition at line 333 of file network_writer.cpp.

                             {
    if (connected_) {
        return true;
    }
 
    // Resolve hostname using getaddrinfo (thread-safe, IPv4/IPv6)
    int sock_type = (protocol_ == protocol_type::tcp) ? SOCK_STREAM : SOCK_DGRAM;
 
    struct addrinfo hints{}, *result = nullptr;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = sock_type;
 
    auto port_str = std::to_string(port_);
    int rv = getaddrinfo(host_.c_str(), port_str.c_str(), &hints, &result);
    if (rv != 0) {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        stats_.connection_failures++;
        stats_.last_error = std::chrono::system_clock::now();
        return false;
    }
 
    // Try each resolved address until one succeeds
    for (auto* rp = result; rp != nullptr; rp = rp->ai_next) {
        socket_fd_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (socket_fd_ < 0) {
            continue;
        }
 
        if (::connect(socket_fd_, rp->ai_addr, static_cast<socklen_t>(rp->ai_addrlen)) == 0) {
            freeaddrinfo(result);
            connected_ = true;
 
            std::lock_guard<std::mutex> lock(stats_mutex_);
            stats_.last_connected = std::chrono::system_clock::now();
            return true;
        }
 
        ::close(socket_fd_);
        socket_fd_ = -1;
    }
 
    freeaddrinfo(result);
 
    std::lock_guard<std::mutex> lock(stats_mutex_);
    stats_.connection_failures++;
    stats_.last_error = std::chrono::system_clock::now();
    return false;
}

References kcenon::logger::log_writer_interface::close(), connect(), connected_, kcenon::logger::network_writer::connection_stats::connection_failures, host_, kcenon::logger::network_writer::connection_stats::last_connected, kcenon::logger::network_writer::connection_stats::last_error, port_, protocol_, socket_fd_, stats_, stats_mutex_, and tcp.

Referenced by attempt_reconnect(), connect(), and network_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect()

void kcenon::logger::network_writer::disconnect ( )

private

Definition at line 382 of file network_writer.cpp.

                                {
    if (socket_fd_ >= 0) {
        ::close(socket_fd_);
        socket_fd_ = -1;
    }
    connected_ = false;
}

References kcenon::logger::log_writer_interface::close(), connected_, and socket_fd_.

Referenced by send_data(), and ~network_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

escape_json()

std::string kcenon::logger::network_writer::escape_json ( const std::string & str ) const

private

Definition at line 503 of file network_writer.cpp.

                                                                {
    std::string escaped;
    for (char c : str) {
        if (c == '"') escaped += "\\\"";
        else if (c == '\\') escaped += "\\\\";
        else if (c == '\n') escaped += "\\n";
        else if (c == '\r') escaped += "\\r";
        else if (c == '\t') escaped += "\\t";
        else escaped += c;
    }
    return escaped;
}

Referenced by format_for_network().

Here is the caller graph for this function:

flush()

common::VoidResult kcenon::logger::network_writer::flush ( )

overridevirtual

Flush pending logs.

Implements kcenon::logger::base_writer.

Definition at line 304 of file network_writer.cpp.

                                       {
    std::unique_lock<std::mutex> lock(buffer_mutex_);
    auto start = std::chrono::steady_clock::now();
    auto timeout = std::chrono::seconds(5); // 5 second timeout
 
    while (!buffer_.empty()) {
        if (buffer_cv_.wait_for(lock, timeout, [this] { return buffer_.empty() || !running_; })) {
            if (!buffer_.empty() && !running_) {
                return make_logger_void_result(logger_error_code::flush_timeout,
                                               "Network writer stopped before flush completed");
            }
        } else {
            return make_logger_void_result(logger_error_code::flush_timeout,
                                           "Network flush timeout");
        }
 
        if (std::chrono::steady_clock::now() - start > timeout) {
            return make_logger_void_result(logger_error_code::flush_timeout,
                                           "Network flush exceeded timeout");
        }
    }
    return common::ok();
}

References buffer_, buffer_cv_, buffer_mutex_, kcenon::logger::flush_timeout, kcenon::logger::make_logger_void_result(), kcenon::common::ok(), and running_.

Here is the call graph for this function:

format_for_network()

std::string kcenon::logger::network_writer::format_for_network ( const log_entry & entry )

private

Definition at line 442 of file network_writer.cpp.

                                                                   {
    // Format as JSON for network transmission
    std::ostringstream oss;
    oss << "{";
 
    // Timestamp
    auto time_t = std::chrono::system_clock::to_time_t(entry.timestamp);
    oss << "\"@timestamp\":\"";
    oss << std::put_time(std::gmtime(&time_t), "%Y-%m-%dT%H:%M:%SZ") << "\",";
 
    // Level - convert logger_system::log_level to common::interfaces::log_level
    auto level = static_cast<common::interfaces::log_level>(static_cast<int>(entry.level));
    oss << "\"level\":\"" << utils::string_utils::level_to_string(level) << "\",";
 
    // Message
    oss << "\"message\":\"" << escape_json(entry.message.to_string()) << "\"";
 
    // Optional fields from source_location
    if (entry.location) {
        std::string file = entry.location->file.to_string();
        std::string function = entry.location->function.to_string();
 
        if (!file.empty()) {
            oss << ",\"file\":\"" << escape_json(file) << "\"";
            oss << ",\"line\":" << entry.location->line;
        }
 
        if (!function.empty()) {
            oss << ",\"function\":\"" << escape_json(function) << "\"";
        }
    }
 
    // Add hostname
    char hostname[256];
    if (gethostname(hostname, sizeof(hostname)) == 0) {
        oss << ",\"host\":\"" << hostname << "\"";
    }
 
    // Tamper-evident signature (Issue #612). The signature covers the
    // unsigned JSON body (closed with '}'); verifiers recompute by
    // stripping the trailing ,"sig_alg":"..","signature":".." suffix,
    // which is a stable canonical form on the wire.
    if (integrity_policy_) {
        std::string unsigned_body = oss.str() + "}";
        std::string sig = integrity_policy_->sign(unsigned_body);
        if (!sig.empty()) {
            oss << ",\"sig_alg\":\"" << integrity_policy_->name() << "\"";
            oss << ",\"signature\":\"" << sig << "\"";
        }
    }
 
    oss << "}\n";
    return oss.str();
}

References escape_json(), integrity_policy_, kcenon::logger::log_entry::level, kcenon::logger::utils::string_utils::level_to_string(), kcenon::logger::log_entry::location, kcenon::logger::log_entry::message, kcenon::logger::log_entry::timestamp, and kcenon::logger::small_string< SSO_SIZE >::to_string().

Referenced by process_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_name()

std::string kcenon::logger::network_writer::get_name ( ) const

inlineoverridevirtual

Get writer name.

Implements kcenon::logger::base_writer.

Definition at line 85 of file network_writer.h.

{ return "network"; }

get_stats()

network_writer::connection_stats kcenon::logger::network_writer::get_stats

(

)

const

Definition at line 328 of file network_writer.cpp.

                                                               {
    std::lock_guard<std::mutex> lock(stats_mutex_);
    return stats_;
}

References stats_, and stats_mutex_.

is_connected()

bool kcenon::logger::network_writer::is_connected ( ) const

inline

Check if connected.

Definition at line 90 of file network_writer.h.

{ return connected_.load(); }

process_buffer()

void kcenon::logger::network_writer::process_buffer ( )

private

Definition at line 419 of file network_writer.cpp.

                                    {
    std::unique_lock<std::mutex> lock(buffer_mutex_);
 
    // Process buffered logs
    while (!buffer_.empty() && running_) {
        auto entry = std::move(buffer_.front());
        buffer_.pop();
        lock.unlock();
 
        // Format and send
        std::string formatted = format_for_network(entry);
        send_data(formatted);
 
        lock.lock();
    }
}

References buffer_, buffer_mutex_, format_for_network(), running_, and send_data().

Referenced by network_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

send_data()

bool kcenon::logger::network_writer::send_data ( const std::string & data )

private

Definition at line 390 of file network_writer.cpp.

                                                    {
    if (!connected_ || socket_fd_ < 0) {
        return false;
    }
 
#ifdef _WIN32
    int sent = ::send(socket_fd_, data.c_str(), static_cast<int>(data.length()), 0);
#else
    ssize_t sent = ::send(socket_fd_, data.c_str(), data.length(), 0);
#endif
    if (sent < 0) {
        if (protocol_ == protocol_type::tcp) {
            // TCP connection lost
            disconnect();
 
            std::lock_guard<std::mutex> lock(stats_mutex_);
            stats_.send_failures++;
            stats_.last_error = std::chrono::system_clock::now();
        }
        return false;
    }
 
    std::lock_guard<std::mutex> lock(stats_mutex_);
    stats_.messages_sent++;
    stats_.bytes_sent += sent;
 
    return true;
}

References kcenon::logger::network_writer::connection_stats::bytes_sent, connected_, disconnect(), kcenon::logger::network_writer::connection_stats::last_error, kcenon::logger::network_writer::connection_stats::messages_sent, protocol_, kcenon::logger::network_writer::connection_stats::send_failures, socket_fd_, stats_, stats_mutex_, and tcp.

Referenced by process_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

set_integrity_policy()

void kcenon::logger::network_writer::set_integrity_policy

(

std::shared_ptr< security::integrity_policy >

policy

)

Enable tamper-evident integrity signing for outbound frames.

Parameters

policy

Signing policy (shared ownership); pass nullptr to disable.

When installed, each JSON frame emitted on the socket carries an extra "signature" field (hex-encoded) computed over the frame without that field (Issue #612, ISO/IEC 27001 A.14.1.3 for the transmission protection aspect). This lets the receiving log aggregator reject tampered frames.

Definition at line 497 of file network_writer.cpp.

                                                    {
    std::lock_guard<std::mutex> lock(buffer_mutex_);
    integrity_policy_ = std::move(policy);
}

References buffer_mutex_, and integrity_policy_.

write()

common::VoidResult kcenon::logger::network_writer::write ( const log_entry & entry )

overridevirtual

Write log entry.

Parameters

entry

The log entry to write

Returns

common::VoidResult indicating success or error

Since

3.5.0 Changed to use log_entry directly

Implements kcenon::logger::base_writer.

Definition at line 269 of file network_writer.cpp.

                                                             {
 
    std::lock_guard<std::mutex> lock(buffer_mutex_);
 
    // Check buffer size
    if (buffer_.size() >= buffer_size_) {
        // Drop oldest message
        buffer_.pop();
        std::lock_guard<std::mutex> stats_lock(stats_mutex_);
        stats_.send_failures++;
        // Note: We still accept the new message after dropping the oldest
    }
 
    // Create a copy of the entry since log_entry is move-only
    if (entry.location) {
        buffer_.emplace(entry.level,
                       entry.message.to_string(),
                       entry.location->file.to_string(),
                       entry.location->line,
                       entry.location->function.to_string(),
                       entry.timestamp);
    } else {
        buffer_.emplace(entry.level,
                       entry.message.to_string(),
                       entry.timestamp);
    }
 
    // Notify send worker
    if (send_worker_) {
        send_worker_->notify_work();
    }
 
    return common::ok();
}

References buffer_, buffer_mutex_, buffer_size_, kcenon::logger::log_entry::level, kcenon::logger::log_entry::location, kcenon::logger::log_entry::message, kcenon::common::ok(), kcenon::logger::network_writer::connection_stats::send_failures, send_worker_, stats_, stats_mutex_, kcenon::logger::log_entry::timestamp, and kcenon::logger::small_string< SSO_SIZE >::to_string().

Here is the call graph for this function:

Member Data Documentation

buffer_

std::queue<log_entry> kcenon::logger::network_writer::buffer_

private

Definition at line 143 of file network_writer.h.

Referenced by flush(), process_buffer(), and write().

buffer_cv_

std::condition_variable kcenon::logger::network_writer::buffer_cv_

private

Definition at line 145 of file network_writer.h.

Referenced by flush().

buffer_mutex_

std::mutex kcenon::logger::network_writer::buffer_mutex_

mutableprivate

Definition at line 144 of file network_writer.h.

Referenced by flush(), process_buffer(), set_integrity_policy(), and write().

buffer_size_

size_t kcenon::logger::network_writer::buffer_size_

private

Definition at line 134 of file network_writer.h.

Referenced by write().

connected_

std::atomic<bool> kcenon::logger::network_writer::connected_ {false}

private

Definition at line 139 of file network_writer.h.

{false};

Referenced by attempt_reconnect(), connect(), disconnect(), and send_data().

host_

std::string kcenon::logger::network_writer::host_

private

Definition at line 131 of file network_writer.h.

Referenced by connect().

integrity_policy_

std::shared_ptr<security::integrity_policy> kcenon::logger::network_writer::integrity_policy_

private

Definition at line 156 of file network_writer.h.

Referenced by format_for_network(), and set_integrity_policy().

port_

uint16_t kcenon::logger::network_writer::port_

private

Definition at line 132 of file network_writer.h.

Referenced by connect().

protocol_

protocol_type kcenon::logger::network_writer::protocol_

private

Definition at line 133 of file network_writer.h.

Referenced by connect(), network_writer(), and send_data().

reconnect_interval_

std::chrono::seconds kcenon::logger::network_writer::reconnect_interval_

private

Definition at line 135 of file network_writer.h.

Referenced by network_writer().

reconnect_worker_

std::unique_ptr<network_reconnect_jthread_worker> kcenon::logger::network_writer::reconnect_worker_

private

Definition at line 149 of file network_writer.h.

Referenced by network_writer(), and ~network_writer().

running_

std::atomic<bool> kcenon::logger::network_writer::running_ {false}

private

Definition at line 140 of file network_writer.h.

{false};

Referenced by attempt_reconnect(), flush(), network_writer(), process_buffer(), and ~network_writer().

send_worker_

std::unique_ptr<network_send_jthread_worker> kcenon::logger::network_writer::send_worker_

private

Definition at line 148 of file network_writer.h.

Referenced by network_writer(), write(), and ~network_writer().

socket_fd_

int kcenon::logger::network_writer::socket_fd_

private

Definition at line 138 of file network_writer.h.

Referenced by connect(), disconnect(), and send_data().

stats_

connection_stats kcenon::logger::network_writer::stats_ {}

private

Definition at line 153 of file network_writer.h.

{};

Referenced by connect(), get_stats(), send_data(), and write().

stats_mutex_

std::mutex kcenon::logger::network_writer::stats_mutex_

mutableprivate

Definition at line 152 of file network_writer.h.

Referenced by connect(), get_stats(), send_data(), and write().

---

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

• include/kcenon/logger/writers/network_writer.h
• src/impl/writers/network_writer.cpp