Taskfile.yml

# https://taskfile.dev

version: "3"

vars:
  PROJECT_NAME: edge
  BUILD_DIR: zig-out
  HELM_CHART_DIR: charts/tero-edge
  HELM_CHART_NAME: tero-edge
  HELM_NAMESPACE: tero-system
  HELM_RELEASE: tero-edge

tasks:
  default:
    desc: "Build the project in debug mode"
    aliases: [b]
    cmds:
      - zig build

  build:
    desc: "Build the project with specified optimization"
    aliases: [build-opt]
    cmds:
      - zig build -Doptimize={{.OPTIMIZE | default "Debug"}}

  build:release:
    desc: "Build the project in release mode (ReleaseFast)"
    aliases: [br, release]
    cmds:
      - zig build -Doptimize=ReleaseFast

  build:safe:
    desc: "Build the project in ReleaseSafe mode"
    aliases: [bs]
    cmds:
      - zig build -Doptimize=ReleaseSafe
      - echo "✅ Built safe"

  build:small:
    desc: "Build the project in ReleaseSmall mode"
    aliases: [bsm]
    cmds:
      - zig build -Doptimize=ReleaseSmall

  run:
    desc: "Build and run the project"
    aliases: [r]
    cmds:
      - zig build run

  run:release:
    desc: "Build and run the project in release mode"
    aliases: [rr]
    cmds:
      - zig build run -Doptimize=ReleaseFast

  test:
    desc: "Run all tests"
    aliases: [t]
    cmds:
      - zig build test -Doptimize=ReleaseSafe

  test:file:
    desc: "Run tests for a specific file"
    aliases: [tf]
    cmds:
      - |
        if [ -z "{{.FILE}}" ]; then
          echo "Usage: task test:file FILE=<path>"
          echo "Example: task test:file FILE=src/json/pretty_print.zig"
          exit 1
        fi
        zig test {{.FILE}}

  test:summary:
    desc: "Run tests with summary output"
    aliases: [ts]
    cmds:
      - zig build test --summary all

  format:
    desc: "Format all Zig source files"
    aliases: [fmt, f]
    dir: "{{.TASKFILE_DIR}}"
    cmds:
      - zig fmt src/
      - zig fmt build.zig

  format:check:
    desc: "Check if code is formatted correctly"
    aliases: [fmt-check, fc]
    dir: "{{.TASKFILE_DIR}}"
    cmds:
      - zig fmt --check src/
      - zig fmt --check build.zig

  lint:zig:
    desc: "Run ziglint on handwritten Zig sources (paths from .ziglint.zon)"
    aliases: [lz]
    dir: "{{.TASKFILE_DIR}}"
    cmds:
      - |
        if ! command -v ziglint >/dev/null 2>&1; then
          echo "ziglint is required before merge. Install it or add it to PATH."
          exit 1
        fi
        ziglint

  lint:
    desc: "Run linting checks"
    aliases: [l]
    cmds:
      - task: format:check
      - task: lint:zig
      - echo "✅ Linting complete"

  clean:
    desc: "Clean build artifacts"
    aliases: [c]
    cmds:
      - rm -rf zig-out/
      - rm -rf zig-cache/
      - rm -rf .zig-cache/
      - echo "✅ Cleaned build artifacts"

  check:
    desc: "Check the project (build without running)"
    cmds:
      - zig build --summary failures

  docs:
    desc: "Generate documentation"
    cmds:
      - echo "Generating documentation..."
      - zig build-lib src/root.zig -femit-docs -fno-emit-bin
      - echo "✅ Documentation generated in zig-out/doc/"

  deps:
    desc: "Check dependencies and Zig installation"
    cmds:
      - zig version
      - zig env

  benchmark:
    desc: "Run full benchmark suite with oha and hyperfine"
    aliases: [bench, bm]
    cmds:
      - ./bench/run.sh

  benchmark:quick:
    desc: "Run quick benchmark (1000 requests)"
    aliases: [bench-quick, bmq]
    cmds:
      - ./bench/run.sh -n 1000 -c 10

  benchmark:heavy:
    desc: "Run heavy benchmark (100000 requests, 100 connections)"
    aliases: [bench-heavy, bmh]
    cmds:
      - ./bench/run.sh -n 100000 -c 100

  benchmark:ci:
    desc: "Run benchmark in CI mode (skip build, use existing binaries)"
    cmds:
      - ./bench/run.sh --skip-build

  benchmark:framer:
    desc: "Run the JSON-array framer microbenchmark (zbench)"
    aliases: [bench-framer, bmf]
    cmds:
      - zig build json-framer-bench

  benchmark:logging:
    desc: "Run edge-tail logging integration tests"
    aliases: [bench-logging, bml]
    cmds:
      - ./bench/logging/run.sh

  benchmark:logging:metrics:
    desc: "Run edge-tail logging benchmark metric profiles (logs/sec, CPU, RSS)"
    aliases: [bench-logging-metrics, bmlm]
    vars:
      BENCH_LINES: 50000000
    cmds:
      - EDGE_TAIL_STDIN_LINES={{.BENCH_LINES}} ./bench/logging/run.sh -s tests/test_benchmark_metrics.py

  benchmark:logging:persistent:
    desc: "Run persistent edge-tail logging workload for Instruments profiling"
    aliases: [bench-logging-persistent, bmlp]
    vars:
      FILES: '{{.FILES | default "12"}}'
      TARGET_LPS: '{{.TARGET_LPS | default "18000"}}'
      FORMAT: '{{.FORMAT | default "raw"}}'
      IO_ENGINE: '{{.IO_ENGINE | default "auto"}}'
      DROP_50PCT: '{{.DROP_50PCT | default "0"}}'
      DURATION_S: '{{.DURATION_S | default "0"}}'
    cmds:
      - zig build tail -Doptimize=Debug
      - |
        ARGS=""
        if [ "{{.DROP_50PCT}}" = "1" ]; then
          ARGS="$ARGS --drop-50pct"
        fi
        if [ "{{.DURATION_S}}" != "0" ]; then
          ARGS="$ARGS --duration-s {{.DURATION_S}}"
        fi
        uv run --project bench/logging python bench/logging/persistent_benchmark.py \
          --edge-tail-bin zig-out/bin/edge-tail \
          --files {{.FILES}} \
          --target-lps {{.TARGET_LPS}} \
          --format {{.FORMAT}} \
          --io-engine {{.IO_ENGINE}} \
          $ARGS

  benchmark:history:
    desc: "Run benchmarks and save to dated history folder"
    aliases: [bench-history, bmh]
    vars:
      DATE:
        sh: date -u +"%Y-%m-%d"
      REQUESTS: '{{.REQUESTS | default (env "REQUESTS") | default "10000"}}'
      CONNECTIONS: '{{.CONNECTIONS | default (env "CONNECTIONS") | default "50"}}'
    cmds:
      - mkdir -p bench/history/{{.DATE}}
      - ./bench/run.sh --requests {{.REQUESTS}} --connections {{.CONNECTIONS}} --output bench/history/{{.DATE}}

  echo-server:
    desc: "Build and run the echo server for manual testing"
    cmds:
      - zig build echo-server -Doptimize=ReleaseFast
      - ./zig-out/bin/echo-server {{.PORT | default "9999"}}

  harness:upstream-pool:
    desc: "Verify upstream pool eviction+retry against the real edge binary"
    aliases: [pool-harness]
    cmds:
      - zig build upstream-pool-harness -Doptimize=ReleaseSafe

  benchmark:setup:
    desc: "Install benchmark dependencies (oha, jq)"
    cmds:
      - |
        echo "Installing benchmark dependencies..."
        if [ "$(uname)" = "Darwin" ]; then
          brew install oha jq
        elif command -v cargo >/dev/null 2>&1; then
          cargo install oha
          echo "Please also install jq via your package manager"
        else
          echo "Please install oha and jq manually:"
          echo "  https://github.com/hatoo/oha"
          exit 1
        fi
        echo "Benchmark dependencies installed"

  watch:
    desc: "Watch for changes and rebuild"
    aliases: [w]
    cmds:
      - |
        echo "Watching for changes... (Ctrl+C to stop)"
        while true; do
          zig build 2>&1 | grep -v "Build succeeded"
          inotifywait -e modify -r src/ build.zig 2>/dev/null || \
          fswatch -1 -r src/ build.zig 2>/dev/null || \
          sleep 2
        done

  watch:test:
    desc: "Watch for changes and run tests"
    aliases: [wt]
    cmds:
      - |
        echo "Watching for changes and running tests... (Ctrl+C to stop)"
        while true; do
          zig build test
          inotifywait -e modify -r src/ 2>/dev/null || \
          fswatch -1 -r src/ 2>/dev/null || \
          sleep 2
        done

  coverage:
    desc: "Generate test coverage report"
    cmds:
      - echo "Coverage reporting is not yet standardized in Zig"
      - echo "Consider using kcov or similar tools manually"

  analyze:
    desc: "Run static analysis"
    cmds:
      - zig build --verbose

  do:
    desc: "Run all pre-commit checks"
    cmds:
      - task: format
      - task: lint
      - task: test
      - echo "✅ All checks passed"

  test:s3-e2e:
    desc: "s3-dump MinIO smoke test: dump a Datadog log to a real S3 server (requires docker)"
    cmds:
      - |
        if ! command -v docker >/dev/null 2>&1; then
          echo "docker is required for task test:s3-e2e"
          exit 1
        fi
        CONTAINER=edge-minio-e2e
        NETWORK=edge-minio-e2e-net
        BUCKET=edge-e2e
        cleanup() {
          docker rm -f "$CONTAINER" >/dev/null 2>&1 || true
          docker network rm "$NETWORK" >/dev/null 2>&1 || true
        }
        trap cleanup EXIT
        cleanup
        docker network create "$NETWORK" >/dev/null
        docker run -d --rm --name "$CONTAINER" --network "$NETWORK" \
          -p 9000:9000 \
          -e MINIO_ROOT_USER=minioadmin \
          -e MINIO_ROOT_PASSWORD=minioadmin \
          minio/minio server /data >/dev/null
        # Wait for the server to report healthy on the published port.
        for i in $(seq 1 30); do
          if curl -fsS http://127.0.0.1:9000/minio/health/live >/dev/null 2>&1; then break; fi
          if [ "$i" = "30" ]; then echo "MinIO did not become healthy"; docker logs "$CONTAINER" || true; exit 1; fi
          sleep 1
        done
        # Edge has no S3 admin client, so create the bucket with mc on the same
        # docker network (reaches the server by container name).
        docker run --rm --network "$NETWORK" --entrypoint /bin/sh minio/mc -c \
          "mc alias set local http://$CONTAINER:9000 minioadmin minioadmin >/dev/null && mc mb -p local/$BUCKET >/dev/null"
        AWS_ACCESS_KEY_ID=minioadmin \
        AWS_SECRET_ACCESS_KEY=minioadmin \
        S3_ENDPOINT=http://127.0.0.1:9000 \
        S3_BUCKET="$BUCKET" \
          zig build test-s3-e2e --summary all

  signoff:
    desc: "Sign off the codebase"
    aliases: ["sign", "s"]
    cmds:
      - task: do
      - task: build:safe
      - task: test:s3-e2e
      - gh signoff

  install:
    desc: "Install the binary"
    cmds:
      - zig build -Doptimize=ReleaseFast
      - echo "Binary installed to {{.BUILD_DIR}}/bin/{{.PROJECT_NAME}}"

  uninstall:
    desc: "Remove installed binary"
    cmds:
      - rm -f {{.BUILD_DIR}}/bin/{{.PROJECT_NAME}}
      - echo "✅ Binary removed"

  info:
    desc: "Show project information"
    cmds:
      - echo "Project {{.PROJECT_NAME}}"
      - echo "Build directory {{.BUILD_DIR}}"
      - zig version
      - echo ""
      - echo "Available build modes:"
      - echo "  - Debug (default)"
      - echo "  - ReleaseFast (task build:release)"
      - echo "  - ReleaseSafe (task build:safe)"
      - echo "  - ReleaseSmall (task build:small)"

  repl:
    desc: "Start Zig REPL (if available)"
    cmds:
      - |
        if command -v ziggy >/dev/null 2>&1; then
          ziggy
        else
          echo "No Zig REPL found. Install ziggy: https://github.com/zigtools/ziggy"
        fi

  # =============================================================================
  # Build & Release
  # =============================================================================

  build:container:
    desc: "🐳 Build container for a distribution (DIST=edge|datadog|otlp|prometheus|tail)"
    dir: "{{.TASKFILE_DIR}}"
    vars:
      DIST: '{{.DIST | default "datadog"}}'
      GIT_SHA:
        sh: git rev-parse --short HEAD
      GIT_SHA_FULL:
        sh: git rev-parse HEAD
      VERSION:
        sh: |
          if git describe --tags --always --dirty >/dev/null 2>&1; then
            git describe --tags --always --dirty
          else
            echo dev
          fi
    cmds:
      - |
        echo "🐳 Building edge-{{.DIST}} container..."
        if [ -n "$CI" ]; then
          # CI: Use buildx with GitHub Actions cache
          docker buildx build \
            --build-arg DISTRIBUTION={{.DIST}} \
            --build-arg VERSION={{.VERSION}} \
            --build-arg COMMIT={{.GIT_SHA_FULL}} \
            --cache-from type=gha,scope=edge-{{.DIST}} \
            --cache-to type=gha,mode=max,scope=edge-{{.DIST}} \
            -t edge-{{.DIST}}:sha-{{.GIT_SHA}} \
            -t edge-{{.DIST}}:local \
            --load \
            .
        else
          # Local: Standard build
          DOCKER_BUILDKIT=1 docker build \
            --build-arg DISTRIBUTION={{.DIST}} \
            --build-arg VERSION={{.VERSION}} \
            --build-arg COMMIT={{.GIT_SHA_FULL}} \
            -t edge-{{.DIST}}:sha-{{.GIT_SHA}} \
            -t edge-{{.DIST}}:local \
            .
        fi
        echo "✅ Built edge-{{.DIST}}:sha-{{.GIT_SHA}} (also tagged as edge-{{.DIST}}:local)"

  build:containers:
    desc: "🐳 Build all distribution containers"
    cmds:
      - task: build:container
        vars: { DIST: "edge" }
      - task: build:container
        vars: { DIST: "datadog" }
      - task: build:container
        vars: { DIST: "otlp" }
      - task: build:container
        vars: { DIST: "prometheus" }
      - task: build:container
        vars: { DIST: "tail" }

  push:container:
    desc: "🚀 Push container to GCP Artifact Registry (DIST=edge|datadog|otlp|prometheus|tail)"
    dir: "{{.TASKFILE_DIR}}"
    vars:
      DIST: '{{.DIST | default "datadog"}}'
      GIT_SHA:
        sh: git rev-parse --short HEAD
      GCP_PROJECT_ID:
        sh: echo "${GCP_PROJECT_ID:-usetero-dev}"
      GCP_REGION:
        sh: echo "${GCP_REGION:-us-central1}"
      GCP_REGISTRY:
        sh: echo "{{.GCP_REGION}}-docker.pkg.dev/{{.GCP_PROJECT_ID}}/edge"
    preconditions:
      - sh: docker image inspect edge-{{.DIST}}:sha-{{.GIT_SHA}} >/dev/null 2>&1
        msg: "Container edge-{{.DIST}}:sha-{{.GIT_SHA}} not found. Run 'task build:container DIST={{.DIST}}' first"
    cmds:
      - |
        echo "🚀 Pushing edge-{{.DIST}} to GCP Artifact Registry..."
        # Tag for GCP registry
        docker tag edge-{{.DIST}}:sha-{{.GIT_SHA}} {{.GCP_REGISTRY}}/edge-{{.DIST}}:{{.GIT_SHA}}
        docker tag edge-{{.DIST}}:sha-{{.GIT_SHA}} {{.GCP_REGISTRY}}/edge-{{.DIST}}:latest
        # Push both tags
        docker push {{.GCP_REGISTRY}}/edge-{{.DIST}}:{{.GIT_SHA}}
        docker push {{.GCP_REGISTRY}}/edge-{{.DIST}}:latest
        echo "✅ Pushed edge-{{.DIST}}:{{.GIT_SHA}} and edge-{{.DIST}}:latest"

  push:containers:
    desc: "🚀 Push all distribution containers to GCP"
    cmds:
      - task: push:container
        vars: { DIST: "edge" }
      - task: push:container
        vars: { DIST: "datadog" }
      - task: push:container
        vars: { DIST: "otlp" }
      - task: push:container
        vars: { DIST: "prometheus" }
      - task: push:container
        vars: { DIST: "tail" }

  release:
    desc: "🎯 Build and push all containers (for CI)"
    cmds:
      - task: build:containers
      - task: push:containers

  release:container:
    desc: "🎯 Build and push a specific distribution (DIST=edge|datadog|otlp|prometheus|tail)"
    vars:
      DIST: '{{.DIST | default "datadog"}}'
    cmds:
      - task: build:container
        vars: { DIST: "{{.DIST}}" }
      - task: push:container
        vars: { DIST: "{{.DIST}}" }

  # =============================================================================
  # CI Setup
  # =============================================================================

  ci:setup:
    desc: "🔧 Install CI/development dependencies (idempotent, safe to run locally)"
    dir: "{{.TASKFILE_DIR}}"
    cmds:
      - |
        echo "🔧 Setting up CI environment..."

        # Clean up Docker resources to free disk space (important for CI with testcontainers)
        if [ -n "$CI" ]; then
          echo "🧹 Cleaning Docker resources in CI..."
          docker system prune -af --volumes 2>/dev/null || true
        fi

        echo "🔧 Checking for required dependencies..."

        # Check for hyperscan/vectorscan (needed for catalog service)
        if ! pkg-config --exists libhs 2>/dev/null; then
          echo "📦 Installing hyperscan..."
          if [ "$(uname)" = "Darwin" ]; then
            # macOS: use vectorscan (hyperscan replacement)
            if command -v brew >/dev/null 2>&1; then
              brew install vectorscan pkg-config
            else
              echo "⚠️  Homebrew not found. Install vectorscan manually or use Hermit."
            fi
          elif [ "$(uname)" = "Linux" ]; then
            # Linux: use hyperscan
            if command -v apt-get >/dev/null 2>&1; then
              sudo apt-get update && sudo apt-get install -y libhyperscan-dev pkg-config
            elif command -v yum >/dev/null 2>&1; then
              sudo yum install -y hyperscan-devel pkg-config
            else
              echo "⚠️  Unknown package manager. Install hyperscan manually."
            fi
          else
            echo "⚠️  Unknown platform: $(uname)"
          fi
        else
          echo "✅ Hyperscan already installed"
        fi

        # Check for ziglint (required by `task lint:zig`, which `do` runs).
        if ! command -v ziglint >/dev/null 2>&1; then
          ZIGLINT_VERSION="v0.5.2"
          case "$(uname -s)" in
            Darwin) zl_os="macos" ;;
            Linux)  zl_os="linux" ;;
            *) zl_os="" ;;
          esac
          case "$(uname -m)" in
            x86_64)  zl_arch="x86_64" ;;
            aarch64|arm64) zl_arch="aarch64" ;;
            *) zl_arch="" ;;
          esac
          if [ -z "$zl_os" ] || [ -z "$zl_arch" ]; then
            echo "Unknown platform $(uname -s)/$(uname -m). Install ziglint manually from https://github.com/rockorager/ziglint"
          else
            echo "Installing ziglint ${ZIGLINT_VERSION} (${zl_arch}-${zl_os})..."
            zl_asset="ziglint-${zl_arch}-${zl_os}.tar.gz"
            zl_url="https://github.com/rockorager/ziglint/releases/download/${ZIGLINT_VERSION}/${zl_asset}"
            zl_tmp="$(mktemp -d)"
            if curl -fsSL "$zl_url" -o "$zl_tmp/ziglint.tar.gz"; then
              tar -xzf "$zl_tmp/ziglint.tar.gz" -C "$zl_tmp"
              if [ -w /usr/local/bin ]; then zl_sudo=""; else zl_sudo="sudo"; fi
              $zl_sudo install -m 0755 "$zl_tmp/ziglint" /usr/local/bin/ziglint
              echo "ziglint installed: $(ziglint --version)"
            else
              echo "Failed to download ziglint from $zl_url"
            fi
            rm -rf "$zl_tmp"
          fi
        else
          echo "ziglint already installed"
        fi

        echo "✅ CI setup complete"

  # =============================================================================
  # Helm Chart
  # =============================================================================

  helm:lint:
    desc: "⛵ Lint the tero-edge Helm chart"
    cmds:
      - helm lint {{.HELM_CHART_DIR}}

  helm:template:
    desc: "⛵ Render Helm templates locally (VALUES=<file>)"
    cmds:
      - |
        if [ -n "{{.VALUES}}" ]; then
          helm template {{.HELM_RELEASE}} {{.HELM_CHART_DIR}} -f {{.VALUES}}
        else
          helm template {{.HELM_RELEASE}} {{.HELM_CHART_DIR}}
        fi

  helm:package:
    desc: "⛵ Package chart into dist/ (VERSION=<semver> optional)"
    cmds:
      - mkdir -p dist
      - |
        if [ -n "{{.VERSION}}" ]; then
          helm package {{.HELM_CHART_DIR}} --version {{.VERSION}} --destination dist
        else
          helm package {{.HELM_CHART_DIR}} --destination dist
        fi

  helm:install:
    desc: "⛵ Install/upgrade chart in cluster (VALUES=<file> optional)"
    cmds:
      - |
        if [ -n "{{.VALUES}}" ]; then
          helm upgrade --install {{.HELM_RELEASE}} {{.HELM_CHART_DIR}} -n {{.HELM_NAMESPACE}} --create-namespace -f {{.VALUES}}
        else
          helm upgrade --install {{.HELM_RELEASE}} {{.HELM_CHART_DIR}} -n {{.HELM_NAMESPACE}} --create-namespace
        fi

  helm:uninstall:
    desc: "⛵ Uninstall chart from cluster"
    cmds:
      - helm uninstall {{.HELM_RELEASE}} -n {{.HELM_NAMESPACE}}

  helm:publish:oci:
    desc: "⛵ Publish packaged chart to OCI (REGISTRY=oci://... VERSION=<semver>)"
    cmds:
      - |
        if [ -z "{{.REGISTRY}}" ]; then
          echo "Usage: task helm:publish:oci REGISTRY=oci://ghcr.io/<owner>/charts VERSION=<semver>"
          exit 1
        fi
        if [ -z "{{.VERSION}}" ]; then
          echo "Usage: task helm:publish:oci REGISTRY=oci://ghcr.io/<owner>/charts VERSION=<semver>"
          exit 1
        fi
        task helm:package VERSION={{.VERSION}}
        helm push dist/{{.HELM_CHART_NAME}}-{{.VERSION}}.tgz {{.REGISTRY}}

  helm:repo:index:
    desc: "⛵ Generate/merge Helm repo index in dist/ (REPO_URL required)"
    cmds:
      - |
        if [ -z "{{.REPO_URL}}" ]; then
          echo "Usage: task helm:repo:index REPO_URL=https://<org>.github.io/<repo>/"
          exit 1
        fi
        mkdir -p dist
        if [ -f dist/index.yaml ]; then
          helm repo index dist --url {{.REPO_URL}} --merge dist/index.yaml
        else
          helm repo index dist --url {{.REPO_URL}}
        fi