sdk-ruby.yml

name: ruby
on:
  workflow_dispatch:
  pull_request:
    paths:
      - ".github/**"
      - "sdks/ruby/**"
  push:
    branches:
      - main
    paths:
      - "sdks/ruby/**"

defaults:
  run:
    working-directory: ./sdks/ruby/src

jobs:
  lint:
    runs-on: ubicloud-standard-4
    steps:
      - name: Checkout code
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

      - name: Set up Ruby
        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
        with:
          ruby-version: "3.2"
          bundler-cache: true
          working-directory: ./sdks/ruby/src

      - name: Run RuboCop
        run: bundle exec rubocop

      - name: Run RBS validate
        run: rbs -I sig validate

      - name: Test gem build
        run: gem build hatchet-sdk.gemspec

  test:
    runs-on: ubicloud-standard-4
    strategy:
      matrix:
        ruby-version: ${{ github.event_name == 'pull_request' && fromJSON('["3.2"]') || fromJSON('["3.2", "3.3"]') }}
        optimistic-scheduling: ["true", "false"]
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

      - name: Install Protoc
        uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
        with:
          version: "25.1"
          repo-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Install Task
        uses: arduino/setup-task@b91d5d2c96a56797b48ac1e0e89220bf64044611 # v2.0.0
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Setup Go
        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
        with:
          go-version: "1.25.9"

      - name: Start Docker dependencies
        working-directory: .
        run: docker compose up -d

      - name: Generate
        working-directory: .
        run: |
          export DATABASE_URL="postgresql://hatchet:hatchet@127.0.0.1:5431/hatchet"
          go run ./cmd/hatchet-migrate

      - name: Setup
        working-directory: .
        run: |
          export SEED_DEVELOPMENT=true
          export SERVER_PORT=8080
          export SERVER_URL=http://localhost:8080
          export SERVER_AUTH_COOKIE_DOMAIN=localhost
          export SERVER_AUTH_COOKIE_INSECURE=true
          export SERVER_DEFAULT_ENGINE_VERSION=V1
          export SERVER_MSGQUEUE_RABBITMQ_URL="amqp://user:password@localhost:5672/"
          export SERVER_OPTIMISTIC_SCHEDULING_ENABLED=${{ matrix.optimistic-scheduling }}

          go run ./cmd/hatchet-admin quickstart

          go run ./cmd/hatchet-engine --config ./generated/ > engine.log 2>&1 &
          go run ./cmd/hatchet-api --config ./generated/ > api.log 2>&1 &

          sleep 30

      - name: Set up Ruby ${{ matrix.ruby-version }}
        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
        with:
          ruby-version: ${{ matrix.ruby-version }}
          bundler-cache: true
          working-directory: ./sdks/ruby/src

      - name: Display Ruby version
        run: ruby -v

      - name: Generate Env File
        working-directory: .
        run: |
          echo "HATCHET_CLIENT_TOKEN=$(go run ./cmd/hatchet-admin token create --config ./generated/ --tenant-id 707d0855-80ab-4e1f-a156-f1c4546cbf52)" >> $GITHUB_ENV
          echo "HATCHET_CLIENT_TLS_ROOT_CA_FILE=../../../certs/ca.cert" >> $GITHUB_ENV
          echo "HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED=true" >> $GITHUB_ENV

      - name: Set HATCHET_CLIENT_NAMESPACE
        run: |
          RUBY_VER=$(ruby -e "puts \"rb#{RUBY_VERSION.gsub('.','')[0..1]}\"")
          SHORT_SHA=$(git rev-parse --short HEAD)
          echo "HATCHET_CLIENT_NAMESPACE=${RUBY_VER}-${SHORT_SHA}" >> $GITHUB_ENV

      - name: Run unit tests
        run: |
          echo "Using HATCHET_CLIENT_NAMESPACE: $HATCHET_CLIENT_NAMESPACE"
          bundle exec rspec --format documentation --tag ~integration

      - name: Run integration tests
        run: bundle exec rspec spec/integration/ --format documentation --tag integration

      - name: Set up Ruby for examples
        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
        with:
          ruby-version: ${{ matrix.ruby-version }}
          bundler-cache: true
          working-directory: ./sdks/ruby/examples

      - name: Wait for API readiness
        working-directory: .
        run: |
          echo "Waiting for API at http://localhost:8080/api/ready..."
          for i in $(seq 1 60); do
            if curl -sf http://localhost:8080/api/ready > /dev/null 2>&1; then
              echo "API ready after ${i}s"
              break
            fi
            if [ "$i" -eq 60 ]; then
              echo "API did not become ready within 60s"
              tail -n 50 engine.log 2>/dev/null || true
              tail -n 50 api.log 2>/dev/null || true
              exit 1
            fi
            sleep 1
          done
          sleep 5

      - name: Start example worker and wait for health
        working-directory: ./sdks/ruby/examples
        run: |
          export HATCHET_CLIENT_WORKER_HEALTHCHECK_PORT=8001
          stdbuf -o0 -e0 bundle exec ruby worker.rb > worker.log 2>&1 &
          WORKER_PID=$!
          echo "Worker started with PID $WORKER_PID"

          MAX_WAIT=45
          POLL_INTERVAL=1
          echo "Waiting 5s for worker to initialize..."
          sleep 5

          for i in $(seq 1 $MAX_WAIT); do
            if ! kill -0 "$WORKER_PID" 2>/dev/null; then
              echo "Worker process (PID $WORKER_PID) exited before becoming healthy"
              echo "=== worker.log ==="
              cat worker.log || true
              echo "=== tail engine.log ==="
              tail -n 80 "$GITHUB_WORKSPACE/engine.log" 2>/dev/null || true
              echo "=== tail api.log ==="
              tail -n 80 "$GITHUB_WORKSPACE/api.log" 2>/dev/null || true
              exit 1
            fi
            if curl -sf http://localhost:8001/health > /dev/null 2>&1; then
              echo "Worker is healthy after ${i}s"
              exit 0
            fi
            if [ $((i % 5)) -eq 0 ]; then
              echo "Still waiting for worker health... ${i}s/${MAX_WAIT}s"
              echo "--- worker.log (last 25 lines) ---"
              tail -n 25 worker.log 2>/dev/null || true
              echo "--- engine.log (last 25 lines) ---"
              tail -n 25 "$GITHUB_WORKSPACE/engine.log" 2>/dev/null || true
              echo "--- api.log (last 25 lines) ---"
              tail -n 25 "$GITHUB_WORKSPACE/api.log" 2>/dev/null || true
            fi
            sleep $POLL_INTERVAL
          done

          echo "Worker failed to become healthy within ${MAX_WAIT}s"
          echo "=== worker.log ==="
          cat worker.log || true
          echo "=== tail engine.log ==="
          tail -n 80 "$GITHUB_WORKSPACE/engine.log" 2>/dev/null || true
          echo "=== tail api.log ==="
          tail -n 80 "$GITHUB_WORKSPACE/api.log" 2>/dev/null || true
          exit 1

      - name: Run e2e tests
        working-directory: ./sdks/ruby/examples
        run: bundle exec rspec -f d --fail-fast

      - name: Upload worker logs
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: ${{ env.HATCHET_CLIENT_NAMESPACE }}-opt-${{ matrix.optimistic-scheduling }}-worker-logs
          path: ./sdks/ruby/examples/worker.log

      - name: Upload engine logs
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: ${{ env.HATCHET_CLIENT_NAMESPACE }}-opt-${{ matrix.optimistic-scheduling }}-engine-logs
          path: engine.log

      - name: Upload API logs
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: ${{ env.HATCHET_CLIENT_NAMESPACE }}-opt-${{ matrix.optimistic-scheduling }}-api-logs
          path: api.log

  old-engine-new-sdk:
    runs-on: ubicloud-standard-4
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          fetch-depth: 0
          fetch-tags: true

      - name: Start Docker dependencies
        working-directory: .
        run: docker compose up -d

      - name: Determine latest stable release tag
        working-directory: .
        run: |
          LATEST_TAG=$(git tag --sort=-v:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -1)
          if [ -z "$LATEST_TAG" ]; then
            echo "ERROR: No stable release tag found"
            exit 1
          fi
          echo "Latest stable tag: $LATEST_TAG"
          echo "LATEST_TAG=$LATEST_TAG" >> $GITHUB_ENV

      - name: Pull release images
        working-directory: .
        run: docker compose -f docker-compose.yml -f docker-compose.release.yml pull hatchet-migrate hatchet-admin hatchet-engine hatchet-api

      - name: Run migrations
        working-directory: .
        run: docker compose -f docker-compose.yml -f docker-compose.release.yml run --rm hatchet-migrate

      - name: Setup config and seed database
        working-directory: .
        run: |
          mkdir -p generated
          docker compose -f docker-compose.yml -f docker-compose.release.yml run --rm \
            hatchet-admin /hatchet/hatchet-admin quickstart --skip certs --generated-config-dir /hatchet/generated

      - name: Generate API token
        working-directory: .
        run: |
          TOKEN=$(docker compose -f docker-compose.yml -f docker-compose.release.yml run -T --rm \
            hatchet-admin /hatchet/hatchet-admin token create --config /hatchet/generated --tenant-id 707d0855-80ab-4e1f-a156-f1c4546cbf52)
          echo "HATCHET_CLIENT_TOKEN=$TOKEN" >> $GITHUB_ENV

      - name: Start engine and API
        working-directory: .
        run: |
          docker compose -f docker-compose.yml -f docker-compose.release.yml up -d hatchet-engine hatchet-api
          sleep 30

      - name: Set up Ruby
        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
        with:
          ruby-version: "3.2"
          bundler-cache: true
          working-directory: ./sdks/ruby/src

      - name: Set HATCHET_CLIENT_NAMESPACE
        run: |
          SHORT_SHA=$(git rev-parse --short HEAD)
          echo "HATCHET_CLIENT_NAMESPACE=old-engine-new-sdk-rb-${SHORT_SHA}" >> $GITHUB_ENV

      - name: Run unit tests
        env:
          HATCHET_CLIENT_TLS_STRATEGY: none
          HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED: "true"
        run: |
          echo "Testing current SDK against engine ${{ env.LATEST_TAG }}"
          echo "Using HATCHET_CLIENT_NAMESPACE: $HATCHET_CLIENT_NAMESPACE"
          bundle exec rspec --format documentation --tag ~integration

      - name: Run integration tests
        env:
          HATCHET_CLIENT_TLS_STRATEGY: none
          HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED: "true"
        run: bundle exec rspec spec/integration/ --format documentation --tag integration

      - name: Set up Ruby for examples
        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
        with:
          ruby-version: "3.2"
          bundler-cache: true
          working-directory: ./sdks/ruby/examples

      - name: Start example worker
        working-directory: ./sdks/ruby/examples
        env:
          HATCHET_CLIENT_TLS_STRATEGY: none
          HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED: "true"
        run: bundle exec ruby worker.rb > worker.log 2>&1 &

      - name: Wait for worker health
        working-directory: .
        run: |
          for i in $(seq 1 60); do
            if curl -s http://localhost:8001/health > /dev/null 2>&1; then
              echo "Worker is healthy after ${i}s"
              exit 0
            fi
            sleep 1
          done
          echo "Worker failed to start within 60s"
          cat ./sdks/ruby/examples/worker.log || true
          exit 1

      - name: Run e2e tests
        working-directory: ./sdks/ruby/examples
        env:
          HATCHET_CLIENT_TLS_STRATEGY: none
          HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED: "true"
        run: bundle exec rspec -f d --fail-fast

      - name: Upload worker logs
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: ${{ env.HATCHET_CLIENT_NAMESPACE }}-worker-logs
          path: ./sdks/ruby/examples/worker.log

      - name: Collect engine logs
        if: always()
        working-directory: .
        run: docker compose -f docker-compose.yml -f docker-compose.release.yml logs hatchet-engine > /tmp/engine.log 2>&1 || true

      - name: Upload engine logs
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: ${{ env.HATCHET_CLIENT_NAMESPACE }}-engine-logs
          path: /tmp/engine.log

      - name: Collect API logs
        if: always()
        working-directory: .
        run: docker compose -f docker-compose.yml -f docker-compose.release.yml logs hatchet-api > /tmp/api.log 2>&1 || true

      - name: Upload API logs
        if: always()
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: ${{ env.HATCHET_CLIENT_NAMESPACE }}-api-logs
          path: /tmp/api.log

      - name: Teardown
        if: always()
        working-directory: .
        run: docker compose -f docker-compose.yml -f docker-compose.release.yml down

  publish:
    runs-on: ubicloud-standard-4
    needs: [lint, test]
    if: github.ref == 'refs/heads/main'
    permissions:
      contents: write
      id-token: write
    steps:
      - name: Checkout Repository
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          submodules: recursive

      - name: Set up Ruby
        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
        with:
          ruby-version: "3.2"
          bundler-cache: true
          working-directory: ./sdks/ruby/src

      - name: Check if version changed
        id: version_check
        run: |
          NEW_VERSION=$(ruby -e "require_relative 'lib/hatchet/version'; puts Hatchet::VERSION")
          CURRENT_VERSION=$(gem info hatchet-sdk --remote --exact 2>/dev/null | grep -oP 'hatchet-sdk \(\K[^)]+' || echo "0.0.0")

          if [ "$CURRENT_VERSION" == "$NEW_VERSION" ]; then
            echo "Version has not changed ($NEW_VERSION). Skipping publish."
            echo "should_publish=false" >> "$GITHUB_OUTPUT"
          else
            echo "Publishing version $NEW_VERSION (current: $CURRENT_VERSION)"
            echo "should_publish=true" >> "$GITHUB_OUTPUT"
          fi

      - name: Configure RubyGems credentials
        if: steps.version_check.outputs.should_publish == 'true'
        uses: rubygems/configure-rubygems-credentials@main

      - name: Publish to RubyGems
        if: steps.version_check.outputs.should_publish == 'true'
        run: |
          gem build hatchet-sdk.gemspec
          NEW_VERSION=$(ruby -e "require_relative 'lib/hatchet/version'; puts Hatchet::VERSION")
          gem push hatchet-sdk-${NEW_VERSION}.gem