555 lines
16 KiB
C#
555 lines
16 KiB
C#
using EonaCat.LogStack.Status.Data;
|
|
using EonaCat.LogStack.Status.Models;
|
|
using EonaCat.LogStack.Status.Services;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System.Text.Json;
|
|
|
|
namespace EonaCat.LogStack.Status.Controllers;
|
|
|
|
// This file is part of the EonaCat project(s) which is released under the Apache License.
|
|
// See the LICENSE file or go to https://EonaCat.com/License for full license details.
|
|
|
|
[ApiController]
|
|
[Route("api")]
|
|
public class ApiController : ControllerBase
|
|
{
|
|
private readonly DatabaseContext _database;
|
|
private readonly MonitoringService _monitorService;
|
|
private readonly IngestionService _ingestionService;
|
|
|
|
public ApiController(DatabaseContext database, MonitoringService monitorService, IngestionService ingestionService)
|
|
{
|
|
_database = database;
|
|
_monitorService = monitorService;
|
|
_ingestionService = ingestionService;
|
|
}
|
|
|
|
[HttpGet("status/summary")]
|
|
public async Task<IActionResult> GetSummary()
|
|
{
|
|
var isAdmin = IsAdmin();
|
|
var stats = await _monitorService.GetStatsAsync(isAdmin);
|
|
return Ok(stats);
|
|
}
|
|
|
|
[HttpGet("monitors")]
|
|
public async Task<IActionResult> GetMonitors()
|
|
{
|
|
var isAdmin = IsAdmin();
|
|
var query = _database.Monitors.Where(m => m.IsActive);
|
|
if (!isAdmin)
|
|
{
|
|
query = query.Where(m => m.IsPublic);
|
|
}
|
|
|
|
return Ok(await query.ToListAsync());
|
|
}
|
|
|
|
[HttpGet("monitors/{id}")]
|
|
public async Task<IActionResult> GetMonitor(int id)
|
|
{
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
if (!IsAdmin() && !monitor.IsPublic)
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
return Ok(monitor);
|
|
}
|
|
|
|
[HttpGet("monitors/{id}/check")]
|
|
public async Task<IActionResult> CheckMonitor(int id)
|
|
{
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var check = await _monitorService.CheckMonitorAsync(monitor);
|
|
return Ok(check);
|
|
}
|
|
|
|
/// <summary>Returns the last N checks for a monitor (default 100).</summary>
|
|
[HttpGet("monitors/{id}/history")]
|
|
public async Task<IActionResult> GetMonitorHistory(int id, [FromQuery] int limit = 100)
|
|
{
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
if (!IsAdmin() && !monitor.IsPublic)
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var checks = await _database.MonitorChecks
|
|
.Where(c => c.MonitorId == id)
|
|
.OrderByDescending(c => c.CheckedAt)
|
|
.Take(Math.Clamp(limit, 1, 1000))
|
|
.ToListAsync();
|
|
|
|
return Ok(checks);
|
|
}
|
|
|
|
/// <summary>Returns uptime percentages over 24h / 7d / 30d windows.</summary>
|
|
[HttpGet("monitors/{id}/uptime")]
|
|
public async Task<IActionResult> GetMonitorUptime(int id)
|
|
{
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
if (!IsAdmin() && !monitor.IsPublic)
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var report = await _monitorService.GetUptimeReportAsync(id);
|
|
return Ok(report);
|
|
}
|
|
|
|
/// <summary>Pause or resume a monitor (admin only).</summary>
|
|
[HttpPost("monitors/{id}/pause")]
|
|
public async Task<IActionResult> PauseMonitor(int id)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
monitor.IsActive = false;
|
|
await _database.SaveChangesAsync();
|
|
return Ok(new { id, active = false });
|
|
}
|
|
|
|
[HttpPost("monitors/{id}/resume")]
|
|
public async Task<IActionResult> ResumeMonitor(int id)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
monitor.IsActive = true;
|
|
monitor.LastChecked = null; // force immediate re-check
|
|
await _database.SaveChangesAsync();
|
|
return Ok(new { id, active = true });
|
|
}
|
|
|
|
[HttpGet("monitors/{id}/alerts")]
|
|
public async Task<IActionResult> GetAlertRules(int id)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var rules = await _database.AlertRules.Where(r => r.MonitorId == id).ToListAsync();
|
|
return Ok(rules);
|
|
}
|
|
|
|
[HttpPost("monitors/{id}/alerts")]
|
|
public async Task<IActionResult> CreateAlertRule(int id, [FromBody] AlertRule rule)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var monitor = await _database.Monitors.FindAsync(id);
|
|
if (monitor == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
rule.MonitorId = id;
|
|
_database.AlertRules.Add(rule);
|
|
await _database.SaveChangesAsync();
|
|
return Ok(rule);
|
|
}
|
|
|
|
[HttpDelete("alerts/{ruleId}")]
|
|
public async Task<IActionResult> DeleteAlertRule(int ruleId)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var rule = await _database.AlertRules.FindAsync(ruleId);
|
|
if (rule == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
_database.AlertRules.Remove(rule);
|
|
await _database.SaveChangesAsync();
|
|
return Ok(new { deleted = ruleId });
|
|
}
|
|
|
|
/// <summary>List incidents (admin sees all; public sees only IsPublic incidents).</summary>
|
|
[HttpGet("incidents")]
|
|
public async Task<IActionResult> GetIncidents([FromQuery] bool activeOnly = false)
|
|
{
|
|
var isAdmin = IsAdmin();
|
|
var query = _database.Incidents.Include(i => i.Updates).AsQueryable();
|
|
if (!isAdmin)
|
|
{
|
|
query = query.Where(i => i.IsPublic);
|
|
}
|
|
|
|
if (activeOnly)
|
|
{
|
|
query = query.Where(i => i.Status != IncidentStatus.Resolved);
|
|
}
|
|
|
|
var list = await query.OrderByDescending(i => i.CreatedAt).ToListAsync();
|
|
return Ok(list);
|
|
}
|
|
|
|
[HttpGet("incidents/{id}")]
|
|
public async Task<IActionResult> GetIncident(int id)
|
|
{
|
|
var incident = await _database.Incidents.Include(i => i.Updates).FirstOrDefaultAsync(i => i.Id == id);
|
|
if (incident == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
if (!IsAdmin() && !incident.IsPublic)
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
return Ok(incident);
|
|
}
|
|
|
|
[HttpPost("incidents")]
|
|
public async Task<IActionResult> CreateIncident([FromBody] Incident incident)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
incident.CreatedAt = DateTime.UtcNow;
|
|
incident.UpdatedAt = DateTime.UtcNow;
|
|
_database.Incidents.Add(incident);
|
|
await _database.SaveChangesAsync();
|
|
return Ok(incident);
|
|
}
|
|
|
|
[HttpPatch("incidents/{id}")]
|
|
public async Task<IActionResult> UpdateIncident(int id, [FromBody] IncidentPatchDto patch)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var incident = await _database.Incidents.FindAsync(id);
|
|
if (incident == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
if (patch.Status.HasValue)
|
|
{
|
|
incident.Status = patch.Status.Value;
|
|
if (patch.Status == IncidentStatus.Resolved)
|
|
{
|
|
incident.ResolvedAt = DateTime.UtcNow;
|
|
}
|
|
}
|
|
if (patch.Severity.HasValue)
|
|
{
|
|
incident.Severity = patch.Severity.Value;
|
|
}
|
|
|
|
if (patch.Body != null)
|
|
{
|
|
incident.Body = patch.Body;
|
|
}
|
|
|
|
incident.UpdatedAt = DateTime.UtcNow;
|
|
|
|
if (!string.IsNullOrWhiteSpace(patch.UpdateMessage))
|
|
{
|
|
_database.IncidentUpdates.Add(new IncidentUpdate
|
|
{
|
|
IncidentId = id,
|
|
Message = patch.UpdateMessage,
|
|
Status = patch.Status ?? incident.Status
|
|
});
|
|
}
|
|
|
|
await _database.SaveChangesAsync();
|
|
return Ok(incident);
|
|
}
|
|
|
|
[HttpDelete("incidents/{id}")]
|
|
public async Task<IActionResult> DeleteIncident(int id)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var incident = await _database.Incidents.FindAsync(id);
|
|
if (incident == null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
_database.Incidents.Remove(incident);
|
|
await _database.SaveChangesAsync();
|
|
return Ok(new { deleted = id });
|
|
}
|
|
|
|
[HttpGet("logs")]
|
|
public async Task<IActionResult> QueryLogs(
|
|
[FromQuery] string? level,
|
|
[FromQuery] string? source,
|
|
[FromQuery] string? search,
|
|
[FromQuery] DateTime? from,
|
|
[FromQuery] DateTime? to,
|
|
[FromQuery] int page = 1,
|
|
[FromQuery] int pageSize = 100)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var query = _database.Logs.AsQueryable();
|
|
if (!string.IsNullOrWhiteSpace(level))
|
|
{
|
|
query = query.Where(x => x.Level == level.ToLower());
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(source))
|
|
{
|
|
query = query.Where(x => x.Source == source);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(search))
|
|
{
|
|
query = query.Where(x => x.Message.Contains(search));
|
|
}
|
|
|
|
if (from.HasValue)
|
|
{
|
|
query = query.Where(x => x.Timestamp >= from.Value);
|
|
}
|
|
|
|
if (to.HasValue)
|
|
{
|
|
query = query.Where(x => x.Timestamp <= to.Value);
|
|
}
|
|
|
|
var total = await query.CountAsync();
|
|
var entries = await query
|
|
.OrderByDescending(x => x.Timestamp)
|
|
.Skip((page - 1) * pageSize)
|
|
.Take(pageSize)
|
|
.ToListAsync();
|
|
|
|
return Ok(new { total, page, pageSize, entries });
|
|
}
|
|
|
|
/// <summary>Returns hourly log volume buckets for charting.</summary>
|
|
[HttpGet("logs/stats")]
|
|
public async Task<IActionResult> GetLogStats([FromQuery] int hours = 24)
|
|
{
|
|
if (!IsAdmin())
|
|
{
|
|
return Unauthorized();
|
|
}
|
|
|
|
var buckets = await _monitorService.GetLogStatsAsync(Math.Clamp(hours, 1, 168));
|
|
return Ok(buckets);
|
|
}
|
|
|
|
[HttpPost("logs/ingest")]
|
|
public async Task<IActionResult> IngestLog([FromBody] LogEntry entry)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(entry.Message))
|
|
{
|
|
return BadRequest("message required");
|
|
}
|
|
|
|
entry.Level = (entry.Level ?? "info").ToLower();
|
|
entry.Timestamp = DateTime.UtcNow;
|
|
await _ingestionService.IngestAsync(entry);
|
|
return Ok(new { success = true });
|
|
}
|
|
|
|
[HttpPost("logs/batch")]
|
|
public async Task<IActionResult> IngestBatch([FromBody] List<LogEntry> entries)
|
|
{
|
|
if (entries == null || !entries.Any())
|
|
{
|
|
return BadRequest("entries required");
|
|
}
|
|
|
|
foreach (var entry in entries)
|
|
{
|
|
entry.Level = (entry.Level ?? "info").ToLower();
|
|
if (entry.Timestamp == default)
|
|
{
|
|
entry.Timestamp = DateTime.UtcNow;
|
|
}
|
|
}
|
|
await _ingestionService.IngestBatchAsync(entries);
|
|
return Ok(new { success = true, count = entries.Count });
|
|
}
|
|
|
|
[HttpPost("logs/eonacat")]
|
|
public async Task<IActionResult> IngestEonaCat([FromBody] object[] events)
|
|
{
|
|
var entries = new List<LogEntry>();
|
|
foreach (var evtObj in events)
|
|
{
|
|
var json = JsonSerializer.Serialize(evtObj);
|
|
var dict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json)!;
|
|
var logEntry = new LogEntry
|
|
{
|
|
Source = dict.TryGetValue("properties", out var props) &&
|
|
props.ValueKind == JsonValueKind.Object &&
|
|
props.Deserialize<Dictionary<string, object?>>()!.TryGetValue("Application", out var appObj)
|
|
? appObj?.ToString() ?? "EonaCat.LogStack" : "EonaCat.LogStack",
|
|
Level = dict.TryGetValue("level", out var level) ? level.GetString() ?? "Info" : "Info",
|
|
Message = dict.TryGetValue("message", out var msg) ? msg.GetString() ?? "" : "",
|
|
Exception = dict.TryGetValue("exception", out var ex) ? ex.ToString() : null,
|
|
Host = dict.TryGetValue("host", out var host) ? host.GetString() : null,
|
|
TraceId = dict.TryGetValue("traceId", out var traceId) ? traceId.GetString() : null,
|
|
Properties = dict.TryGetValue("properties", out var properties) ? properties.GetRawText() : null,
|
|
Timestamp = dict.TryGetValue("timestamp", out var ts) && DateTime.TryParse(ts.GetString(), out var dt) ? dt : DateTime.UtcNow
|
|
};
|
|
logEntry.Level = MapEonaCatLevel(logEntry.Level);
|
|
entries.Add(logEntry);
|
|
}
|
|
if (entries.Any())
|
|
{
|
|
await _ingestionService.IngestBatchAsync(entries);
|
|
}
|
|
|
|
return Ok(new { success = true, count = entries.Count });
|
|
}
|
|
|
|
[HttpPost("logs/serilog")]
|
|
public async Task<IActionResult> IngestSerilog([FromBody] SerilogPayload payload)
|
|
{
|
|
var entries = payload.Events?.Select(e => new LogEntry
|
|
{
|
|
Source = e.Properties?.TryGetValue("Application", out var app) == true ? app?.ToString() ?? "serilog" : "serilog",
|
|
Level = MapSerilogLevel(e.Level),
|
|
Message = e.RenderedMessage ?? e.MessageTemplate ?? "",
|
|
Exception = e.Exception,
|
|
Properties = e.Properties != null ? JsonSerializer.Serialize(e.Properties) : null,
|
|
Timestamp = e.Timestamp == default ? DateTime.UtcNow : e.Timestamp
|
|
}).ToList() ?? new List<LogEntry>();
|
|
|
|
if (entries.Any())
|
|
{
|
|
await _ingestionService.IngestBatchAsync(entries);
|
|
}
|
|
|
|
return Ok(new { success = true, count = entries.Count });
|
|
}
|
|
|
|
private bool IsAdmin() => HttpContext.Session.GetString("IsAdmin") == "true";
|
|
|
|
private static string MapSerilogLevel(string? l) => l?.ToLower() switch
|
|
{
|
|
"verbose" or "debug" => "debug",
|
|
"information" => "info",
|
|
"warning" => "warn",
|
|
"error" => "error",
|
|
"fatal" => "critical",
|
|
_ => "info"
|
|
};
|
|
|
|
private static string MapEonaCatLevel(string? l) => l?.ToLower() switch
|
|
{
|
|
"trace" or "debug" => "debug",
|
|
"information" => "info",
|
|
"warning" => "warn",
|
|
"error" => "error",
|
|
"critical" => "critical",
|
|
_ => "info"
|
|
};
|
|
}
|
|
|
|
public class IncidentPatchDto
|
|
{
|
|
public IncidentStatus? Status { get; set; }
|
|
public IncidentSeverity? Severity { get; set; }
|
|
public string? Body { get; set; }
|
|
/// <summary>If provided, a new IncidentUpdate is appended with this message.</summary>
|
|
public string? UpdateMessage { get; set; }
|
|
}
|
|
|
|
public class EonaCatPayLoad
|
|
{
|
|
public List<EonaCatLogEvent>? Events { get; set; }
|
|
}
|
|
|
|
public class EonaCatLogEvent
|
|
{
|
|
public string Timestamp { get; set; } = default!;
|
|
public string Level { get; set; } = default!;
|
|
public string Message { get; set; } = default!;
|
|
public string Category { get; set; } = default!;
|
|
public int ThreadId { get; set; }
|
|
public string? TraceId { get; set; }
|
|
public string? SpanId { get; set; }
|
|
public ExceptionDto? Exception { get; set; }
|
|
public Dictionary<string, object?>? Properties { get; set; }
|
|
}
|
|
|
|
public class ExceptionDto
|
|
{
|
|
public string Type { get; set; } = default!;
|
|
public string Message { get; set; } = default!;
|
|
public string? StackTrace { get; set; }
|
|
}
|
|
|
|
public class SerilogPayload
|
|
{
|
|
public List<SerilogEvent>? Events { get; set; }
|
|
}
|
|
|
|
public class SerilogEvent
|
|
{
|
|
public DateTime Timestamp { get; set; }
|
|
public string? Level { get; set; }
|
|
public string? MessageTemplate { get; set; }
|
|
public string? RenderedMessage { get; set; }
|
|
public string? Exception { get; set; }
|
|
public Dictionary<string, object?>? Properties { get; set; }
|
|
}
|