rdkafka 0.25.0-aarch64-linux-gnu → 0.25.1-aarch64-linux-gnu

data/lib/rdkafka/admin.rb

@@ -36,8 +36,8 @@ module Rdkafka
           # Read values from the struct
           code = error_desc[:code]
 
-          name = ''
-          desc = ''
+          name = ""
+          desc = ""
 
           name = error_desc[:name].read_string unless error_desc[:name].null?
           desc = error_desc[:desc].read_string unless error_desc[:desc].null?
@@ -71,6 +71,65 @@ module Rdkafka
       end
     end
 
+    # Enable IO event notifications for fiber scheduler integration
+    # When admin operations complete, librdkafka will write to your FD
+    #
+    # @param fd [Integer] file descriptor to signal (from IO.pipe or eventfd)
+    # @param payload [String] data to write to fd (default: "\x01")
+    # @return [nil]
+    # @raise [ClosedInnerError] when the admin client is closed
+    def enable_queue_io_events(fd, payload = "\x01")
+      @native_kafka.enable_main_queue_io_events(fd, payload)
+    end
+
+    # Enable IO event notifications for background events
+    # @param fd [Integer] file descriptor to signal (from IO.pipe or eventfd)
+    # @param payload [String] data to write to fd (default: "\x01")
+    # @return [nil]
+    # @raise [ClosedInnerError] when the admin client is closed
+    def enable_background_queue_io_events(fd, payload = "\x01")
+      @native_kafka.enable_background_queue_io_events(fd, payload)
+    end
+
+    # Polls for events in a non-blocking loop, yielding the count after each iteration.
+    #
+    # This method processes events (stats, errors, etc.) in a single GVL/mutex session,
+    # which is more efficient than repeated individual polls. It uses non-blocking polls
+    # internally (no GVL release between polls).
+    #
+    # Yields the count of events processed after each poll iteration, allowing the caller
+    # to implement timeout or other termination logic by returning `:stop`.
+    #
+    # @yield [count] Called after each poll iteration
+    # @yieldparam count [Integer] Number of events processed in this iteration
+    # @yieldreturn [Symbol, Object] Return `:stop` to break the loop, any other value continues
+    # @return [nil]
+    # @raise [Rdkafka::ClosedAdminError] if called on a closed admin client
+    #
+    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
+    #   Other admin operations will wait until this method returns.
+    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
+    #
+    # @example Drain all pending events
+    #   admin.events_poll_nb_each { |_count| }
+    #
+    # @example With timeout control
+    #   deadline = monotonic_now + timeout_ms
+    #   admin.events_poll_nb_each do |_count|
+    #     :stop if monotonic_now >= deadline
+    #   end
+    def events_poll_nb_each
+      closed_admin_check(__method__)
+
+      @native_kafka.with_inner do |inner|
+        loop do
+          count = Rdkafka::Bindings.rd_kafka_poll_nb(inner, 0)
+          break if count.zero?
+          break if yield(count) == :stop
+        end
+      end
+    end
+
     # @return [Proc] finalizer proc for closing the admin
     # @private
     def finalizer
@@ -113,7 +172,7 @@ module Rdkafka
     # @raise [ConfigError] When the partition count or replication factor are out of valid range
     # @raise [RdkafkaError] When the topic name is invalid or the topic already exists
     # @raise [RdkafkaError] When the topic configuration is invalid
-    def create_topic(topic_name, partition_count, replication_factor, topic_config={})
+    def create_topic(topic_name, partition_count, replication_factor, topic_config = {})
       closed_admin_check(__method__)
 
       # Create a rd_kafka_NewTopic_t representing the new topic
@@ -129,14 +188,12 @@ module Rdkafka
         raise Rdkafka::Config::ConfigError.new(error_buffer.read_string)
       end
 
-      unless topic_config.nil?
-        topic_config.each do |key, value|
-          Rdkafka::Bindings.rd_kafka_NewTopic_set_config(
-            new_topic_ptr,
-            key.to_s,
-            value.to_s
-          )
-        end
+      topic_config&.each do |key, value|
+        Rdkafka::Bindings.rd_kafka_NewTopic_set_config(
+          new_topic_ptr,
+          key.to_s,
+          value.to_s
+        )
       end
 
       # Note that rd_kafka_CreateTopics can create more than one topic at a time
