tiny.profiling.schema

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

1const std = @import("std");23const json = @import("json.zig");45pub const metric_schema = "tiny.profiling.metric/v1";67pub const Family = enum {8    timing,9    memory,10    allocation,11    unknown,1213    pub fn name(self: Family) []const u8 {14        return @tagName(self);15    }16};1718pub const Classification = struct {19    family: Family,20    strict: bool,21};2223pub fn classify(row: std.json.ObjectMap, source_kind: []const u8) Classification {24    if (json.string(row.get("schema"))) |schema_name| {25        if (std.mem.eql(u8, schema_name, metric_schema)) {26            if (strictTiming(row)) return .{ .family = .timing, .strict = true };27            if (strictMemory(row)) return .{ .family = .memory, .strict = true };28            return .{ .family = .unknown, .strict = true };29        }30    }31    if (legacyTiming(row)) return .{ .family = .timing, .strict = false };32    if (legacyMemory(row)) return .{ .family = .memory, .strict = false };33    if (std.mem.eql(u8, source_kind, "allocations") and allocationEvent(row)) return .{ .family = .allocation, .strict = false };34    return .{ .family = .unknown, .strict = false };35}3637pub fn isTimingMetric(row: std.json.ObjectMap) bool {38    if (json.string(row.get("schema"))) |schema_name| {39        if (std.mem.eql(u8, schema_name, metric_schema)) return strictTiming(row);40    }41    return legacyTiming(row);42}4344pub fn isMemoryMetric(row: std.json.ObjectMap, source_kind: []const u8) bool {45    if (std.mem.eql(u8, source_kind, "allocations") and allocationEvent(row)) return true;46    if (json.string(row.get("schema"))) |schema_name| {47        if (std.mem.eql(u8, schema_name, metric_schema)) return strictMemory(row) or legacyMemory(row);48    }49    return legacyMemory(row);50}5152fn strictTiming(row: std.json.ObjectMap) bool {53    if (!familyIs(row, "timing")) return false;54    if (!unitIs(row, "ns")) return false;55    if (!hasIdentity(row)) return false;56    return hasTimingEvidence(row);57}5859fn strictMemory(row: std.json.ObjectMap) bool {60    if (!familyIs(row, "memory")) return false;61    if (!(unitIs(row, "bytes") or unitIs(row, "count"))) return false;62    if (!hasIdentity(row)) return false;63    return hasMemoryEvidence(row);64}6566fn legacyTiming(row: std.json.ObjectMap) bool {67    if (eventIs(row, "bench_end") and hasSampleNs(row)) return true;68    if (kindIs(row, "summary") and hasSummaryTiming(row)) return true;69    return false;70}7172fn legacyMemory(row: std.json.ObjectMap) bool {73    if (eventIs(row, "bench_end") and (hasNumber(row, "alloc_bytes") or hasNumber(row, "alloc_count"))) return true;74    if (kindIs(row, "summary") and summaryIs(row, "memory") and hasMemoryEvidence(row)) return true;75    return false;76}7778fn allocationEvent(row: std.json.ObjectMap) bool {79    const kind = json.string(row.get("kind")) orelse return false;80    return std.mem.eql(u8, kind, "alloc") or81        std.mem.eql(u8, kind, "free") or82        std.mem.eql(u8, kind, "resize") or83        std.mem.eql(u8, kind, "remap") or84        std.mem.eql(u8, kind, "allocator");85}8687fn familyIs(row: std.json.ObjectMap, expected: []const u8) bool {88    return if (json.string(row.get("family"))) |family| std.mem.eql(u8, family, expected) else false;89}9091fn unitIs(row: std.json.ObjectMap, expected: []const u8) bool {92    return if (json.string(row.get("unit"))) |unit| std.mem.eql(u8, unit, expected) else false;93}9495fn eventIs(row: std.json.ObjectMap, expected: []const u8) bool {96    return if (json.string(row.get("event"))) |event| std.mem.eql(u8, event, expected) else false;97}9899fn kindIs(row: std.json.ObjectMap, expected: []const u8) bool {100    return if (json.string(row.get("kind"))) |kind| std.mem.eql(u8, kind, expected) else false;101}102103fn summaryIs(row: std.json.ObjectMap, expected: []const u8) bool {104    return if (json.string(row.get("summary"))) |summary| std.mem.eql(u8, summary, expected) else false;105}106107fn hasIdentity(row: std.json.ObjectMap) bool {108    return hasString(row, "name") or109        hasString(row, "id") or110        hasString(row, "phase") or111        hasString(row, "pass") or112        hasString(row, "analysis") or113        hasString(row, "metric");114}115116fn hasTimingEvidence(row: std.json.ObjectMap) bool {117    return hasSampleNs(row) or118        hasSummaryTiming(row) or119        hasNumber(row, "ns") or120        hasNumber(row, "duration_ns") or121        hasNumber(row, "wall_ns");122}123124fn hasSummaryTiming(row: std.json.ObjectMap) bool {125    return hasNumber(row, "mean_ns") or126        hasNumber(row, "median_ns") or127        hasNumber(row, "p95_ns") or128        hasNumber(row, "p99_ns");129}130131fn hasMemoryEvidence(row: std.json.ObjectMap) bool {132    return hasNumber(row, "value") or133        hasNumber(row, "mean") or134        hasNumber(row, "median") or135        hasNumber(row, "alloc_bytes") or136        hasNumber(row, "alloc_count") or137        hasNumber(row, "allocated_bytes") or138        hasNumber(row, "retained_bytes") or139        hasNumber(row, "high_water_live_bytes");140}141142fn hasSampleNs(row: std.json.ObjectMap) bool {143    return if (row.get("sample_ns")) |value| json.array(value) catch null != null else false;144}145146fn hasString(row: std.json.ObjectMap, field: []const u8) bool {147    return if (json.string(row.get(field))) |value| value.len != 0 else false;148}149150fn hasNumber(row: std.json.ObjectMap, field: []const u8) bool {151    return json.asF64(row.get(field)) != null;152}153154test "profiling schema classifies strict timing rows" {155    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);156    defer arena.deinit();157    const value = try std.json.parseFromSliceLeaky(std.json.Value, arena.allocator(),158        \\{"schema":"tiny.profiling.metric/v1","family":"timing","metric":"duration_ns","unit":"ns","name":"x","median_ns":12}159    , .{});160    const classification = classify(try json.object(value), "bench_jsonl");161    try std.testing.expectEqual(Family.timing, classification.family);162    try std.testing.expect(classification.strict);163}164165test "profiling schema classifies memtrace allocation rows" {166    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);167    defer arena.deinit();168    const value = try std.json.parseFromSliceLeaky(std.json.Value, arena.allocator(),169        \\{"v":1,"kind":"alloc","allocation_id":1,"len":64}170    , .{});171    const classification = classify(try json.object(value), "allocations");172    try std.testing.expectEqual(Family.allocation, classification.family);173    try std.testing.expect(!classification.strict);174}175176test "profiling schema exposes overlapping timing and memory rows" {177    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);178    defer arena.deinit();179    const value = try std.json.parseFromSliceLeaky(std.json.Value, arena.allocator(),180        \\{"schema":"tiny.profiling.metric/v1","event":"bench_end","family":"timing","metric":"duration_ns","unit":"ns","name":"x","sample_ns":[10,20],"alloc_count":2,"alloc_bytes":64}181    , .{});182    const row = try json.object(value);183    try std.testing.expect(isTimingMetric(row));184    try std.testing.expect(isMemoryMetric(row, "bench_jsonl"));185    try std.testing.expectEqual(Family.timing, classify(row, "bench_jsonl").family);186}