tiny.profiling.baseline

1const std = @import("std");2const pretty = @import("pretty");3const sys = @import("sys");45const json = @import("json.zig");6const record = @import("record.zig");78const pretty_json = pretty.json;910pub const schema = "tiny.profiling.baseline/v1";11pub const default_dir = "zig-out/profiling/baselines";1213pub const RunRef = struct {14    run_id: []const u8,15    root: []const u8,16    manifest_path: []const u8,17    results_path: []const u8,18    suite: ?[]const u8 = null,19    git_sha: ?[]const u8 = null,20    git_branch: ?[]const u8 = null,21};2223pub const Entry = struct {24    name: []const u8,25    run: RunRef,26};2728pub const DetailedEntry = struct {29    entry: Entry,30    path: []const u8,31    mtime_ns: i128,32};3334pub const PruneOptions = struct {35    keep_last: ?usize = null,36    older_than_ns: ?i128 = null,37    dry_run: bool = false,38};3940pub const Pruned = struct {41    entry: Entry,42    path: []const u8,43    mtime_ns: i128,44    deleted: bool,45};4647fn entry_name_ascending(_: void, left: Entry, right: Entry) bool {48    return std.mem.order(u8, left.name, right.name) == .lt;49}5051fn detailed_entry_name_ascending(_: void, left: DetailedEntry, right: DetailedEntry) bool {52    return std.mem.order(u8, left.entry.name, right.entry.name) == .lt;53}5455fn detailed_entry_recent_first(_: void, left: DetailedEntry, right: DetailedEntry) bool {56    if (left.mtime_ns == right.mtime_ns) {57        return std.mem.order(u8, left.entry.name, right.entry.name) == .lt;58    }59    return left.mtime_ns > right.mtime_ns;60}6162pub fn save(allocator: std.mem.Allocator, name: []const u8, input: []const u8) !Entry {63    try validateName(name);64    const run = try resolveRun(allocator, input);65    try sys.fs.createDirPath(default_dir);66    const path = try entryPath(allocator, name);67    const body = try renderEntry(allocator, name, run);68    defer allocator.free(body);69    try sys.fs.writeFile(path, body);70    return .{ .name = name, .run = run };71}7273pub fn list(allocator: std.mem.Allocator) ![]Entry {74    const detailed = try listDetailed(allocator);75    var result: std.ArrayList(Entry) = .empty;76    for (detailed) |entry| try result.append(allocator, entry.entry);77    std.mem.sort(Entry, result.items, {}, entry_name_ascending);78    return try result.toOwnedSlice(allocator);79}8081pub fn listDetailed(allocator: std.mem.Allocator) ![]DetailedEntry {82    const entries = sys.fs.listDirAlloc(allocator, default_dir) catch |err| switch (err) {83        error.FileNotFound => return &.{},84        else => |actual| return actual,85    };86    defer sys.fs.freeEntries(allocator, entries);8788    var result: std.ArrayList(DetailedEntry) = .empty;89    for (entries) |entry| {90        if (entry.kind != .file) continue;91        if (!std.mem.endsWith(u8, entry.name, ".json")) continue;92        const stat = sys.fs.statFile(entry.path) catch continue;93        try result.append(allocator, .{94            .entry = try parseEntryFile(allocator, entry.path),95            .path = try allocator.dupe(u8, entry.path),96            .mtime_ns = stat.mtime.nanoseconds,97        });98    }99    std.mem.sort(DetailedEntry, result.items, {}, detailed_entry_name_ascending);100    return try result.toOwnedSlice(allocator);101}102103pub fn prune(allocator: std.mem.Allocator, options: PruneOptions) ![]Pruned {104    if (options.keep_last == null and options.older_than_ns == null) return error.MissingPruneRule;105    const entries = try listDetailed(allocator);106    std.mem.sort(DetailedEntry, entries, {}, detailed_entry_recent_first);107    const now_ns = sys.time.realNanoTimestamp();108    var result: std.ArrayList(Pruned) = .empty;109    for (entries, 0..) |entry, index| {110        if (!shouldPrune(index, entry.mtime_ns, now_ns, options)) continue;111        if (!options.dry_run) try sys.fs.deleteFile(entry.path);112        try result.append(allocator, .{113            .entry = entry.entry,114            .path = entry.path,115            .mtime_ns = entry.mtime_ns,116            .deleted = !options.dry_run,117        });118    }119    return try result.toOwnedSlice(allocator);120}121122pub fn delete(allocator: std.mem.Allocator, name: []const u8) !Entry {123    try validateName(name);124    const path = try entryPath(allocator, name);125    const entry = try parseEntryFile(allocator, path);126    try sys.fs.deleteFile(path);127    return entry;128}129130pub fn resolveRun(allocator: std.mem.Allocator, input: []const u8) !RunRef {131    if (std.mem.endsWith(u8, input, "results.jsonl")) {132        return .{133            .run_id = std.fs.path.basename(std.fs.path.dirname(input) orelse "."),134            .root = std.fs.path.dirname(input) orelse ".",135            .manifest_path = try std.fs.path.join(allocator, &.{ std.fs.path.dirname(input) orelse ".", "manifest.json" }),136            .results_path = input,137        };138    }139    if (std.mem.endsWith(u8, input, ".json") and sys.fs.exists(input)) {140        return try parseRunFile(allocator, input);141    }142143    const manifest = try std.fs.path.join(allocator, &.{ input, "manifest.json" });144    if (sys.fs.exists(manifest)) return try parseManifest(allocator, manifest);145146    const baseline_path = try entryPath(allocator, input);147    if (sys.fs.exists(baseline_path)) {148        const entry = try parseEntryFile(allocator, baseline_path);149        return entry.run;150    }151152    return error.ProfilingRunNotFound;153}154155pub fn parseEntryFile(allocator: std.mem.Allocator, path: []const u8) !Entry {156    const text = try sys.fs.readFileAlloc(allocator, path, 8 * 1024 * 1024);157    const value = try std.json.parseFromSliceLeaky(std.json.Value, allocator, text, .{});158    const object = try json.object(value);159    const actual_schema = json.string(object.get("schema")) orelse return error.InvalidProfilingJson;160    if (!std.mem.eql(u8, actual_schema, schema)) return error.InvalidProfilingJson;161    return .{162        .name = json.string(object.get("name")) orelse return error.InvalidProfilingJson,163        .run = try parseRunRef(object),164    };165}166167pub fn parseManifest(allocator: std.mem.Allocator, path: []const u8) !RunRef {168    const text = try sys.fs.readFileAlloc(allocator, path, 8 * 1024 * 1024);169    const value = try std.json.parseFromSliceLeaky(std.json.Value, allocator, text, .{});170    const object = try json.object(value);171    const actual_schema = json.string(object.get("schema")) orelse return error.InvalidProfilingJson;172    if (!std.mem.eql(u8, actual_schema, record.run_schema)) return error.InvalidProfilingJson;173    return try parseRunRefFromManifest(allocator, object, path);174}175176pub fn entryPath(allocator: std.mem.Allocator, name: []const u8) ![]const u8 {177    try validateName(name);178    const segment = try sanitize(allocator, name);179    const file = try std.fmt.allocPrint(allocator, "{s}.json", .{segment});180    return try std.fs.path.join(allocator, &.{ default_dir, file });181}182183pub fn validateName(name: []const u8) !void {184    if (name.len == 0) return error.InvalidBaselineName;185    if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) return error.InvalidBaselineName;186    for (name) |byte| {187        if (!(std.ascii.isAlphanumeric(byte) or byte == '.' or byte == '_' or byte == '-')) return error.InvalidBaselineName;188    }189}190191fn parseRunFile(allocator: std.mem.Allocator, path: []const u8) !RunRef {192    const text = try sys.fs.readFileAlloc(allocator, path, 8 * 1024 * 1024);193    const value = try std.json.parseFromSliceLeaky(std.json.Value, allocator, text, .{});194    const object = try json.object(value);195    const actual_schema = json.string(object.get("schema")) orelse return error.InvalidProfilingJson;196    if (std.mem.eql(u8, actual_schema, schema)) return (try parseEntryFile(allocator, path)).run;197    if (std.mem.eql(u8, actual_schema, record.run_schema)) return try parseRunRefFromManifest(allocator, object, path);198    return error.InvalidProfilingJson;199}200201fn parseRunRef(object: std.json.ObjectMap) !RunRef {202    return .{203        .run_id = json.string(object.get("run_id")) orelse return error.InvalidProfilingJson,204        .root = json.string(object.get("root")) orelse return error.InvalidProfilingJson,205        .manifest_path = json.string(object.get("manifest_path")) orelse return error.InvalidProfilingJson,206        .results_path = json.string(object.get("results_path")) orelse return error.InvalidProfilingJson,207        .suite = json.string(object.get("suite")),208        .git_sha = json.string(object.get("git_sha")),209        .git_branch = json.string(object.get("git_branch")),210    };211}212213fn parseRunRefFromManifest(allocator: std.mem.Allocator, object: std.json.ObjectMap, manifest_path: []const u8) !RunRef {214    const artifacts = try json.object(object.get("artifacts") orelse return error.InvalidProfilingJson);215    const selection = if (object.get("selection")) |value| try json.object(value) else null;216    const environment = if (object.get("environment")) |value| try json.object(value) else null;217    const git = if (environment) |env| if (env.get("git")) |value| try json.object(value) else null else null;218    const root = std.fs.path.dirname(manifest_path) orelse json.string(artifacts.get("root")) orelse ".";219    const results = try std.fs.path.join(allocator, &.{ root, "results.jsonl" });220    return .{221        .run_id = json.string(object.get("run_id")) orelse std.fs.path.basename(root),222        .root = root,223        .manifest_path = manifest_path,224        .results_path = results,225        .suite = if (selection) |actual| json.string(actual.get("suite")) else null,226        .git_sha = if (git) |actual| json.string(actual.get("commit")) else null,227        .git_branch = if (git) |actual| json.string(actual.get("branch")) else null,228    };229}230231fn renderEntry(allocator: std.mem.Allocator, name: []const u8, run: RunRef) ![]const u8 {232    var out: std.Io.Writer.Allocating = .init(allocator);233    errdefer out.deinit();234    var writer = pretty_json.Writer.init(&out.writer, .minified);235    try writer.beginObject();236    try writer.objectField("schema");237    try writer.write(schema);238    try writer.objectField("name");239    try writer.write(name);240    try writer.objectField("run_id");241    try writer.write(run.run_id);242    try writer.objectField("root");243    try writer.write(run.root);244    try writer.objectField("manifest_path");245    try writer.write(run.manifest_path);246    try writer.objectField("results_path");247    try writer.write(run.results_path);248    try writer.objectField("suite");249    try writer.write(run.suite);250    try writer.objectField("git_sha");251    try writer.write(run.git_sha);252    try writer.objectField("git_branch");253    try writer.write(run.git_branch);254    try writer.endObject();255    try out.writer.writeByte('\n');256    return try out.toOwnedSlice();257}258259fn sanitize(allocator: std.mem.Allocator, value: []const u8) ![]const u8 {260    const result = try allocator.alloc(u8, value.len);261    for (value, 0..) |byte, index| {262        result[index] = if (std.ascii.isAlphanumeric(byte) or byte == '.' or byte == '_' or byte == '-') byte else '_';263    }264    return result;265}266267fn shouldPrune(index: usize, mtime_ns: i128, now_ns: i128, options: PruneOptions) bool {268    const past_keep = if (options.keep_last) |keep_last| index >= keep_last else false;269    const old = if (options.older_than_ns) |age| now_ns - mtime_ns >= age else false;270    if (options.keep_last != null and options.older_than_ns != null) return past_keep and old;271    return past_keep or old;272}273274test "profiling baseline parses manifest run refs" {275    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);276    defer arena_state.deinit();277    const allocator = arena_state.allocator();278    const value = try std.json.parseFromSliceLeaky(std.json.Value, allocator,279        \\{"schema":"tiny.profiling.run/v1","event":"manifest","run_id":"run-a","selection":{"suite":"smoke"},"environment":{"git":{"commit":"abc","branch":"main"}},"artifacts":{"root":"zig-out/profiling/run-a","results":"zig-out/profiling/run-a/results.jsonl","manifest":"zig-out/profiling/run-a/manifest.json"}}280    , .{});281    const run = try parseRunRefFromManifest(allocator, try json.object(value), "zig-out/profiling/run-a/manifest.json");282    try std.testing.expectEqualStrings("run-a", run.run_id);283    try std.testing.expectEqualStrings("smoke", run.suite.?);284    try std.testing.expectEqualStrings("abc", run.git_sha.?);285    try std.testing.expectEqualStrings("zig-out/profiling/run-a", run.root);286    try std.testing.expectEqualStrings("zig-out/profiling/run-a/results.jsonl", run.results_path);287}288289test "profiling baseline resolves relocated manifests to their actual directory" {290    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);291    defer arena_state.deinit();292    const allocator = arena_state.allocator();293    const value = try std.json.parseFromSliceLeaky(std.json.Value, allocator,294        \\{"schema":"tiny.profiling.run/v1","event":"manifest","run_id":"run-a","artifacts":{"root":"zig-out/profiling/run-a","results":"zig-out/profiling/run-a/results.jsonl","manifest":"zig-out/profiling/run-a/manifest.json"}}295    , .{});296    const run = try parseRunRefFromManifest(allocator, try json.object(value), "zig-out/profiling-baseline/run-a/manifest.json");297    try std.testing.expectEqualStrings("run-a", run.run_id);298    try std.testing.expectEqualStrings("zig-out/profiling-baseline/run-a", run.root);299    try std.testing.expectEqualStrings("zig-out/profiling-baseline/run-a/results.jsonl", run.results_path);300}301302test "profiling baseline names reject path shapes" {303    try validateName("main-smoke_1.0");304    try std.testing.expectError(error.InvalidBaselineName, validateName(""));305    try std.testing.expectError(error.InvalidBaselineName, validateName("../main"));306    try std.testing.expectError(error.InvalidBaselineName, validateName("main smoke"));307}308309test "profiling baseline prune rules keep protected recent entries" {310    const now: i128 = 10_000;311    try std.testing.expect(!shouldPrune(0, 0, now, .{ .keep_last = 1, .older_than_ns = 1 }));312    try std.testing.expect(shouldPrune(1, 0, now, .{ .keep_last = 1, .older_than_ns = 1 }));313    try std.testing.expect(shouldPrune(1, now - 1_000, now, .{ .keep_last = 1 }));314    try std.testing.expect(shouldPrune(0, 0, now, .{ .older_than_ns = 1 }));315}

1pub const baseline = @import("baseline.zig");