@@ -372,6 +429,8 @@ module Rdkafka
     #   - RD_KAFKA_RESOURCE_BROKER  = 4
     # @param resource_name [String] name of the resource
     # @param resource_pattern_type [Integer] rd_kafka_ResourcePatternType_t value:
+    #   - RD_KAFKA_RESOURCE_PATTERN_UNKNOWN  = 0
+    #   - RD_KAFKA_RESOURCE_PATTERN_ANY      = 1
     #   - RD_KAFKA_RESOURCE_PATTERN_MATCH    = 2
     #   - RD_KAFKA_RESOURCE_PATTERN_LITERAL  = 3
     #   - RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4
@@ -471,6 +530,8 @@ module Rdkafka
     #   - RD_KAFKA_RESOURCE_BROKER  = 4
     # @param resource_name [String, nil] name of the resource or nil for any
     # @param resource_pattern_type [Integer] rd_kafka_ResourcePatternType_t value:
+    #   - RD_KAFKA_RESOURCE_PATTERN_UNKNOWN  = 0
+    #   - RD_KAFKA_RESOURCE_PATTERN_ANY      = 1
     #   - RD_KAFKA_RESOURCE_PATTERN_MATCH    = 2
     #   - RD_KAFKA_RESOURCE_PATTERN_LITERAL  = 3
     #   - RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4
@@ -572,6 +633,8 @@ module Rdkafka
     #   - RD_KAFKA_RESOURCE_BROKER  = 4
     # @param resource_name [String, nil] name of the resource or nil for any
     # @param resource_pattern_type [Integer] rd_kafka_ResourcePatternType_t value:
+    #   - RD_KAFKA_RESOURCE_PATTERN_UNKNOWN  = 0
+    #   - RD_KAFKA_RESOURCE_PATTERN_ANY      = 1
     #   - RD_KAFKA_RESOURCE_PATTERN_MATCH    = 2
     #   - RD_KAFKA_RESOURCE_PATTERN_LITERAL  = 3
     #   - RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4
@@ -720,10 +783,12 @@ module Rdkafka
 
         raise
       ensure
-        Rdkafka::Bindings.rd_kafka_ConfigResource_destroy_array(
-          configs_array_ptr,
-          pointer_array.size
-        ) if configs_array_ptr
+        if configs_array_ptr
+          Rdkafka::Bindings.rd_kafka_ConfigResource_destroy_array(
+            configs_array_ptr,
+            pointer_array.size
+          )
+        end
       end
 
       handle
@@ -791,7 +856,6 @@ module Rdkafka
       configs_array_ptr = FFI::MemoryPointer.new(:pointer, pointer_array.size)
       configs_array_ptr.write_array_of_pointer(pointer_array)
 
