Admin logs (#5419)

* Add admin logging, models, migrations

* Add logging damage changes

* Add Log admin flag, LogFilter, Logs admin menu tab, message
Refactor admin logging API

* Change admin log get method names

* Fix the name again

* Minute amount of reorganization

* Reset Postgres db snapshot

* Reset Sqlite db snapshot

* Make AdminLog have a composite primary key of round, id

* Minute cleanup

* Change admin system to do a type check instead of index check

* Make admin logs use C# 10 interpolated string handlers

* Implement UI on its own window
Custom controls
Searching
Add admin log converters

* Implement limits into the query

* Change logs to be put into an OutputPanel instead for text wrapping

* Add log <-> player m2m relationship back

* UI improvements, make text wrap, add separators

* Remove entity prefix from damaged log

* Add explicit m2m model, fix any players filter

* Add debug command to test bulk adding logs

* Admin logs now just kinda go

* Add histogram for database update time

* Make admin log system update run every 5 seconds

* Add a cap to the log queue and a metric for how many times it has been reached

* Add metric for logs sent in a round

* Make cvars out of admin logs queue send delay and cap

* Merge fixes

* Reset some changes

* Add test for adding and getting a single log

* Add tests for bulk adding logs

* Add test for querying logs

* Add CallerArgumentExpression to LogStringHandler methods and test

* Improve UI, fix SQLite, add searching by round

* Add entities to admin logs

* Move distinct after orderby

* Add migrations

* ef core eat my ass

* Add cvar for client logs batch size

* Sort logs from newest to oldest by default

* Merge fixes

* Reorganize tests and add one for date ordering

* Add note to log types to not change their numeric values

* Add impacts to logs, better UI filtering

* Make log add callable from shared for convenience

* Get current round id directly from game ticker

* Revert namespace change for DamageableSystem
This commit is contained in:
Javier Guardia Fernández
2021-11-22 18:49:26 +01:00
committed by GitHub
parent 0f7e81b564
commit 319aec109d
65 changed files with 7021 additions and 236 deletions

View File

@@ -0,0 +1,197 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Content.Server.Administration.Logs;
using Content.Server.Database;
using Content.Shared.Administration.Logs;
using Content.Shared.CCVar;
using NUnit.Framework;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
namespace Content.IntegrationTests.Tests.Administration.Logs;
[TestFixture]
[TestOf(typeof(AdminLogSystem))]
public class AddTests : ContentIntegrationTest
{
[Test]
public async Task AddAndGetSingleLog()
{
var server = StartServer(new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = sSystems.GetEntitySystem<AdminLogSystem>();
var guid = Guid.NewGuid();
await server.WaitPost(() =>
{
var coordinates = GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {guid}");
});
await WaitUntil(server, async () =>
{
var logs = sAdminLogSystem.CurrentRoundJson(new LogFilter
{
Search = guid.ToString()
});
await foreach (var json in logs)
{
var root = json.RootElement;
// camelCased automatically
Assert.That(root.TryGetProperty("entity", out _), Is.True);
json.Dispose();
return true;
}
return false;
});
}
[Test]
public async Task AddAndGetUnformattedLog()
{
var server = StartServer(new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sDatabase = server.ResolveDependency<IServerDbManager>();
var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = sSystems.GetEntitySystem<AdminLogSystem>();
var guid = Guid.NewGuid();
await server.WaitPost(() =>
{
var coordinates = GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity} test log: {guid}");
});
LogRecord log = null;
await WaitUntil(server, async () =>
{
var logs = sAdminLogSystem.CurrentRoundLogs(new LogFilter
{
Search = guid.ToString()
});
await foreach (var found in logs)
{
log = found;
return true;
}
return false;
});
await server.WaitPost(() =>
{
Task.Run(async () =>
{
var filter = new LogFilter
{
Round = log.RoundId,
Search = log.Message,
Types = new List<LogType> {log.Type},
};
await foreach (var json in sDatabase.GetAdminLogsJson(filter))
{
var root = json.RootElement;
Assert.That(root.TryGetProperty("entity", out _), Is.True);
Assert.That(root.TryGetProperty("guid", out _), Is.True);
json.Dispose();
}
}).Wait();
});
}
[Test]
[TestCase(500, false)]
[TestCase(500, true)]
public async Task BulkAddLogs(int amount, bool parallel)
{
var server = StartServer(new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = sSystems.GetEntitySystem<AdminLogSystem>();
await server.WaitPost(() =>
{
var coordinates = GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates);
if (parallel)
{
Parallel.For(0, amount, _ =>
{
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log.");
});
}
else
{
for (var i = 0; i < amount; i++)
{
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log.");
}
}
});
await WaitUntil(server, async () =>
{
var messages = sAdminLogSystem.CurrentRoundLogs();
var count = 0;
await foreach (var _ in messages)
{
count++;
}
return count >= amount;
});
}
}

View File

@@ -0,0 +1,108 @@
using System;
using System.Threading.Tasks;
using Content.Server.Administration.Logs;
using Content.Server.GameTicking;
using Content.Shared.Administration.Logs;
using Content.Shared.CCVar;
using NUnit.Framework;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
namespace Content.IntegrationTests.Tests.Administration.Logs;
[TestFixture]
[TestOf(typeof(AdminLogSystem))]
public class FilterTests : ContentIntegrationTest
{
[Test]
[TestCase(DateOrder.Ascending)]
[TestCase(DateOrder.Descending)]
public async Task Date(DateOrder order)
{
var server = StartServer(new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = sSystems.GetEntitySystem<AdminLogSystem>();
var commonGuid = Guid.NewGuid();
var guids = new[] {Guid.NewGuid(), Guid.NewGuid()};
for (var i = 0; i < 2; i++)
{
await server.WaitPost(() =>
{
var coordinates = GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {commonGuid} {guids[i]}");
});
await server.WaitRunTicks(60);
}
await WaitUntil(server, async () =>
{
var commonGuidStr = commonGuid.ToString();
string firstGuidStr;
string secondGuidStr;
switch (order)
{
case DateOrder.Ascending:
// Oldest first
firstGuidStr = guids[0].ToString();
secondGuidStr = guids[1].ToString();
break;
case DateOrder.Descending:
// Newest first
firstGuidStr = guids[1].ToString();
secondGuidStr = guids[0].ToString();
break;
default:
throw new ArgumentOutOfRangeException(nameof(order), order, null);
}
var firstFound = false;
var secondFound = false;
var both = sAdminLogSystem.CurrentRoundLogs(new LogFilter
{
Search = commonGuidStr,
DateOrder = order
});
await foreach (var log in both)
{
if (!log.Message.Contains(commonGuidStr))
{
continue;
}
if (!firstFound)
{
Assert.That(log.Message, Does.Contain(firstGuidStr));
firstFound = true;
continue;
}
Assert.That(log.Message, Does.Contain(secondGuidStr));
secondFound = true;
break;
}
return firstFound && secondFound;
});
}
}

View File

@@ -0,0 +1,70 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Administration.Logs;
using Content.Server.GameTicking;
using Content.Shared.Administration.Logs;
using Content.Shared.CCVar;
using NUnit.Framework;
using Robust.Server.Player;
using Robust.Shared.GameObjects;
namespace Content.IntegrationTests.Tests.Administration.Logs;
[TestFixture]
[TestOf(typeof(AdminLogSystem))]
public class QueryTests : ContentIntegrationTest
{
[Test]
public async Task QuerySingleLog()
{
var serverOptions = new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
}
};
var (client, server) = await StartConnectedServerClientPair(serverOptions: serverOptions);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sPlayers = server.ResolveDependency<IPlayerManager>();
var sAdminLogSystem = sSystems.GetEntitySystem<AdminLogSystem>();
var sGameTicker = sSystems.GetEntitySystem<GameTicker>();
var date = DateTime.UtcNow;
var guid = Guid.NewGuid();
IPlayerSession player = default;
await server.WaitPost(() =>
{
player = sPlayers.GetAllPlayers().First();
sAdminLogSystem.Add(LogType.Unknown, $"{player.AttachedEntity:Entity} test log: {guid}");
});
var filter = new LogFilter
{
Round = sGameTicker.RoundId,
Search = guid.ToString(),
Types = new List<LogType> {LogType.Unknown},
After = date,
AnyPlayers = new[] {player.UserId.UserId}
};
await WaitUntil(server, async () =>
{
await foreach (var _ in sAdminLogSystem.All(filter))
{
return true;
}
return false;
});
}
}