# OpenTelemetry i analityka dla Claude Code, Codex i Cursor

URL: https://developertoolkit.ai/pl/ecosystem/observability/agent-telemetry/
Description: Wyślij telemetrię Claude Code i Codeksa do lokalnego stosu Grafany, poznaj granice dashboardów analitycznych i powiąż commity z sesjami przez Entire CLI.

Telemetria agentów kodujących ma trzy warstwy: eksport OpenTelemetry do kolektora, który utrzymujesz sam, dashboardy analityczne dostawców do adopcji i atrybucji pull requestów oraz pochodzenie każdego commita z Entire CLI. Dashboard claude.ai nie pokazuje kosztu na użytkownika; daje go OpenTelemetry, raport wydatków albo, w planie Enterprise, Analytics API. Dla Cursora 26.09.2026 nie potwierdzono eksportu OpenTelemetry.

Ta strona jest dla **programisty**, który chce widzieć, co robią i ile kosztują jego sesje z agentem, oraz dla **tech leada**, który na najbliższym planowaniu musi odpowiedzieć na pytanie „czy wdrożenie agentów działa?”. Masz 12 licencji, fakturę i dashboard, według którego w zeszłym tygodniu aktywnych było 70% osób. Nikt nie potrafi powiedzieć, na które modele poszły pieniądze, które zmergowane pull requesty napisali agenci ani czy te zmiany przetrwały.

Kanoniczną stroną o produkcyjnych potokach telemetrii, retencji audytu i kluczach łączenia jest [obserwowalność agentów](/pl/workflows/operate/agent-observability/). [Przegląd narzędzi do obserwowalności i jakości](/pl/ecosystem/observability/) pokazuje, gdzie ta strona stoi obok narzędzi do kosztów, review, bezpieczeństwa i ewaluacji. Ta strona to półka z narzędziami: co eksportuje każdy produkt, lokalny stos uruchamiany jednym poleceniem i comiesięczny przegląd adopcji zbudowany na tych danych.

## Co daje ci ta konfiguracja telemetrii

- Działający lokalny stos: Claude Code i Codex eksportują OpenTelemetry do Grafany na twoim laptopie, a jedno zapytanie potwierdza, że dane docierają.
- PromQL dla sześciu paneli Claude Code, o które pyta tech lead: koszt według modelu, tokeny według typu, aktywni użytkownicy, sesje, odsetek zaakceptowanych edycji oraz commity i pull requesty.
- Jasną mapę tego, co pokazuje dashboard analityczny Claude Code, czego nie pokazuje (kosztu na użytkownika) i kiedy przestaje działać (Zero Data Retention).
- Entire CLI skonfigurowane dla każdego narzędzia, dzięki czemu z każdego commita dojdziesz do promptów i sesji, które go wytworzyły.
- Comiesięczny przegląd adopcji w czterech krokach i trzy prompty do skopiowania, które go automatyzują.

## Jaką telemetrię daje każde narzędzie?

Zacznij od tego, która warstwa odpowiada na które pytanie. Telemetria odpowiada na pytanie „co robiły sesje i ile kosztowały?”, analityka na „kto używa agenta i ile zmergowanego kodu z niego pochodzi?”, a pochodzenie commitów na „dlaczego ten commit wygląda właśnie tak?”.

| Warstwa | Claude Code 2.1.283 | Codex CLI 0.157.1 | Cursor |
| --- | --- | --- | --- |
| Eksport OpenTelemetry | Metryki i zdarzenia logów; ślady w becie (`CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1`) | Logi, ślady i metryki z `[otel]` w `config.toml` | Nie potwierdzono 26.09.2026 |
| Sygnał kosztu | `claude_code.cost.usage` (USD) z atrybutami `model`, `effort`, `query_source` | `codex.turn.cost_microusd` | Nie potwierdzono |
| Sygnał dostarczania | `claude_code.commit.count`, `claude_code.pull_request.count`, `claude_code.lines_of_code.count` | Brak metryki commitów i pull requestów w `codex-rs/otel` w tagu `rust-v0.157.1` | Nie potwierdzono |
| Dashboard dostawcy | `claude.ai/analytics/claude-code` (Team, Enterprise); `platform.claude.com/claude-code` (Console) | Dashboard analityczny Enterprise i Analytics API (źródło wtórne: strony pomocy OpenAI widziane tylko we fragmentach wyników wyszukiwania) | Dashboard analityczny Team/Enterprise i Analytics API; AI Code Tracking API (tylko Enterprise, według jego strony dokumentacji, sprawdzone 2026-10-12) przypisuje linie wygenerowane przez AI do commitów (źródło wtórne: dokumentacja cursor.com widziana tylko we fragmentach wyników wyszukiwania; endpointów nie potwierdzono) |
| Widok sesji na twojej maszynie | `/usage` (`/cost` i `/stats` to aliasy); `/insights` zapisuje raport HTML z ostatnich sesji | Zdarzenia `codex exec --json` dla każdego przebiegu | Nie potwierdzono |
| Pochodzenie commitów | Entire CLI (`entire enable --agent claude-code`) | Entire CLI (`--agent codex`) | Entire CLI (`--agent cursor`) |

