tiny.profiling.iteration.receipt

1const std = @import("std");2const pretty = @import("pretty");3const sys = @import("sys");45const profiling = @import("../root.zig");6const batch = @import("batch.zig");7const model = @import("model.zig");8const environment = profiling.environment;9const fingerprint = profiling.fingerprint;10const host = profiling.host;1112const pretty_json = pretty.json;1314pub const Phase = struct {15    name: []const u8,16    external_started_unix_ns: i128,17    external_finished_unix_ns: i128,18    external_elapsed_ns_observed: i128,19    host_state_before: host.state.Snapshot,20    host_state_after: host.state.Snapshot,21    evidence: batch.Batch,22};2324pub const Source = struct {25    path: []const u8,26    backup_path: []const u8,27    before: fingerprint.File,28    edited: fingerprint.File,29    reverted: fingerprint.File,30};3132pub const Artifacts = struct {33    watcher_stdout: []const u8,34    watcher_stderr: []const u8,35    clean_stdout: []const u8,36    clean_stderr: []const u8,37    watcher_receipts: []const u8,38    clean_receipts: []const u8,39    clean_cache: []const u8,40};4142pub const Equivalence = struct {43    count_equal: bool,44    semantic_equal: bool,45    zig_version_equal: bool,4647    pub fn supported(self: Equivalence) bool {48        return self.count_equal and49            self.semantic_equal and50            self.zig_version_equal;51    }52};5354pub const Assessment = struct {55    supported: bool,56    reason: []const u8,57    edit_clean: Equivalence,58    baseline_revert: Equivalence,59};6061pub const Document = struct {62    run_id: []const u8,63    artifact_root: []const u8,64    plan_path: []const u8,65    plan_file: fingerprint.File,66    plan: model.Plan,67    repository_root: []const u8,68    started_unix_ns: i128,69    finished_unix_ns: i128,70    host_environment: environment.Host,71    host_state_start: host.state.Snapshot,72    source: Source,73    watcher_argv: []const []const u8,74    clean_argv: []const []const u8,75    artifacts: Artifacts,76    baseline: Phase,77    edit: Phase,78    clean: Phase,79    revert: Phase,80    assessment: Assessment,81};8283pub fn writeFile(84    allocator: std.mem.Allocator,85    path: []const u8,86    document: Document,87) !void {88    const pending = try std.fmt.allocPrint(89        allocator,90        "{s}.pending",91        .{path},92    );93    defer sys.fs.deleteFile(pending) catch {};94    var file = try sys.fs.createFile(pending, .{ .truncate = true });95    var open = true;96    defer if (open) file.close(sys.fs.debugIo());97    var buffer: [64 * 1024]u8 = undefined;98    var writer = file.writer(sys.fs.debugIo(), &buffer);99    var out = pretty_json.Writer.init(&writer.interface, .minified);100    try writeJson(&out, document);101    try writer.interface.writeByte('\n');102    try writer.interface.flush();103    file.close(sys.fs.debugIo());104    open = false;105    try sys.fs.rename(pending, path);106}107108pub fn writeJson(109    out: *pretty_json.Writer,110    document: Document,111) !void {112    try out.beginObject();113    try field(out, "schema", model.receipt_schema);114    try field(out, "run_id", document.run_id);115    try field(out, "artifact_root", document.artifact_root);116    try field(out, "repository_root", document.repository_root);117    try field(out, "started_unix_ns", document.started_unix_ns);118    try field(out, "finished_unix_ns", document.finished_unix_ns);119    try writePlanSource(out, document);120    try writeMethod(out);121    try out.objectField("environment");122    try out.beginObject();123    try out.objectField("host");124    try environment.writeJson(out, document.host_environment);125    try out.objectField("host_state_start");126    try host.state.writeJson(out, document.host_state_start);127    try out.endObject();128    try out.objectField("plan");129    try writePlan(out, document.plan);130    try out.objectField("source");131    try writeSource(out, document.source);132    try out.objectField("commands");133    try out.beginObject();134    try out.objectField("watcher");135    try out.write(document.watcher_argv);136    try out.objectField("clean");137    try out.write(document.clean_argv);138    try out.endObject();139    try out.objectField("artifacts");140    try out.write(document.artifacts);141    try out.objectField("phases");142    try out.beginObject();143    try out.objectField("baseline");144    try writePhase(out, document.baseline);145    try out.objectField("edit");146    try writePhase(out, document.edit);147    try out.objectField("clean");148    try writePhase(out, document.clean);149    try out.objectField("revert");150    try writePhase(out, document.revert);151    try out.endObject();152    try out.objectField("assessment");153    try writeAssessment(out, document.assessment);154    try out.endObject();155}156157fn writePlanSource(158    out: *pretty_json.Writer,159    document: Document,160) !void {161    const digest = document.plan_file.hex();162    try out.objectField("plan_source");163    try out.beginObject();164    try field(out, "path", document.plan_path);165    try field(out, "bytes", document.plan_file.bytes);166    try field(out, "sha256", digest[0..]);167    try out.endObject();168}169170fn writeMethod(out: *pretty_json.Writer) !void {171    try out.objectField("method");172    try out.beginObject();173    try field(174        out,175        "resident_lane",176        "one skills/worktree/iterate process across baseline, edit, and revert",177    );178    try field(179        out,180        "clean_lane",181        "one-shot -fno-incremental build with an isolated local cache",182    );183    try field(184        out,185        "trigger",186        "exact single semantic source replacement and exact revert",187    );188    try field(189        out,190        "completion",191        "build-owned atomic generation markers after the selected step",192    );193    try field(194        out,195        "semantic_evidence",196        "machine timed-test receipt counts and output-independent status digests",197    );198    try field(199        out,200        "duration_policy",201        "external update, test, and teardown durations are observational only",202    );203    try field(204        out,205        "non_test_duration_limit",206        "external minus test and teardown includes detection, scheduling, compilation, launch, and marker overhead",207    );208    try out.endObject();209}210211fn writePlan(212    out: *pretty_json.Writer,213    plan: model.Plan,214) !void {215    try out.beginObject();216    try field(out, "schema", model.schema);217    try field(out, "name", plan.name);218    try field(out, "step", plan.step);219    try out.objectField("args");220    try out.write(plan.args);221    try out.objectField("patch");222    try out.write(plan.patch);223    try field(out, "timeout_ms", plan.timeout_ms);224    try out.endObject();225}226227fn writeSource(228    out: *pretty_json.Writer,229    source: Source,230) !void {231    try out.beginObject();232    try field(out, "path", source.path);233    try field(out, "backup_path", source.backup_path);234    try out.objectField("before");235    try writeFingerprint(out, source.before);236    try out.objectField("edited");237    try writeFingerprint(out, source.edited);238    try out.objectField("reverted");239    try writeFingerprint(out, source.reverted);240    try out.endObject();241}242243fn writeFingerprint(244    out: *pretty_json.Writer,245    value: fingerprint.File,246) !void {247    const digest = value.hex();248    try out.beginObject();249    try field(out, "bytes", value.bytes);250    try field(out, "sha256", digest[0..]);251    try out.endObject();252}253254fn writePhase(255    out: *pretty_json.Writer,256    phase: Phase,257) !void {258    const tests_and_teardown =259        phase.evidence.aggregate.test_ns_observed +260        phase.evidence.aggregate.teardown_ns_observed;261    const non_test_ns = @max(262        phase.external_elapsed_ns_observed - tests_and_teardown,263        0,264    );265    try out.beginObject();266    try field(out, "name", phase.name);267    try field(268        out,269        "selected_build_step_count",270        @as(u8, 1),271    );272    try field(273        out,274        "completed_build_step_count",275        @as(u8, 1),276    );277    try field(278        out,279        "external_started_unix_ns",280        phase.external_started_unix_ns,281    );282    try field(283        out,284        "external_finished_unix_ns",285        phase.external_finished_unix_ns,286    );287    try field(288        out,289        "external_update_ns_observed",290        phase.external_elapsed_ns_observed,291    );292    try field(293        out,294        "non_test_ns_observed",295        non_test_ns,296    );297    try out.objectField("host_state_before");298    try host.state.writeJson(out, phase.host_state_before);299    try out.objectField("host_state_after");300    try host.state.writeJson(out, phase.host_state_after);301    try out.objectField("generation");302    try out.beginObject();303    try field(out, "marker_path", phase.evidence.marker.path);304    try field(305        out,306        "finished_unix_ns",307        phase.evidence.marker.finished_unix_ns,308    );309    try out.endObject();310    try out.objectField("tests");311    try writeBatch(out, phase.evidence);312    try out.endObject();313}314315fn writeBatch(316    out: *pretty_json.Writer,317    evidence: batch.Batch,318) !void {319    const semantic = evidence.aggregate.semanticHex();320    try out.beginObject();321    try field(322        out,323        "receipt_count",324        evidence.aggregate.receipt_count,325    );326    try field(327        out,328        "selected_test_count",329        evidence.aggregate.selected_test_count,330    );331    try field(332        out,333        "executed_test_count",334        evidence.aggregate.executed_test_count,335    );336    try field(337        out,338        "passed_test_count",339        evidence.aggregate.passed_test_count,340    );341    try field(342        out,343        "skipped_test_count",344        evidence.aggregate.skipped_test_count,345    );346    try field(347        out,348        "failed_test_count",349        evidence.aggregate.failed_test_count,350    );351    try field(352        out,353        "test_ns_observed",354        evidence.aggregate.test_ns_observed,355    );356    try field(357        out,358        "teardown_ns_observed",359        evidence.aggregate.teardown_ns_observed,360    );361    try field(out, "semantic_sha256", semantic[0..]);362    try out.objectField("receipts");363    try out.beginArray();364    for (evidence.receipts) |item| {365        const item_semantic = item.semanticHex();366        try out.beginObject();367        try field(out, "path", item.path);368        try field(out, "zig_version", item.zig_version);369        try field(out, "started_unix_ns", item.started_unix_ns);370        try field(out, "finished_unix_ns", item.finished_unix_ns);371        try field(out, "shard_count", item.shard_count);372        try field(out, "shard_index", item.shard_index);373        try field(out, "selected_test_count", item.selected_test_count);374        try field(out, "executed_test_count", item.executed_test_count);375        try field(out, "passed_test_count", item.passed_test_count);376        try field(out, "skipped_test_count", item.skipped_test_count);377        try field(out, "failed_test_count", item.failed_test_count);378        try field(out, "test_ns_observed", item.test_ns_observed);379        try field(380            out,381            "teardown_ns_observed",382            item.teardown_ns_observed,383        );384        try field(out, "semantic_sha256", item_semantic[0..]);385        try out.endObject();386    }387    try out.endArray();388    try out.endObject();389}390391fn writeAssessment(392    out: *pretty_json.Writer,393    assessment: Assessment,394) !void {395    try out.beginObject();396    try field(out, "supported", assessment.supported);397    try field(out, "reason", assessment.reason);398    try out.objectField("edit_clean");399    try writeEquivalence(out, assessment.edit_clean);400    try out.objectField("baseline_revert");401    try writeEquivalence(out, assessment.baseline_revert);402    try out.endObject();403}404405fn writeEquivalence(406    out: *pretty_json.Writer,407    equivalence: Equivalence,408) !void {409    try out.beginObject();410    try field(out, "count_equal", equivalence.count_equal);411    try field(out, "semantic_equal", equivalence.semantic_equal);412    try field(413        out,414        "zig_version_equal",415        equivalence.zig_version_equal,416    );417    try field(out, "supported", equivalence.supported());418    try out.endObject();419}420421fn field(422    out: *pretty_json.Writer,423    name: []const u8,424    value: anytype,425) !void {426    try out.objectField(name);427    try out.write(value);428}

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