tiny.profiling.report.coverage

1const std = @import("std");2const capture = @import("capture");3const pretty = @import("pretty");4const sys = @import("sys");56const catalog = @import("../root.zig").catalog;7const host = @import("../root.zig").host;8const json = @import("../root.zig").json;9const plan = @import("../root.zig").plan;10const record = @import("../root.zig").record;1112const pretty_json = pretty.json;13const fs_io = sys.fs.debugIo();1415pub const summary_schema = "tiny.repository-source-coverage-summary/v1";16pub const line_schema = "tiny.repository-source-coverage-line/v1";17pub const summary_name = "coverage.summary.json";18pub const lines_name = "coverage.lines.jsonl";19pub const uncovered_name = "coverage.uncovered.jsonl";20pub const line_universe = "git_tracked_zig_physical_lines";2122const max_git_ls_bytes = 32 * 1024 * 1024;23const max_source_file_bytes = 64 * 1024 * 1024;24const max_workload_lines_bytes = 512 * 1024 * 1024;2526pub const Summary = struct {27    source_files: usize,28    physical_lines: usize,29    code_lines: usize,30    blank_lines: usize,31    selected_workloads: usize,32    captured_workloads: usize,33    instrumented_lines: usize,34    covered_lines: usize,35    covered_code_lines: usize,36    uncovered_code_lines: usize,37    uninstrumented_code_lines: usize,38    instrumented_uncovered_code_lines: usize,39    summary_path: []const u8,40    lines_path: []const u8,41    uncovered_path: []const u8,42    workloads: []const []const u8,4344    pub fn coveredPercent(self: Summary) ?f64 {45        if (self.code_lines == 0) return null;46        return (@as(f64, @floatFromInt(self.covered_code_lines)) * 100.0) / @as(f64, @floatFromInt(self.code_lines));47    }48};4950const CoveredLine = struct {51    hits: u64 = 0,52    instrumented_workload_count: usize = 0,53    covered_workloads: std.ArrayListUnmanaged([]const u8) = .empty,5455    fn add(self: *CoveredLine, allocator: std.mem.Allocator, workload: []const u8, hits: u64) !void {56        self.instrumented_workload_count += 1;57        self.hits += hits;58        if (hits == 0) return;59        for (self.covered_workloads.items) |existing| {60            if (std.mem.eql(u8, existing, workload)) return;61        }62        try self.covered_workloads.append(allocator, workload);63    }6465    fn deinit(self: *CoveredLine, allocator: std.mem.Allocator) void {66        self.covered_workloads.deinit(allocator);67    }68};6970const CoverageMap = std.StringHashMapUnmanaged(CoveredLine);7172pub fn writeRunArtifacts(73    allocator: std.mem.Allocator,74    process_io: std.Io,75    paths: record.Paths,76    selection: plan.Selection,77) !Summary {78    const files = try gitTrackedZigFiles(allocator, process_io);79    const repository_root = try sys.fs.cwdAlloc(allocator);80    var coverage_map: CoverageMap = .empty;81    defer deinitCoverageMap(allocator, &coverage_map);8283    var workloads: std.ArrayList([]const u8) = .empty;84    for (catalog.workloads) |workload| {85        if (!selection.selected(workload)) continue;86        const workload_paths = try record.workloadPaths(allocator, paths, workload.name);87        const lane = try host.coverage.plan(allocator, .{}, workload_paths.root);88        if (!sys.fs.exists(lane.summary_path) or !sys.fs.exists(lane.lines_path)) continue;89        try mergeWorkloadLines(90            allocator,91            &coverage_map,92            repository_root,93            lane.summary_path,94            lane.lines_path,95            workload.name,96        );97        try workloads.append(allocator, workload.name);98    }99100    const summary_path = try std.fs.path.join(allocator, &.{ paths.root, summary_name });101    const lines_path = try std.fs.path.join(allocator, &.{ paths.root, lines_name });102    const uncovered_path = try std.fs.path.join(allocator, &.{ paths.root, uncovered_name });103    var summary = try writeLineMaps(allocator, files, &coverage_map, lines_path, uncovered_path);104    summary.selected_workloads = selection.count();105    summary.captured_workloads = workloads.items.len;106    summary.summary_path = summary_path;107    summary.lines_path = lines_path;108    summary.uncovered_path = uncovered_path;109    summary.workloads = try workloads.toOwnedSlice(allocator);110    try writeSummaryFile(summary_path, summary);111    return summary;112}113114fn gitTrackedZigFiles(allocator: std.mem.Allocator, process_io: std.Io) ![]const []const u8 {115    const result = try sys.process.run(allocator, process_io, .{116        .argv = &.{ "git", "ls-files", "*.zig" },117        .stdout_limit = .limited(max_git_ls_bytes),118        .stderr_limit = .limited(64 * 1024),119    });120    defer allocator.free(result.stdout);121    defer allocator.free(result.stderr);122    if (sys.process.exitCode(result.term) != 0) return error.GitLsFilesFailed;123124    var files: std.ArrayList([]const u8) = .empty;125    var lines = std.mem.splitScalar(u8, result.stdout, '\n');126    while (lines.next()) |line| {127        const trimmed = std.mem.trim(u8, line, " \t\r\n");128        if (trimmed.len == 0) continue;129        try files.append(allocator, try allocator.dupe(u8, trimmed));130    }131    return try files.toOwnedSlice(allocator);132}133134fn mergeWorkloadLines(135    allocator: std.mem.Allocator,136    coverage_map: *CoverageMap,137    repository_root: []const u8,138    summary_path: []const u8,139    lines_path: []const u8,140    workload: []const u8,141) !void {142    const source_root = try workloadSourceRoot(allocator, summary_path);143    const text = try sys.fs.readFileAlloc(allocator, lines_path, max_workload_lines_bytes);144    var lines = std.mem.splitScalar(u8, text, '\n');145    while (lines.next()) |raw| {146        const trimmed = std.mem.trim(u8, raw, " \t\r\n");147        if (trimmed.len == 0) continue;148        var parsed = std.json.parseFromSlice(std.json.Value, allocator, trimmed, .{}) catch continue;149        defer parsed.deinit();150        const object = json.object(parsed.value) catch continue;151        const file = json.string(object.get("file")) orelse continue;152        const raw_line = json.asU64(object.get("line")) orelse continue;153        if (raw_line == 0 or raw_line > std.math.maxInt(u32)) continue;154        const hits = json.asU64(object.get("hits")) orelse continue;155        const repository_file = try repositoryFile(allocator, repository_root, source_root, file) orelse continue;156        try addCoveredLine(allocator, coverage_map, repository_file, @intCast(raw_line), hits, workload);157    }158}159160fn workloadSourceRoot(allocator: std.mem.Allocator, path: []const u8) !?[]const u8 {161    const text = try sys.fs.readFileAlloc(allocator, path, max_source_file_bytes);162    var parsed = try std.json.parseFromSlice(std.json.Value, allocator, text, .{});163    defer parsed.deinit();164    const object = try json.object(parsed.value);165    const schema = json.string(object.get("schema")) orelse return error.InvalidCoverageSummary;166    if (!std.mem.eql(u8, schema, capture.coverage.summary_schema)) return error.InvalidCoverageSummary;167    const value = object.get("source_root") orelse return error.InvalidCoverageSummary;168    return switch (value) {169        .null => null,170        .string => |source_root| try allocator.dupe(u8, source_root),171        else => error.InvalidCoverageSummary,172    };173}174175fn repositoryFile(176    allocator: std.mem.Allocator,177    repository_root: []const u8,178    source_root: ?[]const u8,179    file: []const u8,180) !?[]const u8 {181    std.debug.assert(std.fs.path.isAbsolute(repository_root));182    const absolute = if (std.fs.path.isAbsolute(file))183        try std.fs.path.resolve(allocator, &.{file})184    else if (source_root) |root|185        if (std.fs.path.isAbsolute(root))186            try std.fs.path.resolve(allocator, &.{ root, file })187        else188            try std.fs.path.resolve(allocator, &.{ repository_root, root, file })189    else190        try std.fs.path.resolve(allocator, &.{ repository_root, file });191    const relative = try std.fs.path.relative(allocator, repository_root, null, repository_root, absolute);192    if (relative.len == 0 or std.fs.path.isAbsolute(relative)) return null;193    if (std.mem.eql(u8, relative, "..")) return null;194    if (relative.len >= 3 and relative[0] == '.' and relative[1] == '.' and std.fs.path.isSep(relative[2])) return null;195    return relative;196}197198fn addCoveredLine(199    allocator: std.mem.Allocator,200    coverage_map: *CoverageMap,201    file: []const u8,202    line: u32,203    hits: u64,204    workload: []const u8,205) !void {206    const key = try lineKey(allocator, file, line);207    const entry = try coverage_map.getOrPut(allocator, key);208    if (!entry.found_existing) {209        entry.value_ptr.* = .{};210    } else {211        allocator.free(key);212    }213    try entry.value_ptr.add(allocator, workload, hits);214}215216fn writeLineMaps(217    allocator: std.mem.Allocator,218    files: []const []const u8,219    coverage_map: *CoverageMap,220    lines_path: []const u8,221    uncovered_path: []const u8,222) !Summary {223    var lines_file = try sys.fs.cwd().createFile(fs_io, lines_path, .{ .truncate = true });224    defer lines_file.close(fs_io);225    var lines_buffer: [64 * 1024]u8 = undefined;226    var lines_writer = lines_file.writer(fs_io, &lines_buffer);227    defer lines_writer.interface.flush() catch {};228229    var uncovered_file = try sys.fs.cwd().createFile(fs_io, uncovered_path, .{ .truncate = true });230    defer uncovered_file.close(fs_io);231    var uncovered_buffer: [64 * 1024]u8 = undefined;232    var uncovered_writer = uncovered_file.writer(fs_io, &uncovered_buffer);233    defer uncovered_writer.interface.flush() catch {};234235    var summary = Summary{236        .source_files = files.len,237        .physical_lines = 0,238        .code_lines = 0,239        .blank_lines = 0,240        .selected_workloads = 0,241        .captured_workloads = 0,242        .instrumented_lines = 0,243        .covered_lines = 0,244        .covered_code_lines = 0,245        .uncovered_code_lines = 0,246        .uninstrumented_code_lines = 0,247        .instrumented_uncovered_code_lines = 0,248        .summary_path = "",249        .lines_path = lines_path,250        .uncovered_path = uncovered_path,251        .workloads = &.{},252    };253254    for (files) |file| {255        const text = sys.fs.readFileAlloc(allocator, file, max_source_file_bytes) catch continue;256        try writeFileRows(allocator, &summary, coverage_map, file, text, &lines_writer.interface, &uncovered_writer.interface);257    }258    try lines_writer.interface.flush();259    try uncovered_writer.interface.flush();260    return summary;261}262263fn writeFileRows(264    allocator: std.mem.Allocator,265    summary: *Summary,266    coverage_map: *CoverageMap,267    file: []const u8,268    text: []const u8,269    lines_writer: *std.Io.Writer,270    uncovered_writer: *std.Io.Writer,271) !void {272    var cursor: usize = 0;273    var line_number: u32 = 1;274    while (cursor < text.len) : (line_number += 1) {275        const line_end = std.mem.indexOfScalarPos(u8, text, cursor, '\n') orelse text.len;276        const line = text[cursor..line_end];277        const code_line = std.mem.trim(u8, line, " \t\r\n").len != 0;278        const key = try lineKey(allocator, file, line_number);279        defer allocator.free(key);280        const covered_line = coverage_map.get(key);281        const instrumented = covered_line != null;282        const hits = if (covered_line) |covered| covered.hits else 0;283        const covered = hits != 0;284285        summary.physical_lines += 1;286        if (code_line) {287            summary.code_lines += 1;288            if (covered) {289                summary.covered_code_lines += 1;290            } else {291                summary.uncovered_code_lines += 1;292                if (instrumented) {293                    summary.instrumented_uncovered_code_lines += 1;294                } else {295                    summary.uninstrumented_code_lines += 1;296                }297            }298        } else {299            summary.blank_lines += 1;300        }301        if (instrumented) summary.instrumented_lines += 1;302        if (covered) summary.covered_lines += 1;303304        try writeLineRow(lines_writer, file, line_number, code_line, covered_line);305        if (code_line and !covered) try writeLineRow(uncovered_writer, file, line_number, code_line, covered_line);306307        cursor = if (line_end == text.len) text.len else line_end + 1;308    }309}310311fn writeLineRow(312    writer: *std.Io.Writer,313    file: []const u8,314    line: u32,315    code_line: bool,316    covered_line: ?CoveredLine,317) !void {318    var stringify = pretty_json.Writer.init(writer, .minified);319    try stringify.beginObject();320    try stringify.objectField("schema");321    try stringify.write(line_schema);322    try stringify.objectField("file");323    try stringify.write(file);324    try stringify.objectField("line");325    try stringify.write(line);326    try stringify.objectField("source_kind");327    try stringify.write(if (code_line) "code" else "blank");328    try stringify.objectField("instrumented");329    try stringify.write(covered_line != null);330    try stringify.objectField("covered");331    try stringify.write(if (covered_line) |covered| covered.hits != 0 else false);332    try stringify.objectField("hits");333    try stringify.write(if (covered_line) |covered| covered.hits else @as(u64, 0));334    try stringify.objectField("instrumented_workload_count");335    try stringify.write(if (covered_line) |covered| covered.instrumented_workload_count else @as(usize, 0));336    try stringify.objectField("covered_workload_count");337    try stringify.write(if (covered_line) |covered| covered.covered_workloads.items.len else @as(usize, 0));338    try stringify.objectField("covered_workloads");339    try stringify.beginArray();340    if (covered_line) |covered| {341        for (covered.covered_workloads.items) |workload| try stringify.write(workload);342    }343    try stringify.endArray();344    try stringify.endObject();345    try writer.writeByte('\n');346}347348fn writeSummaryFile(path: []const u8, summary: Summary) !void {349    var file = try sys.fs.cwd().createFile(fs_io, path, .{ .truncate = true });350    defer file.close(fs_io);351    var buffer: [8192]u8 = undefined;352    var file_writer = file.writer(fs_io, &buffer);353    const writer = &file_writer.interface;354    var stringify = pretty_json.Writer.init(writer, .indent_2);355    try writeSummaryValue(&stringify, summary);356    try writer.writeByte('\n');357    try writer.flush();358}359360fn writeSummaryValue(stringify: *pretty_json.Writer, summary: Summary) !void {361    try stringify.beginObject();362    try stringify.objectField("schema");363    try stringify.write(summary_schema);364    try stringify.objectField("line_universe");365    try stringify.write(line_universe);366    try stringify.objectField("source_files");367    try stringify.write(summary.source_files);368    try stringify.objectField("physical_lines");369    try stringify.write(summary.physical_lines);370    try stringify.objectField("code_lines");371    try stringify.write(summary.code_lines);372    try stringify.objectField("blank_lines");373    try stringify.write(summary.blank_lines);374    try stringify.objectField("selected_workloads");375    try stringify.write(summary.selected_workloads);376    try stringify.objectField("captured_workloads");377    try stringify.write(summary.captured_workloads);378    try stringify.objectField("instrumented_lines");379    try stringify.write(summary.instrumented_lines);380    try stringify.objectField("covered_lines");381    try stringify.write(summary.covered_lines);382    try stringify.objectField("covered_code_lines");383    try stringify.write(summary.covered_code_lines);384    try stringify.objectField("uncovered_code_lines");385    try stringify.write(summary.uncovered_code_lines);386    try stringify.objectField("uninstrumented_code_lines");387    try stringify.write(summary.uninstrumented_code_lines);388    try stringify.objectField("instrumented_uncovered_code_lines");389    try stringify.write(summary.instrumented_uncovered_code_lines);390    try stringify.objectField("covered_code_percent");391    try stringify.write(summary.coveredPercent());392    try stringify.objectField("artifacts");393    try stringify.beginObject();394    try stringify.objectField("summary");395    try stringify.write(summary.summary_path);396    try stringify.objectField("lines");397    try stringify.write(summary.lines_path);398    try stringify.objectField("uncovered");399    try stringify.write(summary.uncovered_path);400    try stringify.endObject();401    try stringify.objectField("workloads");402    try stringify.beginArray();403    for (summary.workloads) |workload| try stringify.write(workload);404    try stringify.endArray();405    try stringify.endObject();406}407408fn deinitCoverageMap(allocator: std.mem.Allocator, coverage_map: *CoverageMap) void {409    var iterator = coverage_map.iterator();410    while (iterator.next()) |entry| {411        allocator.free(entry.key_ptr.*);412        entry.value_ptr.deinit(allocator);413    }414    coverage_map.deinit(allocator);415}416417fn lineKey(allocator: std.mem.Allocator, file: []const u8, line: u32) ![]const u8 {418    return try std.fmt.allocPrint(allocator, "{s}:{d}", .{ file, line });419}420421test "profiling coverage writes complete line maps" {422    var tmp = std.testing.tmpDir(.{});423    defer tmp.cleanup();424    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);425    defer arena_state.deinit();426    const allocator = arena_state.allocator();427    const root = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", tmp.sub_path[0..] });428    const source_path = try std.fs.path.join(allocator, &.{ root, "a.zig" });429    try sys.fs.writeFile(source_path,430        \\const a = 1;431        \\432        \\const b = 2;433        \\434    );435    var coverage_map: CoverageMap = .empty;436    defer deinitCoverageMap(allocator, &coverage_map);437    try addCoveredLine(allocator, &coverage_map, source_path, 1, 3, "w");438    try addCoveredLine(allocator, &coverage_map, source_path, 3, 0, "w");439440    const lines_path = try std.fs.path.join(allocator, &.{ root, "coverage.lines.jsonl" });441    const uncovered_path = try std.fs.path.join(allocator, &.{ root, "coverage.uncovered.jsonl" });442    const summary = try writeLineMaps(allocator, &.{source_path}, &coverage_map, lines_path, uncovered_path);443    try std.testing.expectEqual(@as(usize, 3), summary.physical_lines);444    try std.testing.expectEqual(@as(usize, 2), summary.code_lines);445    try std.testing.expectEqual(@as(usize, 1), summary.blank_lines);446    try std.testing.expectEqual(@as(usize, 1), summary.covered_code_lines);447    try std.testing.expectEqual(@as(usize, 1), summary.instrumented_uncovered_code_lines);448    try std.testing.expect(sys.fs.exists(lines_path));449    try std.testing.expect(sys.fs.exists(uncovered_path));450}451452test "profiling coverage rebases workload lines onto repository paths" {453    var tmp = std.testing.tmpDir(.{});454    defer tmp.cleanup();455    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);456    defer arena_state.deinit();457    const allocator = arena_state.allocator();458    const root = try std.fs.path.join(allocator, &.{ ".zig-cache", "tmp", tmp.sub_path[0..] });459    const summary_path = try std.fs.path.join(allocator, &.{ root, "coverage.summary.json" });460    const lines_path = try std.fs.path.join(allocator, &.{ root, "coverage.lines.jsonl" });461    const repository_root = try sys.fs.cwdAlloc(allocator);462    const source_root = try std.fs.path.join(allocator, &.{ repository_root, "lib" });463    const workload_summary = capture.coverage.Summary{464        .source_root = source_root,465        .files = &.{.{466            .file = "sys/src/process.zig",467            .instrumented_lines = 1,468            .covered_lines = 1,469        }},470        .lines = &.{.{471            .file = "sys/src/process.zig",472            .line = 1,473            .hits = 3,474        }},475        .instrumented_lines = 1,476        .covered_lines = 1,477    };478    try capture.coverage.writeSummaryFile(summary_path, workload_summary, "coverage.lines.jsonl");479    try capture.coverage.writeLinesJsonlFile(lines_path, workload_summary, "w");480481    var coverage_map: CoverageMap = .empty;482    defer deinitCoverageMap(allocator, &coverage_map);483    try mergeWorkloadLines(allocator, &coverage_map, repository_root, summary_path, lines_path, "w");484485    const covered = coverage_map.get("lib/sys/src/process.zig:1") orelse return error.MissingCoverageLine;486    try std.testing.expectEqual(@as(u64, 3), covered.hits);487    try std.testing.expectEqual(@as(usize, 1), covered.instrumented_workload_count);488    try std.testing.expectEqualStrings("w", covered.covered_workloads.items[0]);489}

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