-
       begin
         @native_kafka.with_inner do |inner|
           Rdkafka::Bindings.rd_kafka_IncrementalAlterConfigs(
@@ -807,10 +871,12 @@ module Rdkafka
 
         raise
       ensure
-        Rdkafka::Bindings.rd_kafka_ConfigResource_destroy_array(
-          configs_array_ptr,
-          pointer_array.size
-        ) if configs_array_ptr
+        if configs_array_ptr
+          Rdkafka::Bindings.rd_kafka_ConfigResource_destroy_array(
+            configs_array_ptr,
+            pointer_array.size
+          )
+        end
       end
 
       handle

data/lib/rdkafka/bindings.rb

@@ -17,10 +17,10 @@ module Rdkafka
     # Returns the library extension based on the host OS
     # @return [String] 'dylib' on macOS, 'so' on other systems
     def self.lib_extension
-      if RbConfig::CONFIG['host_os'] =~ /darwin/
-        'dylib'
+      if /darwin/.match?(RbConfig::CONFIG["host_os"])
+        "dylib"
       else
-        'so'
+        "so"
       end
     end
 
@@ -31,8 +31,8 @@ module Rdkafka
       error_message = e.message
 
       # Check if this is a glibc version mismatch error
-      if error_message =~ /GLIBC_[\d.]+['"` ]?\s*not found/i
-        glibc_version = error_message[/GLIBC_([\d.]+)/, 1] || 'unknown'
+      if /GLIBC_[\d.]+['"` ]?\s*not found/i.match?(error_message)
+        glibc_version = error_message[/GLIBC_([\d.]+)/, 1] || "unknown"
 
         raise Rdkafka::LibraryLoadError, <<~ERROR_MSG.strip
           Failed to load librdkafka due to glibc compatibility issue.
@@ -64,12 +64,12 @@ module Rdkafka
     RD_KAFKA_RESP_ERR__NOENT = -156
     RD_KAFKA_RESP_ERR_NO_ERROR = 0
 
-    RD_KAFKA_OFFSET_END       = -1
+    RD_KAFKA_OFFSET_END = -1
     RD_KAFKA_OFFSET_BEGINNING = -2
-    RD_KAFKA_OFFSET_STORED    = -1000
-    RD_KAFKA_OFFSET_INVALID   = -1001
+    RD_KAFKA_OFFSET_STORED = -1000
+    RD_KAFKA_OFFSET_INVALID = -1001
 
-    RD_KAFKA_PARTITION_UA     = -1
+    RD_KAFKA_PARTITION_UA = -1
     RD_KAFKA_PARTITION_UA_STR = RD_KAFKA_PARTITION_UA.to_s.freeze
 
     EMPTY_HASH = {}.freeze
@@ -90,6 +90,12 @@ module Rdkafka
     attach_function :rd_kafka_poll, [:pointer, :int], :int, blocking: true
     attach_function :rd_kafka_outq_len, [:pointer], :int, blocking: true
 
+    # Non-blocking poll variants (do not release GVL)
+    # These are more efficient for poll(0) calls in fiber schedulers where GVL
+    # release/reacquire overhead is wasteful since we don't expect to wait.
+    # Uses the same underlying C function but with blocking: false to skip GVL release.
+    attach_function :rd_kafka_poll_nb, :rd_kafka_poll, [:pointer, :int], :int, blocking: false
+
     # Metadata
 
     attach_function :rd_kafka_name, [:pointer], :string
@@ -101,14 +107,14 @@ module Rdkafka
     # FFI struct representing a Kafka message (rd_kafka_message_t)
     class Message < FFI::Struct
       layout :err, :int,
-             :rkt, :pointer,
-             :partition, :int32,
-             :payload, :pointer,
-             :len, :size_t,
-             :key, :pointer,
-             :key_len, :size_t,
-             :offset, :int64,
-             :_private, :pointer
+        :rkt, :pointer,
+        :partition, :int32,
+        :payload, :pointer,
+        :len, :size_t,
+        :key, :pointer,
+        :key_len, :size_t,
+        :offset, :int64,
+        :_private, :pointer
     end
 
     attach_function :rd_kafka_message_destroy, [:pointer], :void
@@ -120,20 +126,20 @@ module Rdkafka
     # FFI struct representing a topic partition (rd_kafka_topic_partition_t)
     class TopicPartition < FFI::Struct
       layout :topic, :string,
-             :partition, :int32,
-             :offset, :int64,
-             :metadata, :pointer,
-             :metadata_size, :size_t,
-             :opaque, :pointer,
-             :err, :int,
-             :_private, :pointer
+        :partition, :int32,
+        :offset, :int64,
+        :metadata, :pointer,
+        :metadata_size, :size_t,
+        :opaque, :pointer,
+        :err, :int,
+        :_private, :pointer
     end
 
     # FFI struct representing a topic partition list (rd_kafka_topic_partition_list_t)
     class TopicPartitionList < FFI::Struct
       layout :cnt, :int,
-             :size, :int,
-             :elems, :pointer
+        :size, :int,
+        :elems, :pointer
     end
 
     attach_function :rd_kafka_topic_partition_list_new, [:int32], :pointer
@@ -148,7 +154,7 @@ module Rdkafka
     # separate errors results if obtaining configuration was not possible for any reason
     class ConfigResource < FFI::Struct
       layout :type, :int,
-             :name, :string
+        :name, :string
     end
 
     attach_function :rd_kafka_DescribeConfigs, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
@@ -177,16 +183,16 @@ module Rdkafka
     RD_KAFKA_ADMIN_OP_INCREMENTALALTERCONFIGS = 16
     RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT = 131072
 
-    RD_KAFKA_ALTER_CONFIG_OP_TYPE_SET      = 0
-    RD_KAFKA_ALTER_CONFIG_OP_TYPE_DELETE   = 1
-    RD_KAFKA_ALTER_CONFIG_OP_TYPE_APPEND   = 2
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_SET = 0
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_DELETE = 1
+    RD_KAFKA_ALTER_CONFIG_OP_TYPE_APPEND = 2
     RD_KAFKA_ALTER_CONFIG_OP_TYPE_SUBTRACT = 3
 
     # FFI struct for error description (rd_kafka_err_desc)
     class NativeErrorDesc < FFI::Struct
       layout :code, :int,
-             :name, :pointer,
-             :desc, :pointer
+        :name, :pointer,
+        :desc, :pointer
     end
 
     attach_function :rd_kafka_err2name, [:int], :string
@@ -222,6 +228,15 @@ module Rdkafka
     # Log queue
     attach_function :rd_kafka_set_log_queue, [:pointer, :pointer], :void
     attach_function :rd_kafka_queue_get_main, [:pointer], :pointer
+    attach_function :rd_kafka_queue_get_background, [:pointer], :pointer
+
+    # Queue IO Event Support - for fiber scheduler integration
+    # Enables notifications to a custom FD when queue transitions from empty to non-empty
+    # @param queue rd_kafka_queue_t* - the queue to monitor
+    # @param fd int - file descriptor to write to (provide your own pipe/eventfd)
+    # @param payload const void* - data to write to fd
+    # @param size size_t - size of payload
+    attach_function :rd_kafka_queue_io_event_enable, [:pointer, :int, :pointer, :size_t], :void
     # Per topic configs
     attach_function :rd_kafka_topic_conf_new, [], :pointer
     attach_function :rd_kafka_topic_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
@@ -230,19 +245,19 @@ module Rdkafka
       :void, [:pointer, :int, :string, :string]
     ) do |_client_ptr, level, _level_string, line|
       severity = case level
-                 when 0, 1, 2
-                   Logger::FATAL
-                 when 3
-                   Logger::ERROR
-                 when 4
-                   Logger::WARN
-                 when 5, 6
-                   Logger::INFO
-                 when 7
-                   Logger::DEBUG
-                 else
-                   Logger::UNKNOWN
-                 end
+      when 0, 1, 2
+        Logger::FATAL
+      when 3
+        Logger::ERROR
+      when 4
+        Logger::WARN
+      when 5, 6
+        Logger::INFO
+      when 7
+        Logger::DEBUG
+      else
+        Logger::UNKNOWN
+      end
 
       Rdkafka::Config.ensure_log_thread
       Rdkafka::Config.log_queue << [severity, "rdkafka: #{line}"]
@@ -268,8 +283,8 @@ module Rdkafka
         #
         # Since this cache is shared, having few consumers and/or producers in one process will
         # automatically improve the querying times even with low refresh times.
-        (stats['topics'] || EMPTY_HASH).each do |topic_name, details|
-          partitions_count = details['partitions'].keys.reject { |k| k == RD_KAFKA_PARTITION_UA_STR }.size
+        (stats["topics"] || EMPTY_HASH).each do |topic_name, details|
+          partitions_count = details["partitions"].keys.count { |k| !(k == RD_KAFKA_PARTITION_UA_STR) }
 
           next unless partitions_count.positive?
 
@@ -314,9 +329,7 @@ module Rdkafka
     OAuthbearerTokenRefreshCallback = FFI::Function.new(
       :void, [:pointer, :string, :pointer]
     ) do |client_ptr, config, _opaque|
-      if Rdkafka::Config.oauthbearer_token_refresh_callback
-        Rdkafka::Config.oauthbearer_token_refresh_callback.call(config, Rdkafka::Bindings.rd_kafka_name(client_ptr))
-      end
+      Rdkafka::Config.oauthbearer_token_refresh_callback&.call(config, Rdkafka::Bindings.rd_kafka_name(client_ptr))
     end
 
     # Handle
@@ -344,6 +357,9 @@ module Rdkafka
     attach_function :rd_kafka_commit, [:pointer, :pointer, :bool], :int, blocking: true
     attach_function :rd_kafka_poll_set_consumer, [:pointer], :void, blocking: true
     attach_function :rd_kafka_consumer_poll, [:pointer, :int], :pointer, blocking: true
+    # Non-blocking consumer poll variant (does not release GVL)
+    # More efficient for poll(0) calls in fiber schedulers.
+    attach_function :rd_kafka_consumer_poll_nb, :rd_kafka_consumer_poll, [:pointer, :int], :pointer, blocking: false
     attach_function :rd_kafka_consumer_close, [:pointer], :void, blocking: true
     attach_function :rd_kafka_offsets_store, [:pointer, :pointer], :int, blocking: true
     attach_function :rd_kafka_pause_partitions, [:pointer, :pointer], :int, blocking: true
@@ -426,8 +442,8 @@ module Rdkafka
 
     # Hash mapping partitioner names to their FFI function symbols
     # @return [Hash{String => Symbol}]
-    PARTITIONERS = %w(random consistent consistent_random murmur2 murmur2_random fnv1a fnv1a_random).each_with_object({}) do |name, hsh|
-      method_name = "rd_kafka_msg_partitioner_#{name}".to_sym
+    PARTITIONERS = %w[random consistent consistent_random murmur2 murmur2_random fnv1a fnv1a_random].each_with_object({}) do |name, hsh|
+      method_name = :"rd_kafka_msg_partitioner_#{name}"
       attach_function method_name, [:pointer, :pointer, :size_t, :int32, :pointer, :pointer], :int32
       hsh[name] = method_name
     end
@@ -453,7 +469,7 @@ module Rdkafka
     end
 
     # Create Topics
-    RD_KAFKA_ADMIN_OP_CREATETOPICS     = 1   # rd_kafka_admin_op_t
+    RD_KAFKA_ADMIN_OP_CREATETOPICS = 1   # rd_kafka_admin_op_t
     RD_KAFKA_EVENT_CREATETOPICS_RESULT = 100 # rd_kafka_event_type_t
 
     attach_function :rd_kafka_CreateTopics, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
@@ -464,7 +480,7 @@ module Rdkafka
     attach_function :rd_kafka_CreateTopics_result_topics, [:pointer, :pointer], :pointer, blocking: true
 
     # Delete Topics
-    RD_KAFKA_ADMIN_OP_DELETETOPICS     = 2   # rd_kafka_admin_op_t
+    RD_KAFKA_ADMIN_OP_DELETETOPICS = 2   # rd_kafka_admin_op_t
     RD_KAFKA_EVENT_DELETETOPICS_RESULT = 101 # rd_kafka_event_type_t
 
     attach_function :rd_kafka_DeleteTopics, [:pointer, :pointer, :size_t, :pointer, :pointer], :int32, blocking: true
@@ -495,7 +511,6 @@ module Rdkafka
 
     # Background Queue and Callback
 
-    attach_function :rd_kafka_queue_get_background, [:pointer], :pointer
     attach_function :rd_kafka_conf_set_background_event_cb, [:pointer, :pointer], :void
     attach_function :rd_kafka_queue_destroy, [:pointer], :void
 
@@ -517,7 +532,7 @@ module Rdkafka
     attach_function :rd_kafka_topic_result_name, [:pointer], :pointer
 
     # Create Acls
-    RD_KAFKA_ADMIN_OP_CREATEACLS     = 9
+    RD_KAFKA_ADMIN_OP_CREATEACLS = 9
     RD_KAFKA_EVENT_CREATEACLS_RESULT = 1024
 
     attach_function :rd_kafka_CreateAcls, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
@@ -525,7 +540,7 @@ module Rdkafka
     attach_function :rd_kafka_CreateAcls_result_acls, [:pointer, :pointer], :pointer
 
     # Delete Acls
-    RD_KAFKA_ADMIN_OP_DELETEACLS     = 11
+    RD_KAFKA_ADMIN_OP_DELETEACLS = 11
     RD_KAFKA_EVENT_DELETEACLS_RESULT = 4096
 
     attach_function :rd_kafka_DeleteAcls, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
@@ -535,7 +550,7 @@ module Rdkafka
     attach_function :rd_kafka_DeleteAcls_result_response_matching_acls, [:pointer, :pointer], :pointer
 
     # Describe Acls
-    RD_KAFKA_ADMIN_OP_DESCRIBEACLS     = 10
+    RD_KAFKA_ADMIN_OP_DESCRIBEACLS = 10
     RD_KAFKA_EVENT_DESCRIBEACLS_RESULT = 2048
 
     attach_function :rd_kafka_DescribeAcls, [:pointer, :pointer, :pointer, :pointer], :void
@@ -551,41 +566,42 @@ module Rdkafka
     attach_function :rd_kafka_AclBinding_host, [:pointer], :pointer
     attach_function :rd_kafka_AclBinding_operation, [:pointer], :int32
     attach_function :rd_kafka_AclBinding_permission_type, [:pointer], :int32
-    attach_function :rd_kafka_AclBinding_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t ], :pointer
-    attach_function :rd_kafka_AclBindingFilter_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t ], :pointer
+    attach_function :rd_kafka_AclBinding_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t], :pointer
+    attach_function :rd_kafka_AclBindingFilter_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t], :pointer
     attach_function :rd_kafka_AclBinding_destroy, [:pointer], :void
 
     # rd_kafka_ResourceType_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L7307
