karafka-rdkafka 0.30.0 → 0.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 290a1e79997166534339567e0f46bf560191141a22c754bdd67c656ea68594f4
-  data.tar.gz: 972ca0af039c92a2b68d6767214ede8c06d7da0eaffde72f98c79bfcef0b8943
+  metadata.gz: a0e958e572e7b8e0c56325da653e4635b1dc296868d531f237ec1d275c75d207
+  data.tar.gz: 2ca9f29779c17216cc815ec759cf2a04a0f8c631718f530810aa13b76183cadc
 SHA512:
-  metadata.gz: 33ba78845a20d938ad79d61c859b08303dfe28ffdbf6a0fa5e99184805fa1d842153c0d676ba6fa25640241b71b2188a65d8ac58208e78526a5e2e3eedc433ad
-  data.tar.gz: 92f7639fca0c51e06844f705285df809a8680315d44531953d6d9b0049aff2964a7633933c31522b8fd75f4bb1606cb13f6a1a5c1d097e8a3f7011b5f3e04083
+  metadata.gz: 6d1fa15d28c82fb010b8c2a435285a39358a44973f022c6e0a6cbde422dcacf5ef79ac8ccd92a1dc91c17da799c147413e1555f5450a555e6401b9e2f2fcac75
+  data.tar.gz: 1523595543d9af2b27194492cf88bf2c37bda387009b49d3c9293c00efdb9d6db425657c60184739535ec89bd30dc86102b88cc6b24d26640e73021f36cf0760

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Rdkafka Changelog
 
+## 0.30.1 (2026-09-30)
+- [Fix] Derive `ShareConsumer#name` from the native handle at creation (mirroring `Consumer#name`) instead of leaving it `nil` until an OAuthBearer callback happened to set it. A `nil` name meant downstreams that route the global statistics and error callbacks by client name (e.g. Karafka) silently dropped every share-consumer statistic and background error.
+
 ## 0.30.0 (2026-09-25)
 - [Fix] Register share consumers in `Rdkafka::Clients` and destroy the native handle when `Config#share_consumer` fails part-way. Share consumers own the native handle directly rather than a `NativeKafka` wrapper, so they bypass `build_native_client` and were missed by the `at_exit` shutdown hook, leaving librdkafka to be unloaded with a live share handle.
 - [Feature] Add preview support for KIP-932 share groups ("Queues for Kafka") via `Rdkafka::ShareConsumer`, created with `Config#share_consumer`. Members consume the same partitions cooperatively with per-record acknowledgements (`:accept`, `:release`, `:reject`) instead of committed offsets. Like the regular `Consumer`, `ShareConsumer` is a thin binding that exposes the librdkafka share primitives (`#subscribe`/`#unsubscribe`/`#subscription`, batch `#poll`, `#acknowledge`, `#commit_sync`, `#commit_async`, `#acknowledgement_commit_callback=`, `#close`) but drives none of them itself - there is no built-in poll loop, acknowledgement strategy or offset/lifecycle orchestration, leaving that to a higher layer such as Karafka. The handle is single-threaded by design, servicing log, statistics and error callbacks from within `#poll`. Requires a broker with share groups enabled (Apache Kafka 4.2.0+); librdkafka marks the feature as preview and not production-ready.

data/lib/rdkafka/bindings.rb

@@ -517,6 +517,18 @@ module Rdkafka
     # rd_kafka_share_consumer_new instead of rd_kafka_new. It is single-threaded by design and
     # librdkafka itself rejects concurrent access with RD_KAFKA_RESP_ERR__CONFLICT.
 
+    # Minimal mirror of the head of librdkafka's `struct rd_kafka_share_s`, whose first member is
+    # the wrapped `rd_kafka_t` (`rkshare_rk`). `rd_kafka_share_t` has no public accessors of its
+    # own - not even for the client name - but the handle it wraps is a normal `rd_kafka_t` and is
+    # the very handle librdkafka passes to the statistics, error and OAuthBearer callbacks. Reading
+    # it lets a share consumer report a name that matches its statistics `name` field, which
+    # `rd_kafka_name` cannot do when handed the `rd_kafka_share_t` directly (it would read an
+    # unrelated field and return garbage). This mirrors how the gem already maps other librdkafka
+    # structs by layout for the pinned librdkafka version.
+    class NativeShareConsumer < FFI::Struct
+      layout :rkshare_rk, :pointer
+    end
+
     # Acknowledge types for share consumer records
     RD_KAFKA_SHARE_ACKNOWLEDGE_TYPE_ACCEPT = 1
     RD_KAFKA_SHARE_ACKNOWLEDGE_TYPE_RELEASE = 2

data/lib/rdkafka/share_consumer.rb

@@ -57,14 +57,17 @@ module Rdkafka
     private_constant :State
 
     # The client name librdkafka reports for this consumer (e.g. "rdkafka#consumer-1"), used to
-    # correlate global callbacks (such as the OAuthBearer token refresh callback) with this
-    # instance. librdkafka exposes no name accessor on the share handle, so this is captured
-    # from the first callback that carries it and is nil until then.
-    # @return [String, nil]
+    # correlate the global callbacks (statistics, error and the OAuthBearer token refresh
+    # callback, all of which carry the client name) with this instance. Captured from the native
+    # handle when the consumer is created, so it is available immediately - before the first
+    # {#poll} and without OAuth configured - and stays readable after the consumer is closed or
+    # inherited by a forked child.
+    # @return [String] the librdkafka client name
     attr_reader :name
 
     # @private
-    # Captures the librdkafka client name once known (from callback context)
+    # Lets the OAuthBearer token refresh callback set the name from its callback context. It
+    # carries the same `rd_kafka_name` value already captured at creation, so both paths agree.
     attr_writer :name
 
     # @private
@@ -80,6 +83,18 @@ module Rdkafka
       # every teardown path can skip the native destroy in a forked child (librdkafka is not
       # fork-safe).
       @state = State.new(native, nil, Process.pid)
+      # Capture the librdkafka client name up front. It is needed to correlate this consumer with
+      # the global statistics and error callbacks (which carry the client name) - the common
+      # downstream pattern (e.g. Karafka) filters those broadcast callbacks by matching `name`.
+      #
+      # `rd_kafka_name` has no `rd_kafka_share_t` overload: handing it the share handle reads an
+      # unrelated field and returns garbage. The share handle's first member is the `rd_kafka_t`
+      # it wraps (`rkshare_rk`), which is the same handle librdkafka passes to those callbacks, so
+      # the name read from it matches the statistics `name` field. Capturing it here (rather than
+      # lazily like the regular consumer) keeps it available before the first poll, without OAuth,
+      # and after close or in a forked child, where the native handle must not be touched.
+      # librdkafka assigns the name at creation, so no broker connection is required.
+      @name = Rdkafka::Bindings.rd_kafka_name(Rdkafka::Bindings::NativeShareConsumer.new(native)[:rkshare_rk])
       # Guards handle teardown against in-flight calls: increments happen under this mutex and
       # close holds it while draining and destroying (mirrors NativeKafka's approach)
       @access_mutex = Mutex.new

data/lib/rdkafka/version.rb

@@ -2,7 +2,7 @@
 
 module Rdkafka
   # Current rdkafka-ruby gem version
-  VERSION = "0.30.0"
+  VERSION = "0.30.1"
   # Target librdkafka version to be used
   LIBRDKAFKA_VERSION = "2.15.1"
   # SHA256 hash of the librdkafka source tarball for verification

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.30.1
 platform: ruby
 authors:
 - Thijs Cadier