src/server/stats.c

Go to the documentation of this file.

#include <ascii-chat/stats/runtime.h>
 
#include <libplatform/atomic.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "main.h"
#include "stats.h"
#include "client.h"
#include "render.h"
#include <ascii-chat/common.h>
#include <ascii-chat/common/buffer_sizes.h>
#include <ascii-chat/buffer.h>
#include <ascii-chat/network/packet/queue.h>
#include <ascii-chat/debug/sync.h>
#include <ascii-chat/common/sync.h>
#include <libplatform/lifecycle.h>

server_stats_t g_stats = {0};

mutex_t g_stats_mutex = {0};

static lifecycle_t g_stats_lc = LIFECYCLE_INIT_MUTEX(&g_stats_mutex);

int stats_init(void) {
  if (!lifecycle_init(&g_stats_lc, "stats")) {
    return 0; // Already initialized
  }
  return 0;
}

void stats_cleanup(void) {
  lifecycle_shutdown(&g_stats_lc);
}
 
/* ============================================================================
 * Statistics Collection and Reporting Thread
 * ============================================================================
 */

 
void *stats_logger_thread(void *arg) {
  (void)arg;
 
  while (!atomic_load_bool(&g_should_exit)) {
    // Log buffer domain statistics every 10 seconds with fast exit checking (10ms intervals)
    for (int i = 0; i < 1000 && !atomic_load_bool(&g_should_exit); i++) {
      platform_sleep_us(10 * US_PER_MS_INT); // 10ms sleep
    }
 
    // Check exit condition before proceeding with statistics logging
    // Check multiple times to avoid accessing freed resources during shutdown.
    if (atomic_load_bool(&g_should_exit)) {
      break;
    }
 
    buffer_domain_log_stats(buffer_default_domain(), "media");
    buffer_domain_log_stats(buffer_control_domain(), "control");
    buffer_domain_trim(buffer_default_domain());
    buffer_domain_trim(buffer_control_domain());
 
    // Collect all statistics data first
#ifndef NDEBUG
    char lock_debug_info[BUFFER_SIZE_MEDIUM] = {0};
    // Check exit condition again before accessing lock_debug.
    // lock_debug might be destroyed during shutdown
    if (!atomic_load_bool(&g_should_exit) && debug_sync_is_initialized()) {
      uint64_t total_acquired = 0, total_released = 0;
      uint32_t currently_held = 0;
      debug_sync_get_stats(&total_acquired, &total_released, &currently_held);
 
      safe_snprintf(lock_debug_info, sizeof(lock_debug_info),
                    "Historical Mutex/RWLock Statistics:\n"
                    "  Total locks acquired: %llu\n"
                    "  Total locks released: %llu\n"
                    "  Currently held: %u\n"
                    "  Net locks (acquired - released): %lld",
                    (unsigned long long)total_acquired, (unsigned long long)total_released, currently_held,
                    (long long)total_acquired - (long long)total_released);
    }
#endif
 
    // Collect client statistics
    // Check exit condition again before accessing rwlock.
    // rwlock might be destroyed during shutdown.
    if (atomic_load_bool(&g_should_exit)) {
      break;
    }
 
    rwlock_rdlock(&g_client_manager_rwlock);
    int active_clients = 0;
    int clients_with_audio = 0;
    int clients_with_video = 0;
 
    for (int i = 0; i < MAX_CLIENTS; i++) {
      if (atomic_load_bool(&g_client_manager.clients[i].active)) {
        active_clients++;
        if (atomic_load_bool(&g_client_manager.clients[i].is_sending_audio)) {
          clients_with_audio++;
        }
        if (atomic_load_bool(&g_client_manager.clients[i].is_sending_video)) {
          clients_with_video++;
        }
      }
    }
 
    rwlock_rdunlock(&g_client_manager_rwlock);
 
    log_info("Stats: Clients: %d, Audio: %d, Video: %d", active_clients, clients_with_audio, clients_with_video);
  }
 
  log_server_stats();
 
  asciichat_error_stats_print();
 
  // Clean up thread-local error context before exit
 
  return NULL;
}

void update_server_stats(void) {
  stats_snapshot_t snapshot;
  if (!lifecycle_is_initialized(&g_stats_lc) || stats_scope_snapshot(stats_runtime_scope(), &snapshot) != ASCIICHAT_OK)
    return;
  mutex_lock(&g_stats_mutex);
  g_stats.frames_captured = snapshot.counters[STATS_COUNTER_FRAMES_RECEIVED];
  g_stats.frames_sent = snapshot.counters[STATS_COUNTER_FRAMES_SENT];
  g_stats.frames_dropped = snapshot.counters[STATS_COUNTER_FRAMES_DROPPED];
  double seconds = (double)(snapshot.sampled_ns - snapshot.started_ns) / 1e9;
  g_stats.avg_capture_fps = seconds > 0 ? (double)g_stats.frames_captured / seconds : 0;
  g_stats.avg_send_fps = seconds > 0 ? (double)g_stats.frames_sent / seconds : 0;
  mutex_unlock(&g_stats_mutex);
}

void log_server_stats(void) {
  // Check if stats mutex is initialized (safe in debug builds where stats_init() may not be called)
  if (!lifecycle_is_initialized(&g_stats_lc)) {
    return; // Mutex not initialized, skip logging
  }
 
  // Now safe to use the mutex
  mutex_lock(&g_stats_mutex);
  log_info("Server Statistics:\n"
           "  frames_captured=%llu\n"
           "  frames_sent=%llu\n"
           "  frames_dropped=%llu\n"
           "  Average FPS: capture=%.2f, send=%.2f",
           (unsigned long long)g_stats.frames_captured, (unsigned long long)g_stats.frames_sent,
           (unsigned long long)g_stats.frames_dropped, g_stats.avg_capture_fps, g_stats.avg_send_fps);
  mutex_unlock(&g_stats_mutex);
}