-    RD_KAFKA_RESOURCE_ANY   = 1
+    RD_KAFKA_RESOURCE_ANY = 1
     RD_KAFKA_RESOURCE_TOPIC = 2
     RD_KAFKA_RESOURCE_GROUP = 3
     RD_KAFKA_RESOURCE_BROKER = 4
     RD_KAFKA_RESOURCE_TRANSACTIONAL_ID = 5
 
     # rd_kafka_ResourcePatternType_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L7320
-    RD_KAFKA_RESOURCE_PATTERN_ANY      = 1
-    RD_KAFKA_RESOURCE_PATTERN_MATCH    = 2
-    RD_KAFKA_RESOURCE_PATTERN_LITERAL  = 3
+    RD_KAFKA_RESOURCE_PATTERN_UNKNOWN = 0
+    RD_KAFKA_RESOURCE_PATTERN_ANY = 1
+    RD_KAFKA_RESOURCE_PATTERN_MATCH = 2
+    RD_KAFKA_RESOURCE_PATTERN_LITERAL = 3
     RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4
 
     # rd_kafka_AclOperation_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L8403
-    RD_KAFKA_ACL_OPERATION_ANY              = 1
-    RD_KAFKA_ACL_OPERATION_ALL              = 2
-    RD_KAFKA_ACL_OPERATION_READ             = 3
-    RD_KAFKA_ACL_OPERATION_WRITE            = 4
-    RD_KAFKA_ACL_OPERATION_CREATE           = 5
-    RD_KAFKA_ACL_OPERATION_DELETE           = 6
-    RD_KAFKA_ACL_OPERATION_ALTER            = 7
-    RD_KAFKA_ACL_OPERATION_DESCRIBE         = 8
-    RD_KAFKA_ACL_OPERATION_CLUSTER_ACTION   = 9
+    RD_KAFKA_ACL_OPERATION_ANY = 1
+    RD_KAFKA_ACL_OPERATION_ALL = 2
+    RD_KAFKA_ACL_OPERATION_READ = 3
+    RD_KAFKA_ACL_OPERATION_WRITE = 4
+    RD_KAFKA_ACL_OPERATION_CREATE = 5
+    RD_KAFKA_ACL_OPERATION_DELETE = 6
+    RD_KAFKA_ACL_OPERATION_ALTER = 7
+    RD_KAFKA_ACL_OPERATION_DESCRIBE = 8
+    RD_KAFKA_ACL_OPERATION_CLUSTER_ACTION = 9
     RD_KAFKA_ACL_OPERATION_DESCRIBE_CONFIGS = 10
