async-rabbitmq 0.7.1 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 12f881a8b2274539cd1e93e8ea827140887f0a392952dcd123270acaf5d4aea3
4
- data.tar.gz: 94ad7522a6b7c33d5cde8b892c0629b5db4961b9eb289c4efc6ab6c3f7286c66
3
+ metadata.gz: 42cacea6b44ce97ab03abac57c1d7b0b198103ba0225d8c9bc8aa37f6145fbb4
4
+ data.tar.gz: ac847f5cd9f87acaa811a539a728b5b5bb6eb3c4694b0408733775e705266676
5
5
  SHA512:
6
- metadata.gz: ed9504ed356545629ff40c48ee8e3d7dadd6482538fff0bd3539c2c48dcb020c3b5949538dd1382a4b9b4f5bd650986eda6782efe7b9ce10545e047474788cae
7
- data.tar.gz: cca32432f4ca23fc9b32150ce48684d9fde94feb8a0f9b9927e7186d4de59e6ee32677d3a437549559013e9c94a8350e5ea40eeb1c4f748ef9418470af2c593e
6
+ metadata.gz: 709f0f1339d28fa2ed77d031f375967970cb94d8d879e230bb3c2a223c84a701573ea5ed36b3fd5dbf24eb38ce0acf83d0ec234d23da7478c383621290d48ce9
7
+ data.tar.gz: fbec76e2babf6f6f32ca6e7f86eea6fa2644609102a9bc7b936e72a48ee236b9d0f964b021a17846b6aac95c768072f7a943adbadb650272b4c230d7dd93f79d
data/CHANGELOG.md CHANGED
@@ -2,6 +2,39 @@
2
2
 
3
3
  All notable changes to this project will be documented in this file.
4
4
 
5
+ ## [0.8.0] - 2026-11-14
6
+
7
+ ### Fixed
8
+
9
+ - A server-sent `basic.cancel` no longer leaves the queue in the topology registry. The broker
10
+ cancels a consumer when it can no longer serve the queue, and one of the ways that happens is
11
+ somebody deleting the queue - after which the next connection recovery re-declared it and the
12
+ deletion never stuck. The client now checks, passively, whether the queue is really gone and
13
+ forgets it, with its bindings, if it is. Only `NOT_FOUND` counts as gone: a replicated queue
14
+ mid-election is unavailable, not deleted, and is left in the registry to be re-declared.
15
+ - `on_cancel` and `on_error` no longer run on the channel's dispatch fiber. The obvious thing to
16
+ write in either is an RPC - re-consume, reopen - and an RPC on that fiber waits for a reply only
17
+ that fiber can deliver: fifteen seconds to `rpc_timeout`, then a channel resync. An exception out
18
+ of either escaped `dispatch_loop`, whose rescue sits outside its loop, so the channel stopped
19
+ delivering anything at all, confirms and RPC replies included. Both now run in a task of their
20
+ own and an exception is logged. Bunny dispatches cancel notifications to its consumer work pool
21
+ and the Java client to its work service, for the same reasons. `on_error` also runs after the
22
+ close has released the fibers it stranded, not before.
23
+ - The log line for a broker-sent cancel names the queue, not just the consumer tag.
24
+
25
+ ### Added
26
+
27
+ - `recover_cancelled_consumers:` on `Session.new` and `Session#open_channel`, with
28
+ `Channel#recover_cancelled_consumers=` and `Channel#recovers_cancelled_consumers?`. Off by
29
+ default, as it is in Bunny. When on, a consumer the broker cancels is re-subscribed under the
30
+ same tag, backing off from 1s to 30s for as long as the queue exists and the channel is open.
31
+ Recovery declares nothing: it passively checks that the queue is still there and re-consumes, so
32
+ a queue somebody deleted is never handed back. Re-declaring is the application's call.
33
+ - `consumer.recovered` and `consumer.recovery_failed` events. `consumer.recovery_failed` carries
34
+ `reason: :queue_deleted` - emitted whether or not recovery is enabled, since that is the point
35
+ at which a consumer is known not to be coming back - or `reason: :error` with the exception, once
36
+ per episode rather than once per attempt.
37
+
5
38
  ## [0.7.1] - 2026-10-18
6
39
 
7
40
  ### Added
