How to process Phoenix conn after render before it is sent as a response

There are a bunch of operations you may want to perform before the rendered response in conn is sent to the client, such as minification. In this post I'll show you how to do it easily.

Plug.Conn allows you to register a "before send" hook via register_before_send/2 function:

require Logger

Plug.Conn.register_before_send(conn, fn conn ->
  Logger.info("Sent a #{conn.status} response")
  conn
end)

It's very handy especially if you want to process conn with a plug. Here is an example from a simple minify_response library:

defmodule MinifyResponse.HTML do
  alias MinifyResponse.HTML

  def init(opts \\ []), do: opts

  def call %Plug.Conn{} = conn, _ \\ [] do
    Plug.Conn.register_before_send(conn, &HTML.minify_body/1)
  end

  def minify_body(%Plug.Conn{} = conn) do
    case List.keyfind(conn.resp_headers, "content-type", 0) do
      {_, "text/html" <> _} ->
        body = conn.resp_body
               |> Floki.parse
               |> Floki.raw_html

        %Plug.Conn{conn | resp_body: body}
      _ ->
        conn
    end
  end
end

As you can see in this example, you can for instance use the register_before_send/2 function to process already rendered HTML. However, this is just an example, and there are many other use cases worth exploring.

That's it! It's a very simple yet powerful trick. If you use it in your project to do some cool stuff - let me in the comments, I'd love to hear that!

FAQ

What is the purpose of Plug.Conn.register_before_send/2 in Phoenix?

Plug.Conn.register_before_send/2 allows developers to register a callback function that processes the connection (conn) just before the response is sent to the client. This is useful for operations like logging or modifying the response after it has been rendered but before it's delivered to the client.