authorgravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2026-05-01 19:41:26 -07:00
committergravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2026-05-01 19:41:26 -07:00
logb75056e0b4ae4df6413b7492be53ea8fcb27474e
tree44a0f625e5dc75181711d5d4f4c115faf815e2ac
parentfe7f00320d5c3f1839810a5be61f8dd570200c7e
signaturebadge-check Signed by SSH key SHA256:4hHJbtBRU58AYXwjL7fkz2fnQHdiye8x1QpTCQ0sHNw

more otel

3 files changed, 120 insertions(+), 7 deletions(-)

build.zig+1
......@@ -22,6 +22,7 @@ fn addTest(b: *std.Build, target: std.Build.ResolvedTarget, mode: std.builtin.Mo
2222 _ = mod;
2323 const options = b.addOptions();
2424 options.addOption(u8, "backend", backend);
25 options.addOption([]const u8, "version", std.mem.trimRight(u8, b.run(&.{ "git", "describe", "--tags" }), "\n"));
2526
2627 const exe = b.addExecutable(.{
2728 .name = "test" ++ std.fmt.comptimePrint("{d}", .{backend}),
src/main.zig+3-1
......@@ -5,6 +5,8 @@ const nfs = @import("nfs");
55pub const build_options = @import("build_options");
66
77pub const tracer_backend: tracer.Backend = @enumFromInt(build_options.backend);
8pub const otel_service_name = "zig-tracer test";
9pub const otel_service_version = build_options.version;
810
911pub fn main() !void {
1012 try tracer.init(.{});
......@@ -17,7 +19,7 @@ pub fn main() !void {
1719 try tracer.init_thread(switch (build_options.backend) {
1820 0, 1 => .{},
1921 2, 3 => .{try nfs.mkdtemp()},
20 4 => .{std.heap.c_allocator},
22 4 => .{ std.heap.c_allocator, try std.Uri.parse("http://localhost:4318/v1/traces") },
2123 else => comptime unreachable,
2224 });
2325 defer tracer.deinit_thread();
src/otel.zig+116-6
......@@ -27,15 +27,16 @@ pub fn deinit() void {
2727}
2828
2929threadlocal var allocator: std.mem.Allocator = undefined;
30threadlocal var traces_endpoint: std.Uri = undefined;
3031threadlocal var memfd: nfs.File = undefined;
3132threadlocal var buffered_writer: nio.BufferedWriter(4096, nfs.File) = undefined;
3233threadlocal var trace_id: [16]u8 = undefined;
3334threadlocal var prev_span_id: ?[8]u8 = undefined;
3435threadlocal var spans: std.ArrayListUnmanaged([]const u8) = .empty;
3536
36pub fn init_thread(args: struct { std.mem.Allocator }) !void {
37pub fn init_thread(args: struct { std.mem.Allocator, std.Uri }) !void {
3738 std.log.debug("called otel init_thread", .{});
38 allocator = args[0];
39 allocator, traces_endpoint = args;
3940 memfd = try nfs.memfd_create("zig-tracer", 0);
4041 buffered_writer = .init(memfd);
4142 trace_id = extras.randomBytes(16);
......@@ -93,9 +94,84 @@ pub fn init_thread(args: struct { std.mem.Allocator }) !void {
9394}
9495
9596pub fn deinit_thread() void {
97 deinit_thread_inner() catch {};
98 spans.clearAndFree(allocator);
9699 buffered_writer.flush() catch {};
97100 memfd.close();
98101}
102fn deinit_thread_inner() !void {
103 var instrumentation_scope: std.ArrayListUnmanaged(u8) = .empty;
104 defer instrumentation_scope.deinit(allocator);
105 {
106 const w = instrumentation_scope.writer(allocator);
107 try writef_string(w, 1, "github.com/nektro/zig-tracer");
108 try writef_string(w, 2, "(hash)");
109 try writef_len(w, 3, 0);
110 try writef_varint(w, 4, 0);
111 }
112 var scope_spans: std.ArrayListUnmanaged(u8) = .empty;
113 defer scope_spans.deinit(allocator);
114 {
115 const w = scope_spans.writer(allocator);
116 try writef_len(w, 1, instrumentation_scope.items.len);
117 try w.writeAll(instrumentation_scope.items);
118 instrumentation_scope.clearAndFree(allocator);
119 for (spans.items) |sp| {
120 try writef_len(w, 2, sp.len);
121 try w.writeAll(sp);
122 }
123 }
124 var resource: std.ArrayListUnmanaged(u8) = .empty;
125 defer resource.deinit(allocator);
126 {
127 const w = resource.writer(allocator);
128 try writef_kv(w, 1, .{
129 .@"telemetry.sdk.name" = "github.com/nektro/zig-tracer",
130 .@"telemetry.sdk.version" = "(hash)",
131 .@"telemetry.sdk.language" = "zig",
132 .@"service.name" = root.otel_service_name,
133 .@"os.type" = "linux",
134 });
135 try writef_varint(w, 2, 0);
136 }
137 var resource_spans: std.ArrayListUnmanaged(u8) = .empty;
138 defer resource_spans.deinit(allocator);
139 {
140 const w = resource_spans.writer(allocator);
141 try writef_len(w, 1, resource.items.len);
142 try w.writeAll(resource.items);
143 resource.clearAndFree(allocator);
144 try writef_len(w, 2, scope_spans.items.len);
145 try w.writeAll(scope_spans.items);
146 scope_spans.clearAndFree(allocator);
147 }
148 var export_request: std.ArrayListUnmanaged(u8) = .empty;
149 defer export_request.deinit(allocator);
150 {
151 const w = export_request.writer(allocator);
152 try writef_len(w, 1, resource_spans.items.len);
153 try w.writeAll(resource_spans.items);
154 resource_spans.clearAndFree(allocator);
155 }
156 {
157 var client: std.http.Client = .{ .allocator = allocator };
158 defer client.deinit();
159 var buf: [4096]u8 = @splat(0);
160 var req = try client.open(.POST, traces_endpoint, .{
161 .server_header_buffer = &buf,
162 .headers = .{
163 .content_type = .{ .override = "application/x-protobuf" },
164 },
165 .redirect_behavior = .not_allowed,
166 });
167 defer req.deinit();
168 req.transfer_encoding = .{ .content_length = export_request.items.len };
169 try req.send();
170 try req.writeAll(export_request.items);
171 try req.finish();
172 try req.wait();
173 }
174}
99175
100176pub fn trace_begin(src: std.builtin.SourceLocation, comptime ifmt: []const u8, iargs: anytype) Data {
101177 const span_id = extras.randomBytes(8);
......@@ -119,16 +195,16 @@ pub fn trace_end(ctx: tracer.Ctx) void {
119195}
120196fn trace_end_inner(ctx: tracer.Ctx) !void {
121197 var temp: std.ArrayListUnmanaged(u8) = .empty;
122 defer temp.deinit(allocator);
123198 const w = temp.writer(allocator);
199 defer if (ctx.data.name.len > 0) allocator.free(ctx.data.name);
124200 try writef_bytes(w, 1, &trace_id);
125201 try writef_bytes(w, 2, &ctx.data.span_id);
202 try writef_string(w, 3, "");
126203 if (ctx.data.parent_id) |*pi| try writef_bytes(w, 4, pi);
127204 try writef_string(w, 5, ctx.data.name);
128 if (ctx.data.name.len > 0) allocator.free(ctx.data.name);
129205 try writef_varint(w, 6, 2);
130 try writef_varint(w, 7, ctx.data.time_start_ns);
131 try writef_varint(w, 8, @intCast(time.nanoTimestamp()));
206 try writef_i64(w, 7, @floatFromInt(ctx.data.time_start_ns));
207 try writef_i64(w, 8, @floatFromInt(time.nanoTimestamp()));
132208 try spans.append(allocator, temp.items);
133209}
134210
......@@ -297,3 +373,37 @@ fn writef_varint(w: anytype, nr: u64, i: u64) !void {
297373 try write_tag(w, nr, .varint);
298374 try write_varint(w, i);
299375}
376
377fn writef_len(w: anytype, nr: u64, l: u64) !void {
378 try write_tag(w, nr, .len);
379 try write_varint(w, l);
380}
381
382// https://opentelemetry.io/docs/specs/semconv/registry/attributes/
383fn writef_kv(w: anytype, nr: u64, kvs: anytype) !void {
384 var temp: std.ArrayListUnmanaged(u8) = .empty;
385 defer temp.deinit(allocator);
386 const x = temp.writer(allocator);
387
388 var temp2: std.ArrayListUnmanaged(u8) = .empty;
389 defer temp2.deinit(allocator);
390 const y = temp2.writer(allocator);
391
392 inline for (comptime std.meta.fields(@TypeOf(kvs))) |field| {
393 try writef_string(x, 1, field.name);
394
395 try writef_string(y, 1, @field(kvs, field.name));
396 try writef_len(x, 2, temp2.items.len);
397 try x.writeAll(temp2.items);
398 temp2.clearRetainingCapacity();
399
400 try writef_len(w, nr, temp.items.len);
401 try w.writeAll(temp.items);
402 temp.clearRetainingCapacity();
403 }
404}
405
406fn writef_i64(w: anytype, nr: u64, i: f64) !void {
407 try write_tag(w, nr, .i64);
408 try w.writeAll(&std.mem.toBytes((i)));
409}