feat: add statistics API and dashboard for asset metrics

- Implemented `/api/stats` endpoint to return JSON metrics including active assets, total uploads, storage usage, and recent activity.
- Created `stats.html` page to display real-time statistics with auto-refresh functionality.
- Enhanced asset logging to include uploader IP and detailed event information for uploads and deletions.
- Updated asset model to store uploader IP for audit purposes.
- Improved logging functionality to ensure log directory exists before writing.
- Refactored asset creation and management to support new features and logging.

src/api.rs

@@ -3,7 +3,10 @@ use base64::{Engine, engine::general_purpose};
 use serde::Deserialize;
 use serde_json::json;
 
-use crate::{DATA_STORAGE, logs::log_to_file};
+use crate::{
+    DATA_STORAGE,
+    logs::{log_asset_event, log_to_file},
+};
 
 #[derive(Deserialize, Debug)]
 pub struct UploadRequest {
@@ -13,20 +16,43 @@ pub struct UploadRequest {
 }
 
 #[post("/api/upload")]
-async fn api_upload(req: web::Json<UploadRequest>) -> Result<HttpResponse, actix_web::Error> {
+async fn api_upload(req: HttpRequest, body: web::Json<UploadRequest>) -> Result<HttpResponse, actix_web::Error> {
     // Convert to bytes
-    let content_bytes = if req.content_type == "text/plain" {
-        req.content.as_bytes().to_vec() // UTF-8 bytes
+    let content_bytes = if body.content_type == "text/plain" {
+        body.content.as_bytes().to_vec() // UTF-8 bytes
     } else {
         // Decode base64 → bytes
-        general_purpose::STANDARD.decode(&req.content).unwrap()
+        general_purpose::STANDARD.decode(&body.content).unwrap()
     };
-    let asset = crate::data_mgt::Asset::new(req.duration, req.content_type.clone(), content_bytes);
+    let connection_info = req.connection_info();
+    let uploader_ip = connection_info
+        .realip_remote_addr()
+        .or_else(|| connection_info.peer_addr())
+        .unwrap_or("-")
+        .to_string();
+
+    let asset = crate::data_mgt::Asset::new(
+        body.duration,
+        body.content_type.clone(),
+        content_bytes,
+        Some(uploader_ip.clone()),
+    );
 
     let id = asset
         .save()
         .map_err(|e| actix_web::error::ErrorInternalServerError(format!("Failed to save asset: {}", e)))?;
 
+    log_asset_event(
+        "upload",
+        asset.id(),
+        asset.mime(),
+        asset.size_bytes(),
+        asset.share_duration(),
+        asset.created_at(),
+        asset.expires_at(),
+        asset.uploader_ip().unwrap_or("-"),
+    );
+
     let response_body = json!({ "link": format!("/bhs/{}", id) });
     Ok(HttpResponse::Ok().json(response_body))
 }
@@ -48,3 +74,140 @@ async fn api_get_asset(req: HttpRequest, path: web::Path<String>) -> Result<Http
     log_to_file(&req, now);
     Ok(HttpResponse::Ok().content_type(asset.mime()).body(asset.content()))
 }
+
+#[derive(serde::Serialize)]
+struct StatsResponse {
+    active_assets: usize,
+    total_uploads: usize,
+    total_deleted: usize,
+    storage_bytes: u64,
+    image_count: usize,
+    text_count: usize,
+    avg_response_ms: f64,
+    total_requests: usize,
+    recent_activity: Vec<ActivityItem>,
+}
+
+#[derive(serde::Serialize)]
+struct ActivityItem {
+    action: String,
+    mime: String,
+    size_bytes: usize,
+    timestamp: String,
+}
+
+#[get("/api/stats")]
+async fn api_stats() -> Result<HttpResponse, actix_web::Error> {
+    use crate::LOG_DIR;
+    use std::fs;
+
+    let mut active_assets = 0;
+    let mut storage_bytes: u64 = 0;
+    let mut image_count = 0;
+    let mut text_count = 0;
+
+    // Count active assets and calculate storage
+    if let Ok(entries) = fs::read_dir(DATA_STORAGE) {
+        for entry in entries.flatten() {
+            if let Ok(data) = fs::read(entry.path()) {
+                if let Ok(asset) = serde_json::from_slice::<crate::data_mgt::Asset>(&data) {
+                    if !asset.is_expired() {
+                        active_assets += 1;
+                        storage_bytes += asset.size_bytes() as u64;
+                        if asset.mime().starts_with("image/") {
+                            image_count += 1;
+                        } else if asset.mime().starts_with("text/") {
+                            text_count += 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Parse log for upload/delete counts, response times, and recent activity
+    let mut total_uploads = 0;
+    let mut total_deleted = 0;
+    let mut recent_activity: Vec<ActivityItem> = Vec::new();
+    let mut total_response_ms: f64 = 0.0;
+    let mut request_count: usize = 0;
+
+    let log_path = format!("{}access.log", LOG_DIR);
+    if let Ok(content) = fs::read_to_string(&log_path) {
+        for line in content.lines() {
+            // Parse response time from request logs
+            if line.contains("dur_ms=") {
+                if let Some(dur_str) = line.split("dur_ms=").nth(1) {
+                    if let Some(dur_val) = dur_str.split_whitespace().next() {
+                        if let Ok(ms) = dur_val.parse::<f64>() {
+                            total_response_ms += ms;
+                            request_count += 1;
+                        }
+                    }
+                }
+            }
+
+            if line.contains("event=asset") {
+                if line.contains("action=upload") {
+                    total_uploads += 1;
+                } else if line.contains("action=delete_expired") {
+                    total_deleted += 1;
+                }
+
+                // Parse for recent activity (last 20)
+                if let Some(activity) = parse_activity_line(line) {
+                    recent_activity.push(activity);
+                }
+            }
+        }
+    }
+
+    let avg_response_ms = if request_count > 0 { total_response_ms / request_count as f64 } else { 0.0 };
+
+    // Keep only last 20, most recent first
+    recent_activity.reverse();
+    recent_activity.truncate(20);
+
+    let response = StatsResponse {
+        active_assets,
+        total_uploads,
+        total_deleted,
+        storage_bytes,
+        image_count,
+        text_count,
+        avg_response_ms,
+        total_requests: request_count,
+        recent_activity,
+    };
+
+    Ok(HttpResponse::Ok().json(response))
+}
+
+fn parse_activity_line(line: &str) -> Option<ActivityItem> {
+    let timestamp = line.split_whitespace().next()?.to_string();
+
+    let action = if line.contains("action=upload") {
+        "upload".to_string()
+    } else if line.contains("action=delete_expired") {
+        "delete".to_string()
+    } else {
+        return None;
+    };
+
+    let mime = line.split("mime=").nth(1)?.split_whitespace().next()?.to_string();
+
+    let size_bytes: usize = line
+        .split("size_bytes=")
+        .nth(1)?
+        .split_whitespace()
+        .next()?
+        .parse()
+        .ok()?;
+
+    Some(ActivityItem {
+        action,
+        mime,
+        size_bytes,
+        timestamp,
+    })
+}