strawberry/tests/test_fleet_overlay.cpp

162 lines
5.7 KiB
C++

// Fleet overlay scoring: ReplayOptions.fleet_surprisal fills WindowSummary.fleet_bits.
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <unistd.h>
#include <string>
#include <string_view>
#include <vector>
#include "strawberry/database.hpp"
#include "strawberry/fleet_export.hpp"
#include "strawberry/learn/replay.hpp"
#include "strawberry/store/log_store.hpp"
#include "strawberry/telemetry.hpp"
using namespace strawberry;
#define CHECK(cond) \
do { \
if (!(cond)) { \
std::fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
std::exit(1); \
} \
} while (0)
namespace {
constexpr int64_t kSec = 1'000'000'000;
constexpr int64_t kT0 = 1'800'000'000 * kSec;
TelemetryEvent exec(int64_t ts, int pid, const std::string& node, const std::string& parent, const std::string& exe,
const std::string& cmdline) {
ProcessExecRecord r;
r.timestamp_ns = ts;
r.pid = pid;
r.process_node_id = node;
r.parent_node_id = parent;
r.exe = exe;
r.cmdline = cmdline;
r.source = "live";
return {store::RecordType::process_exec, encode_process_exec(r)};
}
TelemetryEvent connect(int64_t ts, int pid, const std::string& address, int port) {
BehaviorEvent b;
b.type = BehaviorEvent::Type::connect;
b.timestamp_ns = static_cast<uint64_t>(ts);
b.pid = pid;
b.family = 2;
b.address = address;
b.port = static_cast<uint16_t>(port);
return {store::RecordType::connect, encode_behavior(b)};
}
std::vector<TelemetryEvent> events() {
std::vector<TelemetryEvent> ev;
ev.push_back(exec(kT0 + kSec, 300, "process_300_b_1", "", "/usr/bin/curl", "curl x"));
ev.push_back(connect(kT0 + 2 * kSec, 300, "1.2.3.4", 443));
return ev;
}
} // namespace
int main() {
learn::ReplayOptions o;
o.live = true;
o.warmup_ns = 0;
o.fleet_surprisal = [](learn::TupleKind, std::string_view) { return 7.0f; };
learn::WindowSummary captured{};
bool got = false;
o.on_window_closed = [&](const learn::ReplayWindow&, const learn::WindowSummary& s) {
captured = s;
got = true;
};
learn::Replayer r(o);
for (const auto& e : events()) r.feed(e.type, e.payload);
r.finish();
CHECK(got);
bool any = false;
for (float v : captured.fleet_bits) {
CHECK(v <= 7.0f);
if (v == 7.0f) any = true;
}
CHECK(any);
learn::ReplayOptions o2 = o;
o2.fleet_surprisal = {};
learn::WindowSummary cap2{};
bool got2 = false;
o2.on_window_closed = [&](const learn::ReplayWindow&, const learn::WindowSummary& s) {
cap2 = s;
got2 = true;
};
learn::Replayer r2(o2);
for (const auto& e : events()) r2.feed(e.type, e.payload);
r2.finish();
CHECK(got2);
for (float v : cap2.fleet_bits) CHECK(v == 0.0f);
{
// export_store with a fleet_surprisal callback populates fleet slots x[37..41].
namespace fs = std::filesystem;
const auto dir = fs::temp_directory_path() / ("sb_fleet_overlay_exp_" + std::to_string(::getpid()));
const auto out1 = fs::temp_directory_path() / ("sb_fleet_overlay_exp1_" + std::to_string(::getpid()) + ".sbx");
const auto out2 = fs::temp_directory_path() / ("sb_fleet_overlay_exp2_" + std::to_string(::getpid()) + ".sbx");
std::error_code ec;
fs::remove_all(dir, ec);
{
Database db;
CHECK(db.open(dir.string()));
auto evs = events();
CHECK(db.append_telemetry(evs, true));
db.close();
}
fleet::ExportManifest m;
m.node_uid = "n-ov";
std::string err;
auto fsur = [](learn::TupleKind, std::string_view) { return 5.0f; };
CHECK(fleet::export_store(dir.string(), m, out1.string(), err, "", fsur));
bool saw_fleet = false;
std::size_t nfeat = 0;
fleet::ExportManifest back;
CHECK(fleet::read_export_bundle(out1.string(), back, [&](uint32_t type, std::string_view payload) {
if (type == static_cast<uint32_t>(store::RecordType::export_window_feature)) {
fleet::ExportWindowFeature f;
if (fleet::decode_export_window_feature(payload, f)) {
++nfeat;
for (std::size_t i = 37; i <= 41; ++i)
if (f.features[i] == 5.0f / 16.0f) saw_fleet = true;
}
}
}));
CHECK(nfeat >= 1);
CHECK(saw_fleet);
// Control: no callback -> fleet slots all zero.
std::string err2;
CHECK(fleet::export_store(dir.string(), m, out2.string(), err2));
std::size_t nfeat2 = 0;
bool nonzero = false;
fleet::ExportManifest back2;
CHECK(fleet::read_export_bundle(out2.string(), back2, [&](uint32_t type, std::string_view payload) {
if (type == static_cast<uint32_t>(store::RecordType::export_window_feature)) {
fleet::ExportWindowFeature f;
if (fleet::decode_export_window_feature(payload, f)) {
++nfeat2;
for (std::size_t i = 37; i <= 41; ++i)
if (f.features[i] != 0.0f) nonzero = true;
}
}
}));
CHECK(nfeat2 >= 1);
CHECK(!nonzero);
fs::remove_all(dir, ec);
fs::remove(out1, ec);
fs::remove(out2, ec);
}
std::puts("ok");
return 0;
}