prettier and more consistent connection log messages

2 files changed, 30 insertions, 12 deletions

diff --git a/src/rabbit_net.erl b/src/rabbit_net.erl
index b944ec81..fef8ae88 100644
--- a/src/rabbit_net.erl
+++ b/src/rabbit_net.erl
@@ -19,7 +19,7 @@
 
 -export([is_ssl/1, ssl_info/1, controlling_process/2, getstat/2,
          recv/1, async_recv/3, port_command/2, setopts/2, send/2, close/1,
-         sockname/1, peername/1, peercert/1]).
+         sockname/1, peername/1, peercert/1, connection_string/2]).
 
 %%---------------------------------------------------------------------------
 
@@ -62,6 +62,8 @@
 -spec(peercert/1 ::
         (socket())
         -> 'nossl' | ok_val_or_error(rabbit_ssl:certificate())).
+-spec(connection_string/2 ::
+        (socket(), 'inbound' | 'outbound') -> ok_val_or_error(string())).
 
 -endif.
 
@@ -141,3 +143,20 @@ peername(Sock)   when is_port(Sock) -> inet:peername(Sock).
 
 peercert(Sock)   when ?IS_SSL(Sock) -> ssl:peercert(Sock#ssl_socket.ssl);
 peercert(Sock)   when is_port(Sock) -> nossl.
+
+connection_string(Sock, Direction) ->
+    {From, To} = case Direction of
+                     inbound  -> {fun peername/1, fun sockname/1};
+                     outbound -> {fun sockname/1, fun peername/1}
+                 end,
+    case {From(Sock), To(Sock)} of
+        {{ok, {FromAddress, FromPort}}, {ok, {ToAddress, ToPort}}} ->
+            {ok, lists:flatten(
+                   io_lib:format("~s:~p -> ~s:~p",
+                                 [rabbit_misc:ntoab(FromAddress), FromPort,
+                                  rabbit_misc:ntoab(ToAddress),   ToPort]))};
+        {{error, _Reason} = Error, _} ->
+            Error;
+        {_, {error, _Reason} = Error} ->
+            Error
+    end.
diff --git a/src/rabbit_reader.erl b/src/rabbit_reader.erl
index fce61129..61def406 100644
--- a/src/rabbit_reader.erl
+++ b/src/rabbit_reader.erl
@@ -182,20 +182,19 @@ inet_op(F) -> rabbit_misc:throw_on_error(inet_error, F).
 socket_op(Sock, Fun) ->
     case Fun(Sock) of
         {ok, Res}       -> Res;
-        {error, Reason} -> rabbit_log:error("error on TCP connection ~p:~p~n",
+        {error, Reason} -> rabbit_log:error("error on AMQP connection ~p: ~p~n",
                                             [self(), Reason]),
-                           rabbit_log:info("closing TCP connection ~p~n",
-                                           [self()]),
                            exit(normal)
     end.
 
 start_connection(Parent, ChannelSupSupPid, Collector, StartHeartbeatFun, Deb,
                  Sock, SockTransform) ->
     process_flag(trap_exit, true),
-    {PeerAddress, PeerPort} = socket_op(Sock, fun rabbit_net:peername/1),
-    PeerAddressS = rabbit_misc:ntoab(PeerAddress),
-    rabbit_log:info("starting TCP connection ~p from ~s:~p~n",
-                    [self(), PeerAddressS, PeerPort]),
+    ConnStr = socket_op(Sock, fun (Sock0) ->
+                                      rabbit_net:connection_string(
+                                        Sock0, inbound)
+                              end),
+    rabbit_log:info("accepting AMQP connection ~p (~s)~n", [self(), ConnStr]),
     ClientSock = socket_op(Sock, SockTransform),
     erlang:send_after(?HANDSHAKE_TIMEOUT * 1000, self(),
                       handshake_timeout),
@@ -230,11 +229,11 @@ start_connection(Parent, ChannelSupSupPid, Collector, StartHeartbeatFun, Deb,
                        fun rabbit_log:warning/2;
                   true ->
                        fun rabbit_log:error/2
-               end)("exception on TCP connection ~p from ~s:~p~n~p~n",
-                    [self(), PeerAddressS, PeerPort, Ex])
+               end)("exception on AMQP connection ~p (~s)~n~p~n",
+                    [self(), ConnStr, Ex])
     after
-        rabbit_log:info("closing TCP connection ~p from ~s:~p~n",
-                        [self(), PeerAddressS, PeerPort]),
+        rabbit_log:info("closing AMQP connection ~p (~s)~n",
+                        [self(), ConnStr]),
         %% We don't close the socket explicitly. The reader is the
         %% controlling process and hence its termination will close
         %% the socket. Furthermore, gen_tcp:close/1 waits for pending