This is how the Ruby lib bunny makes it:

https://github.com/ruby-amqp/bunny/blob/f29c8b7deea72a04efbe81fd244a224757403d5f/lib/bunny/session.rb#L1187-L1191

if you set a heartbeat value of 0 on the client side it will use the server's suggested value instead of disabling it

That's what it's supposed to do. See Matthias's explanation in #83.

Since you were so convinced that the server will accept a veto of heartbeats, I went to look at the server code:
https://github.com/rabbitmq/rabbitmq-server/blame/master/src/rabbit_reader.erl#L1166
.. and it's been like that since it was imported into git, at least:
https://github.com/rabbitmq/rabbitmq-common/blame/7caafeb817e3b8f2c8f026dfcd73343930c24e31/src/rabbit_reader.erl#L1116

The spec is not a great guide, but for the heartbeat field it does say (merely):

The delay, in seconds, of the connection heartbeat that the client wants. Zero means the client does not want a heartbeat.

Compare with, for example, the guidance for frame-max:

If the client specifies a frame max that is higher than the value provided by the server, the server MUST close the connection without attempting a negotiated close.

I'm compelled to conclude that the comments in #83 were misinterpreted -- they apply to channel-max and frame-max, but not to heartbeat, at least for RabbitMQ (I'm not going to go look at any other server code!).

@squaremo @carlhoerberg

Hi Guys,

What's the conclusion? Can the client get option to disable the heartbeat?

RabbitMQ clearly states that a client should be able to disable heartbeats by setting the configuration value to 0:

Heartbeats can be disabled by setting the timeout interval to 0 on the client side at connection time.

https://www.rabbitmq.com/heartbeats.html#disabling

@robross0606,

It looks to me like the documentation you linked to contradicts itself. A little higher up it also states

A zero value indicates that a peer suggests disabling heartbeats entirely. To disable heartbeats, both peers have to opt in and use the value of 0.

I'm unfamiliar with erlang, but the server code this appears to confirm this is what was implemented...

tune(#'connection.tune'{channel_max = ServerChannelMax,
                        frame_max   = ServerFrameMax,
                        heartbeat   = ServerHeartbeat},
     #amqp_params_network{channel_max = ClientChannelMax,
                          frame_max   = ClientFrameMax,
                          heartbeat   = ClientHeartbeat}, State) ->
    [ChannelMax, Heartbeat, FrameMax] =
        lists:zipwith(fun (Client, Server) when Client =:= 0; Server =:= 0 ->
                              lists:max([Client, Server]);
                          (Client, Server) ->
                              lists:min([Client, Server])
                      end,
                      [ClientChannelMax, ClientHeartbeat, ClientFrameMax],
                      [ServerChannelMax, ServerHeartbeat, ServerFrameMax]),

If I interpret the above correctly, when either or both the client and server value are zero, then the maximum of the two will be used, otherwise the minimum value will be used. i.e.

So the only way to disable heartbeats is by setting both the client and server to zero. For interest, the same issue was reported with the erlang client, and they reached the same conclusion.

Sheesh, you’d think they would have updated and clarified the documentation by now if this is something so legacy that it cannot be changed in code. 😑

I agree. I've raised the following rabbitmq/rabbitmq-website#1386

Going to close this as the behaviour is out of amqplibs' control

Sheesh, you’d think they would have updated and clarified the documentation by now if this is something so legacy that it cannot be changed in code.

@robross0606 perhaps it was just overlooked. The RabbitMQ docs are open-source so there is plenty of opportunity for users to contribute.

amqp-client.js implements this pragmatically, set to zero on the client side means disable it. And amqp-client.js of course enables TCP keepalive, which is a much more reliable keepalive mechanism than AMQP heartbeats.