tiny.profiling.ingest.parser

1const std = @import("std");2const ingest = @import("root.zig");34pub const Result = struct {5    valid: bool,6    event: ingest.event.Event = .{},7};89const State = enum(u8) {10    root,11    key,12    key_string,13    value,14    value_string,15    nested,16    document,17};1819const Step = enum(u8) {20    next,21    valid,22    invalid,23};2425comptime {26    std.debug.assert(@typeInfo(State).@"enum".field_names.len == 7);27    std.debug.assert(@typeInfo(Step).@"enum".field_names.len == 3);28    std.debug.assert(@sizeOf(State) == 1);29    std.debug.assert(@sizeOf(Step) == 1);30}3132const Parser = struct {33    state: State = .root,34    field: ingest.event.Field = .other,35    matcher: ingest.matching.Matcher = ingest.matching.Matcher.kinds(),36    event: ingest.event.Event = .{},3738    fn accept(39        self: *Parser,40        scanner: *const std.json.Scanner,41        token: std.json.Token,42        key: ?ingest.duplicate.Key,43    ) Step {44        std.debug.assert(@backingInt(self.state) < 7);45        std.debug.assert(@backingInt(self.field) < 21);46        return switch (self.state) {47            .root => self.acceptRoot(token),48            .key => self.acceptKey(token, key),49            .key_string => self.acceptKeyString(token, key),50            .value => self.acceptValue(token),51            .value_string => self.acceptValueString(token),52            .nested => self.acceptNested(scanner, token),53            .document => if (token == .end_of_document) .valid else .invalid,54        };55    }5657    fn acceptRoot(self: *Parser, token: std.json.Token) Step {58        std.debug.assert(self.state == .root);59        if (token != .object_begin) return .invalid;60        self.state = .key;61        std.debug.assert(self.state == .key);62        return .next;63    }6465    fn acceptKey(66        self: *Parser,67        token: std.json.Token,68        key: ?ingest.duplicate.Key,69    ) Step {70        std.debug.assert(self.state == .key);71        if (token == .object_end) {72            self.state = .document;73            return .next;74        }75        return self.acceptKeyPart(token, key);76    }7778    fn acceptKeyString(79        self: *Parser,80        token: std.json.Token,81        key: ?ingest.duplicate.Key,82    ) Step {83        std.debug.assert(self.state == .key_string);84        return self.acceptKeyPart(token, key);85    }8687    fn acceptKeyPart(88        self: *Parser,89        token: std.json.Token,90        key: ?ingest.duplicate.Key,91    ) Step {92        switch (self.state) {93            .key => std.debug.assert(self.state == .key),94            .key_string => std.debug.assert(self.state == .key_string),95            else => unreachable,96        }97        switch (token) {98            .partial_string,99            .partial_string_escaped_1,100            .partial_string_escaped_2,101            .partial_string_escaped_3,102            .partial_string_escaped_4,103            => self.state = .key_string,104            .string => {105                const actual = key orelse return .invalid;106                self.field = ingest.selector.field(actual.hash, actual.bytes);107                self.state = .value;108            },109            else => return .invalid,110        }111        switch (self.state) {112            .key_string => std.debug.assert(self.state == .key_string),113            .value => std.debug.assert(self.state == .value),114            else => unreachable,115        }116        return .next;117    }118119    fn acceptValue(self: *Parser, token: std.json.Token) Step {120        std.debug.assert(self.state == .value);121        self.event.clear(self.field);122        self.matcher = ingest.matching.Matcher.values(self.field);123        if (ingest.matching.feedToken(&self.matcher, token)) |part| {124            return self.finishValuePart(part);125        }126        switch (token) {127            .object_begin => self.state = .nested,128            .array_begin => {129                self.event.assignArray(self.field);130                self.state = .nested;131            },132            .number => |number| {133                self.event.assignNumber(self.field, number);134                self.state = .key;135            },136            .true, .false, .null => self.state = .key,137            else => return .invalid,138        }139        return .next;140    }141142    fn acceptValueString(self: *Parser, token: std.json.Token) Step {143        std.debug.assert(self.state == .value_string);144        const part = ingest.matching.feedToken(&self.matcher, token) orelse return .invalid;145        return self.finishValuePart(part);146    }147148    fn finishValuePart(self: *Parser, part: ingest.matching.StringPart) Step {149        switch (self.state) {150            .value => std.debug.assert(self.state == .value),151            .value_string => std.debug.assert(self.state == .value_string),152            else => unreachable,153        }154        if (part == .partial) {155            self.state = .value_string;156        } else {157            switch (self.field) {158                .kind => self.event.kind = self.matcher.kind(),159                .schema => self.event.schema_metric = self.matcher.schemaMetric(),160                .event => self.event.event_bench_end = self.matcher.eventBenchEnd(),161                .summary => self.event.summary_memory = self.matcher.summaryMemory(),162                else => {},163            }164            self.state = .key;165        }166        switch (self.state) {167            .value_string => std.debug.assert(self.state == .value_string),168            .key => std.debug.assert(self.state == .key),169            else => unreachable,170        }171        return .next;172    }173174    fn acceptNested(175        self: *Parser,176        scanner: *const std.json.Scanner,177        token: std.json.Token,178    ) Step {179        std.debug.assert(self.state == .nested);180        std.debug.assert(scanner.stackHeight() >= 1);181        switch (token) {182            .object_end, .array_end => if (scanner.stackHeight() == 1) {183                self.state = .key;184            },185            .end_of_document => return .invalid,186            else => {},187        }188        return .next;189    }190};191192pub fn line(bytes: []const u8, scratch: ingest.duplicate.Scratch) error{ScratchExceeded}!Result {193    std.debug.assert(bytes.len >= 2);194    std.debug.assert(bytes[0] == '{');195    std.debug.assert(bytes[bytes.len - 1] == '}');196    std.debug.assert(scratch.json_stack.len > 0);197    std.debug.assert(scratch.key_bytes.len >= bytes.len);198    std.debug.assert(scratch.objects.len * 8 >= scratch.json_stack.len);199    @memset(scratch.json_stack, 0);200    var allocator_storage: [0]u8 = .{};201    var fixed = std.heap.FixedBufferAllocator.init(&allocator_storage);202    var scanner = std.json.Scanner.initCompleteInput(fixed.allocator(), bytes);203    scanner.stack.bytes.items = scratch.json_stack[0..0];204    scanner.stack.bytes.capacity = scratch.json_stack.len;205    std.debug.assert(scanner.stack.bytes.capacity == scratch.json_stack.len);206    var duplicates = ingest.duplicate.Tracker.init(scratch);207    var parser = Parser{};208    const token_bound = std.math.add(usize, bytes.len, 2) catch unreachable;209    std.debug.assert(token_bound > bytes.len);210    for (0..token_bound) |_| {211        const token = scanner.next() catch |err| switch (err) {212            error.OutOfMemory => return error.ScratchExceeded,213            else => return .{ .valid = false },214        };215        const observation = try duplicates.observe(&scanner, token);216        const key: ?ingest.duplicate.Key = switch (observation) {217            .none => null,218            .unique => |actual| actual,219            .duplicate => return .{ .valid = false },220        };221        switch (parser.accept(&scanner, token, key)) {222            .next => {},223            .valid => return .{ .valid = true, .event = parser.event },224            .invalid => return .{ .valid = false },225        }226    }227    return .{ .valid = false };228}

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