third_party_rust_tracing/.github/workflows/CI.yml

name: CI

on:
  push:
    branches:
    - master
    - "v0.1.x"
  pull_request: {}

env:
  # Disable incremental compilation.
  #
  # Incremental compilation is useful as part of an edit-build-test-edit cycle,
  # as it lets the compiler avoid recompiling code that hasn't changed. However,
  # on CI, we're not making small edits; we're almost always building the entire
  # project from scratch. Thus, incremental compilation on CI actually
  # introduces *additional* overhead to support making future builds
  # faster...but no future builds will ever occur in any given CI environment.
  #
  # See https://matklad.github.io/2021/09/04/fast-rust-builds.html#ci-workflow
  # for details.
  CARGO_INCREMENTAL: 0
  # Allow more retries for network requests in cargo (downloading crates) and
  # rustup (installing toolchains). This should help to reduce flaky CI failures
  # from transient network timeouts or other issues.
  CARGO_NET_RETRY: 10
  RUSTUP_MAX_RETRIES: 10
  # Don't emit giant backtraces in the CI logs.
  RUST_BACKTRACE: short
  MSRV: 1.49.0
  # TODO: remove this once tracing's MSRV is bumped.
  APPENDER_MSRV: 1.53.0

jobs:
  ### check jobs ###

  check:
    # Run `cargo check` first to ensure that the pushed code at least compiles.
    name: cargo check
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        profile: minimal
        override: true
    - name: Check
      uses: actions-rs/cargo@v1
      with:
        command: check
        args: --all --tests --benches

  style:
    # Check style.
    name: cargo fmt
    needs: check
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        components: rustfmt
        profile: minimal
        override: true
    - name: rustfmt
      uses: actions-rs/cargo@v1
      with:
        command: fmt
        args: --all -- --check

  warnings:
    # Check for any warnings. This is informational and thus is allowed to fail.
    runs-on: ubuntu-latest
    needs: check
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        components: clippy
        profile: minimal
    - name: Clippy
      uses: actions-rs/clippy-check@v1
      with:
        token: ${{ secrets.GITHUB_TOKEN }}
        args: --all --examples --tests --benches -- -D warnings

  minimal-versions:
    # Check for minimal-versions errors where a dependency is too
    # underconstrained to build on the minimal supported version of all
    # dependencies in the dependency graph.
    name: cargo check (-Zminimal-versions)
    needs: check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: nightly
          profile: minimal
          override: true
      - name: install cargo-hack
        uses: taiki-e/install-action@cargo-hack
      - name: "check --all-features -Z minimal-versions"
        run: |
          # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
          # from determining minimal versions based on dev-dependencies.
          cargo hack --remove-dev-deps --workspace
          # Update Cargo.lock to minimal version dependencies.
          cargo update -Z minimal-versions
          cargo hack check \
            --package tracing \
            --package tracing-core \
            --package tracing-subscriber \
            --all-features --ignore-private

  cargo-hack:
    needs: check
    name: cargo check (feature combinations)
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # cargo hack --feature-powerset will have a significant permutation
        # number, we can't just use --all as it increases the runtime
        # further than what we would like to
        subcrate:
        - tracing-attributes
        - tracing-core
        - tracing-futures
        - tracing-log
        - tracing-macros
        - tracing-serde
        - tracing-tower
        - tracing-opentelemetry
        - tracing
        - tracing-subscriber
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        profile: minimal
        override: true

    - name: install cargo-hack
      uses: taiki-e/install-action@cargo-hack
    - name: cargo hack check
      working-directory: ${{ matrix.subcrate }}
      # tracing and tracing-subscriber have too many features to be checked by
      # cargo-hack --feature-powerset with all features in the powerset, so
      # exclude some
      run: |
        CARGO_HACK=(cargo hack check --feature-powerset --no-dev-deps)
        case "${{ matrix.subcrate }}" in
          tracing)
            EXCLUDE_FEATURES=(
              max_level_off max_level_error max_level_warn max_level_info
              max_level_debug max_level_trace release_max_level_off
              release_max_level_error release_max_level_warn
              release_max_level_info release_max_level_debug
              release_max_level_trace
            )
            ${CARGO_HACK[@]} --exclude-features "${EXCLUDE_FEATURES[*]}"
            ;;
          tracing-subscriber)
            INCLUDE_FEATURES=(fmt ansi json registry env-filter)
            ${CARGO_HACK[@]} --include-features "${INCLUDE_FEATURES[*]}"
            ;;
          *)
            ${CARGO_HACK[@]}
            ;;
        esac
      shell: bash

  check-msrv:
    # Run `cargo check` on our minimum supported Rust version (1.49.0).
    name: "cargo check (MSRV on ubuntu-latest)"
    needs: check
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: "install Rust ${{ env.MSRV }}"
      uses: actions-rs/toolchain@v1
      with:
        toolchain: ${{ env.MSRV }}
        profile: minimal
    - name: "install Rust nightly"
      uses: actions-rs/toolchain@v1
      with:
        toolchain: nightly
        profile: minimal
    - name: Select minimal versions
      uses: actions-rs/cargo@v1
      with:
        command: update
        args: -Z minimal-versions
        toolchain: nightly
    - name: Check
      uses: actions-rs/cargo@v1
      with:
        command: check
        # skip the following crates:
        # - tracing-appender, as it has its own MSRV.
        #   TODO(eliza): remove this when appender is on the same MSRV as
        #   everything else
        # - the examples, as they are not published & we don't care about
        #   MSRV support for them.
        # - tracing-futures, as it depends on ancient tokio versions.
        #   TODO(eliza): remove this when the ancient tokio deps are dropped
        args: >-
          --workspace --all-features --locked
          --exclude=tracing-appender
          --exclude=tracing-examples
          --exclude=tracing-futures
          --exclude=tracing-opentelemetry
        toolchain: ${{ env.MSRV }}

  # TODO: remove this once tracing's MSRV is bumped.
  check-msrv-appender:
    # Run `cargo check` on our minimum supported Rust version (1.53.0).
    name: "cargo check (tracing-appender MSRV)"
    needs: check
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: "install Rust ${{ env.APPENDER_MSRV }}"
      uses: actions-rs/toolchain@v1
      with:
        toolchain: ${{ env.APPENDER_MSRV }}
        profile: minimal
    - name: "install Rust nightly"
      uses: actions-rs/toolchain@v1
      with:
        toolchain: nightly
        profile: minimal
    - name: Select minimal versions
      uses: actions-rs/cargo@v1
      with:
        command: update
        args: -Z minimal-versions
        toolchain: nightly
    - name: Check
      uses: actions-rs/cargo@v1
      with:
        command: check
        args: --all-features --locked -p tracing-appender
        toolchain: ${{ env.APPENDER_MSRV }}

  ### test jobs #############################################################

  test:
    # Test against stable Rust across macOS, Windows, and Linux, and against
    # beta and nightly rust on Ubuntu.
    name: "cargo test (${{ matrix.rust }} on ${{ matrix.os }})"
    needs: check
    strategy:
      matrix:
        # test all Rust versions on ubuntu-latest
        os: [ubuntu-latest]
        rust: [stable, beta, nightly]
        # test stable Rust on Windows and MacOS as well
        include:
          - rust: stable
            os: windows-latest
          - rust: stable
            os: macos-latest
      fail-fast: false
    runs-on: ${{ matrix.os }}
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        toolchain: ${{ matrix.rust }}
        profile: minimal
        override: true
    - name: install cargo-nextest
      uses: taiki-e/install-action@nextest
    - name: Run tests
      run: cargo nextest run --profile ci --workspace
    # TODO(eliza): punt on this for now because the generated JUnit report is
    # missing some fields that this action needs to give good output.
    # - name: Publish Test Report
    #   uses: mikepenz/action-junit-report@v3
    #   if: always() # always run even if the previous step fails
    #   with:
    #     report_paths: 'target/nextest/ci/junit.xml'
    #     check_name: "cargo test (Rust ${{ matrix.rust }} on ${{ matrix.os }})"
    #     check_title_template: "{{SUITE_NAME}}::{{TEST_NAME}}"
    - name: Run doctests
      run: cargo test --doc --workspace

  test-build-wasm:
    name: build tests (wasm)
    needs: check
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # TODO(securityinsanity): slowly add wasm32 test runner to each crate, and move to seperate actions that run tests.
        subcrate:
        - tracing-appender
        - tracing-attributes
        - tracing-core
        - tracing-error
        - tracing-flame
        - tracing-journald
        - tracing-log
        - tracing-macros
        - tracing-opentelemetry
        - tracing-serde
        - tracing-subscriber
        - tracing-tower
      fail-fast: false
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        target: wasm32-unknown-unknown
        toolchain: stable
        override: true
    - name: build all tests
      uses: actions-rs/cargo@v1
      with:
        command: test
        args: --no-run -p ${{ matrix.subcrate }}

  test-wasm:
    name: cargo test (wasm)
    needs: check
    runs-on: ubuntu-latest
    strategy:
      matrix:
        subcrate:
        - tracing
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        target: wasm32-unknown-unknown
        toolchain: stable
        override: true
    - name: install test runner for wasm
      uses: taiki-e/install-action@wasm-pack
    - name: run wasm tests
      run: cd ${{ matrix.subcrate }} && wasm-pack test --node

  test-features-stable:
    # Feature flag tests that run on stable Rust.
    # TODO(david): once tracing's MSRV goes up to Rust 1.51, we should be able to switch to
    # using cargo's V2 feature resolver (https://doc.rust-lang.org/cargo/reference/resolver.html#resolver-versions)
    # and avoid cd'ing into each crate's directory.
    name: cargo test (feature-specific)
    needs: check
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        profile: minimal
        override: true
    - name: "Test log support"
      run: cargo test
      working-directory: "tracing/test-log-support"
    - name: "Test static max level"
      run: cargo test
      working-directory: "tracing/test_static_max_level_features"
    - name: "Test static max level (release)"
      run: cargo test --release
      working-directory: "tracing/test_static_max_level_features"
    - name: "Test tracing-core no-std support"
      run: cargo test --no-default-features
      working-directory: tracing-core
    - name: "Test tracing no-std support"
      run: cargo test --lib --no-default-features
      working-directory: tracing
      # this skips running doctests under the `--no-default-features` flag,
      # as rustdoc isn't aware of cargo's feature flags.
    - name: "Test tracing-subscriber no-std support"
      run: cargo test --lib --tests --no-default-features
      working-directory: tracing-subscriber
    - name: "Test tracing-subscriber with liballoc only"
      run: cargo test --lib --tests --no-default-features --features "alloc"
      working-directory: tracing-subscriber
    - name: "Test tracing-subscriber with no default features"
      run: cargo test --lib --tests --no-default-features --features "std"
      working-directory: tracing-subscriber

  # all required checks except for the main test run (which we only require
  # specific matrix combinations from)
  all_required:
    name: "all systems go!"
    runs-on: ubuntu-latest
    needs:
      - style
      - minimal-versions
      - cargo-hack
      - check-msrv
      - check-msrv-appender
      - test-build-wasm
      - test-wasm
      - test-features-stable
    steps:
      - run: exit 0