data/README.md CHANGED
@@ -1,7 +1,7 @@
1
1
  # async-rabbitmq
2
2
 
3
3
  A fiber-native RabbitMQ (AMQP 0-9-1) client for Ruby, built on the amazing work
4
- of [Bunny](https://github.com/ruby-amqp/bunny).
4
+ of [Bunny](https://github.com/ruby-amqp/bunny) and [Async](https://github.com/socketry/async).
5
5
 
6
6
  ## Installing
7
7
 
@@ -466,7 +466,39 @@ starts), `on_blocked` / `on_unblocked` (connection.blocked),
466
466
  `Channel#on_return` (mandatory messages the broker could not route),
467
467
  `on_cancel` (broker cancelled a consumer), `on_error` (broker closed the
468
468
  channel). A broker-closed channel can be reopened in place with
469
- `Channel#reopen`.
469
+ `Channel#reopen`. Every one of these runs in a task of its own, so a callback
470
+ may issue RPCs — re-consume, reopen, declare — and a callback that raises is
471
+ logged rather than taken out on the channel.
472
+
473
+ ### A consumer the broker cancels
474
+
475
+ RabbitMQ cancels a consumer when it can no longer serve the queue to it: the
476
+ queue was deleted, the node holding it failed, a replicated queue's leader
477
+ moved. The connection is untouched, so none of the recovery above runs — a
478
+ `basic.cancel` frame is the only notice there is, and without `on_cancel` the
479
+ worker goes on publishing and heartbeating while consuming nothing.
480
+
481
+ Nothing is re-subscribed by default, which matches Bunny, the Java client and
482
+ the .NET client. `recover_cancelled_consumers: true`, on the session or on one
483
+ channel, re-subscribes under the same consumer tag, backing off from 1s to 30s
484
+ for as long as the queue exists and the channel is open.
485
+
486
+ **Recovery never declares anything.** One of the reasons a consumer gets
487
+ cancelled is somebody deleting the queue, and a client that answered that by
488
+ re-declaring would hand back a queue nobody could get rid of while a consumer
489
+ was attached. So the client passively checks whether the queue is still there
490
+ and re-consumes only if it is. If it has gone, the consumer stays gone and the
491
+ queue is dropped from the topology registry too — otherwise the next connection
492
+ recovery would re-declare it and the deletion would never stick. Only
493
+ `NOT_FOUND` counts as gone; a replicated queue mid-election is unavailable, not
494
+ deleted. Re-declaring is the application's call, and `on_cancel` is where to
495
+ make it: declare the queue there and the re-subscribe that follows will find
496
+ it.
497
+
498
+ ```ruby
499
+ session = AsyncRabbitMQ::Session.new(..., recover_cancelled_consumers: true)
500
+ channel.on_cancel { |tag| logger.warn("consumer #{tag} cancelled by the broker") }
501
+ ```
470
502
 
471
503
  ## Errors
472
504
 
@@ -520,6 +552,8 @@ logged and skipped; it never breaks the connection.
520
552
  | `channel.rpc` | `channel`, `method` (`"queue.declare-ok"`), `duration` |
521
553
  | `consumer.registered` | `channel`, `queue`, `consumer_tag`, `manual_ack` |
522
554
  | `consumer.cancelled` | `channel`, `consumer_tag`, `queue`, `reason` (`:client`, `:broker`) |
555
+ | `consumer.recovered` | `channel`, `consumer_tag`, `queue`, `attempts` |
556
+ | `consumer.recovery_failed` | `channel`, `consumer_tag`, `queue`, `reason` (`:queue_deleted`, `:error`), `error` |
523
557
  | `message.published` | `channel`, `exchange`, `routing_key`, `count`, `bytes`, `delivery_tag` |
524
558
  | `message.confirmed` | `channel`, `delivery_tag`, `multiple`, `acked` |
525
559
  | `message.returned` | `channel`, `exchange`, `routing_key`, `code`, `text`, `bytes` |
@@ -71,6 +71,12 @@ module AsyncRabbitMQ
71
71
  # after an RPC timeout, used when the session has no rpc_timeout set.
72
72
  RESYNC_TIMEOUT = 5
73
73
 
74
+ # First wait before re-subscribing a consumer the broker cancelled, and the
75
+ # ceiling the doubling stops at. Only used when the channel was asked to
76
+ # recover cancelled consumers; see #recovers_cancelled_consumers?.
77
+ RECOVER_CONSUMER_DELAY = 1
78
+ RECOVER_CONSUMER_MAX_DELAY = 30
79
+
74
80
  # Pushed onto the work queue to retire one handler worker. Compared by
75
81
  # identity, so it can never collide with a delivery.
76
82
  WORKER_STOP = Object.new.freeze
@@ -94,7 +100,8 @@ module AsyncRabbitMQ
94
100
  # concurrently on this channel (Bunny-parity: default 1 = serialized).
95
101
  # Resizable at runtime via #pool_size=; basic_qos adjusts it automatically
96
102
  # when prefetch_count > 0 so the two stay coupled.
97
- def initialize(channel_id, session, frame_io, frame_max:, logger:, pool_size: 1, rpc_timeout: nil)
103
+ def initialize(channel_id, session, frame_io, frame_max:, logger:, pool_size: 1, rpc_timeout: nil,
104
+ recover_cancelled_consumers: false)
98
105
  @channel_id = channel_id
99
106
  @session = session
100
107
  @notifier = session.respond_to?(:notifier) ? session.notifier : nil
@@ -124,6 +131,7 @@ module AsyncRabbitMQ
124
131
  @on_cancel = nil
125
132
  @on_error = nil
126
133
  @on_handler_error = nil
134
+ @recover_cancelled_consumers = recover_cancelled_consumers
127
135
  @on_error_disposition = :dead_letter
128
136
  @resyncing = false
129
137
  @resync_condition = nil
@@ -647,10 +655,33 @@ module AsyncRabbitMQ
647
655
  # Register a callback invoked when the broker cancels a consumer server-side
648
656
  # (e.g. the queue is deleted or an HA failover occurs).
649
657
  # The block receives the consumer_tag that was cancelled.
658
+ #
659
+ # The callback runs in a task of its own, so it may issue RPCs - a
660
+ # re-consume, a declare - and an exception out of it is logged rather than
661
+ # taken out on the channel.
650
662
  def on_cancel(&block)
651
663
  @on_cancel = block
652
664
  end
653
665
 
666
+ # Re-subscribe a consumer the broker cancels, under the same consumer tag.
667
+ #
668
+ # Off by default, as it is in Bunny, and for a reason worth stating: the
669
+ # broker cancels a consumer when it can no longer serve the queue, and one
670
+ # of the ways that happens is somebody deleting the queue. A client that
671
+ # recovers by re-declaring would hand back a queue nobody can get rid of
672
+ # while a consumer is attached. So recovery here never declares anything.
673
+ # It passively checks that the queue is still there and re-consumes if it
674
+ # is; if the queue has gone it stops, and forgets the queue so that a later
675
+ # connection recovery does not re-declare it either.
676
+ #
677
+ # Retries back off from RECOVER_CONSUMER_DELAY to RECOVER_CONSUMER_MAX_DELAY
678
+ # and continue for as long as the queue exists and the channel is open.
679
+ attr_writer :recover_cancelled_consumers
680
+
681
+ def recovers_cancelled_consumers?
682
+ @recover_cancelled_consumers
683
+ end
684
+
654
685
  # Register a callback invoked when the broker closes this channel due to an
655
686
  # error (e.g. 404 queue not found). The block receives the channel and the
656
687
  # AMQ::Protocol::Channel::Close method frame.
@@ -1273,18 +1304,7 @@ module AsyncRabbitMQ
1273
1304
  handle_channel_close(method)
1274
1305
 
1275
1306
  when AMQ::Protocol::Basic::Cancel
1276
- # Server-initiated consumer cancel (e.g. queue deleted, HA failover).
1277
- # Remove from @consumers so deliveries are no longer dispatched to a dead block.
1278
- entry = @consumers.delete(method.consumer_tag)
1279
- topology&.delete_consumer(method.consumer_tag)
1280
- if entry
1281
- @logger.warn("Channel #{@channel_id}: broker cancelled consumer #{method.consumer_tag}")
1282
- instrument("consumer.cancelled") do
1283
- { channel: @channel_id, consumer_tag: method.consumer_tag, queue: entry[:queue_name], reason: :broker }
1284
- end
1285
- @on_cancel&.call(method.consumer_tag)
1286
- end
1287
- wake_each_waiters(method.consumer_tag)
1307
+ handle_broker_cancel(method.consumer_tag)
1288
1308
  # No CancelOk to send for server-initiated cancel (no-wait is implicit).
1289
1309
 
1290
1310
  when AMQ::Protocol::Channel::Flow
@@ -1354,7 +1374,6 @@ module AsyncRabbitMQ
1354
1374
  forget_consumers_in_topology
1355
1375
  @session.channel_closed(@channel_id)
1356
1376
  instrument("channel.closed") { { channel: @channel_id, reason: :broker, code: code, text: text } }
1357
- @on_error&.call(self, method)
1358
1377
 
1359
1378
  error = if FrameIO::SOFT_ERROR_CODES.include?(code)
1360
1379
  ChannelError.new(code: code, text: text, channel_id: @channel_id, close_method: method)
@@ -1369,6 +1388,157 @@ module AsyncRabbitMQ
1369
1388
  @queue&.push(nil)
1370
1389
  stop_workers(discard: true)
1371
1390
  wake_each_waiters
1391
+ # Last, and in a task of its own. The lines above exist to release fibers
1392
+ # this close has stranded; a hook that is slow, or that raises, must not
1393
+ # come between them and the fibers waiting on them. The natural thing to
1394
+ # write in this hook is a reopen, which is an RPC, and an RPC on the
1395
+ # dispatch fiber waits for a reply only the dispatch fiber can deliver.
1396
+ notify_app("on_error") { @on_error.call(self, method) } if @on_error
1397
+ end
1398
+
1399
+ # An application callback never runs on the dispatch fiber. Two reasons,
1400
+ # both load-bearing. An RPC issued from a callback waits for a reply that
1401
+ # only this fiber delivers, so it deadlocks until rpc_timeout and then
1402
+ # drags the channel through a resync - and a re-consume is the obvious
1403
+ # thing to write in on_cancel. And an exception out of a callback escapes
1404
+ # #handle_message, whose rescue sits outside dispatch_loop's `loop`, so the
1405
+ # loop ends and the channel stops delivering anything at all: no
1406
+ # deliveries, no confirms, no RPC replies, with one line to say so.
1407
+ #
1408
+ # Bunny hands cancel notifications to its consumer work pool and the Java
1409
+ # client to its work service, for the same reason.
1410
+ def notify_app(name)
1411
+ @session.spawn_background do
1412
+ yield
1413
+ rescue *PROPAGATE_FROM_HANDLER
1414
+ raise
1415
+ rescue Exception => e # rubocop:disable Lint/RescueException
1416
+ @logger.error("Channel #{@channel_id}: #{name} callback raised #{e.class}: #{e.message}")
1417
+ end
1418
+ end
1419
+
1420
+ # The broker cancels a consumer when it can no longer serve the queue to
1421
+ # it: the queue was deleted, the node holding it failed, a replicated
1422
+ # queue's leader moved. The connection is untouched, so connection
1423
+ # recovery never runs - this frame is the only notice there is.
1424
+ #
1425
+ # The consumer goes from @consumers first, so no delivery is dispatched to
1426
+ # a block that is no longer subscribed, and everything beyond that
1427
+ # bookkeeping happens off this fiber.
1428
+ def handle_broker_cancel(tag)
1429
+ entry = @consumers.delete(tag)
1430
+ topology&.delete_consumer(tag)
1431
+ return wake_each_waiters(tag) unless entry
1432
+
1433
+ @logger.warn("Channel #{@channel_id}: broker cancelled consumer #{tag} on #{entry[:queue_name]}")
1434
+ instrument("consumer.cancelled") do
1435
+ { channel: @channel_id, consumer_tag: tag, queue: entry[:queue_name], reason: :broker }
1436
+ end
1437
+ notify_app("on_cancel") { @on_cancel.call(tag) } if @on_cancel
1438
+ @session.spawn_background { reconcile_cancelled_consumer(tag, entry) }
1439
+ end
1440
+
1441
+ # Why the broker cancelled is not on the wire, and the two reasons want
1442
+ # opposite handling: a queue that moved or was briefly unavailable should
1443
+ # be consumed from again, while a queue somebody deleted must be left
1444
+ # deleted. A passive declare is the only way to tell them apart. Spring
1445
+ # AMQP's listener container probes the same way, and for the same reason
1446
+ # declares nothing.
1447
+ #
1448
+ # Runs whether or not this channel recovers cancelled consumers, because
1449
+ # forgetting a deleted queue is not a recovery feature: a queue left in the
1450
+ # topology registry is re-declared on the next connection recovery, and
1451
+ # then the deletion never sticks.
1452
+ def reconcile_cancelled_consumer(tag, entry)
1453
+ queue = entry[:queue_name]
1454
+ return forget_deleted_queue(tag, queue) if queue_deleted?(queue)
1455
+ return wake_each_waiters(tag) unless recovers_cancelled_consumers?
1456
+
1457
+ recover_cancelled_consumer(tag, entry)
1458
+ end
1459
+
1460
+ # Re-consume under the same tag, for as long as the queue is there and this
1461
+ # channel can carry a consumer. Nothing is declared and nothing is bound:
1462
+ # whatever the queue is, it is the one that was there before.
1463
+ def recover_cancelled_consumer(tag, entry)
1464
+ queue = entry[:queue_name]
1465
+ delay = RECOVER_CONSUMER_DELAY
1466
+ failures = 0
1467
+
1468
+ loop do
1469
+ # The channel is gone, or the connection is: either way the consumers
1470
+ # on it are somebody else's problem now (#reopen, or recovery).
1471
+ return wake_each_waiters(tag) unless open? && @session.open?
1472
+
1473
+ begin
1474
+ basic_consume(queue, consumer_tag: tag, manual_ack: entry[:manual_ack], exclusive: entry[:exclusive],
1475
+ arguments: entry[:arguments] || {}, on_error: entry[:on_error], &entry[:block])
1476
+ @logger.info("Channel #{@channel_id}: re-subscribed consumer #{tag} to #{queue}")
1477
+ instrument("consumer.recovered") do
1478
+ { channel: @channel_id, consumer_tag: tag, queue: queue, attempts: failures + 1 }
1479
+ end
1480
+ return
1481
+ rescue *PROPAGATE_FROM_HANDLER
1482
+ raise
1483
+ rescue => e
1484
+ failures += 1
1485
+ # One line per episode at warn, the rest at debug: a broker that is
1486
+ # away for an hour would otherwise write a warning every attempt for
1487
+ # the whole hour, and an application counting warnings would read
1488
+ # one outage as hundreds.
1489
+ if failures == 1
1490
+ @logger.warn("Channel #{@channel_id}: could not re-subscribe #{tag} to #{queue}, " \
1491
+ "retrying: #{e.class}: #{e.message}")
1492
+ instrument("consumer.recovery_failed") do
1493
+ { channel: @channel_id, consumer_tag: tag, queue: queue, reason: :error, error: e }
1494
+ end
1495
+ else
1496
+ @logger.debug("Channel #{@channel_id}: re-subscribe attempt #{failures} for #{tag} failed: #{e.message}")
1497
+ end
1498
+ end
1499
+
1500
+ sleep delay
1501
+ delay = [delay * 2, RECOVER_CONSUMER_MAX_DELAY].min
1502
+ # Re-checked every round, not just once: a queue deleted while we were
1503
+ # retrying has to stop the loop, and it is also what keeps an endless
1504
+ # retry endless only while there is something to consume from.
1505
+ return forget_deleted_queue(tag, queue) if queue_deleted?(queue)
1506
+ end
1507
+ end
1508
+
1509
+ # The queue behind a cancelled consumer has gone. Drop it from the topology
1510
+ # registry, with its bindings, so a later connection recovery does not
1511
+ # re-declare a queue somebody deleted on purpose - the "deleted queue comes
1512
+ # back" bug the Java client has been fixing instances of for years.
1513
+ def forget_deleted_queue(tag, queue)
1514
+ topology&.delete_queue(queue)
1515
+ @logger.warn("Channel #{@channel_id}: queue #{queue} no longer exists; consumer #{tag} will not be recovered")
1516
+ instrument("consumer.recovery_failed") do
1517
+ { channel: @channel_id, consumer_tag: tag, queue: queue, reason: :queue_deleted }
1518
+ end
1519
+ wake_each_waiters(tag)
1520
+ end
1521
+
1522
+ # Deleted, as opposed to merely unreachable. A passive declare, on a channel
1523
+ # of its own because a passive declare that fails closes the channel it ran
1524
+ # on - which would take the queue's fellow consumers down with it.
1525
+ #
1526
+ # Only NOT_FOUND counts. A replicated queue mid-election is the very case
1527
+ # this whole path exists for and it does not answer 404, so treating every
1528
+ # channel error as a deletion would forget a queue that is coming back and
1529
+ # stop topology recovery ever re-declaring it. Anything inconclusive - a
1530
+ # connection that went while we were asking, too - reads as "still there",
1531
+ # which costs a retry and never costs a queue.
1532
+ def queue_deleted?(name)
1533
+ @session.with_channel { |probe| probe.queue(name, passive: true) }
1534
+ false
1535
+ rescue ChannelError => e
1536
+ e.code == 404
1537
+ rescue *PROPAGATE_FROM_HANDLER
1538
+ raise
1539
+ rescue => e
1540
+ @logger.debug("Channel #{@channel_id}: could not check whether #{name} still exists: #{e.class}: #{e.message}")
1541
+ false
1372
1542
  end
1373
1543
 
1374
1544
  # Release fibers blocked in #each for one consumer, or for all of them.
@@ -36,6 +36,8 @@ module AsyncRabbitMQ
36
36
  channel.rpc
37
37
  consumer.registered
38
38
  consumer.cancelled
39
+ consumer.recovered
40
+ consumer.recovery_failed
39
41
  message.published
40
42
  message.confirmed
41
43
  message.returned
@@ -161,6 +161,7 @@ module AsyncRabbitMQ
161
161
  recovery_interval: RECOVERY_INITIAL,
162
162
  recovery_max_interval: RECOVERY_MAX,
163
163
  recover_topology: true,
164
+ recover_cancelled_consumers: false,
164
165
  topology_recovery_filter: nil,
165
166
  instrumenter: nil,
166
167
  notifier: nil,
@@ -194,6 +195,9 @@ module AsyncRabbitMQ
194
195
  @recovery_interval = recovery_interval
195
196
  @recovery_max_interval = recovery_max_interval
196
197
  @recover_topology = recover_topology
198
+ # The default every channel opened on this session takes; see
199
+ # Channel#recovers_cancelled_consumers? for why it is off.
200
+ @recover_cancelled_consumers = recover_cancelled_consumers
197
201
  @topology = TopologyRegistry.new(filter: topology_recovery_filter)
198
202
  @logger = logger
199
203
  @notifier = notifier || Notifier.new(logger: logger)
@@ -354,12 +358,15 @@ module AsyncRabbitMQ
354
358
  # Open a new channel. Returns an AsyncRabbitMQ::Channel.
355
359
  # +pool_size+ bounds concurrent consumer-handler fibers on the channel
356
360
  # (Bunny-parity: default 1). basic_qos will auto-adjust it to prefetch_count.
357
- def open_channel(pool_size: 1)
361
+ # +recover_cancelled_consumers+ defaults to the session's setting; see
362
+ # Channel#recovers_cancelled_consumers?.
363
+ def open_channel(pool_size: 1, recover_cancelled_consumers: @recover_cancelled_consumers)
358
364
  raise NotOpenError, "Session is not open" unless open?
359
365
  channel = @channel_mutex.acquire do
360
366
  channel_id = next_channel_id
361
367
  Channel.new(channel_id, self, @frame_io, frame_max: @negotiated_fm || @frame_max, logger: @logger,
362
- pool_size: pool_size, rpc_timeout: @rpc_timeout).tap { |ch| @channels[channel_id] = ch }
368
+ pool_size: pool_size, rpc_timeout: @rpc_timeout,
369
+ recover_cancelled_consumers: recover_cancelled_consumers).tap { |ch| @channels[channel_id] = ch }
363
370
  end
364
371
  channel.open
365
372
  channel
@@ -1,3 +1,3 @@
1
1
  module AsyncRabbitMQ
2
- VERSION = "0.7.1"
2
+ VERSION = "0.8.0"
3
3
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: async-rabbitmq
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.7.1
4
+ version: 0.8.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Russell Penney