build.zig

const std = @import("std");

pub const Frontend = enum { stdio, httpz };

fn keepProfilingSymbols(m: *std.Build.Module) void {
    m.omit_frame_pointer = false;
    m.strip = false;
}

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    // Keep frame pointers + symbols so sampling profilers (Instruments) can
    // unwind and name frames instead of dumping self-time onto
    // <deduplicated_symbol>. Pair with -Doptimize=ReleaseFast for a realistic
    // profile. Must be applied to every module in the hot path (deps included),
    // since it's a per-module setting.
    const profiling = b.option(bool, "profiling", "Keep frame pointers and symbols for profilers") orelse false;
    const version = b.option([]const u8, "version", "Build version exposed in metrics") orelse "dev";
    const commit = b.option([]const u8, "commit", "Build commit exposed in metrics") orelse "unknown";
    // stdio is the default. httpz hands a batch of up to 16 requests to one
    // pool thread, so one slow intake response parks the rest of that batch,
    // and a health probe behind them times out — the ECS incident this suite
    // reproduces (bench/matrix: c02, c05). stdio runs a task per connection,
    // and measures 2 to 2.8 times the throughput of httpz once the intake is
    // slow, with a p99.9 within 50 ms of its p50 instead of ten times it.
    // httpz stays buildable and tested: bench/matrix runs every case against
    // both.
    const frontend = b.option(
        Frontend,
        "frontend",
        "Inbound HTTP frontend (stdio = std.Io-native, httpz = event loop + worker pool)",
    ) orelse .stdio;

    const build_options = b.addOptions();
    build_options.addOption([]const u8, "version", version);
    build_options.addOption([]const u8, "commit", commit);
    build_options.addOption(Frontend, "frontend", frontend);

    // ==========================================================================
    // Dependencies
    // ==========================================================================

    const zimdjson = b.dependency("zimdjson", .{
        .target = target,
        .optimize = optimize,
    });
    const zbench_dep = b.dependency("zbench", .{
        .target = target,
        .optimize = optimize,
    });
    const policy_dep = b.dependency("policy_zig", .{
        .target = target,
        .optimize = optimize,
    });
    const metrics_dep = b.dependency("metrics", .{
        .target = target,
        .optimize = optimize,
    });
    const httpz_dep = b.dependency("httpz", .{
        .target = target,
        .optimize = optimize,
    });
    const httpz_mod = httpz_dep.module("httpz");

    // Shared modules from policy-zig ensure type identity across boundaries.
    const proto_mod = policy_dep.module("proto");
    const o11y_mod = policy_dep.module("observability");
    // Optional extensions module (pulls in the z3 S3 client). Only edge code
    // that wires s3-dump imports it.
    const ext_mod = policy_dep.module("extensions");

    // ==========================================================================
    // Edge Library Module
    // ==========================================================================

    const mod = b.addModule("edge", .{
        .root_source_file = b.path("src/root.zig"),
        .target = target,
        .imports = &.{
            .{ .name = "proto", .module = proto_mod },
            .{ .name = "zimdjson", .module = zimdjson.module("zimdjson") },
            .{ .name = "policy_zig", .module = policy_dep.module("policy_zig") },
            .{ .name = "o11y", .module = o11y_mod },
            .{ .name = "extensions", .module = ext_mod },
            .{ .name = "metrics_zig", .module = metrics_dep.module("metrics") },
            .{ .name = "httpz", .module = httpz_mod },
        },
    });
    mod.addOptions("build_options", build_options);

    if (profiling) {
        for ([_]*std.Build.Module{
            mod,
            proto_mod,
            o11y_mod,
            policy_dep.module("policy_zig"),
            zimdjson.module("zimdjson"),
            metrics_dep.module("metrics"),
            httpz_mod,
        }) |m| keepProfilingSymbols(m);
    }

    // ==========================================================================
    // Main Executable
    // ==========================================================================

    const exe = b.addExecutable(.{
        .name = "edge",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "edge", .module = mod },
            },
        }),
    });
    exe.root_module.addImport("proto", proto_mod);
    exe.root_module.addImport("zimdjson", zimdjson.module("zimdjson"));
    exe.root_module.addImport("policy_zig", policy_dep.module("policy_zig"));
    exe.root_module.addImport("o11y", o11y_mod);
    exe.root_module.addImport("extensions", ext_mod);
    exe.root_module.addImport("metrics_zig", metrics_dep.module("metrics"));
    exe.root_module.addImport("httpz", httpz_mod);
    exe.root_module.addOptions("build_options", build_options);
    exe.root_module.link_libc = true;
    exe.root_module.linkSystemLibrary("z", .{});
    exe.root_module.linkSystemLibrary("zstd", .{});

    if (profiling) keepProfilingSymbols(exe.root_module);

    b.installArtifact(exe);

    // ==========================================================================
    // Distribution Builds
    // ==========================================================================

    const distributions = .{
        .{ "datadog", "src/datadog_main.zig", "Datadog ingestion" },
        .{ "otlp", "src/otlp_main.zig", "OpenTelemetry (OTLP) ingestion" },
        .{ "prometheus", "src/prometheus_main.zig", "Prometheus metrics scraping" },
        .{ "tail", "src/edge_tail_main.zig", "Log tailing" },
        .{ "edge", "src/main.zig", "Full distribution (OTLP, Datadog & Prometheus)" },
        .{ "lambda", "src/lambda_main.zig", "AWS Lambda extension (Datadog)" },
    };

    inline for (distributions) |dist| {
        const name = dist[0];
        const source = dist[1];
        const desc = dist[2];

        const dist_exe = b.addExecutable(.{
            .name = "edge-" ++ name,
            .root_module = b.createModule(.{
                .root_source_file = b.path(source),
                .target = target,
                .optimize = optimize,
            }),
        });
        dist_exe.root_module.addImport("proto", proto_mod);
        dist_exe.root_module.addImport("zimdjson", zimdjson.module("zimdjson"));
        dist_exe.root_module.addImport("policy_zig", policy_dep.module("policy_zig"));
        dist_exe.root_module.addImport("o11y", o11y_mod);
        dist_exe.root_module.addImport("extensions", ext_mod);
        dist_exe.root_module.addImport("metrics_zig", metrics_dep.module("metrics"));
        dist_exe.root_module.addImport("httpz", httpz_mod);
        dist_exe.root_module.addOptions("build_options", build_options);
        dist_exe.root_module.link_libc = true;
        dist_exe.root_module.linkSystemLibrary("z", .{});
        dist_exe.root_module.linkSystemLibrary("zstd", .{});

        if (profiling) keepProfilingSymbols(dist_exe.root_module);

        const dist_step = b.step(name, "Build the " ++ name ++ " distribution (" ++ desc ++ ")");
        dist_step.dependOn(&b.addInstallArtifact(dist_exe, .{}).step);

        const run_dist_step = b.step("run-" ++ name, "Run the " ++ name ++ " distribution");
        const run_dist_cmd = b.addRunArtifact(dist_exe);
        run_dist_step.dependOn(&run_dist_cmd.step);
        run_dist_cmd.step.dependOn(b.getInstallStep());
        if (b.args) |args| {
            run_dist_cmd.addArgs(args);
        }
    }

    // ==========================================================================
    // Run Step
    // ==========================================================================

    const run_step = b.step("run", "Run the app");
    const run_cmd = b.addRunArtifact(exe);
    run_step.dependOn(&run_cmd.step);
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    // ==========================================================================
    // Tests
    // ==========================================================================

    const mod_tests = b.addTest(.{
        .root_module = mod,
    });
    mod_tests.root_module.link_libc = true;
    mod_tests.root_module.linkSystemLibrary("z", .{});
    mod_tests.root_module.linkSystemLibrary("zstd", .{});
    mod_tests.root_module.addImport("metrics_zig", metrics_dep.module("metrics"));
    mod_tests.root_module.addOptions("build_options", build_options);
    // Benchmark fixture embedded by test-only code in src/signals/otlp/metrics.zig.
    // It lives under bench/ (outside the src package), so @embedFile needs it wired
    // in as a named module import rather than a relative path.
    mod_tests.root_module.addAnonymousImport("otlp_metrics_benchmark_pb", .{
        .root_source_file = b.path("bench/scaling/payloads/otlp-metrics.pb"),
    });

    const run_mod_tests = b.addRunArtifact(mod_tests);
    const test_step = b.step("test", "Run tests");
    test_step.dependOn(&run_mod_tests.step);

    // The echo server is its own module (src/bench is outside the src
    // package), so its tests need their own artifact or they never run. The
    // matrix trusts this binary to behave like an intake, which makes its
    // parsing and its `/stats` output worth a check.
    const echo_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/bench/echo_server.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    echo_tests.root_module.addImport("head_repair", b.createModule(.{
        .root_source_file = b.path("src/frontend/stdio/head_repair.zig"),
        .target = target,
        .optimize = optimize,
    }));
    test_step.dependOn(&b.addRunArtifact(echo_tests).step);

    // Real-storage smoke test for the s3-dump extension, filtered to the MinIO
    // e2e test. Excluded from `test` (it needs a live backend); driven by
    // `task test:s3-e2e`, which starts MinIO, creates the bucket, and sets the
    // S3 env vars this test reads.
    const s3_e2e_tests = b.addTest(.{
        .root_module = mod,
        .filters = &.{"e2e minio"},
    });
    s3_e2e_tests.root_module.link_libc = true;
    s3_e2e_tests.root_module.linkSystemLibrary("z", .{});
    s3_e2e_tests.root_module.linkSystemLibrary("zstd", .{});
    s3_e2e_tests.root_module.addImport("metrics_zig", metrics_dep.module("metrics"));
    s3_e2e_tests.root_module.addOptions("build_options", build_options);
    s3_e2e_tests.root_module.addAnonymousImport("otlp_metrics_benchmark_pb", .{
        .root_source_file = b.path("bench/scaling/payloads/otlp-metrics.pb"),
    });
    const run_s3_e2e_tests = b.addRunArtifact(s3_e2e_tests);
    const s3_e2e_step = b.step("test-s3-e2e", "Run the s3-dump MinIO smoke test (needs S3 env vars)");
    s3_e2e_step.dependOn(&run_s3_e2e_tests.step);

    // ==========================================================================
    // Benchmark Tools
    // ==========================================================================

    const echo_server = b.addExecutable(.{
        .name = "echo-server",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/bench/echo_server.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    // The fake intake must take the heads a real intake takes, so it shares
    // the frontend's head repair rather than keeping its own copy.
    echo_server.root_module.addImport("head_repair", b.createModule(.{
        .root_source_file = b.path("src/frontend/stdio/head_repair.zig"),
        .target = target,
        .optimize = optimize,
    }));

    const echo_step = b.step("echo-server", "Build the echo server for benchmarking");
    echo_step.dependOn(&b.addInstallArtifact(echo_server, .{}).step);

    // Upstream connection-pool poisoning harness: reproduces the stale-keepalive
    // poison (ziglang/zig#30165 send-side) and verifies the eviction fix.
    const pool_harness = b.addExecutable(.{
        .name = "upstream-pool-harness",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/bench/upstream_pool_harness.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    const pool_harness_step = b.step("upstream-pool-harness", "Verify upstream pool eviction+retry against real edge");
    const run_pool_harness = b.addRunArtifact(pool_harness);
    run_pool_harness.step.dependOn(b.getInstallStep()); // harness spawns zig-out/bin/edge
    pool_harness_step.dependOn(&run_pool_harness.step);

    // Datadog log search/filter microbenchmark (zbench).
    const datadog_log_bench = b.addExecutable(.{
        .name = "datadog-log-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/bench/datadog_log_bench.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "edge", .module = mod },
                .{ .name = "zbench", .module = zbench_dep.module("zbench") },
                .{ .name = "proto", .module = proto_mod },
                .{ .name = "o11y", .module = o11y_mod },
            },
        }),
    });
    datadog_log_bench.root_module.addAnonymousImport("datadog_wrapped_log", .{
        .root_source_file = b.path("bench/datadog/payloads/wrapped_log.json"),
    });
    // The bench has a --profile mode for attaching Instruments; always keep
    // frame pointers + symbols so ReleaseFast stacks symbolicate.
    keepProfilingSymbols(datadog_log_bench.root_module);
    datadog_log_bench.root_module.link_libc = true;
    datadog_log_bench.root_module.linkSystemLibrary("z", .{});
    datadog_log_bench.root_module.linkSystemLibrary("zstd", .{});

    const datadog_log_bench_step = b.step("datadog-log-bench", "Run the Datadog log eval matrix benchmark");
    const run_datadog_log_bench = b.addRunArtifact(datadog_log_bench);
    // Forward CLI args (e.g. `zig build datadog-log-bench -- --profile plain/none 30`)
    // and install the binary so a profiler can be attached to it directly.
    if (b.args) |args| run_datadog_log_bench.addArgs(args);
    datadog_log_bench_step.dependOn(&run_datadog_log_bench.step);
    datadog_log_bench_step.dependOn(&b.addInstallArtifact(datadog_log_bench, .{}).step);

    // JSON-array framer microbenchmark (zbench).
    const json_framer_bench = b.addExecutable(.{
        .name = "json-framer-bench",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/bench/json_framer_bench.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "edge", .module = mod },
                .{ .name = "zbench", .module = zbench_dep.module("zbench") },
            },
        }),
    });
    json_framer_bench.root_module.link_libc = true;
    json_framer_bench.root_module.linkSystemLibrary("z", .{});
    json_framer_bench.root_module.linkSystemLibrary("zstd", .{});

    const json_framer_bench_step = b.step("json-framer-bench", "Run the JSON-array framer benchmark");
    const run_json_framer_bench = b.addRunArtifact(json_framer_bench);
    json_framer_bench_step.dependOn(&run_json_framer_bench.step);

    const run_echo_step = b.step("run-echo-server", "Run the echo server");
    const run_echo_cmd = b.addRunArtifact(echo_server);
    run_echo_step.dependOn(&run_echo_cmd.step);
    run_echo_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_echo_cmd.addArgs(args);
    }
}