A roadrunner event handler that emits every roadrunner event as a telemetry event.

Roadrunner hands its request, connection, and WebSocket events to one roadrunner_event_handler and drops them by default. Make this module the handler to get them as telemetry events, and from there into telemetry_metrics, Prometheus, OpenTelemetry, or your own handlers:

%% sys.config
[{roadrunner, [{event_handler, roadrunner_telemetry}]}].

Then attach handlers as usual:

telemetry:attach(log_requests, [roadrunner, request, stop],
    fun(_Event, #{duration := D}, #{method := M, path := P, status := S}, _) ->
        Us = erlang:convert_time_unit(D, native, microsecond),
        logger:info("~s ~s -> ~p (~p us)", [M, P, S, Us])
    end, undefined).

Events

Durations are in native time units: convert them with erlang:convert_time_unit/3. Each event's meaning is described in roadrunner_event_handler.

The request events follow the telemetry span convention: start carries system_time and monotonic_time, stop and exception carry duration and monotonic_time, and all three share a telemetry_span_context in their metadata, so tools that pair span events (such as opentelemetry_telemetry) can pair them.

• [roadrunner, request, start]
  • Measurements: system_time, monotonic_time
  • Metadata: request_id, peer, method, path, scheme, listener_name, telemetry_span_context, plus client_ip when the listener resolved one behind a trusted proxy
• [roadrunner, request, stop]
  • Measurements: duration, monotonic_time
  • Metadata: the start metadata plus status and response_kind
• [roadrunner, request, exception]
  • Measurements: duration, monotonic_time
  • Metadata: the start metadata plus kind, reason and stacktrace
• [roadrunner, request, rejected]
  • Measurements: system_time
  • Metadata: listener_name, peer, reason
• [roadrunner, request, throttled]
  • Measurements: system_time
  • Metadata: listener_name, reason
• [roadrunner, response, send_failed]
  • Measurements: system_time
  • Metadata: phase, reason, plus the connection's logger process metadata when it was set (request_id, peer, method, path)
• [roadrunner, listener, accept]
  • Measurements: system_time
  • Metadata: listener_name, peer
• [roadrunner, listener, conn_close]
  • Measurements: duration
  • Metadata: listener_name, peer, requests_served, reason
• [roadrunner, listener, conn_rejected]
  • Measurements: system_time
  • Metadata: listener_name, reason
• [roadrunner, listener, accept_error]
  • Measurements: system_time
  • Metadata: listener_name, reason
• [roadrunner, listener, slots_reconciled]
  • Measurements: system_time
  • Metadata: listener_name, released, counter_was, live_conns_bounded
• [roadrunner, drain, acknowledged]
  • Measurements: system_time
  • Metadata: listener_name, peer, request_id, deadline
• [roadrunner, ws, upgrade]
  • Measurements: system_time
  • Metadata: listener_name, peer, request_id, module
• [roadrunner, ws, frame_in] and [roadrunner, ws, frame_out]
  • Measurements: system_time, payload_size
  • Metadata: the upgrade metadata plus opcode
• [roadrunner, ws, frame_rejected]
  • Measurements: system_time, size
  • Metadata: the upgrade metadata plus reason

An event roadrunner adds before this package knows it is dropped.

Stability

An event's name, and the measurement and metadata keys listed above, follow the stability of the roadrunner event they come from (see roadrunner_event_handler): [roadrunner, request, start | stop], [roadrunner, ws, upgrade], and [roadrunner, ws, frame_out] are stable. Any event may gain keys in a minor release.

Cost

Every event goes through telemetry:execute/3, which looks its handlers up in an ETS table shared by every scheduler. Once your handlers are attached, call telemetry:persist/0 to move that table into persistent_term, which makes the lookup much cheaper under load.