add SpanExporter and StdoutExporter

Signed-off-by: drumato <[email protected]>

Author: Drumato

src/api/trace.zig

@@ -2,6 +2,9 @@ pub const Tracer = @import("trace/tracer.zig").Tracer;
 pub const TracerProvider = @import("trace/provider.zig").TracerProvider;
 pub const TracerConfig = @import("trace/config.zig").TracerConfig;
 
+pub const TraceID = [16]u8;
+pub const SpanID = [8]u8;
+
 test {
     _ = @import("trace/config.zig");
     _ = @import("trace/provider.zig");

src/sdk/trace.zig

@@ -1,3 +1,7 @@
+pub const exporter = @import("trace/exporter.zig");
 test {
+    _ = @import("trace/exporter.zig");
+    _ = @import("trace/id_generator.zig");
     _ = @import("trace/provider.zig");
+    _ = @import("trace/span_exporter.zig");
 }

src/sdk/trace/exporter.zig

@@ -0,0 +1,3 @@
+test {
+    _ = @import("exporters/stdout_exporter.zig");
+}

src/sdk/trace/exporters/stdout_exporter.zig

@@ -0,0 +1,58 @@
+const std = @import("std");
+const pb = @import("../../../opentelemetry/proto/trace/v1.pb.zig");
+const protobuf = @import("protobuf");
+const SpanExporter = @import("../span_exporter.zig").SpanExporter;
+
+/// GenericWriterExporter is the generic SpanExporter that outputs spans to the given writer.
+fn GenericWriterExporter(
+    comptime Writer: type,
+) type {
+    return struct {
+        writer: Writer,
+
+        const Self = @This();
+
+        pub fn init(writer: Writer) Self {
+            return Self{
+                .writer = writer,
+            };
+        }
+
+        pub fn exportSpans(ctx: *anyopaque, spans: []pb.Span) anyerror!void {
+            const self: *Self = @ptrCast(@alignCast(ctx));
+            try std.json.stringify(spans, .{}, self.writer);
+        }
+
+        pub fn shutdown(_: *anyopaque) anyerror!void {}
+
+        pub fn asSpanExporter(self: *Self) SpanExporter {
+            return .{
+                .ptr = self,
+                .vtable = &.{
+                    .exportSpansFn = exportSpans,
+                    .shutdownFn = shutdown,
+                },
+            };
+        }
+    };
+}
+
+/// StdoutExporter outputs spans into OS stdout.
+/// ref: https://opentelemetry.io/docs/specs/otel/trace/sdk_exporters/stdout/
+pub const StdoutExporter = GenericWriterExporter(std.io.Writer(std.fs.File, std.fs.File.WriteError, std.fs.File.write));
+
+/// InmemoryExporter exports spans to in-memory buffer.
+/// it is designed for testing GenericWriterExporter.
+pub const InmemoryExporter = GenericWriterExporter(std.ArrayList(u8).Writer);
+
+test "GenericWriterExporter" {
+    var out_buf = std.ArrayList(u8).init(std.testing.allocator);
+    defer out_buf.deinit();
+    var inmemory_exporter = InmemoryExporter.init(out_buf.writer());
+    var exporter = inmemory_exporter.asSpanExporter();
+
+    var spans = [_]pb.Span{};
+    try exporter.exportSpans(spans[0..spans.len]);
+
+    // TODO: detailed output test
+}

src/sdk/trace/id_generator.zig

@@ -0,0 +1,25 @@
+const trace = @import("../../api/trace.zig");
+/// IDGenerator is the interface that generates traceID/spanID.
+pub const IDGenerator = struct {
+    newIDsFn: *const fn (
+        *IDGenerator,
+    ) TraceSpanID,
+    newSpanIDFn: *const fn (
+        *IDGenerator,
+        trace_id: trace.TraceID,
+    ) trace.SpanID,
+};
+
+/// TraceSpanID is the set of traceID/spanID.
+pub const TraceSpanID = struct {
+    traceID: trace.TraceID,
+    spanID: trace.SpanID,
+};
+
+/// RandomIDGenerator generates traceID/spanID randomly.
+pub const RandomIDGenerator = struct {
+    const Self = @This();
+    pub fn init() Self {
+        return .{};
+    }
+};

src/sdk/trace/span_exporter.zig

@@ -0,0 +1,30 @@
+const pb = @import("../../opentelemetry/proto/trace/v1.pb.zig");
+
+/// SpanExporter is the interface that provides an
+pub const SpanExporter = struct {
+    // std.mem.Allocator's style
+    ptr: *anyopaque,
+    vtable: *const VTable,
+
+    const Self = @This();
+
+    /// VTable defines the methods that the SpanExporter's instance must implement.
+    pub const VTable = struct {
+        /// exportSpans is the method that export a batch of spans.
+        /// NOTE: In other languages, the span types is ReadOnlySpan for improving stability.
+        /// but it is not defined in the OpenTelemetry specification, so for now we don't use it.
+        exportSpansFn: *const fn (
+            ctx: *anyopaque,
+            spans: []pb.Span,
+        ) anyerror!void,
+
+        shutdownFn: *const fn (ctx: *anyopaque) anyerror!void,
+    };
+
+    pub fn exportSpans(
+        self: Self,
+        spans: []pb.Span,
+    ) anyerror!void {
+        return self.vtable.exportSpansFn(self.ptr, spans);
+    }
+};