Recordings hold the assigns your users saw and the params they sent. Treat them like application data.
Protect the dashboard
Mount the dashboard behind authentication, in a scope whose pipeline requires an admin, and pass your authentication hooks to :on_mount:
scope "/admin" do
pipe_through [:browser, :require_admin]
phoenix_replay "/replay", on_mount: [{MyAppWeb.UserAuth, :ensure_admin}]
endFor rules per recording or action, add a PhoenixReplay.Authorization module; see Dashboard. Without one, everyone who reaches the dashboard can list, view and delete every recording.
Sanitizing
Everything recorded passes through a PhoenixReplay.Sanitizer before it is stored: assigns with sanitize_assigns/1, and event params, URL params and the session with sanitize_params/1.
PhoenixReplay.Sanitizer.Default:
- replaces the values of keys containing
password,token,secret,api_key,apikey,private_key,credential,card_number,credit_cardorone_time, in any case, with"[FILTERED]"; keys are kept so templates still render, - in params and form values, also filters keys with
cvv,cvc,csc,ssn,pinorotpas a word of their own (card_cvv,pinCode, but notshipping); assigns keep those, since an assign such as:pinis rarely a secret and a filtered one can break the replay, - recurses into maps, lists, tuples and structs, including Ecto schemas,
- compacts
Ecto.ChangesetandPhoenix.HTML.Formruntime metadata, - drops LiveView internals that cannot be replayed.
Custom sanitizers
Implement the behaviour and delegate to the default for what you keep:
defmodule MyApp.ReplaySanitizer do
@behaviour PhoenixReplay.Sanitizer
@impl true
def sanitize_assigns(assigns) do
assigns
|> Map.drop([:current_user, :billing_address])
|> PhoenixReplay.Sanitizer.Default.sanitize_assigns()
end
@impl true
defdelegate sanitize_params(params), to: PhoenixReplay.Sanitizer.Default
endconfig :phoenix_replay, sanitizer: MyApp.ReplaySanitizerA sanitizer can also be set per live session with on_mount: [{PhoenixReplay.Recorder, sanitizer: MyApp.CheckoutSanitizer}]. Keep sanitizers free of exceptions: they run inside your LiveViews.
Redacting values
A sanitizer runs inside your LiveViews on every event, so it filters by key, which is cheap. An email address typed into a form, a card number in a log message or a phone number in SQL carries no telling key. Finding those takes detection, so a PhoenixReplay.Redactor masks them when a session is saved, in a background task, where its cost never reaches your users.
Mask matches of your own patterns:
config :phoenix_replay, redact: [~r/\b\d{13,19}\b/, ~r/[\w.+-]+@[\w-]+\.[\w.]+/]Or detect personal data with Obscura, an optional dependency:
def deps do
[{:obscura, "~> 0.2"}]
endconfig :phoenix_replay, redact: {PhoenixReplay.Redactor.Obscura, []}PhoenixReplay.Redactor.Obscura finds emails, phone numbers, card numbers, US social security numbers, IBANs and IP addresses, and replaces them with placeholders such as "[EMAIL]". Choose others with entities:.
The redactor sees every string in a recording: its URL, params and session, assigns, event params, and collected SQL, logs and exit reasons. Struct types are kept, so templates still render; a template that parses a redacted value may render differently than it did live.
Sessions still running are redacted when the dashboard opens them, so they show the same values as once they are saved. The player shows the redaction's progress meanwhile. If a redactor fails, the session is not saved and the dashboard does not show it: nothing unredacted is stored or displayed. The buffer of running sessions holds sanitized but unredacted values in memory until they are saved.
Ecto query parameters and URL query strings are left out of collected events unless you enable them.
What the browser sends
With the client module's replayParams and replayMetadata, the browser sends, when the LiveView connects and as they change:
- the viewport's width, height and pixel ratio, and the screen's orientation angle,
- the media settings the page's CSS can see: the color scheme, reduced motion, contrast, whether the pointer is a finger or a mouse, and whether it hovers,
- an id for the browser tab, kept in
sessionStorage, and the page a live navigation came from.
None of these says much on its own, but together with the user agent they narrow down which browser a session came from, as fingerprinting does. The replay applies the media settings to the page, so a dark-mode or phone session looks as it did; keep fewer with client: [media: [:color_scheme]], or none with client: [media: false]. They are stored with the recording, and the player's Visit tab shows them. replayRecorder adds the pointer, touches and scrolling when pointer: true, and the form controls and client state below.
Form controls and client state
When the client module's replayRecorder runs, what users type and choose in form controls is recorded by default, with or without phx-change, and so is state your code reports with replayState. Both pass through sanitize_params/1 under the control's name or the reported key, like event params.
These are never read in the browser at all, so they never leave it:
- password inputs, including one a "show password" toggle turned into text,
- fields whose
autocompletenames a card (cc-number,cc-csc…), a password (current-password,new-password) or a one-time code (one-time-code), - hidden and file inputs, and buttons,
- anything inside an element with
data-phx-replay-ignore.
Mark anything else private with that attribute, such as a free-text field that may hold health or financial details:
<div data-phx-replay-ignore>
<.input field={@form[:notes]} type="textarea" />
</div>Turn form controls off with state: [inputs: false], or all client state with state: false.
What is never recorded
handle_info/2message contents; only the message tag is kept,- the contents of streams and uploads,
- the controls listed above, and what happens in the browser that neither a form control nor
replayStatereports.
Video export
An exported video shows what the player shows, so the sanitizer and redactor have already applied. The export browser loads the replay from a private endpoint PhoenixReplay starts on 127.0.0.1 and a free port, with a secret made at that moment; its pages need a token signed with that secret.
Any other request the replayed page makes, such as a stylesheet, script, font or image, is passed to your endpoint in the same VM, as a request from 127.0.0.1 without your proxy's headers. If your app trusts requests by their loopback address, or by headers such as X-Forwarded-For that a proxy normally sets, keep that in mind: a page rendered in an export can reach the routes it links to the same way.
Retention
Keep recordings only as long as you need them, with :retention limits; see Storage.