# `PhoenixReplay.Telemetry`
[🔗](https://github.com/elixir-vibe/phoenix_replay/blob/v0.6.2/lib/phoenix_replay/telemetry.ex#L1)

Telemetry events emitted by PhoenixReplay.

Each event is emitted once its effect is complete: the session is no
longer buffered and, for `:persisted`, the recording is in storage.

  * `[:phoenix_replay, :recording, :persisted]` — a recording was saved.
    Measurements: `%{event_count: integer, duration_ms: integer}`.
    Metadata: `%{id: String.t(), view: module}`.
  * `[:phoenix_replay, :recording, :discarded]` — a session ended and was
    not saved, because it had no user interaction or was not sampled by
    `keep: [rate: ...]`. Metadata: `%{id: String.t(), reason:
    :not_interactive | :not_sampled}`.
  * `[:phoenix_replay, :recording, :failed]` — a recording could not be
    saved and was dropped. Metadata: `%{id: String.t(), reason: term}`.
  * `[:phoenix_replay, :recording, :recovered]` — a session whose node
    stopped before it ended was saved from its chunks when the
    application started. Measurements and metadata as for `:persisted`.

Collector failures are emitted where they happen:

  * `[:phoenix_replay, :collector, :exception]` — a
    `PhoenixReplay.Collector`, the log handler or LiveComponent recording
    raised while handling an event, which was not recorded. Metadata:
    `%{collector: module, event: [atom], kind: atom, reason: term,
    stacktrace: list}`.

# `collector_failed`

```elixir
@spec collector_failed(module(), [atom()], atom(), term(), Exception.stacktrace()) ::
  :ok
```

Emits `[:phoenix_replay, :collector, :exception]`.

# `discarded`

```elixir
@spec discarded(
  PhoenixReplay.Recording.id(),
  PhoenixReplay.Session.TailSampling.reason()
) :: :ok
```

Emits `[:phoenix_replay, :recording, :discarded]`.

# `failed`

```elixir
@spec failed(PhoenixReplay.Recording.id(), term()) :: :ok
```

Emits `[:phoenix_replay, :recording, :failed]`.

# `persisted`

```elixir
@spec persisted(PhoenixReplay.Recording.t()) :: :ok
```

Emits `[:phoenix_replay, :recording, :persisted]`.

# `recovered`

```elixir
@spec recovered(PhoenixReplay.Recording.t()) :: :ok
```

Emits `[:phoenix_replay, :recording, :recovered]`.

---

*Consult [api-reference.md](api-reference.md) for complete listing*
