Erlang Ranch Websocket Client fails to detect dropped Internet connection

I've written a very standard websocket client using Gun. It works as expected, connects, sends and receives messages, etc. Everything is very normal.

However, I discovered that it doesn't detect a broken internet connection. If I unplug the Ethernet cable from my PC, the Gun client does nothing. I don't get any kind of error, "DOWN" message, or any info of any kind. And, then if I reconnect the Ethernet cable, nothing happens. Gun just seems to pause and does nothing.

Ideally, I want some kind of message from Gun if the connection goes down. That way, I can handle things accordingly, and attempt to reconnect.

What am I missing? How can I detect a dropped connection from Gun?

My Client code is:

-module(test_client).
-behaviour(gen_server).

-include_lib("kernel/include/logger.hrl").


%% API.
-export([start_link/0]).

%% gen_server.
-export([init/1]).
-export([handle_call/3]).
-export([handle_cast/2]).
-export([handle_info/2]).
-export([terminate/2]).
-export([code_change/3]).

-record(state, {
    uri,
    port,
    path
}).

%% API.

-spec start_link() -> {ok, pid()}.
start_link() ->
    gen_server:start_link(?MODULE, [], []).

%% gen_server.

init([]) ->

    ?LOG_INFO(#{pid=>self(), module=>?MODULE, where=>init, msg=>started}),

    URI = "127.0.0.1",
    Port = 443,
    Path = "/ws",
    Opts = #{transport => tls, protocols => [http],retry => 5,retry_timeout => 2000},

    gen_server:cast(self(), connect),

    {ok,  #state{uri=URI, port=Port, path=Path, conn_opts=Opts}}.

handle_call(_Request, _From, State) ->
    {reply, ignored, State}.

handle_cast(connect, State0) ->
    {ok, ConnPid} = gun:open(State0#state.uri, State0#state.port, State0#state.conn_opts),
    _ = monitor(process, ConnPid),
    {noreply, State0#state{conn_pid=ConnPid};

handle_cast(_Msg, State) ->
    {noreply, State}.

handle_info({gun_up, ConnPID, http}, State) ->
    ?LOG_INFO(#{pid=>self(), module=>?MODULE, where=>info, msg=>gun_up, conn_pid=>ConnPID}),
    gun:ws_upgrade(ConnPid),
    {noreply, State#state{conn_pid=ConnPID}};

handle_info({gun_upgrade, ConnPID, ConnRef, _, _}, State) ->
    ?LOG_INFO(#{pid=>self(), module=>?MODULE, where=>info, msg=>gun_upgrade, conn_pid=>ConnPID, conn_ref=>ConnRef}),
    {noreply, State#state{conn_pid=ConnPID}};

handle_info({gun_down, ConnPID, ws, closed, _, _}, State) ->
    ?LOG_INFO(#{pid=>self(), module=>?MODULE, where=>info, msg=>gun_down, conn_pid=>ConnPID}),
    gun:close(ConnPID),
    gen_server:cast(self(), retry_connect),
    {noreply, State#state{conn_pid=null}};   

handle_info({gun_ws, _ConnPID, _ConnRef, RawMsg}, State) ->
    io:format("Receive: ~p~n", [RawMsg]),
    {noreply, State};

handle_info({gun_response, ConnPID, _ConnRef, _Err, Code, _Headers}, State0) ->
    ?LOG_ERROR(#{pid=>self(), module=>?MODULE, where=>info, msg=>gun_response, code=>Code}),
    gun:close(ConnPID),
    {noreply, State0#state{conn_pid=null}};

handle_info({gun_error, ConnPID, _StreamRef, Reason}, State0) ->
    ?LOG_ERROR(#{pid=>self(), module=>?MODULE, where=>info, msg=>gun_error, code=>Reason}),
    gun:close(ConnPID),
    {noreply, State0#state{conn_pid=null}};

handle_info({gun_error, ConnPID,Reason}, State0) ->
    ?LOG_ERROR(#{pid=>self(), module=>?MODULE, where=>info, msg=>gun_error, code=>Reason}),
    gun:close(ConnPID),
    {noreply, State0#state{conn_pid=null}};

handle_info({'DOWN', Mref, process, ConnPid, Reason}, State) ->
    ?LOG_ERROR(#{pid=>self(), module=>?MODULE, where=>info, msg=>monitor_down, code=>Reason}),
    demonitor(Mref),
    gun:close(ConnPid),
    {noreply, State#state{conn_pid=null}};   

handle_info(Info, State) ->
    ?LOG_ERROR(#{pid=>self(), module=>?MODULE, where=>info, status=>unknown, msg=>Info}),
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

Looks like you need implement a handler of ping/pong frames, for more info, please take a look to RFC https://www.rfc-editor.org/rfc/rfc6455#section-5.5.2 and https://www.rfc-editor.org/rfc/rfc6455#section-5.5.3. So, when server send ping, the client applications, eg: browser should answered pong back to server side and you can handle it by WebSocket. But if server send ping and don't get pong in answer from client side - this will be mean that the connect is lost. Hope, this will be helpful.