zzstoatzz.io
logfire client for zig
fix: use thread-local storage for trace context
concurrent requests on different thread pool workers were sharing
the same trace_id because current_trace_id was process-global.
now each thread has its own trace context via threadlocal:
- tl_trace_id: current trace ID for this thread
- tl_active_span_count: span nesting depth for this thread
this ensures each HTTP request gets its own trace_id even when
handled by different workers concurrently.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+23
-13
src/root.zig
+23
-13
src/root.zig
···
51
51
var global_instance: ?*Logfire = null;
52
52
var global_mutex: std.Thread.Mutex = .{};
53
53
54
+
/// thread-local trace context - each thread gets its own trace
55
+
threadlocal var tl_trace_id: ?[16]u8 = null;
56
+
threadlocal var tl_active_span_count: u32 = 0;
57
+
54
58
pub const Logfire = struct {
55
59
allocator: std.mem.Allocator,
56
60
config: Config,
···
65
69
/// allocated data points (freed on flush)
66
70
allocated_data_points: std.ArrayList(*NumberDataPoint),
67
71
68
-
/// trace context
69
-
current_trace_id: ?[16]u8,
70
-
active_span_count: std.atomic.Value(u32),
72
+
/// span ID counter (global, just needs to be unique)
71
73
span_id_counter: std.atomic.Value(u64),
72
74
73
75
/// background flush thread
···
87
89
.pending_metrics = .{},
88
90
.pending_mutex = .{},
89
91
.allocated_data_points = .{},
90
-
.current_trace_id = null,
91
-
.active_span_count = std.atomic.Value(u32).init(0),
92
92
.span_id_counter = std.atomic.Value(u64).init(1),
93
93
.flush_thread = null,
94
94
.running = std.atomic.Value(bool).init(true),
···
170
170
}
171
171
172
172
pub fn createSpan(self: *Logfire, name: []const u8, attributes: anytype) Span {
173
-
// generate new trace ID if no active spans (root span)
174
-
if (self.active_span_count.fetchAdd(1, .acquire) == 0) {
175
-
self.current_trace_id = generateTraceId();
173
+
// generate new trace ID if no active spans on this thread
174
+
if (tl_active_span_count == 0) {
175
+
tl_trace_id = generateTraceId();
176
176
}
177
+
tl_active_span_count += 1;
177
178
const span_id = self.span_id_counter.fetchAdd(1, .monotonic);
178
-
return Span.init(self, name, span_id, attributes);
179
+
return Span.init(self, name, span_id, tl_trace_id, attributes);
179
180
}
180
181
181
182
/// called when a span ends to track active span count
182
183
pub fn spanEnded(self: *Logfire) void {
183
-
_ = self.active_span_count.fetchSub(1, .release);
184
+
_ = self;
185
+
if (tl_active_span_count > 0) {
186
+
tl_active_span_count -= 1;
187
+
}
184
188
}
185
189
186
-
/// start a new trace (generates new trace ID)
190
+
/// start a new trace (generates new trace ID for this thread)
187
191
pub fn newTrace(self: *Logfire) void {
188
-
self.current_trace_id = generateTraceId();
192
+
_ = self;
193
+
tl_trace_id = generateTraceId();
194
+
}
195
+
196
+
/// get the current thread's trace ID
197
+
pub fn currentTraceId() ?[16]u8 {
198
+
return tl_trace_id;
189
199
}
190
200
191
201
pub fn recordLog(self: *Logfire, level: Level, message: []const u8, attributes: anytype) void {
192
202
const record = LogRecord.init(
193
-
self.current_trace_id,
203
+
tl_trace_id,
194
204
level,
195
205
message,
196
206
attributes,
+2
-2
src/span.zig
+2
-2
src/span.zig
···
33
33
};
34
34
35
35
/// create a span (called by Logfire.createSpan)
36
-
pub fn init(logfire: *root.Logfire, name: []const u8, span_id_num: u64, attrs: anytype) Span {
36
+
pub fn init(logfire: *root.Logfire, name: []const u8, span_id_num: u64, trace_id: ?[16]u8, attrs: anytype) Span {
37
37
var s = Span{
38
38
.logfire = logfire,
39
39
.data = .{
40
40
.name = name,
41
-
.trace_id = logfire.current_trace_id orelse [_]u8{0} ** 16,
41
+
.trace_id = trace_id orelse [_]u8{0} ** 16,
42
42
.span_id = undefined,
43
43
.start_time_ns = std.time.nanoTimestamp(),
44
44
.end_time_ns = 0,