# Alerte pe iPhone pentru eșecurile din GitHub Actions

> Eșecurile din GitHub Actions ajung pe iPhone cu un singur pas în workflow, grupate pe repository și branch, cu o revenire când branch-ul e iar verde.

Source: https://honk-me.app/ro/ghiduri/alerte-esec-github-actions

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](https://honk-me.app/ro/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:

```sh
# 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:

```yaml
      - 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:

```yaml
      # 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:

```yaml
      - 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](https://honk-me.app/ro/ghiduri/notificari-deploy) îți arată și cum îi spui lui Honk despre deploy-urile reușite.