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,
+    })
+}

src/data_mgt.rs

@@ -3,6 +3,7 @@ use chrono::{Duration, Utc};
 use serde::{Deserialize, Serialize};
 
 use crate::DATA_STORAGE;
+use crate::logs::log_asset_event;
 
 #[derive(Debug, Serialize, Deserialize, Default)]
 pub struct Asset {
@@ -12,10 +13,12 @@ pub struct Asset {
     expires_at: i64,
     mime: String,
     content: Vec<u8>,
+    #[serde(default)]
+    uploader_ip: Option<String>,
 }
 
 impl Asset {
-    pub fn new(share_duration: u32, mime: String, content: Vec<u8>) -> Self {
+    pub fn new(share_duration: u32, mime: String, content: Vec<u8>, uploader_ip: Option<String>) -> Self {
         let id = uuid::Uuid::new_v4().to_string();
         let created_at = Utc::now().timestamp_millis();
         let expires_at = created_at + Duration::minutes(share_duration as i64).num_milliseconds();
@@ -26,6 +29,7 @@ impl Asset {
             expires_at,
             mime,
             content,
+            uploader_ip,
         }
     }
     pub fn is_expired(&self) -> bool {
@@ -44,6 +48,26 @@ impl Asset {
         self.content.clone()
     }
 
+    pub fn share_duration(&self) -> u32 {
+        self.share_duration
+    }
+
+    pub fn created_at(&self) -> i64 {
+        self.created_at
+    }
+
+    pub fn expires_at(&self) -> i64 {
+        self.expires_at
+    }
+
+    pub fn size_bytes(&self) -> usize {
+        self.content.len()
+    }
+
+    pub fn uploader_ip(&self) -> Option<&str> {
+        self.uploader_ip.as_deref()
+    }
+
     pub fn to_bytes(&self) -> Result<Vec<u8>> {
         let bytes = serde_json::to_vec(self)?;
         Ok(bytes)
@@ -68,6 +92,16 @@ pub async fn clear_assets() -> Result<()> {
             let asset = serde_json::from_slice::<Asset>(&data)?;
             if asset.is_expired() {
                 println!("Removing expired asset: {}", asset.id());
+                log_asset_event(
+                    "delete_expired",
+                    asset.id(),
+                    asset.mime(),
+                    asset.size_bytes(),
+                    asset.share_duration(),
+                    asset.created_at(),
+                    asset.expires_at(),
+                    asset.uploader_ip().unwrap_or("-"),
+                );
                 std::fs::remove_file(&path)?;
             }
         }

src/logs.rs

@@ -11,6 +11,12 @@ pub fn log_to_file(req: &HttpRequest, start: Instant) {
 
     let log_path = LOG_DIR.to_string() + "access.log";
 
+    // Ensure log directory exists
+    if let Err(e) = std::fs::create_dir_all(LOG_DIR) {
+        eprintln!("failed to create log dir: {}", e);
+        return;
+    }
+
     let Ok(mut file) = OpenOptions::new().create(true).append(true).open(log_path) else {
         eprintln!("failed to open log file");
         return;
@@ -40,3 +46,35 @@ pub fn log_to_file(req: &HttpRequest, start: Instant) {
 
     let _ = file.write_all(line.as_bytes());
 }
+
+pub fn log_asset_event(
+    action: &str,
+    id: &str,
+    mime: &str,
+    size_bytes: usize,
+    duration_min: u32,
+    created_at_ms: i64,
+    expires_at_ms: i64,
+    uploader_ip: &str,
+) {
+    // Ensure logging directory exists before writing
+    if let Err(e) = std::fs::create_dir_all(LOG_DIR) {
+        eprintln!("failed to create log dir for asset event: {}", e);
+        return;
+    }
+
+    let log_path = LOG_DIR.to_string() + "access.log";
+
+    let Ok(mut file) = OpenOptions::new().create(true).append(true).open(log_path) else {
+        eprintln!("failed to open log file for asset event");
+        return;
+    };
+
+    let ts = chrono::Local::now().to_rfc3339();
+
+    let line = format!(
+        "{ts} event=asset action={action} id={id} mime={mime} size_bytes={size_bytes} duration_min={duration_min} created_at_ms={created_at_ms} expires_at_ms={expires_at_ms} uploader_ip={uploader_ip}\n"
+    );
+
+    let _ = file.write_all(line.as_bytes());
+}

src/main.rs

@@ -10,9 +10,9 @@ use actix_web::{
 use serde_json::Value;
 use std::{env, fs, path::PathBuf, sync::LazyLock};
 
-pub static HTML_DIR: &str = "html/";
-pub static LOG_DIR: &str = "logs/";
-pub static DATA_STORAGE: &str = "storage/";
+pub static HTML_DIR: &str = "data/html/";
+pub static LOG_DIR: &str = "data/logs/";
+pub static DATA_STORAGE: &str = "data/storage/";
 
 pub static BIND_ADDR: LazyLock<String> = LazyLock::new(|| match env::var("BIND_ADDR") {
     Ok(addr) => {
@@ -43,7 +43,7 @@ pub static STATIC_PAGES: LazyLock<Vec<String>> = LazyLock::new(|| {
 });
 
 use crate::{
-    api::{api_get_asset, api_upload},
+    api::{api_get_asset, api_stats, api_upload},
     logs::log_to_file,
 };
 
@@ -102,6 +102,7 @@ async fn main() -> std::io::Result<()> {
             .service(view_asset)
             .service(api_get_asset)
             .service(api_upload)
+            .service(api_stats)
             .service(catch_all)
     })
     .bind((BIND_ADDR.clone(), *BIND_PORT))?