# `PhoenixMicro.Telemetry`
[🔗](https://github.com/iamkanishka/phoenix_micro/blob/v1.0.0/lib/phoenix_micro/telemetry.ex#L1)

Centralised Telemetry event definitions and emission helpers.

## Events emitted

| Event | Measurements | Metadata |
|-------|-------------|----------|
| `[:phoenix_micro, :message, :received]` | `%{count: 1}` | topic, transport, attempt |
| `[:phoenix_micro, :message, :processed]` | `%{duration: t}` | topic, transport, consumer |
| `[:phoenix_micro, :message, :failed]` | `%{count: 1}` | topic, reason, final |
| `[:phoenix_micro, :message, :published]` | `%{count: 1}` | topic, transport, batched |
| `[:phoenix_micro, :rpc, :request]` | `%{count: 1}` | topic, correlation_id |
| `[:phoenix_micro, :rpc, :response]` | `%{duration: t}` | topic, correlation_id |
| `[:phoenix_micro, :rpc, :timeout]` | `%{count: 1}` | topic, correlation_id |
| `[:phoenix_micro, :transport, :connected]` | `%{count: 1}` | transport |
| `[:phoenix_micro, :transport, :disconnected]` | `%{count: 1}` | transport, reason |

## Attaching a default logger handler

In your application's `start/2`:

    PhoenixMicro.Telemetry.attach_default_logger()

# `attach_default_logger`

```elixir
@spec attach_default_logger(keyword()) :: :ok
```

Attaches a default Logger-based Telemetry handler for all PhoenixMicro events.
Useful for development; in production prefer structured metrics exporters.

# `message_failed`

```elixir
@spec message_failed(String.t(), map()) :: :ok
```

Emits a message_failed event.

# `message_processed`

```elixir
@spec message_processed(String.t(), map()) :: :ok
```

Emits a message_processed event with duration.

# `message_published`

```elixir
@spec message_published(String.t(), map()) :: :ok
```

Emits a message_published event.

# `message_received`

```elixir
@spec message_received(String.t(), map()) :: :ok
```

Emits a message_received event.

# `metrics`

```elixir
@spec metrics() :: [struct()]
```

Returns a list of `Telemetry.Metrics` metric definitions.

## Usage with Phoenix

    # In your Telemetry module
    def metrics do
      PhoenixMicro.Telemetry.metrics() ++ [
        # your other metrics
      ]
    end

# `rpc_request`

```elixir
@spec rpc_request(String.t(), map()) :: :ok
```

Emits an RPC request event.

# `rpc_response`

```elixir
@spec rpc_response(String.t(), map()) :: :ok
```

Emits an RPC response event with duration.

# `rpc_timeout`

```elixir
@spec rpc_timeout(String.t(), map()) :: :ok
```

Emits an RPC timeout event.

# `transport_connected`

```elixir
@spec transport_connected(atom()) :: :ok
```

Emits a transport_connected event.

# `transport_disconnected`

```elixir
@spec transport_disconnected(atom(), term()) :: :ok
```

Emits a transport_disconnected event.

---

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