generate coverage + codecov (#504)

jaggederest · web-flow · commit 67db28beea31 · 2025-09-26T12:00:40.000-07:00
* generate coverage + codecov

* test arguments

* correct token

* coverage in integration?

* integration coverage fixes

* merge down to a single test run instead of test + coverage separately

* integration troubleshooting

* ensure cov generation uses --release

* remove redundant build

* explicit checks for coverage changes and manually kill pgdog before coverage run

* try stopping between sub-suites

* debug output in verify profiles

* pour on the debug logging

* further debugging

* path bug

* search anywhere for profiles

* whee!

* fail to bail when profiles havent changed

* add a new test to produce a diff

* add bigint binary test for more coverage there (just to check coverage is working)

* add codecov config, basic test for arrays
diff --git a/.github/codecov.yml b/.github/codecov.yml
@@ -0,0 +1,48 @@
+codecov:
+  notify:
+    wait_for_ci: true
+    after_n_builds: 1
+  require_ci_to_pass: true
+  disable_default_path_fixes: false
+
+comment:
+  layout: "reach,diff,flags,tree"
+  behavior: default
+  require_changes: true
+  show_carryforward_flags: true
+
+coverage:
+  precision: 2
+  round: down
+  range: 60..90
+  status:
+    project:
+      default:
+        informational: true
+        target: auto
+        threshold: 1
+        base: auto
+    patch:
+      default:
+        informational: true
+        target: 80
+        threshold: 5
+        base: auto
+    changes: false
+
+flags:
+  unit:
+    paths:
+      - pgdog
+    carryforward: true
+  integration:
+    paths:
+      - integration
+    carryforward: false
+
+ignore:
+  - "**/tests/**"
+  - "**/examples/**"
+  - integration/python/venv
+
+slack_app: true
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -48,6 +48,7 @@ jobs:
         with:
           toolchain: stable
           override: true
+          components: llvm-tools-preview
       - uses: useblacksmith/rust-cache@v3
         with:
           prefix-key: "v1" # Change this when updating tooling
@@ -68,18 +69,35 @@ jobs:
           bash integration/toxi/setup.sh
       - name: Install test dependencies
         run: cargo install cargo-nextest --version "0.9.78" --locked
-      - name: Run tests
-        run: cargo nextest run -E 'package(pgdog)' --no-fail-fast --test-threads=1
+      - name: Install coverage tooling
+        run: cargo install cargo-llvm-cov --locked --version "0.6.10"
+      - name: Run tests with coverage
+        env:
+          RUSTFLAGS: "-C link-dead-code"
+        run: |
+          cargo llvm-cov clean --workspace
+          cargo llvm-cov nextest --lcov --output-path lcov.info --no-fail-fast --test-threads=1 --filter-expr "package(pgdog)"
       - name: Run documentation tests
         run: cargo test --doc
+      # Requires CODECOV_TOKEN secret for upload
+      - uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        with:
+          files: lcov.info
+          flags: unit
+          fail_ci_if_error: true
   integration:
     runs-on: blacksmith-4vcpu-ubuntu-2404
+    env:
+      LLVM_PROFILE_FILE: ${{ github.workspace }}/target/llvm-cov-target/profiles/pgdog-%p-%m.profraw
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
           override: true
+          components: llvm-tools-preview
       - uses: useblacksmith/rust-cache@v3
         with:
           prefix-key: release-1
@@ -101,29 +119,82 @@ jobs:
           bash integration/toxi/setup.sh
           sudo curl -SL https://github.com/docker/compose/releases/download/v2.36.1/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
           sudo chmod +x /usr/local/bin/docker-compose
-      - name: Build PgDog
-        run: cargo build --release
+      - name: Install coverage tooling
+        run: cargo install cargo-llvm-cov --locked --version "0.6.10"
+      - name: Prepare instrumented PgDog build
+        env:
+          RUSTFLAGS: "-C link-dead-code"
+        run: |
+          cargo llvm-cov clean --workspace
+          mkdir -p target/llvm-cov-target/profiles
+          cargo llvm-cov run --no-report --release --package pgdog --bin pgdog -- --help
+          rm -f target/llvm-cov-target/profiles/*.profraw
+          rm -f target/llvm-cov-target/profiles/.last_snapshot
+          rm -rf target/llvm-cov-target/reports
+          BIN_PATH=$(find target/llvm-cov-target -type f -path '*/release/pgdog' | head -n 1)
+          if [ -z "$BIN_PATH" ]; then
+            echo "Instrumented PgDog binary not found" >&2
+            exit 1
+          fi
+          echo "Using instrumented binary at $BIN_PATH"
+          echo "PGDOG_BIN=$(realpath "$BIN_PATH")" >> "$GITHUB_ENV"
       - name: Load balancer
         run: bash integration/load_balancer/run.sh
       - name: pgbench
         run: bash integration/pgbench/run.sh
+      - name: Verify coverage (pgbench)
+        run: bash integration/verify_profiles.sh pgbench
       - name: Go
         run: bash integration/go/run.sh
+      - name: Verify coverage (go)
+        run: bash integration/verify_profiles.sh go
       - name: JavaScript
         run: bash integration/js/pg_tests/run.sh
+      - name: Verify coverage (javascript)
+        run: bash integration/verify_profiles.sh javascript
       - name: Toxi
         run: bash integration/toxi/run.sh
+      - name: Verify coverage (toxi)
+        run: bash integration/verify_profiles.sh toxi
       - name: Python
         run: bash integration/python/run.sh
+      - name: Verify coverage (python)
+        run: bash integration/verify_profiles.sh python
       - name: Ruby
         run: bash integration/ruby/run.sh
+      - name: Verify coverage (ruby)
+        run: bash integration/verify_profiles.sh ruby
       - name: Java
         run: bash integration/java/run.sh
+      - name: Verify coverage (java)
+        run: bash integration/verify_profiles.sh java
       - name: More complex stuff
         run: bash integration/complex/run.sh
+      - name: Verify coverage (complex)
+        run: bash integration/verify_profiles.sh complex
       - name: Rust
         run: bash integration/rust/run.sh
+      - name: Verify coverage (rust)
+        run: bash integration/verify_profiles.sh rust
       - name: Dry run
         run: bash integration/dry_run/run.sh
+      - name: Verify coverage (dry_run)
+        run: bash integration/verify_profiles.sh dry_run
       # - name: Plugins
       #   run: bash integration/plugins/run.sh
+      - name: Ensure PgDog stopped
+        run: |
+          if pgrep -x pgdog > /dev/null; then
+            killall -TERM pgdog
+            sleep 5
+          fi
+      - name: Generate integration coverage report
+        run: cargo llvm-cov report --release --package pgdog --lcov --output-path integration.lcov
+      # Requires CODECOV_TOKEN secret for upload
+      - uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        with:
+          files: integration.lcov
+          flags: integration
+          fail_ci_if_error: true
diff --git a/integration/common.sh b/integration/common.sh
@@ -16,22 +16,77 @@ function wait_for_pgdog() {
 function run_pgdog() {
     # We expect all test scripts to define $SCRIPT_DIR.
     pushd ${COMMON_DIR}/../
-    # Testing in release is faster
-    # and a more reliable test of what happens
-    # in prod.
-    cargo build --release
     local config_path=${1:-"integration"}
-    target/release/pgdog \
+    local binary="${PGDOG_BIN:-}"
+    local pid_file="${COMMON_DIR}/pgdog.pid"
+    local config_file="${COMMON_DIR}/pgdog.config"
+    if [ -z "${binary}" ]; then
+        # Testing in release is faster and mirrors production.
+        cargo build --release
+        binary="target/release/pgdog"
+    fi
+    if [ -f "${pid_file}" ]; then
+        local existing_pid=$(cat "${pid_file}")
+        if [ -n "${existing_pid}" ] && kill -0 "${existing_pid}" 2> /dev/null; then
+            local existing_config=""
+            if [ -f "${config_file}" ]; then
+                existing_config=$(cat "${config_file}")
+            fi
+            if [ "${existing_config}" = "${config_path}" ]; then
+                popd
+                return
+            fi
+            stop_pgdog
+        fi
+    fi
+    echo "Launching PgDog binary '${binary}' with config path '${config_path}'"
+    "${binary}" \
         --config ${config_path}/pgdog.toml \
         --users ${config_path}/users.toml \
         > ${COMMON_DIR}/log.txt &
+    echo $! > "${pid_file}"
+    printf '%s\n' "${config_path}" > "${config_file}"
+    if [ -z "${PGDOG_STOP_TRAP:-}" ]; then
+        trap stop_pgdog EXIT
+        export PGDOG_STOP_TRAP=1
+    fi
     popd
 }
 
 function stop_pgdog() {
-    killall -TERM pgdog 2> /dev/null || true
-    cat ${COMMON_DIR}/log.txt
-    rm ${COMMON_DIR}/log.txt
+    local pid_file="${COMMON_DIR}/pgdog.pid"
+    local config_file="${COMMON_DIR}/pgdog.config"
+    if [ -f "${pid_file}" ]; then
+        local pid=$(cat "${pid_file}")
+        if [ -n "${pid}" ] && kill -0 "${pid}" 2> /dev/null; then
+            kill -TERM "${pid}" 2> /dev/null || true
+            local waited=0
+            while kill -0 "${pid}" 2> /dev/null && [ ${waited} -lt 30 ]; do
+                sleep 1
+                waited=$((waited + 1))
+            done
+            if kill -0 "${pid}" 2> /dev/null; then
+                kill -KILL "${pid}" 2> /dev/null || true
+            fi
+        fi
+        rm -f "${pid_file}"
+    else
+        killall -TERM pgdog 2> /dev/null || true
+        local waited=0
+        while pgrep -x pgdog > /dev/null && [ ${waited} -lt 30 ]; do
+            sleep 1
+            waited=$((waited + 1))
+        done
+    fi
+    sleep 1
+    if [ -f "${config_file}" ]; then
+        # Keep the config file so we can restart with the same arguments later.
+        :
+    fi
+    if [ -f ${COMMON_DIR}/log.txt ]; then
+        cat ${COMMON_DIR}/log.txt
+        rm ${COMMON_DIR}/log.txt
+    fi
 }
 
 function start_toxi() {
diff --git a/integration/complex/passthrough_auth/run.sh b/integration/complex/passthrough_auth/run.sh
@@ -7,10 +7,15 @@ export PGHOST=127.0.0.1
 
 killall -TERM pgdog 2> /dev/null || true
 
-${SCRIPT_DIR}/../../../target/release/pgdog \
+PGDOG_BIN_PATH="${PGDOG_BIN:-${SCRIPT_DIR}/../../../target/release/pgdog}"
+
+"${PGDOG_BIN_PATH}" \
     --config ${SCRIPT_DIR}/pgdog-enabled.toml \
     --users ${SCRIPT_DIR}/users.toml &
-sleep 1
+
+until pg_isready -h 127.0.0.1 -p 6432 -U pgdog -d pgdog; do
+    sleep 1
+done
 
 if ! psql -U pgdog1 pgdog -c 'SELECT 1' > /dev/null; then
     echo "AutoDB not working"
@@ -28,10 +33,13 @@ fi
 
 killall -TERM pgdog
 
-${SCRIPT_DIR}/../../../target/release/pgdog \
+"${PGDOG_BIN_PATH}" \
     --config ${SCRIPT_DIR}/pgdog-disabled.toml \
     --users ${SCRIPT_DIR}/users.toml &
-sleep 1
+
+until pg_isready -h 127.0.0.1 -p 6432 -U pgdog -d pgdog; do
+    sleep 1
+done
 
 if psql -U pgdog1 pgdog -c 'SELECT 1' 2> /dev/null; then
     echo "AutoDB should be disabled"
diff --git a/integration/load_balancer/run.sh b/integration/load_balancer/run.sh
@@ -1,37 +1,29 @@
 #!/bin/bash
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 set -e
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+source ${SCRIPT_DIR}/../common.sh
 
 pushd ${SCRIPT_DIR}
 
 export PGUSER=postgres
-
 export PGHOST=127.0.0.1
 export PGDATABASE=postgres
 export PGPASSWORD=postgres
 
-docker-compose up -d
+echo "[load_balancer] Using PGDOG_BIN=${PGDOG_BIN}"
+echo "[load_balancer] LLVM_PROFILE_FILE=${LLVM_PROFILE_FILE}"
 
+docker-compose up -d
 
 echo "Waiting for Postgres to be ready"
-
 for p in 45000 45001 45002; do
     export PGPORT=${p}
     while ! pg_isready; do
         sleep 1
     done
 done
 
-
-pushd ${SCRIPT_DIR}/../../
-cargo build --release
-popd
-
-sleep 2
-
-cargo run --release -- \
-    --config ${SCRIPT_DIR}/pgdog.toml \
-    --users ${SCRIPT_DIR}/users.toml &
+run_pgdog ${SCRIPT_DIR}
 
 export PGPORT=6432
 while ! pg_isready; do
@@ -43,6 +35,9 @@ go get
 go test -v -count 3
 popd
 
-killall pgdog
+stop_pgdog
+
+PGDOG_NO_RESTART=1 bash ${SCRIPT_DIR}/../verify_profiles.sh load_balancer
 
 docker-compose down
+popd
diff --git a/integration/python/test_asyncpg.py b/integration/python/test_asyncpg.py
@@ -138,6 +138,32 @@ async def test_insert_allshard(conns):
     no_out_of_sync()
 
 
+@pytest.mark.asyncio
+async def test_bigint_binary(conns):
+    big_value = 1 << 62
+    for conn in conns:
+        await conn.execute("DROP TABLE IF EXISTS binary_bigint")
+        await conn.execute("CREATE TABLE binary_bigint (id BIGINT)")
+        await conn.execute("INSERT INTO binary_bigint (id) VALUES($1)", big_value)
+        row = await conn.fetchrow("SELECT id FROM binary_bigint")
+        assert row["id"] == big_value
+        await conn.execute("DROP TABLE binary_bigint")
+    no_out_of_sync()
+
+
+@pytest.mark.asyncio
+async def test_int_array_binary(conns):
+    values = [1, 2, 3]
+    for conn in conns:
+        await conn.execute("DROP TABLE IF EXISTS binary_array")
+        await conn.execute("CREATE TABLE binary_array (vals INT[])")
+        await conn.execute("INSERT INTO binary_array (vals) VALUES($1)", values)
+        row = await conn.fetchrow("SELECT vals FROM binary_array")
+        assert row["vals"] == values
+        await conn.execute("DROP TABLE binary_array")
+    no_out_of_sync()
+
+
 @pytest.mark.asyncio
 async def test_direct_shard(conns):
     conn = conns[1]
diff --git a/integration/verify_profiles.sh b/integration/verify_profiles.sh
diff --git a/pgdog/src/admin/parser.rs b/pgdog/src/admin/parser.rs