Źródła: dokumentacja Claude Code o [monitorowaniu](https://code.claude.com/docs/en/monitoring-usage) i [analityce](https://code.claude.com/docs/en/analytics); kod źródłowy Codeksa (`codex-rs/config/src/types.rs` i `codex-rs/otel/src/metrics/names.rs` w tagu `rust-v0.157.1`); README `entireio/cli`; wszystko czytane 26.09.2026.

Wspólny słownik OpenTelemetry dla agentów (`invoke_agent`, `execute_tool`) znajduje się w repozytorium `open-telemetry/semantic-conventions-genai` i 26.09.2026 wciąż był oznaczony jako **Status: Development**, więc każde narzędzie używa własnych nazw. Buduj dziś dashboardy osobno dla każdego narzędzia i licz się ze zmianą nazw.

## Co pokazuje dashboard analityczny Claude Code, a czego nie?

Dashboard dla planów Team i Enterprise pod adresem `claude.ai/analytics/claude-code` to najszybszy widok adopcji. Ma cztery ograniczenia, które zmieniają sposób korzystania z niego:

- **Brak kosztu na użytkownika.** Pokazuje zaakceptowane linie, odsetek przyjętych sugestii, dzienną liczbę aktywnych użytkowników, sesje, metryki wkładu oraz ranking 10 osób z eksportem CSV wszystkich użytkowników. Tokeny i koszt na użytkownika dają OpenTelemetry albo raport wydatków w ustawieniach analityki organizacji.
- **Metryki wkładu wymagają GitHuba i są w publicznej becie.** Właściciel organizacji (rola Owner) włącza analitykę i przełącznik **GitHub analytics** na `claude.ai/admin-settings/claude-code`, a administrator GitHuba instaluje aplikację z `github.com/apps/claude`. Dane zwykle pojawiają się w ciągu 24 godzin. Liczą się tylko użytkownicy twojej organizacji claude.ai; użycie przez API w Console się nie liczy.
- **Zero Data Retention wyłącza metryki wkładu.** Organizacja z ZDR widzi tylko metryki użycia, więc atrybucja pull requestów musi pochodzić z twoich etykiet albo trailerów Entire.
- **Atrybucja jest celowo ostrożna.** Zmergowany pull request się liczy, gdy sesje Claude Code z okresu od 21 dni przed do 2 dni po merge'u pasują do dodanych linii. Kod przepisany w ponad 20% nie jest przypisywany, a pliki lock, wyniki buildów i snapshoty są pomijane. Przypisane pull requesty dostają na GitHubie etykietę `claude-code-assisted`.

Ta etykieta to najtańsze zapytanie o atrybucję, jakie masz. W wyszukiwarce GitHuba `is:pr is:merged label:claude-code-assisted` pokazuje każdy zmergowany pull request przypisany przez silnik, bez dostępu do API. W planie Enterprise Claude Enterprise Analytics API zwraca raporty zaangażowania, użycia i kosztów na użytkownika dla klucza z zakresem `read:analytics`; plan Team nie ma tego API. Klienci Console używają Claude Code Analytics API z kluczem Admin API, a sama Console zaznacza, że pokazywane wydatki są szacunkami, a nie danymi rozliczeniowymi.

## Wyślij telemetrię Claude Code i Codeksa do lokalnego stosu Grafany

To pełny przykład: jeden kontener, dwa agenty i jedno zapytanie, które dowodzi, że dane docierają. Działa na laptopie i kosztuje tylko miejsce na dysku. Obraz `grafana/otel-lgtm` zawiera OpenTelemetry Collector, Prometheusa, Loki, Tempo, Pyroscope i Grafanę; Grafana opisuje go jako przeznaczony do developmentu, demonstracji i testów, a nie do produkcji.

1. **Uruchom stos.** W terminalu:

    ```bash
    docker run --rm --name lgtm \
      -p 3000:3000 -p 4317:4317 -p 4318:4318 -p 9090:9090 \
      grafana/otel-lgtm
    ```

    Port 3000 to Grafana (logowanie `admin` / `admin`), 4317 to OTLP przez gRPC, 4318 to OTLP przez HTTP, a 9090 to Prometheus, który prompty poniżej odpytują bezpośrednio.

2. **Skieruj każdego agenta na kolektor.** Ustawienia różnią się między narzędziami.

      **Claude Code**

        Wyeksportuj zmienne w powłoce, z której uruchamiasz `claude`, albo wpisz te same klucze pod `env` w `~/.claude/settings.json`. Claude Code ignoruje zmienne eksporterów w `.claude/settings.json` i `.claude/settings.local.json` repozytorium, więc repozytorium nie może włączyć telemetrii ani jej przekierować.

        ```bash
        export CLAUDE_CODE_ENABLE_TELEMETRY=1
        export OTEL_METRICS_EXPORTER=otlp
        export OTEL_LOGS_EXPORTER=otlp
        export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
        export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
        export OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=cumulative
        export OTEL_METRIC_EXPORT_INTERVAL=10000
        export OTEL_METRICS_INCLUDE_REPOSITORY=true
        claude
        ```

        Claude Code nie ma domyślnego protokołu OTLP, więc `OTEL_EXPORTER_OTLP_PROTOCOL` jest wymagane. Domyślna temporalność to `delta`; dokumentacja każe przełączyć ją na `cumulative`, gdy wymaga tego backend, a stos oparty na Prometheusie przechowuje liczniki skumulowane. Interwał 10 sekund służy do testów; domyślnie jest to 60 sekund. `OTEL_METRICS_INCLUDE_REPOSITORY=true` (od v2.1.269) dodaje `vcs.repository.name` i pokrewne atrybuty, więc możesz filtrować po repozytorium.

        Treść promptów, dane wejściowe narzędzi i odpowiedzi pozostają zredagowane, dopóki nie ustawisz `OTEL_LOG_USER_PROMPTS`, `OTEL_LOG_TOOL_DETAILS` albo `OTEL_LOG_ASSISTANT_RESPONSES`. Tutaj zostaw je wyłączone.

      **Codex**

        Dodaj tabelę `[otel]` do `~/.codex/config.toml`. Nazwy pól pochodzą z `OtelConfigToml` w kodzie źródłowym Codeksa, a ten blok ładuje się bez błędu w codex-cli 0.157.1. Literówka w nazwie klucza jest w 0.157.1 po cichu ignorowana i zostawia ten eksporter na wartości domyślnej; literówka w nazwie eksportera, na przykład `otlp-grcp`, kończy start błędem `Error loading config.toml: unknown variant`:

        ```toml
        [otel]
        environment = "dev"
        log_user_prompt = false
        exporter = { otlp-grpc = { endpoint = "http://localhost:4317" } }
        trace_exporter = { otlp-grpc = { endpoint = "http://localhost:4317" } }
        metrics_exporter = { otlp-grpc = { endpoint = "http://localhost:4317" } }
        ```

        Ustaw wszystkie trzy eksportery. W 0.157.1 eksportery logów i śladów mają domyślnie wartość `none`, a `metrics_exporter` domyślnie `statsig`, czyli wewnętrzny cel Codeksa. Dla kolektora HTTP użyj `otlp-http = { endpoint = "...", protocol = "binary" }` z pełną ścieżką sygnału (na przykład `http://localhost:4318/v1/logs`). Nagłówki dla kolektora z uwierzytelnianiem trafiają do tabeli `headers = { ... }` jawnym tekstem, więc zapisuj ten plik z menedżera sekretów i nigdy go nie commituj.

        Szukaj między innymi metryk `codex.thread.started`, `codex.turn.token_usage`, `codex.turn.cost_microusd`, `codex.tool.call` i `codex.api_request`.

      **Cursor**

        26.09.2026 nie udało się potwierdzić eksportu OpenTelemetry z Cursora, więc Cursor nic do tego stosu nie wysyła. Dwie potwierdzone drogi dają część obrazu:

        - **Entire CLI** zapisuje sesje Cursora przy każdym commicie przez `.cursor/hooks.json` (zobacz niżej [powiązanie commita z sesją](#powiąż-commit-z-sesją-agenta-za-pomocą-entire-cli)).
        - **Hooki Cursora** dostają zdarzenia agenta jako JSON przez stdio (potwierdzone 28.08.2026), więc hook może dopisywać zdarzenia do pliku, który czyta twój kolektor. Strona o hookach Cursora wymienia nazwy zdarzeń takie jak `sessionStart`, `preToolUse`, `postToolUse`, `beforeShellExecution`, `afterFileEdit`, `stop`, `subagentStart` i `subagentStop` (sprawdzone 2026-10-12); sprawdź ją ponownie, zanim zbudujesz na nich panele.

        Do użycia i wydatków zespołu Cursor ma dashboard analityczny Team/Enterprise i Analytics API, a także AI Code Tracking API (tylko Enterprise, według jego strony dokumentacji, sprawdzone 2026-10-12), które przypisuje linie wygenerowane przez AI do commitów (źródło wtórne: dokumentacja cursor.com widziana tylko we fragmentach wyników wyszukiwania; endpointów nie potwierdzono). Sprawdź, co twój plan faktycznie eksportuje, zanim komukolwiek obiecasz liczbę.

3. **Sprawdź, czy dane docierają.** Uruchom po jednej krótkiej sesji w każdym agencie, otwórz Grafanę pod `http://localhost:3000`, przejdź do **Explore**, wybierz źródło danych Prometheus i uruchom:

    ```promql
    {__name__=~"claude_code_session_count.*|codex_thread_started.*"}
    ```

    Dla Claude Code w ciągu około 10 sekund zobaczysz po jednej serii na start sesji. Kropki w nazwach OpenTelemetry zmieniają się w Prometheusie w podkreślenia, a Prometheus może dopisać jednostkę lub sufiks `_total`, dlatego każde zapytanie tutaj dopasowuje nazwę po prefiksie. Zdarzenia znajdziesz, wybierając źródło Loki i szukając `user_prompt`. Jeśli nic nie dociera, uruchom `claude --debug-file /tmp/claude-otel.log` i poszukaj w tym pliku `[3P telemetry]`; linie oznaczone `[Anthropic telemetry]` to operacyjna telemetria samego Anthropic i nie wskazują problemu.

4. **Zbuduj sześć paneli Claude Code.** Utwórz dashboard z jednym panelem na zapytanie, każdy dla zakresu 7 dni:

    ```promql
    # Cost by model (USD, client-side estimate)
    sum by (model) (increase({__name__=~"claude_code_cost_usage.*"}[7d]))

    # Tokens by type: input, output, cacheRead, cacheCreation
    sum by (type) (increase({__name__=~"claude_code_token_usage.*"}[7d]))

    # Active users (count only; never chart per person)
    count(count by (user_email) (increase({__name__=~"claude_code_session_count.*"}[7d]) > 0))

    # Sessions by start type: fresh, resume, continue, agents_view
    sum by (start_type) (increase({__name__=~"claude_code_session_count.*"}[7d]))

    # Edit accept rate: Edit, Write, NotebookEdit decisions
    sum(increase({__name__=~"claude_code_code_edit_tool_decision.*", decision="accept"}[7d]))
      / sum(increase({__name__=~"claude_code_code_edit_tool_decision.*"}[7d]))

    # Commits and pull requests the agent created
    sum(increase({__name__=~"claude_code_commit_count.*|claude_code_pull_request_count.*"}[7d]))
    ```

    Panel odsetka akceptacji liczy każdą decyzję, także edycje zaakceptowane bez udziału człowieka przez ustawienia, tryb uprawnień albo hook (`source="config"` lub `source="hook"`), więc w liberalnych trybach zbliża się do 100%. Żeby zmierzyć akceptację przez ludzi, dodaj filtr `source=~"user_.*"` w liczniku i mianowniku.

    Przy seriach per sesja `increase()` pomija pierwszą próbkę każdej serii, więc krótkie sesje są niedoliczane. Do sum, które uzgadniasz z fakturą, użyj `sum by (model) (max_over_time({__name__=~"claude_code_cost_usage.*"}[7d]))` albo ustaw `OTEL_METRICS_INCLUDE_SESSION_ID=false` dla metryk dashboardu.

    Jeśli brakuje etykiety takiej jak `user_email`, otwórz metrykę w Explore i użyj nazwy etykiety, którą pokazuje twój stos. Panele Codeksa dodasz tak samo, gdy pojawią się serie `codex_`.

5. **Przejdź z laptopa na zespół.** Gdy panele odpowiadają na prawdziwe pytania, zastąp kontener produkcyjnym kolektorem i rozprowadź zmienne Claude Code przez [ustawienia zarządzane](/pl/org/managed-policy/), które nadpisują zmienne eksporterów ustawione przez programistów. Dla rotowanego tokenu kolektora wskaż w ustawieniach `otelHeadersHelper` skrypt, który wypisuje nagłówki jako JSON; Claude Code domyślnie uruchamia go ponownie co 29 minut. Produkcyjny potok (strumień analityczny z pseudonimizacją, strumień audytowy z tożsamościami, retencja) opisuje strona [obserwowalność agentów](/pl/workflows/operate/agent-observability/).

Dwa otwarte stosy referencyjne oszczędzą ci pracy nad dashboardem, jeśli potrzebujesz więcej niż sześciu paneli. Stan na 26.09.2026 (gwiazdki GitHuba odczytane przez GitHub API na potrzeby katalogu badawczego serwisu): `ColeMurray/claude-code-otel` (506 gwiazdek) to stos Docker Compose z kolektorem, Prometheusem, Loki i Grafaną oraz gotowymi dashboardami kosztów, narzędzi, użytkowników i sesji (`make up`); `anthropics/claude-code-monitoring-guide` (370 gwiazdek) to przewodnik Anthropic o ROI z plikami `docker-compose.yml`, `otel-collector-config.yaml`, dashboardami Grafany i promptem do generowania raportów. Żaden nie obejmuje Codeksa.

**Ile telemetria kosztuje w kontekście**

Eksport OpenTelemetry konfigurujesz zmiennymi środowiskowymi i `config.toml`, więc nie dodaje on żadnych tokenów do kontekstu agenta. Jeśli połączysz agenta z Grafaną przez serwer Grafana MCP (`uvx mcp-grafana`, opisany na [stronie o serwerach MCP do obserwowalności](/pl/ecosystem/mcp/observability-mcp/)), jego schematy narzędzi trafiają do kontekstu: uruchom `/context` w Claude Code przed dodaniem serwera i po nim.

## Powiąż commit z sesją agenta za pomocą Entire CLI

Metryki powiedzą ci, że w zeszłym tygodniu 40 commitów powstało w sesjach agentów. Nie powiedzą, dlaczego konkretna linia w `billing/retry.ts` wygląda tak, jak wygląda. Tę lukę wypełnia Entire CLI (Entire Inc., licencja MIT, `entireio/cli`): instaluje hooki gita i hooki dla każdego agenta, podczas pracy agenta zapisuje prompty, transkrypt, wywołania narzędzi, zmienione pliki i zużycie tokenów, a przy commicie łączy je w checkpoint powiązany trailerem `Entire-Checkpoint: <id>`. Entire nigdy nie tworzy commitów na twojej gałęzi.

Popularność na 26.09.2026: 5,1 tys. gwiazdek na GitHubie; najnowsza stabilna wersja v0.11.3, wydana 25.09.2026 (GitHub API i strona wydań). To binarka w Go; pakiet npm `entire` to niezwiązany projekt.

**Claude Code**

    ```bash
    brew install --cask entireio/tap/entire
    cd your-project
    entire enable --agent claude-code   # hooks land in .claude/settings.json
    entire status
    ```

**Codex**

    ```bash
    brew install --cask entireio/tap/entire
    cd your-project
    entire enable --agent codex         # hooks land in .codex/hooks.json
    entire status
    ```

**Cursor**

    ```bash
    brew install --cask entireio/tap/entire
    cd your-project
    entire enable --agent cursor        # hooks land in .cursor/hooks.json
    entire status
    ```

Kolejnego agenta dodasz później poleceniem `entire agent add codex`. Ustawienia zespołu trafiają do `.entire/settings.json`, a osobiste nadpisania do ignorowanego przez gita `.entire/settings.local.json`. README podaje też inne sposoby instalacji: skrypt instalacyjny, Scoop w Windows i `go install`.

Przegląd pull requesta napisanego przez agenta wygląda wtedy tak:

```bash
git log -1 --format=%B                        # message ends with: Entire-Checkpoint: <id>
entire checkpoint explain <CHECKPOINT_ID>     # prompts, transcript, files touched, tokens
entire search "rate limiter retry"            # search across checkpoints, commits and sessions
```

`CHECKPOINT_ID` to wartość po `Entire-Checkpoint:` w wiadomości commita. Checkpointy są zapisywane jako refy gita pod `refs/entire/checkpoints/` i wypychane zwykłym `git push`; starsza pojedyncza gałąź `entire/checkpoints/v1` to starszy backend (legacy).

**Entire przechowuje transkrypty w twoim repozytorium**

Każdy, kto może czytać repozytorium, może czytać checkpointy. Redakcja sekretów działa przed zapisaniem checkpointu, ale według dokumentacji jest „best effort”, a krótkotrwałe gałęzie pomocnicze (shadow branches) zawierają surowe migawki katalogu roboczego, których nigdy nie wolno wypychać ręcznie. W publicznym repozytorium wysyłaj checkpointy do prywatnego poleceniem `entire enable --checkpoint-remote github:your-org/checkpoints`. Entire domyślnie wysyła anonimową telemetrię użycia do PostHoga; wyłączysz ją flagą `--telemetry=false`.

## Przeprowadź comiesięczny przegląd adopcji: użycie, atrybucja, wyniki

Telemetria opłaca się tylko wtedy, gdy prowadzi do decyzji. Opisany niżej przegląd odbywa się co miesiąc, a jego właścicielem jest tech lead. Stosuje podział na wykorzystanie, wpływ i koszt, którego używa AI Measurement Framework firmy DX (źródło wtórne: strona badań DX widziana we fragmencie wyników wyszukiwania), z definicjami metryk ze strony serwisu o [frameworkach metryk](/pl/org/metrics-frameworks/).

1. **Użycie: kto używa którego agenta, na jakich modelach i za ile.** Pobierz aktywnych użytkowników, sesje i koszt według modelu z paneli Grafany (Claude Code i Codex) oraz z dashboardów dostawców (wszystkie trzy narzędzia). Porównaj liczbę aktywnych użytkowników z liczbą opłaconych licencji. Raportuj koszt według modelu i repozytorium, nigdy według osoby.

2. **Atrybucja: które zmergowane zmiany powstały z udziałem agenta.** Połącz trzy źródła, od najmocniejszego: własną etykietę pull requesta `agent-assisted` albo pole wyboru w szablonie, etykietę `claude-code-assisted` z dashboardu Claude Code i trailery `Entire-Checkpoint` w zmergowanych commitach. Pull request z którymkolwiek z nich liczy się jako wspomagany przez agenta. Sama etykieta dostawcy zaniża wynik, bo pomija Codeksa i Cursora i jest celowo ostrożna.

3. **Wyniki: czy te zmiany przetrwały.** Dla kohorty wspomaganej przez agenta i dla pozostałych zmian policz odsetek przyjętych zmian, odsetek poprawek w ciągu 14 dni i czas review, zgodnie z definicjami ze strony o metrykach. Podziel miesięczne wydatki na agentów (licencje plus użycie) przez liczbę przyjętych zmian wspomaganych przez agenta, aby dostać koszt przyjętej zmiany.

4. **Zdecyduj i zapisz.** Wybierz najwyżej dwie zmiany na kolejny miesiąc (zmianę modelu, poprawkę pliku kontekstowego, szkolenie dla repozytorium z niską adopcją) i zapisz, która liczba powinna się poruszyć. Tech lead zatwierdza przegląd; kolejny przegląd sprawdza, czy liczba się poruszyła.

**Prompt do skopiowania: skonfiguruj i sprawdź lokalną telemetrię agentów**

```text
Set up local OpenTelemetry for my coding agents and prove it works. Do not change any repository files.

1. Check whether Docker is running. Start grafana/otel-lgtm with ports 3000, 4317, 4318 and 9090 published, container name lgtm.
2. Print the shell exports I need for Claude Code: CLAUDE_CODE_ENABLE_TELEMETRY=1, OTLP metrics and logs exporters, protocol grpc, endpoint http://localhost:4317, cumulative metrics temporality, a 10-second metric interval, OTEL_METRICS_INCLUDE_REPOSITORY=true. Keep prompt, tool-detail and response logging off.
3. Show the [otel] block for ~/.codex/config.toml with exporter, trace_exporter and metrics_exporter all set to otlp-grpc at http://localhost:4317. If ~/.codex/config.toml already has an [otel] table, show a diff instead of overwriting it.
4. After I run one session in each agent, query Prometheus at http://localhost:9090/api/v1/label/__name__/values and list every metric name starting with claude_code_ or codex_.
5. If a list is empty, tell me the most likely cause from this checklist: missing protocol variable, exporter variables placed in project settings, metrics_exporter left at its default, wrong port.
```

**Prompt do skopiowania: szkic comiesięcznego przeglądu adopcji agentów**

```text
Draft this month's agent adoption review for the repository in the current directory. Read-only: use gh and the Prometheus HTTP API at http://localhost:9090 only, and write nothing to GitHub.

Usage: from Prometheus, report 30-day increase of claude_code cost by model, token usage by type, distinct active users (a count only) and sessions. List any codex_ metrics present with their 30-day totals.

Attribution: list merged PRs from the last 30 days. Mark a PR agent-assisted if it has the label agent-assisted or claude-code-assisted, or if any of its commits has an Entire-Checkpoint trailer. Report counts per source and the combined cohort size.

Outcomes: for the agent-assisted cohort and the others, compute median time from open to merge, and the share of PRs reverted or referenced by a later PR whose title starts with "fix" within 14 days. Mark each heuristic.

Output one Markdown page: a table per section, three observations, and two proposed changes for next month with the number each should move. Never report any metric per individual engineer. Before finishing, spot-check five PRs by hand against your cohort assignment and show the comparison.
```

**Prompt do skopiowania: wyjaśnij commit napisany przez agenta**

```text
Explain why the most recent commit that touched src/billing/retry.ts was written the way it was.

1. Find the commit with git log -1 -- src/billing/retry.ts and read its message.
2. If it has an Entire-Checkpoint trailer, run entire checkpoint explain on that id and summarise: the original prompt, what the agent tried first, which tests it ran, and anything it left open.
3. If there is no trailer, say so, and fall back to the pull request description and review comments through gh pr list --search <sha> --state merged.
4. End with one sentence: is the current behaviour intended by the prompt, or an agent side effect that needs a test?
```

## Skąd wiesz, że liczby z telemetrii są prawdziwe?

Dashboard, którego nikt nie sprawdził, to opinia. Zweryfikuj go raz przy konfiguracji, a potem co miesiąc, bez czytania żadnego diffu agenta:

- **Uzgodnij koszt z fakturą.** `claude_code.cost.usage` i `codex.turn.cost_microusd` są liczone po stronie klienta, a Console sama zaznacza, że jej dane o wydatkach są szacunkami. Porównaj miesięczną sumę z telemetrii z fakturą; raportujesz liczbę z faktury, a telemetria służy do jej rozbicia.
- **Przetestuj każdy obraz maszyny.** Jedna sesja na każdy obraz laptopa i obraz CI, a po niej zapytanie z kroku 3. Obraz CI bez zmiennych to cicha dziura w każdej sumie.
- **Sprawdź wyrywkowo atrybucję.** Weź pięć zmergowanych pull requestów i potwierdź każdą etykietę albo trailer Entire z sesją, która je wytworzyła. Zapisz odsetek błędów na stronie przeglądu.
- **Alarmuj o ciszy.** Alert Grafany „brak danych `claude_code_session_count` przez 24 godziny w dniu roboczym” wyłapie zepsuty eksporter wcześniej niż comiesięczny przegląd.
- **Trzymaj tożsamości z dala od analityki.** Przegląd liczy użytkowników, ale nigdy ich nie szereguje. Strona o [ścieżkach kariery](/pl/org/career-ladders/) wyjaśnia, dlaczego liczby tokenów czy pull requestów na osobę stają się celami, pod które ludzie zaczynają optymalizować pracę (prawo Goodharta).

**Pułapki: ustawienia telemetrii, które wyglądają dobrze, a nie działają**

- `CLAUDE_CODE_TELEMETRY=1` nic nie robi; właściwa zmienna to `CLAUDE_CODE_ENABLE_TELEMETRY=1`, a nic nie jest eksportowane, dopóki nie ustawisz `OTEL_METRICS_EXPORTER` lub `OTEL_LOGS_EXPORTER`.
- Zmienne eksporterów w `.claude/settings.json` repozytorium są celowo ignorowane.
- `/cost` nie jest osobnym poleceniem; to alias `/usage`, podobnie jak `/stats`.
- Dashboard Claude Code nie ma widoku kosztu na użytkownika; użyj OpenTelemetry albo raportu wydatków.
- Nieustawiony `metrics_exporter` w Codeksie 0.157.1 oznacza `statsig`, a nie „wyłączone”.
- Literówka w nazwie klucza `[otel]` w Codeksie 0.157.1 nie daje błędu; eksporter po prostu zostaje na wartości domyślnej.
- `npm i entire` instaluje niezwiązany pakiet; Entire CLI to cask Homebrew `entireio/tap/entire`.
- `grafana/otel-lgtm` to obraz deweloperski; nie rób z niego głównego systemu danych zespołu.

## Co się psuje przy zbieraniu telemetrii agentów i jak to naprawić?

**Claude Code działa, ale metryki nie docierają.** Zwykle brakuje `OTEL_EXPORTER_OTLP_PROTOCOL` albo zmienne trafiły do ustawień projektu. Naprawa: ustaw protokół, przenieś zmienne do powłoki, ustawień użytkownika lub ustawień zarządzanych i sprawdź w pliku debugowania błędy `[3P telemetry]`.

**Metryki docierają, ale panele są puste albo skaczą.** Temporalność delta trafia do backendu, który oczekuje wartości skumulowanych. Naprawa: ustaw `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=cumulative` i uruchom sesję ponownie.

**Brakuje telemetrii Codeksa.** Albo nazwa klucza ma literówkę (Codex po cichu ją ignoruje), albo `[otel]` leży w innym `CODEX_HOME` niż ten, z którego czyta sesja. Naprawa: potwierdź `CODEX_HOME`, a potem porównaj swoje klucze z `exporter`, `trace_exporter` i `metrics_exporter`. Zgłoszony problem (openai/codex#12913, status niepotwierdzony dla 0.157.1) mówi, że `codex exec` nie emituje metryk OpenTelemetry, więc sprawdź przebiegi headless osobno, zanim zbudujesz na nich panele.

**Magazyn Prometheusa szybko rośnie.** `session.id` jest domyślnie na każdej metryce Claude Code, więc każda sesja to nowa seria. Naprawa: w dużym zespole ustaw `OTEL_METRICS_INCLUDE_SESSION_ID=false` i trzymaj identyfikatory sesji w zdarzeniach logów, gdzie kardynalność jest tania.

**Przegląd adopcji pokazuje, że wygrywa Claude Code, a Codeksa nie widać.** Etykieta dostawcy przypisuje tylko Claude Code, a Codex 0.157.1 nie emituje metryki commitów. Naprawa: przypisuj przez własną etykietę `agent-assisted` i trailery Entire, które obejmują wszystkie trzy narzędzia.

**Sekret pojawia się w magazynie logów.** Ktoś włączył `OTEL_LOG_TOOL_DETAILS` albo `OTEL_LOG_USER_PROMPTS`. Naprawa: zrotuj sekret, usuń rekordy i kieruj treść wyłącznie do potoku audytowego opisanego na stronie [obserwowalność agentów](/pl/workflows/operate/agent-observability/).

**Atrybucja pull requestów znika po zmianie umowy.** Zero Data Retention wyłącza metryki wkładu. Naprawa: trzymaj własną etykietę i trailery Entire jako podstawową atrybucję, aby przegląd nie zależał od jednej funkcji dostawcy.

## Dokąd dalej z telemetrią agentów

- [Pomiar pracy z agentami](/pl/ecosystem/observability/) — Przegląd narzędzi do telemetrii, kosztów, review, bezpieczeństwa i ewaluacji oraz tego, co włączyć najpierw.
- [Obserwowalność agentów](/pl/workflows/operate/agent-observability/) — Potok produkcyjny: kolektor z rozdzielonymi strumieniami, klucze łączenia z pull requestami, retencja audytu.
- [Frameworki metryk](/pl/org/metrics-frameworks/) — Kanoniczne definicje odsetka przyjętych zmian, odsetka poprawek i kosztu przyjętej zmiany.
- [Ile kosztowali agenci?](/pl/ecosystem/observability/agent-cost-tracking/) — ccusage, /usage i budżety w bramkach dla wydatków na programistę i na zespół.
- [Serwery MCP do obserwowalności](/pl/ecosystem/mcp/observability-mcp/) — Pozwól agentowi odpytywać Grafanę, Sentry, Datadoga i PostHoga w trybie tylko do odczytu.
- [Pakiet dowodów](/pl/workflows/ship/evidence-bundle/) — Kontrakt pull requesta, którego pola pochodzenia przenoszą identyfikator sesji.
- [Prywatność i przetwarzanie danych](/pl/org/privacy-data-handling/) — Warunki dostawców, Zero Data Retention i to, co może zawierać telemetria.