-    RD_KAFKA_ACL_OPERATION_ALTER_CONFIGS    = 11
+    RD_KAFKA_ACL_OPERATION_ALTER_CONFIGS = 11
     RD_KAFKA_ACL_OPERATION_IDEMPOTENT_WRITE = 12
 
     # rd_kafka_AclPermissionType_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L8435
-    RD_KAFKA_ACL_PERMISSION_TYPE_ANY     = 1
-    RD_KAFKA_ACL_PERMISSION_TYPE_DENY    = 2
-    RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW   = 3
+    RD_KAFKA_ACL_PERMISSION_TYPE_ANY = 1
+    RD_KAFKA_ACL_PERMISSION_TYPE_DENY = 2
+    RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
 
     # Extracting error details from Acl results
     attach_function :rd_kafka_acl_result_error, [:pointer], :pointer
@@ -595,14 +611,13 @@ module Rdkafka
     attach_function :rd_kafka_event_error_string, [:pointer], :pointer
     attach_function :rd_kafka_AclBinding_error, [:pointer], :pointer
 
-
     # FFI struct for native error (rd_kafka_error_t)
     class NativeError < FFI::Struct
       layout :code, :int32,
-             :errstr, :pointer,
-             :fatal, :u_int8_t,
-             :retriable, :u_int8_t,
-             :txn_requires_abort, :u_int8_t
+        :errstr, :pointer,
+        :fatal, :u_int8_t,
+        :retriable, :u_int8_t,
+        :txn_requires_abort, :u_int8_t
     end
 
     attach_function :rd_kafka_group_result_error, [:pointer], NativeError.by_ref # rd_kafka_group_result_t* => rd_kafka_error_t*

