flatten events, include aarch + os, remove eid

Author: karlseguin

src/app.zig

@@ -4,21 +4,26 @@ const Loop = @import("jsruntime").Loop;
 const Allocator = std.mem.Allocator;
 const Telemetry = @import("telemetry/telemetry.zig").Telemetry;
 
+pub const RunMode = enum {
+    serve,
+    fetch,
+};
+
 // Container for global state / objects that various parts of the system
 // might need.
 pub const App = struct {
     loop: *Loop,
     allocator: Allocator,
     telemetry: Telemetry,
 
-    pub fn init(allocator: Allocator) !App {
+    pub fn init(allocator: Allocator, run_mode: RunMode) !App {
         const loop = try allocator.create(Loop);
         errdefer allocator.destroy(loop);
 
         loop.* = try Loop.init(allocator);
         errdefer loop.deinit();
 
-        const telemetry = Telemetry.init(allocator, loop);
+        const telemetry = Telemetry.init(allocator, loop, run_mode);
         errdefer telemetry.deinit();
 
         return .{

src/cdp/testing.zig

@@ -168,7 +168,7 @@ const TestContext = struct {
 
 pub fn context() TestContext {
     return .{
-        .app = App.init(std.testing.allocator) catch unreachable,
+        .app = App.init(std.testing.allocator, .serve) catch unreachable,
         .arena = std.heap.ArenaAllocator.init(std.testing.allocator),
     };
 }

src/main.zig

@@ -70,9 +70,9 @@ pub fn main() !void {
                 return args.printUsageAndExit(false);
             };
 
-            var app = try @import("app.zig").App.init(alloc);
+            var app = try @import("app.zig").App.init(alloc, .serve);
             defer app.deinit();
-            app.telemetry.record(.{ .run = .{ .mode = .serve, .version = version } });
+            app.telemetry.record(.{ .run = {} });
 
             const timeout = std.time.ns_per_s * @as(u64, opts.timeout);
             server.run(&app, address, timeout) catch |err| {
@@ -83,9 +83,9 @@ pub fn main() !void {
         .fetch => |opts| {
             log.debug("Fetch mode: url {s}, dump {any}", .{ opts.url, opts.dump });
 
-            var app = try @import("app.zig").App.init(alloc);
+            var app = try @import("app.zig").App.init(alloc, .fetch);
             defer app.deinit();
-            app.telemetry.record(.{ .run = .{ .mode = .fetch, .version = version } });
+            app.telemetry.record(.{ .run = {} });
 
             // vm
             const vm = jsruntime.VM.init();

src/telemetry/lightpanda.zig

@@ -4,10 +4,13 @@ const ArenAallocator = std.heap.ArenaAllocator;
 
 const Loop = @import("jsruntime").Loop;
 const Client = @import("asyncio").Client;
+const Event = @import("telemetry.zig").Event;
+const RunMode = @import("../app.zig").RunMode;
 
 const log = std.log.scoped(.telemetry);
 
-const URL = "https://httpbin.io/post";
+const DATA_VERSION = 1;
+const URL = "https://1df7a24e33.endpoints.dev";
 
 pub const LightPanda = struct {
     uri: std.Uri,
@@ -34,15 +37,15 @@ pub const LightPanda = struct {
         self.client_context_pool.deinit();
     }
 
-    pub fn send(self: *LightPanda, iid: ?[]const u8, eid: []const u8, event: anytype) !void {
+    pub fn send(self: *LightPanda, iid: ?[]const u8, run_mode: RunMode, event: *const Event) !void {
         var arena = std.heap.ArenaAllocator.init(self.allocator);
         errdefer arena.deinit();
 
         const resp_header_buffer = try arena.allocator().alloc(u8, 4096);
-        const body = try std.json.stringifyAlloc(arena.allocator(), .{
+        const body = try std.json.stringifyAlloc(arena.allocator(), EventWrap{
             .iid = iid,
-            .eid = eid,
             .event = event,
+            .run_mode = run_mode,
         }, .{});
 
         const sending = try self.sending_pool.create();
@@ -159,38 +162,39 @@ const Sending = struct {
     }
 };
 
-// // wraps a telemetry event so that we can serialize it to plausible's event endpoint
-// const EventWrap = struct {
-//     iid: ?[]const u8,
-//     eid: []const u8,
-//     event: *const Event,
-
-//     pub fn jsonStringify(self: *const EventWrap, jws: anytype) !void {
-//         try jws.beginObject();
-//         try jws.objectField("iid");
-//         try jws.write(self.iid);
-//         try jws.objectField("eid");
-//         try jws.write(self.eid);
-//         try jws.objectField("event");
-//         try jws.write(@tagName(self.event.*));
-//         try jws.objectField("props");
-//         switch (self.event) {
-//             inline else => |props| try jws.write(props),
-//         }
-//         try jws.endObject();
-//     }
-// };
-
-// const testing = std.testing;
-// test "telemetry: lightpanda json event" {
-//     const json = try std.json.stringifyAlloc(testing.allocator, EventWrap{
-//         .iid = "1234",
-//         .eid = "abc!",
-//         .event = .{ .run = .{ .mode = .serve, .version = "over 9000!" } }
-//     }, .{});
-//     defer testing.allocator.free(json);
-
-//     try testing.expectEqualStrings(
-//         \\{"event":"run","iid""1234","eid":"abc!","props":{"version":"over 9000!","mode":"serve"}}
-//     , json);
-// }
+// wraps a telemetry event so that we can serialize it to plausible's event endpoint
+const EventWrap = struct {
+    iid: ?[]const u8,
+    event: *const Event,
+    run_mode: RunMode,
+
+    const builtin = @import("builtin");
+    const build_info = @import("build_info");
+
+    pub fn jsonStringify(self: *const EventWrap, jws: anytype) !void {
+        try jws.beginObject();
+        try jws.objectField("iid");
+        try jws.write(self.iid);
+        try jws.objectField("event");
+        try jws.write(@tagName(self.event.*));
+        try jws.objectField("mode");
+        try jws.write(self.run_mode);
+        try jws.objectField("version");
+        try jws.write(DATA_VERSION);
+        try jws.objectField("os");
+        try jws.write(builtin.os.tag);
+        try jws.objectField("version");
+        try jws.write(build_info.git_commit);
+        try jws.objectField("arch");
+        try jws.write(builtin.cpu.arch);
+        switch (self.event.*) {
+            .run => {},
+            .navigate => {},
+            .flag => |f| {
+                try jws.objectField("flag");
+                try jws.write(f);
+            },
+        }
+        try jws.endObject();
+    }
+};

src/telemetry/telemetry.zig

@@ -5,6 +5,7 @@ const Allocator = std.mem.Allocator;
 
 const Loop = @import("jsruntime").Loop;
 const uuidv4 = @import("../id.zig").uuidv4;
+const RunMode = @import("../app.zig").RunMode;
 
 const log = std.log.scoped(.telemetry);
 const ID_FILE = "lightpanda.id";
@@ -20,24 +21,21 @@ fn TelemetryT(comptime P: type) type {
         // null on IO error
         iid: ?[36]u8,
 
-        // a "execution" id is an id that represents this specific run
-        eid: [36]u8,
         provider: P,
 
         disabled: bool,
 
+        run_mode: RunMode,
+
         const Self = @This();
 
-        pub fn init(allocator: Allocator, loop: *Loop) Self {
+        pub fn init(allocator: Allocator, loop: *Loop, run_mode: RunMode) Self {
             const disabled = std.process.hasEnvVarConstant("LIGHTPANDA_DISABLE_TELEMETRY");
 
-            var eid: [36]u8 = undefined;
-            uuidv4(&eid);
-
             return .{
-                .iid = if (disabled) null else getOrCreateId(),
-                .eid = eid,
                 .disabled = disabled,
+                .run_mode = run_mode,
+                .iid = if (disabled) null else getOrCreateId(),
                 .provider = try P.init(allocator, loop),
             };
         }
@@ -51,7 +49,7 @@ fn TelemetryT(comptime P: type) type {
                 return;
             }
             const iid: ?[]const u8 = if (self.iid) |*iid| iid else null;
-            self.provider.send(iid, &self.eid, &event) catch |err| {
+            self.provider.send(iid, self.run_mode, &event) catch |err| {
                 log.warn("failed to record event: {}", .{err});
             };
         }
@@ -83,31 +81,22 @@ fn getOrCreateId() ?[36]u8 {
 }
 
 pub const Event = union(enum) {
-    run: Run,
+    run: void,
     navigate: void,
     flag: []const u8, // used for testing
-
-    const Run = struct {
-        version: []const u8,
-        mode: RunMode,
-
-        const RunMode = enum {
-            fetch,
-            serve,
-        };
-    };
 };
 
 const NoopProvider = struct {
     fn init(_: Allocator, _: *Loop) !NoopProvider {
         return .{};
     }
     fn deinit(_: NoopProvider) void {}
-    pub fn send(_: NoopProvider, _: ?[]const u8, _: []const u8, _: anytype) !void {}
+    pub fn send(_: NoopProvider, _: ?[]const u8, _: RunMode, _: *const Event) !void {}
 };
 
 extern fn setenv(name: [*:0]u8, value: [*:0]u8, override: c_int) c_int;
 extern fn unsetenv(name: [*:0]u8) c_int;
+
 const testing = std.testing;
 test "telemetry: disabled by environment" {
     _ = setenv(@constCast("LIGHTPANDA_DISABLE_TELEMETRY"), @constCast(""), 0);
@@ -118,14 +107,14 @@ test "telemetry: disabled by environment" {
             return .{};
         }
         fn deinit(_: @This()) void {}
-        pub fn send(_: @This(), _: ?[]const u8, _: []const u8, _: anytype) !void {
+        pub fn send(_: @This(), _: ?[]const u8, _: RunMode, _: *const Event) !void {
             unreachable;
         }
     };
 
-    var telemetry = TelemetryT(FailingProvider).init(testing.allocator, undefined);
+    var telemetry = TelemetryT(FailingProvider).init(testing.allocator, undefined, .serve);
     defer telemetry.deinit();
-    telemetry.record(.{ .run = .{ .mode = .serve, .version = "123" } });
+    telemetry.record(.{ .run = {} });
 }
 
 test "telemetry: getOrCreateId" {
@@ -146,7 +135,7 @@ test "telemetry: sends event to provider" {
     defer std.fs.cwd().deleteFile(ID_FILE) catch {};
     std.fs.cwd().deleteFile(ID_FILE) catch {};
 
-    var telemetry = TelemetryT(MockProvider).init(testing.allocator, undefined);
+    var telemetry = TelemetryT(MockProvider).init(testing.allocator, undefined, .serve);
     defer telemetry.deinit();
     const mock = &telemetry.provider;
 
@@ -162,29 +151,29 @@ test "telemetry: sends event to provider" {
 
 const MockProvider = struct {
     iid: ?[]const u8,
-    eid: ?[]const u8,
+    run_mode: ?RunMode,
     allocator: Allocator,
     events: std.ArrayListUnmanaged(Event),
 
     fn init(allocator: Allocator, _: *Loop) !@This() {
         return .{
             .iid = null,
-            .eid = null,
+            .run_mode = null,
             .events = .{},
             .allocator = allocator,
         };
     }
     fn deinit(self: *MockProvider) void {
         self.events.deinit(self.allocator);
     }
-    pub fn send(self: *MockProvider, iid: ?[]const u8, eid: []const u8, events: *const Event) !void {
+    pub fn send(self: *MockProvider, iid: ?[]const u8, run_mode: RunMode, events: *const Event) !void {
         if (self.iid == null) {
-            try testing.expectEqual(null, self.eid);
+            try testing.expectEqual(null, self.run_mode);
             self.iid = iid.?;
-            self.eid = eid;
+            self.run_mode = run_mode;
         } else {
             try testing.expectEqualStrings(self.iid.?, iid.?);
-            try testing.expectEqualStrings(self.eid.?, eid);
+            try testing.expectEqual(self.run_mode.?, run_mode);
         }
         try self.events.append(self.allocator, events.*);
     }

src/unit_tests.zig

@@ -45,7 +45,7 @@ pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
 
-    var app = try App.init(allocator);
+    var app = try App.init(allocator, .serve);
     defer app.deinit();
 
     const env = Env.init(allocator);