GitHub te poate anunța deja despre rulările de workflow. Activezi în aplicația GitHub Mobile notificările pentru Actions și primești o notificare pentru rulările pornite de tine. Dacă îți ajunge atât, nu mai ai nimic de făcut.

Honk e pentru când ai nevoie de mai mult: eșecuri din multe repository-uri, inclusiv rulările pornite de alții, adunate câte un grup pe branch, în același inbox cu serverele și joburile cron, plus o revenire când branch-ul e din nou verde. Ghidul îl adaugă cu un singur pas la finalul unui job.

Înainte să începi

Un cont Honk. Deocamdată, Honk e disponibil doar pe bază de invitație: cere acces.
Un proiect pentru CI și o cheie API: în aplicația web, deschide proiectul, apoi Chei, și creează una.

1. Salvează URL-ul și cheia ca secrete

Secretele de repository merg pentru un singur repository, iar cele de organizație te scutesc să repeți pasul peste tot. Cu GitHub CLI:

# with the GitHub CLI, for one repository (or use --org for all of them)
gh secret set HONK_URL --body "https://honk-me.app"
gh secret set HONK_KEY        # paste the ingestion key when asked

2. Adaugă un pas care rulează doar la eșec

Pune pasul ăsta ultimul în jobul care te interesează. if: failure() îl rulează doar dacă a eșuat un pas anterior. Folosește jq și curl, care există deja pe orice runner găzduit de GitHub, deci nu ai nimic de instalat:

      - name: Tell Honk
        if: failure()
        env:
          HONK_URL: ${{ secrets.HONK_URL }}
          HONK_KEY: ${{ secrets.HONK_KEY }}
          WORKFLOW: ${{ github.workflow }}
          REPO: ${{ github.repository }}
          BRANCH: ${{ github.ref_name }}
          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
          ATTEMPT: ${{ github.run_id }}-${{ github.run_attempt }}
        run: |
          jq -n --arg title "CI failed: $WORKFLOW on $BRANCH" --arg url "$RUN_URL" --arg key "ci/$REPO/$BRANCH" \
            '{title: $title, message: $url, url: $url, severity: "long", event_type: "problem",
              group_key: $key, source: "github-actions", category: "deployments"}' |
          curl -sS --max-time 10 --retry 3 --retry-all-errors "$HONK_URL/v1/messages" \
            -H "Authorization: Bearer $HONK_KEY" -H "Content-Type: application/json" \
            -H "Idempotency-Key: gh-$ATTEMPT" --data-binary @- || true

Câteva alegeri de aici contează:

Cheia de grup e formată din repository și branch, ci/acme/api/main. Primul eșec pe main te anunță; următoarele eșecuri pe main intră în același grup și devin actualizări discrete. Un eșec pe alt branch are grupul lui.
Cheia de idempotență e ID-ul rulării plus numărul încercării. Dacă curl reîncearcă după un răspuns pierdut, Honk întoarce evenimentul original în loc să creeze altul. Când apeși însă Re-run, noua încercare e un eveniment nou.
jq construiește JSON-ul, așa că ghilimelele din numele unui workflow sau al unui branch nu pot strica cererea.
|| true: dacă Honk e indisponibil, un build eșuat nu se transformă niciodată într-un alt fel de eșec.

3. Opțional: o revenire când e din nou verde

Ca să închizi incidentul când branch-ul trece din nou, adaugă un al doilea pas, care rulează la succes. El întreabă GitHub dacă rularea anterioară de pe branch a eșuat și abia atunci raportează o revenire:

      # needs `permissions: actions: read` when the workflow restricts the token
      - name: Tell Honk it works again
        if: success()
        env:
          GH_TOKEN: ${{ github.token }}
          HONK_URL: ${{ secrets.HONK_URL }}
          HONK_KEY: ${{ secrets.HONK_KEY }}
          WORKFLOW: ${{ github.workflow }}
          REPO: ${{ github.repository }}
          BRANCH: ${{ github.ref_name }}
          ATTEMPT: ${{ github.run_id }}-${{ github.run_attempt }}
        run: |
          previous=$(gh run list --repo "$REPO" --workflow "$WORKFLOW" --branch "$BRANCH" \
            --limit 2 --json conclusion --jq '.[1].conclusion')
          [ "$previous" = "failure" ] || exit 0
          jq -n --arg title "CI green again: $WORKFLOW on $BRANCH" --arg key "ci/$REPO/$BRANCH" \
            '{title: $title, message: "The last run passed.", severity: "beep", event_type: "recovery",
              group_key: $key, source: "github-actions", category: "deployments"}' |
          curl -sS --max-time 10 --retry 3 --retry-all-errors "$HONK_URL/v1/messages" \
            -H "Authorization: Bearer $HONK_KEY" -H "Content-Type: application/json" \
            -H "Idempotency-Key: gh-$ATTEMPT-ok" --data-binary @- || true

Fără pasul ăsta nu se strică nimic: un episod fără evenimente noi devine inactiv după 24 de ore, iar următorul eșec deschide unul nou și te anunță din nou.

Același lucru cu CLI-ul honk-me

Dacă preferi CLI-ul, care se ocupă singur de reîncercări, cu o singură cheie de idempotență și o limită totală de timp, instalează-l în pași care rulează doar la eșec și apelează problem. Go e deja instalat pe runnerele Linux găzduite de GitHub:

      - name: Install honk-me
        if: failure()
        run: |
          go install github.com/honk-me/honk-go/cmd/honk-me@latest
          echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"

      - name: Notify
        if: failure()
        env:
          HONK_URL: ${{ secrets.HONK_URL }}
          HONK_KEY: ${{ secrets.HONK_KEY }}
        run: |
          honk-me problem --group-key "ci/${{ github.repository }}/${{ github.ref_name }}" \
            --title "CI failed: ${{ github.workflow }}" --message "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" \
            --source github-actions --category deployments \
            --idempotency-key "gh-${{ github.run_id }}-${{ github.run_attempt }}" || true

Ce primești

Primul eșec pe main vine ca Claxon lung, iar din inbox deschizi rularea cu o atingere. Repetările de pe același branch actualizează un singur grup în loc să-ți mai vibreze telefonul, iar orele de liniște țin eșecurile din CI până dimineață, dacă nu le trimiți ca urgente. Ghidul pentru deploy-uri îți arată și cum îi spui lui Honk despre deploy-urile reușite.

Deocamdată, Honk e disponibil doar pe bază de invitație: cere acces. Tot ce face acest ghid merge și pe planul Free.