data/lib/rdkafka/callbacks.rb

@@ -92,15 +92,15 @@ module Rdkafka
 
       # @param acl_result_pointer [FFI::Pointer] pointer to the delete ACL result response struct
       def initialize(acl_result_pointer)
-        @matching_acls=[]
+        @matching_acls = []
         rd_kafka_error_pointer = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_response_error(acl_result_pointer)
         @result_error = Rdkafka::Bindings.rd_kafka_error_code(rd_kafka_error_pointer)
         @error_string = Rdkafka::Bindings.rd_kafka_error_string(rd_kafka_error_pointer)
         if @result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
-           # Get the number of matching acls
-           pointer_to_size_t = FFI::MemoryPointer.new(:int32)
-           @matching_acls = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_response_matching_acls(acl_result_pointer, pointer_to_size_t)
-           @matching_acls_count = pointer_to_size_t.read_int
+          # Get the number of matching acls
+          pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+          @matching_acls = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_response_matching_acls(acl_result_pointer, pointer_to_size_t)
+          @matching_acls_count = pointer_to_size_t.read_int
         end
       end
 
@@ -123,7 +123,7 @@ module Rdkafka
 
       # @param event_ptr [FFI::Pointer] pointer to the event
       def initialize(event_ptr)
-        @matching_acls=[]
+        @matching_acls = []
         @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
         @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
         if @result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
@@ -144,7 +144,7 @@ module Rdkafka
 
       # @param event_ptr [FFI::Pointer] pointer to the event
       def initialize(event_ptr)
-        @results=[]
+        @results = []
         @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
         @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
 
@@ -166,7 +166,7 @@ module Rdkafka
 
       # @param event_ptr [FFI::Pointer] pointer to the event
       def initialize(event_ptr)
-        @results=[]
+        @results = []
         @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
         @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
 
@@ -452,14 +452,14 @@ module Rdkafka
 
           # FFI Function used for Create Topic and Delete Topic callbacks
           background_event_callback_function = FFI::Function.new(
-              :void, [:pointer, :pointer, :pointer]
+            :void, [:pointer, :pointer, :pointer]
           ) do |client_ptr, event_ptr, opaque_ptr|
             BackgroundEventCallback.call(client_ptr, event_ptr, opaque_ptr)
           end
 
           # FFI Function used for Message Delivery callbacks
           delivery_callback_function = FFI::Function.new(
-              :void, [:pointer, :pointer, :pointer]
+            :void, [:pointer, :pointer, :pointer]
           ) do |client_ptr, message_ptr, opaque_ptr|
             DeliveryCallback.call(client_ptr, message_ptr, opaque_ptr)
           end