icsboyx/bhs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor statistics page and enhance logging

Browse Source 
- Updated the layout and styling of the statistics page for better responsiveness and visual appeal.
- Introduced a new error page for 404 errors with user-friendly messaging and navigation options.
- Enhanced logging functionality to capture detailed events related to asset uploads, deletions, and HTTP requests.
- Implemented an AssetTracker to manage assets in memory, allowing for efficient tracking and retrieval.
- Improved the API for uploading and retrieving assets, ensuring better error handling and response formatting.
- Added auto-refresh functionality to the statistics page to keep data up-to-date.
This commit is contained in:
icsboyx
2026-01-11 07:51:47 +01:00
parent 81656ec0da
commit cde83139b1
13 changed files with 974 additions and 847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
src/api.rs
View File

@@ -1,11 +1,12 @@
use actix_web::{HttpRequest, HttpResponse, get, post, web};
use base64::{Engine, engine::general_purpose};
use serde::Deserialize;
use serde_json::json;
use crate::{
DATA_STORAGE,
logs::{log_asset_event, log_to_file},
data_mgt::AssetTracker,
logs::{LogEventType, log_event},
};
#[derive(Deserialize, Debug)]
@@ -16,7 +17,11 @@ pub struct UploadRequest {
}
#[post("/api/upload")]
async fn api_upload(req: HttpRequest, body: web::Json<UploadRequest>) -> Result<HttpResponse, actix_web::Error> {
async fn api_upload(
req: HttpRequest,
body: web::Json<UploadRequest>,
assets: web::Data<AssetTracker>,
) -> Result<HttpResponse, actix_web::Error> {
// Convert to bytes
let content_bytes = if body.content_type == "text/plain" {
body.content.as_bytes().to_vec() // UTF-8 bytes
@@ -38,41 +43,27 @@ async fn api_upload(req: HttpRequest, body: web::Json<UploadRequest>) -> Result<
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("-"),
);
log_event(LogEventType::AssetUploaded(&asset));
let id = asset.id();
assets.add_asset(asset).await;
let response_body = json!({ "link": format!("/bhs/{}", id) });
Ok(HttpResponse::Ok().json(response_body))
}
#[get("/api/content/{id}")]
async fn api_get_asset(req: HttpRequest, path: web::Path<String>) -> Result<HttpResponse, actix_web::Error> {
let now = std::time::Instant::now();
async fn api_get_asset(
req: HttpRequest,
path: web::Path<String>,
assets: web::Data<AssetTracker>,
) -> Result<HttpResponse, actix_web::Error> {
log_event(LogEventType::HttpRequest(&req.into()));
let id = path.into_inner();
let asset_path = format!("{}{}", DATA_STORAGE, id);
let data = std::fs::read(&asset_path).map_err(|_| actix_web::error::ErrorNotFound("Asset not found"))?;
let asset = serde_json::from_slice::<crate::data_mgt::Asset>(&data)
.map_err(|_| actix_web::error::ErrorInternalServerError("Failed to parse asset data"))?;
if asset.is_expired() {
return Err(actix_web::error::ErrorNotFound("Asset has expired"));
match assets.get_asset(&path.into_inner()).await {
None => Ok(HttpResponse::NotFound().body("Asset not found")),
Some(asset) => Ok(HttpResponse::Ok()
.content_type(asset.mime())
.body(asset.content().clone())),
}
log_to_file(&req, now);
Ok(HttpResponse::Ok().content_type(asset.mime()).body(asset.content()))
}
#[derive(serde::Serialize)]
@@ -83,7 +74,6 @@ struct StatsResponse {
storage_bytes: u64,
image_count: usize,
text_count: usize,
avg_response_ms: f64,
total_requests: usize,
recent_activity: Vec<ActivityItem>,
}
@@ -92,78 +82,88 @@ struct StatsResponse {
struct ActivityItem {
action: String,
mime: String,
size_bytes: usize,
share_duration: u32,
timestamp: String,
}
#[derive(Deserialize)]
struct LogEventLine {
time: String,
event: LogEventBody,
}
#[derive(Deserialize)]
enum LogEventBody {
AssetUploaded(LogAsset),
AssetDeleted(LogAsset),
HttpRequest(LogHttpRequest),
}
#[derive(Deserialize)]
struct LogAsset {
id: String,
share_duration: u32,
created_at: i64,
expires_at: i64,
mime: String,
uploader_ip: Option<String>,
}
#[derive(Deserialize)]
struct LogHttpRequest {
method: String,
path: String,
query_string: String,
scheme: String,
ip: String,
real_ip: String,
user_agent: String,
}
#[get("/api/stats")]
async fn api_stats() -> Result<HttpResponse, actix_web::Error> {
async fn api_stats(assets: web::Data<AssetTracker>) -> 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;
let (active_assets, storage_bytes, image_count, text_count) =
assets.stats_summary().await;
// 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 let Ok(entry) = serde_json::from_str::<LogEventLine>(line) {
match entry.event {
LogEventBody::HttpRequest(_req) => {
request_count += 1;
}
LogEventBody::AssetUploaded(asset) => {
total_uploads += 1;
recent_activity.push(ActivityItem {
action: "upload".to_string(),
mime: asset.mime,
share_duration: asset.share_duration,
timestamp: entry.time,
});
}
LogEventBody::AssetDeleted(asset) => {
total_deleted += 1;
recent_activity.push(ActivityItem {
action: "delete".to_string(),
mime: asset.mime,
share_duration: asset.share_duration,
timestamp: entry.time,
});
}
}
}
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);
@@ -175,39 +175,9 @@ async fn api_stats() -> Result<HttpResponse, actix_web::Error> {
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,
})
}