diff --git a/CHANGELOG.md b/CHANGELOG.md index 1feb88c..2f2e537 100755 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,14 @@ + +## Version 0.6.0 - 2025-12-29 + +Integrates monitoring metrics into connection handling to provide real-time insights into network performance. Redesigns the dashboard with advanced metrics and charts for enhanced visualization of system data. + +**Changes:** 9 files, 1245 lines +**Languages:** C (1245 lines) + ## Version 0.5.0 - 2025-12-28 Enhances authentication security by preventing timing attacks and clearing sensitive memory, while adding rate limiting to protect against abusive client requests. Enables SSL hostname verification and preferred cipher suites for improved connection security, and fixes request denial when rate limit allocation fails. diff --git a/src/connection.c b/src/connection.c index 167903c..be51977 100755 --- a/src/connection.c +++ b/src/connection.c @@ -215,6 +215,7 @@ void connection_accept(int listener_fd) { } monitor.active_connections++; + monitor.total_connections_accepted++; log_debug("New connection on fd %d from %s, total: %d", client_fd, conn->client_ip, monitor.active_connections); } @@ -527,6 +528,9 @@ void connection_connect_to_upstream(connection_t *client, const char *data, size if (gai_err == 0 && result) freeaddrinfo(result); log_debug("DNS resolution failed for %s: %s", route->upstream_host, gai_err ? gai_strerror(gai_err) : "no address returned"); + if (client->vhost_stats) { + monitor_record_error(client->vhost_stats, ERROR_TYPE_DNS); + } connection_send_error_response(client, 502, "Bad Gateway", "Cannot resolve upstream hostname"); return; } @@ -555,10 +559,20 @@ void connection_connect_to_upstream(connection_t *client, const char *data, size if (up_fd < 0) { log_debug("All %d connection attempts failed for %s:%d", MAX_UPSTREAM_RETRIES, route->upstream_host, route->upstream_port); + if (client->vhost_stats) { + monitor_record_upstream_connect(client->vhost_stats, 0, 0); + } connection_send_error_response(client, 502, "Bad Gateway", "Failed to connect to upstream"); return; } + if (client->vhost_stats) { + monitor_record_upstream_connect(client->vhost_stats, 1, 0); + if (retry_count > 0) { + client->vhost_stats->upstream_retries += retry_count; + } + } + connection_add_to_epoll(up_fd, EPOLLIN | EPOLLOUT); connection_t *up = &connections[up_fd]; @@ -821,6 +835,10 @@ static void handle_client_read(connection_t *conn) { conn->vhost_stats = monitor_get_or_create_vhost_stats(conn->request.host); monitor_record_request_start(conn->vhost_stats, conn->request.is_websocket); + monitor_record_method(conn->vhost_stats, http_method_from_string(conn->request.method)); + if (conn->request.content_length > 0) { + monitor_record_request_size(conn->vhost_stats, conn->request.content_length); + } conn->state = CLIENT_STATE_FORWARDING; connection_connect_to_upstream(conn, data_start, len_to_forward); @@ -867,6 +885,7 @@ static ssize_t splice_forward(connection_t *conn, connection_t *pair) { if (conn->vhost_stats) { monitor_record_bytes(conn->vhost_stats, bytes_from_pipe, bytes_to_pipe); + monitor_record_splice_transfer(conn->vhost_stats, bytes_from_pipe); } return bytes_from_pipe; @@ -998,10 +1017,19 @@ static void handle_forwarding(connection_t *conn) { conn->original_content_length = http_get_content_length(src_data, headers_end); conn->response_headers_parsed = 1; - log_debug("Response Content-Type: %s, textual: %d, content-length: %ld", + int status_code = http_extract_status_code(src_data, headers_end); + if (status_code > 0 && conn->vhost_stats) { + monitor_record_status(conn->vhost_stats, status_code); + } + if (conn->original_content_length > 0 && conn->vhost_stats) { + monitor_record_response_size(conn->vhost_stats, conn->original_content_length); + } + + log_debug("Response Content-Type: %s, textual: %d, content-length: %ld, status: %d", content_type[0] ? content_type : "(none)", conn->is_textual_content, - conn->original_content_length); + conn->original_content_length, + status_code); } } @@ -1084,6 +1112,10 @@ static void handle_forwarding(connection_t *conn) { pair->write_buf.tail += output_len; buffer_consume(&conn->read_buf, data_to_forward); + if (conn->vhost_stats) { + monitor_record_buffer_transfer(conn->vhost_stats, output_len); + } + connection_do_write(pair); connection_modify_epoll(pair->fd, EPOLLIN | EPOLLOUT); } @@ -1096,6 +1128,9 @@ static void handle_ssl_handshake(connection_t *conn) { time_t elapsed = time(NULL) - conn->ssl_handshake_start; if (elapsed > SSL_HANDSHAKE_TIMEOUT_SEC) { log_debug("SSL handshake timeout for fd %d after %ld seconds", conn->fd, (long)elapsed); + if (conn->vhost_stats) { + monitor_record_error(conn->vhost_stats, ERROR_TYPE_TIMEOUT); + } if (conn->pair) { connection_send_error_response(conn->pair, 504, "Gateway Timeout", "SSL handshake timeout"); } @@ -1144,6 +1179,9 @@ static void handle_ssl_handshake(connection_t *conn) { connection_modify_epoll(conn->fd, EPOLLOUT); } else { log_debug("SSL handshake failed for fd %d: %d", conn->fd, ssl_error); + if (conn->vhost_stats) { + monitor_record_error(conn->vhost_stats, ERROR_TYPE_SSL); + } if (conn->pair) { connection_send_error_response(conn->pair, 502, "Bad Gateway", "SSL handshake failed"); } else { @@ -1218,6 +1256,9 @@ void connection_handle_event(struct epoll_event *event) { if (event->events & (EPOLLERR | EPOLLHUP)) { if (event->events & EPOLLERR) { log_debug("EPOLLERR on fd %d", fd); + if (conn->vhost_stats) { + monitor_record_error(conn->vhost_stats, ERROR_TYPE_CONNECTION); + } } connection_close(fd); return; @@ -1267,6 +1308,9 @@ void connection_cleanup_idle(void) { conn->fd != -1) { if (current_time - conn->last_activity > CONNECTION_TIMEOUT) { log_debug("Closing idle connection fd=%d", i); + if (conn->vhost_stats) { + monitor_record_error(conn->vhost_stats, ERROR_TYPE_TIMEOUT); + } connection_close(i); } } diff --git a/src/dashboard.c b/src/dashboard.c index 7b3b9bc..ccba962 100755 --- a/src/dashboard.c +++ b/src/dashboard.c @@ -19,275 +19,120 @@ static const char *DASHBOARD_HTML = " \n" " \n" "\n" "\n" "
\n" -"
\n" -"
0
\n" -"
Connections
\n" -"
\n" -"
\n" -"
0
\n" -"
Memory
\n" -"
\n" -"
\n" -"
0
\n" -"
CPU %
\n" -"
\n" -"
\n" -"
0.00
\n" -"
Load 1m
\n" -"
\n" -"
\n" -"
0.00
\n" -"
Load 5m
\n" -"
\n" -"
\n" -"
0.00
\n" -"
Load 15m
\n" -"
\n" +"
100
Health
\n" +"
0
Req/sec
\n" +"
0
p50 ms
\n" +"
0
p99 ms
\n" +"
0%
Errors
\n" +"
0
Conns
\n" +"
0
CPU
\n" +"
0
Memory
\n" +"
0s
Uptime
\n" "
\n" -"\n" -"
\n" -"
CPU Usage
\n" -" \n" +"
\n" +"
Latency Distribution
\n" +"
Status Codes
\n" +"
HTTP Methods
\n" +"
Efficiency
\n" "
\n" -"\n" -"
\n" -"
Memory Usage
\n" -" \n" +"
\n" +"
CPU Usage
\n" +"
Memory Usage
\n" "
\n" -"\n" -"
\n" -"
Network I/O
\n" -"
\n" -"
RX
\n" -"
TX
\n" -"
\n" -" \n" +"
\n" +"
Network I/O
\n" +"
RX
TX
\n" +"
\n" +"
Disk I/O
\n" +"
Read
Write
\n" +"
\n" "
\n" -"\n" -"
\n" -"
Disk I/O
\n" -"
\n" -"
Read
\n" -"
Write
\n" -"
\n" -" \n" -"
\n" -"\n" -"
\n" -"
Load Average
\n" -"
\n" -"
1 min
\n" -"
5 min
\n" -"
15 min
\n" -"
\n" -" \n" -"
\n" -"\n" -"
\n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -" \n" -"
Virtual HostHTTP ReqWS ReqTotal ReqAvg Resp (ms)SentReceived
\n" -"
\n" -"\n" +"
Load Average
\n" +"
1m
5m
15m
\n" +"
\n" +"
Virtual HostRPSTotalp50p992xx4xx5xxErr%SentRecv
\n" " \n" "\n" "\n"; @@ -497,6 +342,91 @@ void dashboard_serve_stats_api(connection_t *conn, const char *request_data, siz cJSON_AddNumberToObject(current, "load_5m", load5); cJSON_AddNumberToObject(current, "load_15m", load15); + monitor_compute_health_score(); + double current_rps = monitor_get_current_rps(); + cJSON_AddNumberToObject(current, "health_score", monitor.health_score); + cJSON_AddNumberToObject(current, "requests_per_second", current_rps); + cJSON_AddNumberToObject(current, "error_rate_1m", monitor.error_rate_1m); + cJSON_AddNumberToObject(current, "uptime_seconds", (double)(time(NULL) - monitor.uptime_start)); + cJSON_AddNumberToObject(current, "peak_rps", monitor.peak_rps); + cJSON_AddNumberToObject(current, "total_connections", (double)monitor.total_connections_accepted); + + cJSON *latency = cJSON_CreateObject(); + if (latency) { + cJSON_AddNumberToObject(latency, "p50_ms", histogram_percentile(&monitor.global_latency, 0.50)); + cJSON_AddNumberToObject(latency, "p90_ms", histogram_percentile(&monitor.global_latency, 0.90)); + cJSON_AddNumberToObject(latency, "p95_ms", histogram_percentile(&monitor.global_latency, 0.95)); + cJSON_AddNumberToObject(latency, "p99_ms", histogram_percentile(&monitor.global_latency, 0.99)); + cJSON_AddNumberToObject(latency, "mean_ms", histogram_mean(&monitor.global_latency)); + cJSON *histogram_arr = cJSON_CreateArray(); + if (histogram_arr) { + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + cJSON_AddItemToArray(histogram_arr, cJSON_CreateNumber(monitor.global_latency.buckets[i])); + } + cJSON_AddItemToObject(latency, "histogram", histogram_arr); + } + cJSON *labels = cJSON_CreateArray(); + if (labels) { + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + cJSON_AddItemToArray(labels, cJSON_CreateString(LATENCY_BUCKET_LABELS[i])); + } + cJSON_AddItemToObject(latency, "bucket_labels", labels); + } + cJSON_AddItemToObject(root, "latency", latency); + } + + uint64_t total_2xx = 0, total_3xx = 0, total_4xx = 0, total_5xx = 0; + uint64_t methods[HTTP_METHOD_COUNT] = {0}; + uint64_t total_splice = 0, total_buffer = 0; + uint64_t total_splice_bytes = 0, total_buffer_bytes = 0; + for (vhost_stats_t *s = monitor.vhost_stats_head; s; s = s->next) { + total_2xx += s->status_counts.status_2xx; + total_3xx += s->status_counts.status_3xx; + total_4xx += s->status_counts.status_4xx; + total_5xx += s->status_counts.status_5xx; + for (int i = 0; i < HTTP_METHOD_COUNT; i++) { + methods[i] += s->method_counts.counts[i]; + } + total_splice += s->splice_transfers; + total_buffer += s->buffered_transfers; + total_splice_bytes += s->bytes_via_splice; + total_buffer_bytes += s->bytes_via_buffer; + } + + cJSON *status_codes = cJSON_CreateObject(); + if (status_codes) { + cJSON_AddNumberToObject(status_codes, "2xx", (double)total_2xx); + cJSON_AddNumberToObject(status_codes, "3xx", (double)total_3xx); + cJSON_AddNumberToObject(status_codes, "4xx", (double)total_4xx); + cJSON_AddNumberToObject(status_codes, "5xx", (double)total_5xx); + cJSON_AddItemToObject(root, "status_codes", status_codes); + } + + cJSON *methods_obj = cJSON_CreateObject(); + if (methods_obj) { + cJSON_AddNumberToObject(methods_obj, "GET", (double)methods[HTTP_METHOD_GET]); + cJSON_AddNumberToObject(methods_obj, "POST", (double)methods[HTTP_METHOD_POST]); + cJSON_AddNumberToObject(methods_obj, "PUT", (double)methods[HTTP_METHOD_PUT]); + cJSON_AddNumberToObject(methods_obj, "DELETE", (double)methods[HTTP_METHOD_DELETE]); + cJSON_AddNumberToObject(methods_obj, "PATCH", (double)methods[HTTP_METHOD_PATCH]); + cJSON_AddNumberToObject(methods_obj, "HEAD", (double)methods[HTTP_METHOD_HEAD]); + cJSON_AddNumberToObject(methods_obj, "OPTIONS", (double)methods[HTTP_METHOD_OPTIONS]); + cJSON_AddNumberToObject(methods_obj, "OTHER", (double)methods[HTTP_METHOD_OTHER]); + cJSON_AddItemToObject(root, "methods", methods_obj); + } + + cJSON *efficiency = cJSON_CreateObject(); + if (efficiency) { + double total_transfers = (double)(total_splice + total_buffer); + double splice_ratio = total_transfers > 0 ? (double)total_splice / total_transfers : 0; + cJSON_AddNumberToObject(efficiency, "zero_copy_ratio", splice_ratio); + cJSON_AddNumberToObject(efficiency, "splice_transfers", (double)total_splice); + cJSON_AddNumberToObject(efficiency, "buffer_transfers", (double)total_buffer); + cJSON_AddNumberToObject(efficiency, "bytes_via_splice", (double)total_splice_bytes); + cJSON_AddNumberToObject(efficiency, "bytes_via_buffer", (double)total_buffer_bytes); + cJSON_AddItemToObject(root, "efficiency", efficiency); + } + cJSON_AddItemToObject(root, "cpu_history", format_history(&monitor.cpu_history, HISTORY_SECONDS)); cJSON_AddItemToObject(root, "memory_history", format_history(&monitor.memory_history, HISTORY_SECONDS)); cJSON_AddItemToObject(root, "network_rx_history", format_network_history(&monitor.network_history, HISTORY_SECONDS, "rx_kbps")); @@ -522,6 +452,29 @@ void dashboard_serve_stats_api(connection_t *conn, const char *request_data, siz cJSON_AddNumberToObject(p, "bytes_sent", s->bytes_sent); cJSON_AddNumberToObject(p, "bytes_recv", s->bytes_recv); cJSON_AddItemToObject(p, "throughput_history", format_history(&s->throughput_history, 60)); + + cJSON_AddNumberToObject(p, "latency_p50", histogram_percentile(&s->latency_histogram, 0.50)); + cJSON_AddNumberToObject(p, "latency_p90", histogram_percentile(&s->latency_histogram, 0.90)); + cJSON_AddNumberToObject(p, "latency_p95", histogram_percentile(&s->latency_histogram, 0.95)); + cJSON_AddNumberToObject(p, "latency_p99", histogram_percentile(&s->latency_histogram, 0.99)); + cJSON_AddNumberToObject(p, "rps", rate_tracker_get_rps(&s->requests_per_second)); + + double vhost_total = (double)(s->status_counts.status_2xx + s->status_counts.status_3xx + + s->status_counts.status_4xx + s->status_counts.status_5xx); + double error_rate = vhost_total > 0 ? (double)s->status_counts.status_5xx / vhost_total : 0; + cJSON_AddNumberToObject(p, "error_rate", error_rate); + + cJSON_AddNumberToObject(p, "status_2xx", (double)s->status_counts.status_2xx); + cJSON_AddNumberToObject(p, "status_3xx", (double)s->status_counts.status_3xx); + cJSON_AddNumberToObject(p, "status_4xx", (double)s->status_counts.status_4xx); + cJSON_AddNumberToObject(p, "status_5xx", (double)s->status_counts.status_5xx); + + cJSON_AddNumberToObject(p, "upstream_success", (double)s->upstream_connect_success); + cJSON_AddNumberToObject(p, "upstream_failures", (double)s->upstream_connect_failures); + cJSON_AddNumberToObject(p, "dns_failures", (double)s->dns_failures); + cJSON_AddNumberToObject(p, "ssl_failures", (double)s->ssl_failures); + cJSON_AddNumberToObject(p, "timeout_errors", (double)s->timeout_errors); + cJSON_AddItemToArray(processes, p); } } diff --git a/src/http.c b/src/http.c index 7e2c881..9c67147 100755 --- a/src/http.c +++ b/src/http.c @@ -283,3 +283,28 @@ int http_find_header_line_bounds(const char* data, size_t len, const char* name, *line_end = NULL; return 0; } + +int http_extract_status_code(const char *data, size_t len) { + if (!data || len < 12) return 0; + + if (strncmp(data, "HTTP/1.", 7) != 0 && strncmp(data, "HTTP/2", 6) != 0) { + return 0; + } + + const char *p = data; + while (p < data + len && *p != ' ') p++; + if (p >= data + len) return 0; + while (p < data + len && *p == ' ') p++; + if (p >= data + len) return 0; + + int status = 0; + for (int i = 0; i < 3 && p + i < data + len; i++) { + if (p[i] >= '0' && p[i] <= '9') { + status = status * 10 + (p[i] - '0'); + } else { + break; + } + } + + return (status >= 100 && status < 600) ? status : 0; +} diff --git a/src/http.h b/src/http.h index 765ba95..3fbbb48 100755 --- a/src/http.h +++ b/src/http.h @@ -12,5 +12,6 @@ long http_get_content_length(const char *headers, size_t headers_len); int http_find_headers_end(const char *data, size_t len, size_t *headers_end); int http_rewrite_content_length(char *headers, size_t *headers_len, size_t max_len, long new_length); int http_find_header_line_bounds(const char* data, size_t len, const char* name, const char** line_start, const char** line_end); +int http_extract_status_code(const char *data, size_t len); #endif diff --git a/src/logging.c b/src/logging.c index 3f764bf..a01cf5c 100755 --- a/src/logging.c +++ b/src/logging.c @@ -32,7 +32,7 @@ static void rotate_log_file(void) { g_log_file = NULL; } - char old_path[520], new_path[520]; + char old_path[536], new_path[536]; snprintf(old_path, sizeof(old_path), "%s.%d", g_log_path, LOG_MAX_ROTATIONS); unlink(old_path); diff --git a/src/monitor.c b/src/monitor.c index 4cd7f96..d6455eb 100755 --- a/src/monitor.c +++ b/src/monitor.c @@ -151,6 +151,8 @@ static void load_stats_from_db(void) { void monitor_init(const char *db_file) { memset(&monitor, 0, sizeof(system_monitor_t)); monitor.start_time = time(NULL); + monitor.uptime_start = time(NULL); + monitor.health_score = 100.0; history_deque_init(&monitor.cpu_history, HISTORY_SECONDS); history_deque_init(&monitor.memory_history, HISTORY_SECONDS); @@ -161,6 +163,10 @@ void monitor_init(const char *db_file) { history_deque_init(&monitor.load5_history, HISTORY_SECONDS); history_deque_init(&monitor.load15_history, HISTORY_SECONDS); + histogram_init(&monitor.global_latency); + histogram_init(&monitor.connection_lifetime); + rate_tracker_init(&monitor.global_rps); + if (sqlite3_open(db_file, &monitor.db) != SQLITE_OK) { fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(monitor.db)); if (monitor.db) { @@ -487,6 +493,14 @@ vhost_stats_t* monitor_get_or_create_vhost_stats(const char *vhost_name) { new_stats->last_update = time(NULL); history_deque_init(&new_stats->throughput_history, 60); request_time_deque_init(&new_stats->request_times, 100); + + histogram_init(&new_stats->latency_histogram); + histogram_init(&new_stats->request_size_histogram); + histogram_init(&new_stats->response_size_histogram); + histogram_init(&new_stats->ttfb_histogram); + histogram_init(&new_stats->upstream_connect_latency); + rate_tracker_init(&new_stats->requests_per_second); + new_stats->next = monitor.vhost_stats_head; monitor.vhost_stats_head = new_stats; @@ -501,6 +515,8 @@ void monitor_record_request_start(vhost_stats_t *stats, int is_websocket) { stats->http_requests++; } stats->total_requests++; + rate_tracker_increment(&stats->requests_per_second); + rate_tracker_increment(&monitor.global_rps); } void monitor_record_request_end(vhost_stats_t *stats, double start_time) { @@ -510,6 +526,8 @@ void monitor_record_request_end(vhost_stats_t *stats, double start_time) { double duration_ms = ((end_time.tv_sec + end_time.tv_nsec / 1e9) - start_time) * 1000.0; if (duration_ms >= 0 && duration_ms < 60000) { request_time_deque_push(&stats->request_times, duration_ms); + histogram_add(&stats->latency_histogram, duration_ms); + histogram_add(&monitor.global_latency, duration_ms); } } @@ -518,3 +536,278 @@ void monitor_record_bytes(vhost_stats_t *stats, long long sent, long long recv) stats->bytes_sent += sent; stats->bytes_recv += recv; } + +const double LATENCY_BUCKET_BOUNDS[HISTOGRAM_BUCKETS] = { + 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, + 500.0, 1000.0, 2500.0, 5000.0, 10000.0, 30000.0, 60000.0, 1e9 +}; + +const char* LATENCY_BUCKET_LABELS[HISTOGRAM_BUCKETS] = { + "0-1ms", "1-2ms", "2-5ms", "5-10ms", "10-25ms", "25-50ms", "50-100ms", "100-250ms", + "250-500ms", "500ms-1s", "1-2.5s", "2.5-5s", "5-10s", "10-30s", "30-60s", "60s+" +}; + +const double SIZE_BUCKET_BOUNDS[HISTOGRAM_BUCKETS] = { + 128.0, 512.0, 1024.0, 4096.0, 16384.0, 65536.0, 262144.0, 1048576.0, + 4194304.0, 16777216.0, 67108864.0, 268435456.0, 1073741824.0, 4294967296.0, 1e15, 1e18 +}; + +void histogram_init(histogram_t *h) { + if (!h) return; + memset(h, 0, sizeof(histogram_t)); + h->min_value = 1e18; + h->max_value = -1e18; +} + +void histogram_add(histogram_t *h, double value) { + if (!h) return; + h->total_count++; + h->sum += value; + if (value < h->min_value) h->min_value = value; + if (value > h->max_value) h->max_value = value; + + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + if (value <= LATENCY_BUCKET_BOUNDS[i]) { + h->buckets[i]++; + return; + } + } + h->overflow++; +} + +static void histogram_add_with_bounds(histogram_t *h, double value, const double *bounds) { + if (!h) return; + h->total_count++; + h->sum += value; + if (value < h->min_value) h->min_value = value; + if (value > h->max_value) h->max_value = value; + + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + if (value <= bounds[i]) { + h->buckets[i]++; + return; + } + } + h->overflow++; +} + +double histogram_percentile(histogram_t *h, double p) { + if (!h || h->total_count == 0) return 0.0; + uint64_t target = (uint64_t)(h->total_count * p); + uint64_t cumulative = 0; + + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + cumulative += h->buckets[i]; + if (cumulative >= target) { + return LATENCY_BUCKET_BOUNDS[i]; + } + } + return LATENCY_BUCKET_BOUNDS[HISTOGRAM_BUCKETS - 1]; +} + +double histogram_mean(histogram_t *h) { + if (!h || h->total_count == 0) return 0.0; + return h->sum / h->total_count; +} + +void rate_tracker_init(rate_tracker_t *rt) { + if (!rt) return; + memset(rt, 0, sizeof(rate_tracker_t)); + rt->slot_start = time(NULL); +} + +void rate_tracker_increment(rate_tracker_t *rt) { + if (!rt) return; + time_t now = time(NULL); + int slot = now % RATE_TRACKER_SLOTS; + + if (now != rt->slot_start) { + int slots_to_clear = (int)(now - rt->slot_start); + if (slots_to_clear >= RATE_TRACKER_SLOTS) { + memset(rt->counts, 0, sizeof(rt->counts)); + } else { + for (int i = 1; i <= slots_to_clear; i++) { + int clear_slot = (rt->current_slot + i) % RATE_TRACKER_SLOTS; + rt->counts[clear_slot] = 0; + } + } + rt->current_slot = slot; + rt->slot_start = now; + } + + rt->counts[slot]++; +} + +uint32_t rate_tracker_get_rps(rate_tracker_t *rt) { + if (!rt) return 0; + time_t now = time(NULL); + int prev_slot = (now - 1) % RATE_TRACKER_SLOTS; + if ((now - rt->slot_start) > RATE_TRACKER_SLOTS) return 0; + return rt->counts[prev_slot]; +} + +uint32_t rate_tracker_get_total_last_minute(rate_tracker_t *rt) { + if (!rt) return 0; + time_t now = time(NULL); + if ((now - rt->slot_start) > RATE_TRACKER_SLOTS) { + return 0; + } + + uint32_t total = 0; + for (int i = 0; i < RATE_TRACKER_SLOTS; i++) { + total += rt->counts[i]; + } + return total; +} + +http_method_t http_method_from_string(const char *method) { + if (!method) return HTTP_METHOD_OTHER; + if (strcmp(method, "GET") == 0) return HTTP_METHOD_GET; + if (strcmp(method, "POST") == 0) return HTTP_METHOD_POST; + if (strcmp(method, "PUT") == 0) return HTTP_METHOD_PUT; + if (strcmp(method, "DELETE") == 0) return HTTP_METHOD_DELETE; + if (strcmp(method, "PATCH") == 0) return HTTP_METHOD_PATCH; + if (strcmp(method, "HEAD") == 0) return HTTP_METHOD_HEAD; + if (strcmp(method, "OPTIONS") == 0) return HTTP_METHOD_OPTIONS; + return HTTP_METHOD_OTHER; +} + +void monitor_record_method(vhost_stats_t *stats, http_method_t method) { + if (!stats || method >= HTTP_METHOD_COUNT) return; + stats->method_counts.counts[method]++; +} + +void monitor_record_status(vhost_stats_t *stats, int status_code) { + if (!stats) return; + if (status_code >= 100 && status_code < 200) { + stats->status_counts.status_1xx++; + } else if (status_code >= 200 && status_code < 300) { + stats->status_counts.status_2xx++; + } else if (status_code >= 300 && status_code < 400) { + stats->status_counts.status_3xx++; + } else if (status_code >= 400 && status_code < 500) { + stats->status_counts.status_4xx++; + } else if (status_code >= 500 && status_code < 600) { + stats->status_counts.status_5xx++; + } else { + stats->status_counts.status_unknown++; + } +} + +void monitor_record_request_size(vhost_stats_t *stats, long size) { + if (!stats || size < 0) return; + histogram_add_with_bounds(&stats->request_size_histogram, (double)size, SIZE_BUCKET_BOUNDS); +} + +void monitor_record_response_size(vhost_stats_t *stats, long size) { + if (!stats || size < 0) return; + histogram_add_with_bounds(&stats->response_size_histogram, (double)size, SIZE_BUCKET_BOUNDS); + stats->response_bytes_total += size; +} + +void monitor_record_ttfb(vhost_stats_t *stats, double ttfb_ms) { + if (!stats || ttfb_ms < 0) return; + histogram_add(&stats->ttfb_histogram, ttfb_ms); +} + +void monitor_record_upstream_connect(vhost_stats_t *stats, int success, double latency_ms) { + if (!stats) return; + if (success) { + stats->upstream_connect_success++; + if (latency_ms >= 0) { + histogram_add(&stats->upstream_connect_latency, latency_ms); + } + } else { + stats->upstream_connect_failures++; + } +} + +void monitor_record_splice_transfer(vhost_stats_t *stats, long long bytes) { + if (!stats) return; + stats->splice_transfers++; + stats->bytes_via_splice += bytes; +} + +void monitor_record_buffer_transfer(vhost_stats_t *stats, long long bytes) { + if (!stats) return; + stats->buffered_transfers++; + stats->bytes_via_buffer += bytes; +} + +void monitor_record_connection_opened(vhost_stats_t *stats) { + if (!stats) return; + stats->connections_opened++; + monitor.total_connections_accepted++; +} + +void monitor_record_connection_closed(vhost_stats_t *stats) { + if (!stats) return; + stats->connections_closed++; +} + +void monitor_record_keepalive_reuse(vhost_stats_t *stats) { + if (!stats) return; + stats->keep_alive_reused++; +} + +void monitor_record_error(vhost_stats_t *stats, int error_type) { + if (!stats) return; + switch (error_type) { + case ERROR_TYPE_DNS: + stats->dns_failures++; + break; + case ERROR_TYPE_SSL: + stats->ssl_failures++; + break; + case ERROR_TYPE_TIMEOUT: + stats->timeout_errors++; + break; + case ERROR_TYPE_CONNECTION: + stats->connection_errors++; + break; + } +} + +void monitor_compute_health_score(void) { + uint64_t total_requests = 0; + uint64_t total_errors = 0; + uint64_t total_upstream_failures = 0; + uint64_t total_upstream_attempts = 0; + uint64_t total_timeouts = 0; + + for (vhost_stats_t *s = monitor.vhost_stats_head; s != NULL; s = s->next) { + total_requests += s->total_requests; + total_errors += s->status_counts.status_5xx; + total_upstream_failures += s->upstream_connect_failures; + total_upstream_attempts += s->upstream_connect_success + s->upstream_connect_failures; + total_timeouts += s->timeout_errors; + } + + double error_rate = total_requests > 0 ? (double)total_errors / total_requests : 0; + double upstream_fail_rate = total_upstream_attempts > 0 ? (double)total_upstream_failures / total_upstream_attempts : 0; + double timeout_rate = total_requests > 0 ? (double)total_timeouts / total_requests : 0; + + monitor.health_score = 100.0 * (1.0 - (error_rate * 0.5 + upstream_fail_rate * 0.3 + timeout_rate * 0.2)); + if (monitor.health_score < 0) monitor.health_score = 0; + if (monitor.health_score > 100) monitor.health_score = 100; + + monitor.error_rate_1m = error_rate; +} + +void monitor_update_connection_states(void) { + memset(monitor.connections_by_state, 0, sizeof(monitor.connections_by_state)); +} + +double monitor_get_current_rps(void) { + uint32_t total_rps = 0; + for (vhost_stats_t *s = monitor.vhost_stats_head; s != NULL; s = s->next) { + total_rps += rate_tracker_get_rps(&s->requests_per_second); + } + + double rps = (double)total_rps; + if (rps > monitor.peak_rps) { + monitor.peak_rps = rps; + monitor.peak_rps_time = time(NULL); + } + return rps; +} diff --git a/src/monitor.h b/src/monitor.h index 4a4aa0b..a4b560c 100755 --- a/src/monitor.h +++ b/src/monitor.h @@ -22,4 +22,41 @@ void disk_history_deque_push(disk_history_deque_t *dq, double time, double read_ void request_time_deque_init(request_time_deque_t *dq, int capacity); void request_time_deque_push(request_time_deque_t *dq, double time_ms); +void histogram_init(histogram_t *h); +void histogram_add(histogram_t *h, double value); +double histogram_percentile(histogram_t *h, double p); +double histogram_mean(histogram_t *h); + +void rate_tracker_init(rate_tracker_t *rt); +void rate_tracker_increment(rate_tracker_t *rt); +uint32_t rate_tracker_get_rps(rate_tracker_t *rt); +uint32_t rate_tracker_get_total_last_minute(rate_tracker_t *rt); + +http_method_t http_method_from_string(const char *method); +void monitor_record_method(vhost_stats_t *stats, http_method_t method); +void monitor_record_status(vhost_stats_t *stats, int status_code); +void monitor_record_request_size(vhost_stats_t *stats, long size); +void monitor_record_response_size(vhost_stats_t *stats, long size); +void monitor_record_ttfb(vhost_stats_t *stats, double ttfb_ms); +void monitor_record_upstream_connect(vhost_stats_t *stats, int success, double latency_ms); +void monitor_record_splice_transfer(vhost_stats_t *stats, long long bytes); +void monitor_record_buffer_transfer(vhost_stats_t *stats, long long bytes); +void monitor_record_connection_opened(vhost_stats_t *stats); +void monitor_record_connection_closed(vhost_stats_t *stats); +void monitor_record_keepalive_reuse(vhost_stats_t *stats); +void monitor_record_error(vhost_stats_t *stats, int error_type); + +void monitor_compute_health_score(void); +void monitor_update_connection_states(void); +double monitor_get_current_rps(void); + +#define ERROR_TYPE_DNS 0 +#define ERROR_TYPE_SSL 1 +#define ERROR_TYPE_TIMEOUT 2 +#define ERROR_TYPE_CONNECTION 3 + +extern const double LATENCY_BUCKET_BOUNDS[HISTOGRAM_BUCKETS]; +extern const char* LATENCY_BUCKET_LABELS[HISTOGRAM_BUCKETS]; +extern const double SIZE_BUCKET_BOUNDS[HISTOGRAM_BUCKETS]; + #endif diff --git a/src/types.h b/src/types.h index 2b3a225..eb50a22 100755 --- a/src/types.h +++ b/src/types.h @@ -35,6 +35,9 @@ #define SSL_HANDSHAKE_TIMEOUT_SEC 10 #define MAX_CONNECTIONS_PER_IP 100 #define HOSTNAME_MAX_LEN 256 +#define HISTOGRAM_BUCKETS 16 +#define RATE_TRACKER_SLOTS 60 +#define HTTP_METHOD_COUNT 8 typedef enum { CONN_TYPE_UNUSED, @@ -51,6 +54,45 @@ typedef enum { CLIENT_STATE_CLOSING } client_state_t; +typedef enum { + HTTP_METHOD_GET = 0, + HTTP_METHOD_POST, + HTTP_METHOD_PUT, + HTTP_METHOD_DELETE, + HTTP_METHOD_PATCH, + HTTP_METHOD_HEAD, + HTTP_METHOD_OPTIONS, + HTTP_METHOD_OTHER +} http_method_t; + +typedef struct { + uint32_t buckets[HISTOGRAM_BUCKETS]; + uint32_t overflow; + uint64_t total_count; + double sum; + double min_value; + double max_value; +} histogram_t; + +typedef struct { + uint64_t counts[HTTP_METHOD_COUNT]; +} method_counter_t; + +typedef struct { + uint64_t status_1xx; + uint64_t status_2xx; + uint64_t status_3xx; + uint64_t status_4xx; + uint64_t status_5xx; + uint64_t status_unknown; +} status_counter_t; + +typedef struct { + uint32_t counts[RATE_TRACKER_SLOTS]; + int current_slot; + time_t slot_start; +} rate_tracker_t; + typedef struct { char *data; size_t capacity; @@ -199,6 +241,43 @@ typedef struct vhost_stats_s { double last_update; history_deque_t throughput_history; request_time_deque_t request_times; + + histogram_t latency_histogram; + histogram_t request_size_histogram; + histogram_t response_size_histogram; + histogram_t ttfb_histogram; + histogram_t upstream_connect_latency; + + method_counter_t method_counts; + status_counter_t status_counts; + rate_tracker_t requests_per_second; + + uint64_t keep_alive_reused; + uint64_t connections_opened; + uint64_t connections_closed; + + uint64_t splice_transfers; + uint64_t buffered_transfers; + uint64_t bytes_via_splice; + uint64_t bytes_via_buffer; + + uint64_t upstream_connect_success; + uint64_t upstream_connect_failures; + uint64_t upstream_retries; + + uint64_t rate_limit_rejections; + uint64_t auth_failures; + uint64_t patch_blocks; + + uint64_t dns_failures; + uint64_t ssl_failures; + uint64_t timeout_errors; + uint64_t connection_errors; + + double peak_rps; + time_t peak_rps_time; + long long response_bytes_total; + struct vhost_stats_s *next; } vhost_stats_t; @@ -221,6 +300,22 @@ typedef struct { double last_disk_update_time; vhost_stats_t *vhost_stats_head; sqlite3 *db; + + histogram_t global_latency; + histogram_t connection_lifetime; + rate_tracker_t global_rps; + + uint64_t total_connections_accepted; + uint64_t connections_by_state[5]; + + uint64_t total_rate_limit_checks; + uint64_t total_rate_limit_blocks; + + time_t uptime_start; + double health_score; + double error_rate_1m; + double peak_rps; + time_t peak_rps_time; } system_monitor_t; #endif diff --git a/tests/test_logging.c b/tests/test_logging.c new file mode 100755 index 0000000..a7abfab --- /dev/null +++ b/tests/test_logging.c @@ -0,0 +1,277 @@ +#include "test_framework.h" +#include "../src/logging.h" +#include +#include +#include +#include +#include + +void test_logging_debug_mode(void) { + TEST_SUITE_BEGIN("Logging Debug Mode"); + + logging_set_debug(0); + TEST_ASSERT_EQ(0, logging_get_debug(), "Debug mode disabled"); + + logging_set_debug(1); + TEST_ASSERT_EQ(1, logging_get_debug(), "Debug mode enabled"); + + logging_set_debug(0); + TEST_ASSERT_EQ(0, logging_get_debug(), "Debug mode disabled again"); + + TEST_SUITE_END(); +} + +void test_logging_set_file(void) { + TEST_SUITE_BEGIN("Logging Set File"); + + char tmp_path[] = "/tmp/test_rproxy_log_XXXXXX"; + int fd = mkstemp(tmp_path); + TEST_ASSERT(fd >= 0, "Temp file created"); + close(fd); + + int result = logging_set_file(tmp_path); + TEST_ASSERT_EQ(0, result, "Set log file succeeds"); + + log_info("Test log message"); + + struct stat st; + stat(tmp_path, &st); + TEST_ASSERT(st.st_size > 0, "Log file has content"); + + logging_cleanup(); + unlink(tmp_path); + + TEST_SUITE_END(); +} + +void test_logging_set_file_null(void) { + TEST_SUITE_BEGIN("Logging Set File NULL"); + + int result = logging_set_file(NULL); + TEST_ASSERT_EQ(0, result, "NULL path returns to stdout"); + + log_info("Test message to stdout"); + TEST_ASSERT(1, "Logging to stdout works"); + + TEST_SUITE_END(); +} + +void test_logging_set_file_invalid(void) { + TEST_SUITE_BEGIN("Logging Set File Invalid Path"); + + int result = logging_set_file("/nonexistent/directory/log.txt"); + TEST_ASSERT_EQ(-1, result, "Invalid path returns -1"); + + TEST_SUITE_END(); +} + +void test_logging_log_functions(void) { + TEST_SUITE_BEGIN("Logging Log Functions"); + + char tmp_path[] = "/tmp/test_rproxy_log_XXXXXX"; + int fd = mkstemp(tmp_path); + close(fd); + + logging_set_file(tmp_path); + + log_info("Info message: %d", 42); + log_error("Error message: %s", "test error"); + + logging_set_debug(1); + log_debug("Debug message: %s", "debug info"); + logging_set_debug(0); + + log_debug("This should not appear"); + + struct stat st; + stat(tmp_path, &st); + TEST_ASSERT(st.st_size > 0, "Log messages written"); + + FILE *f = fopen(tmp_path, "r"); + char content[4096] = {0}; + if (f) { + size_t bytes_read = fread(content, 1, sizeof(content) - 1, f); + (void)bytes_read; + fclose(f); + } + + TEST_ASSERT(strstr(content, "INFO") != NULL, "INFO level present"); + TEST_ASSERT(strstr(content, "ERROR") != NULL, "ERROR level present"); + TEST_ASSERT(strstr(content, "DEBUG") != NULL, "DEBUG level present"); + TEST_ASSERT(strstr(content, "42") != NULL, "Info param present"); + TEST_ASSERT(strstr(content, "test error") != NULL, "Error param present"); + + logging_cleanup(); + unlink(tmp_path); + + TEST_SUITE_END(); +} + +void test_logging_cleanup(void) { + TEST_SUITE_BEGIN("Logging Cleanup"); + + char tmp_path[] = "/tmp/test_rproxy_log_XXXXXX"; + int fd = mkstemp(tmp_path); + close(fd); + + logging_set_file(tmp_path); + log_info("Before cleanup"); + + logging_cleanup(); + + log_info("After cleanup to stdout"); + TEST_ASSERT(1, "Cleanup completed and logging works"); + + unlink(tmp_path); + + TEST_SUITE_END(); +} + +void test_logging_multiple_files(void) { + TEST_SUITE_BEGIN("Logging Multiple File Switches"); + + char tmp1[] = "/tmp/test_rproxy_log1_XXXXXX"; + char tmp2[] = "/tmp/test_rproxy_log2_XXXXXX"; + + int fd1 = mkstemp(tmp1); + int fd2 = mkstemp(tmp2); + close(fd1); + close(fd2); + + logging_set_file(tmp1); + log_info("Message to file 1"); + + logging_set_file(tmp2); + log_info("Message to file 2"); + + struct stat st1, st2; + stat(tmp1, &st1); + stat(tmp2, &st2); + + TEST_ASSERT(st1.st_size > 0, "First file has content"); + TEST_ASSERT(st2.st_size > 0, "Second file has content"); + + logging_cleanup(); + unlink(tmp1); + unlink(tmp2); + + TEST_SUITE_END(); +} + +void test_logging_error_with_errno(void) { + TEST_SUITE_BEGIN("Logging Error With Errno"); + + char tmp_path[] = "/tmp/test_rproxy_log_XXXXXX"; + int fd = mkstemp(tmp_path); + close(fd); + + logging_set_file(tmp_path); + + errno = ENOENT; + log_error("File not found error"); + errno = 0; + + log_error("Error without errno"); + + errno = EPERM; + log_error("Permission denied: %s", "/test/file"); + errno = 0; + + logging_cleanup(); + + FILE *f = fopen(tmp_path, "r"); + char content[4096] = {0}; + if (f) { + size_t bytes_read = fread(content, 1, sizeof(content) - 1, f); + (void)bytes_read; + fclose(f); + } + + TEST_ASSERT(strstr(content, "File not found") != NULL, "First error logged"); + TEST_ASSERT(strstr(content, "without errno") != NULL, "Second error logged"); + + unlink(tmp_path); + + TEST_SUITE_END(); +} + +void test_logging_debug_disabled(void) { + TEST_SUITE_BEGIN("Logging Debug Disabled"); + + char tmp_path[] = "/tmp/test_rproxy_log_XXXXXX"; + int fd = mkstemp(tmp_path); + close(fd); + + logging_set_file(tmp_path); + logging_set_debug(0); + + log_debug("This should not appear"); + log_info("This should appear"); + + struct stat st; + stat(tmp_path, &st); + TEST_ASSERT(st.st_size > 0, "File has some content"); + + FILE *f = fopen(tmp_path, "r"); + char content[4096] = {0}; + if (f) { + size_t bytes_read = fread(content, 1, sizeof(content) - 1, f); + (void)bytes_read; + fclose(f); + } + + TEST_ASSERT(strstr(content, "should appear") != NULL, "Info message present"); + + logging_cleanup(); + unlink(tmp_path); + + TEST_SUITE_END(); +} + +void test_logging_format_strings(void) { + TEST_SUITE_BEGIN("Logging Format Strings"); + + char tmp_path[] = "/tmp/test_rproxy_log_XXXXXX"; + int fd = mkstemp(tmp_path); + close(fd); + + logging_set_file(tmp_path); + + log_info("Int: %d, String: %s, Float: %.2f", 42, "test", 3.14); + log_error("Code: %d, Msg: %s", 500, "Internal error"); + + logging_set_debug(1); + log_debug("Debug: %s %d", "value", 123); + logging_set_debug(0); + + logging_cleanup(); + + FILE *f = fopen(tmp_path, "r"); + char content[4096] = {0}; + if (f) { + size_t bytes_read = fread(content, 1, sizeof(content) - 1, f); + (void)bytes_read; + fclose(f); + } + + TEST_ASSERT(strstr(content, "42") != NULL, "Int formatted"); + TEST_ASSERT(strstr(content, "test") != NULL, "String formatted"); + TEST_ASSERT(strstr(content, "500") != NULL, "Error code formatted"); + + unlink(tmp_path); + + TEST_SUITE_END(); +} + +void run_logging_tests(void) { + test_logging_debug_mode(); + test_logging_set_file(); + test_logging_set_file_null(); + test_logging_set_file_invalid(); + test_logging_log_functions(); + test_logging_cleanup(); + test_logging_multiple_files(); + test_logging_error_with_errno(); + test_logging_debug_disabled(); + test_logging_format_strings(); +}