karafka-rdkafka 0.30.1-aarch64-linux-gnu → 0.31.0-aarch64-linux-gnu

data/lib/rdkafka/bindings.rb

@@ -90,780 +90,18 @@ module Rdkafka
     # librdkafka components without initializing the client
     # See: https://github.com/confluentinc/librdkafka/issues/4590
     attach_function :rd_kafka_global_init, [], :void
-
-    # Polling
-
-    attach_function :rd_kafka_flush, [:pointer, :int], :int, blocking: true
-    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
-    # Both return a newly allocated string the caller must release with rd_kafka_mem_free; they
-    # are attached as :pointer (not :string) so we can free them instead of leaking. clusterid
-    # also takes a timeout_ms (the previous arity was wrong, leaving that argument as garbage).
-    attach_function :rd_kafka_memberid, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_clusterid, [:pointer, :int], :pointer, blocking: true
-    attach_function :rd_kafka_mem_free, [:pointer, :pointer], :void
-    attach_function :rd_kafka_metadata, [:pointer, :int, :pointer, :pointer, :int], :int, blocking: true
-    attach_function :rd_kafka_metadata_destroy, [:pointer], :void, blocking: true
-
-    # 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
-    end
-
-    attach_function :rd_kafka_message_destroy, [:pointer], :void
-    attach_function :rd_kafka_message_timestamp, [:pointer, :pointer], :int64
-    attach_function :rd_kafka_topic_new, [:pointer, :string, :pointer], :pointer
-    attach_function :rd_kafka_topic_destroy, [:pointer], :pointer
-    attach_function :rd_kafka_topic_name, [:pointer], :string
-
-    # 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
-    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
-    end
-
-    attach_function :rd_kafka_topic_partition_list_new, [:int32], :pointer
-    attach_function :rd_kafka_topic_partition_list_add, [:pointer, :string, :int32], :pointer
-    attach_function :rd_kafka_topic_partition_list_set_offset, [:pointer, :string, :int32, :int64], :void
-    attach_function :rd_kafka_topic_partition_list_destroy, [:pointer], :void
-    attach_function :rd_kafka_topic_partition_list_copy, [:pointer], :pointer
-
-    # FFI struct representing a config resource (rd_kafka_ConfigResource_t)
-    # Structs for management of configurations. Each configuration is attached to a resource
-    # and one resource can have many configuration details. Each resource will also have
-    # separate errors results if obtaining configuration was not possible for any reason
-    class ConfigResource < FFI::Struct
-      layout :type, :int,
-        :name, :string
-    end
-
-    attach_function :rd_kafka_DescribeConfigs, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_ConfigResource_new, [:int32, :pointer], :pointer
-    attach_function :rd_kafka_ConfigResource_destroy, [:pointer], :void
-    attach_function :rd_kafka_ConfigResource_destroy_array, [:pointer, :int32], :void
-    attach_function :rd_kafka_event_DescribeConfigs_result, [:pointer], :pointer
-    attach_function :rd_kafka_DescribeConfigs_result_resources, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_ConfigResource_configs, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_ConfigEntry_name, [:pointer], :string
-    attach_function :rd_kafka_ConfigEntry_value, [:pointer], :string
-    attach_function :rd_kafka_ConfigEntry_is_read_only, [:pointer], :int
-    attach_function :rd_kafka_ConfigEntry_is_default, [:pointer], :int
-    attach_function :rd_kafka_ConfigEntry_is_sensitive, [:pointer], :int
-    attach_function :rd_kafka_ConfigEntry_is_synonym, [:pointer], :int
-    attach_function :rd_kafka_ConfigEntry_synonyms, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_ConfigResource_error, [:pointer], :int
-    attach_function :rd_kafka_ConfigResource_error_string, [:pointer], :string
-    attach_function :rd_kafka_IncrementalAlterConfigs, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_IncrementalAlterConfigs_result_resources, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_ConfigResource_add_incremental_config, [:pointer, :string, :int32, :string], :pointer
-    attach_function :rd_kafka_event_IncrementalAlterConfigs_result, [:pointer], :pointer
-
-    RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS = 5
-    RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT = 104
-
-    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_SUBTRACT = 3
-
-    # List Offsets
-    RD_KAFKA_ADMIN_OP_LISTOFFSETS = 21
-    RD_KAFKA_EVENT_LISTOFFSETS_RESULT = 0x400000
-
-    # rd_kafka_IsolationLevel_t
-    RD_KAFKA_ISOLATION_LEVEL_READ_UNCOMMITTED = 0
-    RD_KAFKA_ISOLATION_LEVEL_READ_COMMITTED = 1
-
-    # rd_kafka_OffsetSpec_t
-    RD_KAFKA_OFFSET_SPEC_MAX_TIMESTAMP = -3
-    RD_KAFKA_OFFSET_SPEC_EARLIEST = -2
-    RD_KAFKA_OFFSET_SPEC_LATEST = -1
-
-    attach_function :rd_kafka_ListOffsets, [:pointer, :pointer, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_event_ListOffsets_result, [:pointer], :pointer
-    attach_function :rd_kafka_ListOffsets_result_infos, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_ListOffsetsResultInfo_topic_partition, [:pointer], :pointer
-    attach_function :rd_kafka_ListOffsetsResultInfo_timestamp, [:pointer], :int64
-    attach_function :rd_kafka_AdminOptions_set_isolation_level, [:pointer, :int], :pointer
-    attach_function :rd_kafka_topic_partition_get_leader_epoch, [:pointer], :int32
-
-    # FFI struct for error description (rd_kafka_err_desc)
-    class NativeErrorDesc < FFI::Struct
-      layout :code, :int,
-        :name, :pointer,
-        :desc, :pointer
-    end
-
-    attach_function :rd_kafka_err2name, [:int], :string
-    attach_function :rd_kafka_err2str, [:int], :string
-    attach_function :rd_kafka_error_is_fatal, [:pointer], :int
-    attach_function :rd_kafka_error_is_retriable, [:pointer], :int
-    attach_function :rd_kafka_error_txn_requires_abort, [:pointer], :int
-    attach_function :rd_kafka_error_destroy, [:pointer], :void
-    attach_function :rd_kafka_get_err_descs, [:pointer, :pointer], :void
-    attach_function :rd_kafka_fatal_error, [:pointer, :pointer, :int], :int
-    attach_function :rd_kafka_test_fatal_error, [:pointer, :int, :string], :int
-
-    # Configuration
-
-    enum :kafka_config_response, [
-      :config_unknown, -2,
-      :config_invalid, -1,
-      :config_ok, 0
-    ]
-
-    attach_function :rd_kafka_conf_new, [], :pointer
-    attach_function :rd_kafka_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
-    attach_function :rd_kafka_conf_get, [:pointer, :string, :pointer, :pointer], :kafka_config_response
-    attach_function :rd_kafka_conf, [:pointer], :pointer
-    attach_function :rd_kafka_conf_dump, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_conf_dump_free, [:pointer, :size_t], :void
-    attach_function :rd_kafka_conf_destroy, [:pointer], :void
-    callback :log_cb, [:pointer, :int, :string, :string], :void
-    attach_function :rd_kafka_conf_set_log_cb, [:pointer, :log_cb], :void
-    attach_function :rd_kafka_conf_set_opaque, [:pointer, :pointer], :void
-    callback :stats_cb, [:pointer, :string, :int, :pointer], :int
-    attach_function :rd_kafka_conf_set_stats_cb, [:pointer, :stats_cb], :void
-    callback :error_cb, [:pointer, :int, :string, :pointer], :void
-    attach_function :rd_kafka_conf_set_error_cb, [:pointer, :error_cb], :void
-    attach_function :rd_kafka_rebalance_protocol, [:pointer], :string
-    callback :oauthbearer_token_refresh_cb, [:pointer, :string, :pointer], :void
-    attach_function :rd_kafka_conf_set_oauthbearer_token_refresh_cb, [:pointer, :oauthbearer_token_refresh_cb], :void
-    attach_function :rd_kafka_oauthbearer_set_token, [:pointer, :string, :int64, :pointer, :pointer, :int, :pointer, :int], :int
-    attach_function :rd_kafka_oauthbearer_set_token_failure, [:pointer, :string], :int
-    # 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
-    # Arguments:
-    # - queue (rd_kafka_queue_t*) - the queue to monitor
-    # - fd (int) - file descriptor to write to (provide your own pipe/eventfd)
-    # - payload (const void*) - data to write to fd
-    # - 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_destroy, [:pointer], :void
-    attach_function :rd_kafka_topic_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
-
-    LogCallback = FFI::Function.new(
-      :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
-
-      Rdkafka::Config.ensure_log_thread
-      Rdkafka::Config.log_queue << [severity, "rdkafka: #{line}"]
-    end
-
-    StatsCallback = FFI::Function.new(
-      :int, [:pointer, :string, :int, :pointer]
-    ) do |_client_ptr, json, _json_len, _opaque|
-      if Rdkafka::Config.statistics_callback
-        stats = JSON.parse(json)
-
-        # If user requested statistics callbacks, we can use the statistics data to get the
-        # partitions count for each topic when this data is published. That way we do not have
-        # to query this information when user is using `partition_key`. This takes around 0.02ms
-        # every statistics interval period (most likely every 5 seconds) and saves us from making
-        # any queries to the cluster for the partition count.
-        #
-        # One edge case is if user would set the `statistics.interval.ms` much higher than the
-        # default current partition count refresh (30 seconds). This is taken care of as the lack
-        # of reporting to the partitions cache will cause cache expire and blocking refresh.
-        #
-        # If user sets `topic.metadata.refresh.interval.ms` too high this is on the user.
-        #
-        # 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.count { |k| !(k == RD_KAFKA_PARTITION_UA_STR) }
-
-          next unless partitions_count.positive?
-
-          Rdkafka::Producer.partitions_count_cache.set(topic_name, partitions_count)
-        end
-
-        Rdkafka::Config.statistics_callback.call(stats)
-      end
-
-      # Return 0 so librdkafka frees the json string
-      RD_KAFKA_RESP_ERR_NO_ERROR
-    end
-
-    # Retrieves fatal error details from a kafka client handle.
-    # This is a helper method to extract fatal error information consistently
-    # across different parts of the codebase (callbacks, testing utilities, etc.).
-    #
-    # @param client_ptr [FFI::Pointer] Native kafka client pointer
-    # @return [Hash, nil] Hash with :error_code and :error_string if fatal error occurred,
-    #   nil otherwise
-    #
-    # @example
-    #   details = Rdkafka::Bindings.extract_fatal_error(client_ptr)
-    #   if details
-    #     puts "Fatal error #{details[:error_code]}: #{details[:error_string]}"
-    #   end
-    def self.extract_fatal_error(client_ptr)
-      error_buffer = FFI::MemoryPointer.new(:char, FATAL_ERROR_BUFFER_SIZE)
-
-      error_code = rd_kafka_fatal_error(client_ptr, error_buffer, FATAL_ERROR_BUFFER_SIZE)
-
-      return nil if error_code == RD_KAFKA_RESP_ERR_NO_ERROR
-
-      {
-        error_code: error_code,
-        error_string: error_buffer.read_string
-      }
-    end
-
-    ErrorCallback = FFI::Function.new(
-      :void, [:pointer, :int, :string, :pointer]
-    ) do |client_ptr, err_code, reason, _opaque|
-      if Rdkafka::Config.error_callback
-        instance_name = client_ptr.null? ? nil : Rdkafka::Bindings.rd_kafka_name(client_ptr)
-
-        # Handle fatal errors according to librdkafka documentation:
-        # When ERR__FATAL is received, we must call rd_kafka_fatal_error()
-        # to get the actual underlying fatal error code and description.
-        error = if err_code == RD_KAFKA_RESP_ERR__FATAL
-          Rdkafka::RdkafkaError.build_fatal(
-            client_ptr,
-            fallback_error_code: err_code,
-            fallback_message: reason,
-            instance_name: instance_name
-          )
-        else
-          Rdkafka::RdkafkaError.build(err_code, broker_message: reason, instance_name: instance_name)
-        end
-
-        error.set_backtrace(caller)
-        Rdkafka::Config.error_callback.call(error)
-      end
-    end
-
-    # The OAuth callback is currently global and contextless. This means that the callback will be
-    # called for all instances, and the callback must be able to determine to which instance it is
-    # associated. The instance name will be provided in the callback, allowing the callback to
-    # reference the correct instance.
-    #
-    # An example of how to use the instance name in the callback is given below.
-    # The `refresh_token` is configured as the `oauthbearer_token_refresh_callback`.
-    # `instances` is a map of client names to client instances, maintained by the user.
-    #
-    # ```
-    #   def refresh_token(config, client_name)
-    #     client = instances[client_name]
-    #     client.oauthbearer_set_token(
-    #       token: 'new-token-value',
-    #       lifetime_ms: token-lifetime-ms,
-    #       principal_name: 'principal-name'
-    #     )
-    #   end
-    # ```
-    OAuthbearerTokenRefreshCallback = FFI::Function.new(
-      :void, [:pointer, :string, :pointer]
-    ) do |client_ptr, config, opaque_ptr|
-      if Rdkafka::Config.oauthbearer_token_refresh_callback && !client_ptr.null?
-        client_name = Rdkafka::Bindings.rd_kafka_name(client_ptr)
-
-        # Share consumers have no way to query their librdkafka client name (the share handle
-        # exposes no name accessor), so hand it over here - where librdkafka provides it -
-        # letting applications correlate this callback's client name with a ShareConsumer via
-        # ShareConsumer#name.
-        Rdkafka::Config.opaques[opaque_ptr.to_i]&.capture_client_name(client_name)
-
-        Rdkafka::Config.oauthbearer_token_refresh_callback.call(config, client_name)
-      end
-    end
-
-    # Handle
-
-    enum :kafka_type, [
-      :rd_kafka_producer,
-      :rd_kafka_consumer
-    ]
-
-    attach_function :rd_kafka_new, [:kafka_type, :pointer, :pointer, :int], :pointer
-
-    attach_function :rd_kafka_destroy, [:pointer], :void
-
-    # Consumer
-
-    attach_function :rd_kafka_subscribe, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_unsubscribe, [:pointer], :int, blocking: true
-    attach_function :rd_kafka_subscription, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_assign, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_incremental_assign, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_incremental_unassign, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_assignment, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_assignment_lost, [:pointer], :int, blocking: true
-    attach_function :rd_kafka_committed, [:pointer, :pointer, :int], :int, blocking: true
-    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_queue_get_consumer, [:pointer], :pointer
-    attach_function :rd_kafka_consume_batch_queue, [:pointer, :int, :pointer, :size_t], :ssize_t, blocking: true
-    attach_function :rd_kafka_consume_batch_queue_nb, :rd_kafka_consume_batch_queue, [:pointer, :int, :pointer, :size_t], :ssize_t, blocking: false
-    attach_function :rd_kafka_offsets_store, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_pause_partitions, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_resume_partitions, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_seek, [:pointer, :int32, :int64, :int], :int, blocking: true
-    attach_function :rd_kafka_offsets_for_times, [:pointer, :pointer, :int], :int, blocking: true
-    attach_function :rd_kafka_position, [:pointer, :pointer], :int, blocking: true
-    # those two are used for eos support
-    attach_function :rd_kafka_consumer_group_metadata, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_consumer_group_metadata_destroy, [:pointer], :void, blocking: true
-
-    # Headers
-    attach_function :rd_kafka_header_get_all, [:pointer, :size_t, :pointer, :pointer, SizePtr], :int
-    attach_function :rd_kafka_message_headers, [:pointer, :pointer], :int
-
-    # Rebalance
-
-    callback :rebalance_cb_function, [:pointer, :int, :pointer, :pointer], :void
-    attach_function :rd_kafka_conf_set_rebalance_cb, [:pointer, :rebalance_cb_function], :void, blocking: true
-
-    RebalanceCallback = FFI::Function.new(
-      :void, [:pointer, :int, :pointer, :pointer]
-    ) do |client_ptr, code, partitions_ptr, opaque_ptr|
-      case code
-      when RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS
-        if Rdkafka::Bindings.rd_kafka_rebalance_protocol(client_ptr) == "COOPERATIVE"
-          Rdkafka::Bindings.rd_kafka_incremental_assign(client_ptr, partitions_ptr)
-        else
-          Rdkafka::Bindings.rd_kafka_assign(client_ptr, partitions_ptr)
-        end
-      else # RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS or errors
-        if Rdkafka::Bindings.rd_kafka_rebalance_protocol(client_ptr) == "COOPERATIVE"
-          Rdkafka::Bindings.rd_kafka_incremental_unassign(client_ptr, partitions_ptr)
-        else
-          Rdkafka::Bindings.rd_kafka_assign(client_ptr, FFI::Pointer::NULL)
-        end
-      end
-
-      opaque = Rdkafka::Config.opaques[opaque_ptr.to_i]
-      return unless opaque
-
-      tpl = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(partitions_ptr).freeze
-      begin
-        case code
-        when RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS
-          opaque.call_on_partitions_assigned(tpl)
-        when RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS
-          opaque.call_on_partitions_revoked(tpl)
-        end
-      rescue Exception => err
-        Rdkafka::Config.logger.error("Unhandled exception: #{err.class} - #{err.message}")
-      end
-    end
-
-    # Share consumer (KIP-932, preview)
-    #
-    # The share consumer is a distinct librdkafka handle type (rd_kafka_share_t) created with
-    # 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
-    RD_KAFKA_SHARE_ACKNOWLEDGE_TYPE_REJECT = 3
-
-    attach_function :rd_kafka_share_consumer_new, [:pointer, :pointer, :size_t], :pointer
-    attach_function :rd_kafka_share_consumer_close, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_share_consumer_closed, [:pointer], :int
-    attach_function :rd_kafka_share_destroy, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_share_set_log_queue, [:pointer, :pointer], :pointer
-
-    attach_function :rd_kafka_share_subscribe, [:pointer, :pointer], :int, blocking: true
-    attach_function :rd_kafka_share_unsubscribe, [:pointer], :int, blocking: true
-    attach_function :rd_kafka_share_subscription, [:pointer, :pointer], :int, blocking: true
-
-    attach_function :rd_kafka_share_poll, [:pointer, :int, :pointer], :pointer, blocking: true
-    attach_function :rd_kafka_messages_count, [:pointer], :size_t
-    attach_function :rd_kafka_messages_get, [:pointer, :size_t], :pointer
-    attach_function :rd_kafka_messages_destroy, [:pointer], :void
-    attach_function :rd_kafka_message_delivery_count, [:pointer], :int16
-
-    # The by-coordinates acknowledge variant is the only one we bind: Ruby messages are copies
-    # that do not retain the native rd_kafka_message_t pointer, so the message-pointer variants
-    # (rd_kafka_share_acknowledge / rd_kafka_share_acknowledge_type) cannot be used safely here.
-    attach_function :rd_kafka_share_acknowledge_offset, [:pointer, :string, :int32, :int64, :int], :int
-
-    attach_function :rd_kafka_share_commit_sync, [:pointer, :int, :pointer], :pointer, blocking: true
-    attach_function :rd_kafka_share_commit_async, [:pointer], :pointer
-
-    callback :share_acknowledgement_commit_cb, [:pointer, :pointer, :int, :pointer], :void
-    attach_function :rd_kafka_share_set_acknowledgement_commit_cb, [:pointer, :share_acknowledgement_commit_cb, :pointer], :pointer
-
-    # Accessors for the rd_kafka_share_partition_offsets_list_t handed to the acknowledgement
-    # commit callback. The list is owned by librdkafka for the duration of the callback: read it
-    # inside the callback only, never destroy or retain it.
-    attach_function :rd_kafka_share_partition_offsets_list_count, [:pointer], :size_t
-    attach_function :rd_kafka_share_partition_offsets_list_get, [:pointer, :size_t], :pointer
-    attach_function :rd_kafka_share_partition_offsets_partition, [:pointer], :pointer
-    attach_function :rd_kafka_share_partition_offsets_offsets, [:pointer], :pointer
-    attach_function :rd_kafka_share_partition_offsets_offsets_cnt, [:pointer], :size_t
-
-    attach_function :rd_kafka_share_oauthbearer_set_token, [:pointer, :string, :int64, :string, :pointer, :size_t, :pointer, :size_t], :int
-    attach_function :rd_kafka_share_oauthbearer_set_token_failure, [:pointer, :string], :int
-
-    # Stats
-
-    attach_function :rd_kafka_query_watermark_offsets, [:pointer, :string, :int, :pointer, :pointer, :int], :int, blocking: true
-
-    # Producer
-    RD_KAFKA_VTYPE_END = 0
-    RD_KAFKA_VTYPE_TOPIC = 1
-    RD_KAFKA_VTYPE_RKT = 2
-    RD_KAFKA_VTYPE_PARTITION = 3
-    RD_KAFKA_VTYPE_VALUE = 4
-    RD_KAFKA_VTYPE_KEY = 5
-    RD_KAFKA_VTYPE_OPAQUE = 6
-    RD_KAFKA_VTYPE_MSGFLAGS = 7
-    RD_KAFKA_VTYPE_TIMESTAMP = 8
-    RD_KAFKA_VTYPE_HEADER = 9
-    RD_KAFKA_VTYPE_HEADERS = 10
-    RD_KAFKA_PURGE_F_QUEUE = 1
-    RD_KAFKA_PURGE_F_INFLIGHT = 2
-
-    RD_KAFKA_MSG_F_COPY = 0x2
-
-    attach_function :rd_kafka_producev, [:pointer, :varargs], :int, blocking: true
-    attach_function :rd_kafka_purge, [:pointer, :int], :int, blocking: true
-    callback :delivery_cb, [:pointer, :pointer, :pointer], :void
-    attach_function :rd_kafka_conf_set_dr_msg_cb, [:pointer, :delivery_cb], :void
-    attach_function :rd_kafka_init_transactions, [:pointer, :int], :pointer, blocking: true
-    attach_function :rd_kafka_send_offsets_to_transaction, [:pointer, :pointer, :pointer, :int], :pointer, blocking: true
-    attach_function :rd_kafka_begin_transaction, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_abort_transaction, [:pointer, :int], :pointer, blocking: true
-    attach_function :rd_kafka_commit_transaction, [:pointer, :int], :pointer, blocking: true
-
-    # 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}"
-      attach_function method_name, [:pointer, :pointer, :size_t, :int32, :pointer, :pointer], :int32
-      hsh[name] = method_name
-    end
-
-    # Calculates the partition for a message based on the partitioner
-    #
-    # @param topic_ptr [FFI::Pointer] pointer to the topic handle
-    # @param str [String] the partition key string
-    # @param partition_count [Integer, nil] number of partitions
-    # @param partitioner [String] name of the partitioner to use
-    # @return [Integer] partition number or RD_KAFKA_PARTITION_UA if unassigned
-    # @raise [Rdkafka::Config::ConfigError] when an unknown partitioner is specified
-    def self.partitioner(topic_ptr, str, partition_count, partitioner = "consistent_random")
-      # Return RD_KAFKA_PARTITION_UA(unassigned partition) when partition count is nil/zero.
-      return RD_KAFKA_PARTITION_UA unless partition_count&.nonzero?
-
-      str_ptr = str.empty? ? FFI::MemoryPointer::NULL : FFI::MemoryPointer.from_string(str)
-      method_name = PARTITIONERS.fetch(partitioner) do
-        raise Rdkafka::Config::ConfigError.new("Unknown partitioner: #{partitioner}")
-      end
-
-      public_send(method_name, topic_ptr, str_ptr, partition_key_length(str), partition_count, nil, nil)
-    end
-
-    # Partition key length as the character count (legacy default).
-    #
-    # @param str [String] the partition key string
-    # @return [Integer]
-    def self.partition_key_size(str)
-      str.size
-    end
-
-    # Partition key length as the byte count, which is what librdkafka hashes (UTF-8 bytes copied
-    # into the key pointer) and what other Kafka clients use.
-    #
-    # @param str [String] the partition key string
-    # @return [Integer]
-    def self.partition_key_bytesize(str)
-      str.bytesize
-    end
-
-    # Length of the partition key passed to librdkafka. Aliased to one of the methods above by
-    # `Rdkafka::Config.partitioner_key_uses_bytesize=`, so the per-message path does not check the
-    # setting on every call.
-    singleton_class.alias_method :partition_key_length, :partition_key_size
-
-    # Create Topics
-    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
-    attach_function :rd_kafka_NewTopic_new, [:pointer, :size_t, :size_t, :pointer, :size_t], :pointer, blocking: true
-    attach_function :rd_kafka_NewTopic_set_config, [:pointer, :string, :string], :int32, blocking: true
-    attach_function :rd_kafka_NewTopic_destroy, [:pointer], :void, blocking: true
-    attach_function :rd_kafka_event_CreateTopics_result, [:pointer], :pointer, blocking: true
-    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_EVENT_DELETETOPICS_RESULT = 101 # rd_kafka_event_type_t
-
-    attach_function :rd_kafka_DeleteTopics, [:pointer, :pointer, :size_t, :pointer, :pointer], :int32, blocking: true
-    attach_function :rd_kafka_DeleteTopic_new, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_DeleteTopic_destroy, [:pointer], :void, blocking: true
-    attach_function :rd_kafka_event_DeleteTopics_result, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_DeleteTopics_result_topics, [:pointer, :pointer], :pointer, blocking: true
-
-    # Create partitions
-    RD_KAFKA_ADMIN_OP_CREATEPARTITIONS = 3
-    RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT = 102
-
-    attach_function :rd_kafka_CreatePartitions, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
-    attach_function :rd_kafka_NewPartitions_new, %i[pointer size_t pointer size_t], :pointer
-    attach_function :rd_kafka_NewPartitions_destroy, [:pointer], :void
-    attach_function :rd_kafka_event_CreatePartitions_result, [:pointer], :pointer
-    attach_function :rd_kafka_CreatePartitions_result_topics, [:pointer, :pointer], :pointer
-
-    # Delete Group
-    RD_KAFKA_ADMIN_OP_DELETEGROUPS = 7   # rd_kafka_admin_op_t
-    RD_KAFKA_EVENT_DELETEGROUPS_RESULT = 106 # rd_kafka_event_type_t
-
-    attach_function :rd_kafka_DeleteGroups, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_DeleteGroup_new, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_DeleteGroup_destroy, [:pointer], :void, blocking: true
-    attach_function :rd_kafka_event_DeleteGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteGroups_result_t*
-    attach_function :rd_kafka_DeleteGroups_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_DeleteGroups_result_t*, size_t* => rd_kafka_group_result_t**
-
-    # Alter Consumer Group Offsets
-    RD_KAFKA_ADMIN_OP_ALTERCONSUMERGROUPOFFSETS = 15   # rd_kafka_admin_op_t
-    RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT = 0x10000 # rd_kafka_event_type_t
-
-    attach_function :rd_kafka_AlterConsumerGroupOffsets, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_AlterConsumerGroupOffsets_new, [:pointer, :pointer], :pointer, blocking: true # const char*, const rd_kafka_topic_partition_list_t* => rd_kafka_AlterConsumerGroupOffsets_t*
-    attach_function :rd_kafka_AlterConsumerGroupOffsets_destroy, [:pointer], :void, blocking: true
-    attach_function :rd_kafka_event_AlterConsumerGroupOffsets_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_AlterConsumerGroupOffsets_result_t*
-    attach_function :rd_kafka_AlterConsumerGroupOffsets_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_AlterConsumerGroupOffsets_result_t*, size_t* => rd_kafka_group_result_t**
-
-    # Delete Consumer Group Offsets
-    RD_KAFKA_ADMIN_OP_DELETECONSUMERGROUPOFFSETS = 8   # rd_kafka_admin_op_t
-    RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT = 107 # rd_kafka_event_type_t
-
-    attach_function :rd_kafka_DeleteConsumerGroupOffsets, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_DeleteConsumerGroupOffsets_new, [:pointer, :pointer], :pointer, blocking: true # const char*, const rd_kafka_topic_partition_list_t* => rd_kafka_DeleteConsumerGroupOffsets_t*
-    attach_function :rd_kafka_DeleteConsumerGroupOffsets_destroy, [:pointer], :void, blocking: true
-    attach_function :rd_kafka_event_DeleteConsumerGroupOffsets_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteConsumerGroupOffsets_result_t*
-    attach_function :rd_kafka_DeleteConsumerGroupOffsets_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_DeleteConsumerGroupOffsets_result_t*, size_t* => rd_kafka_group_result_t**
-
-    # Delete Records
-    RD_KAFKA_ADMIN_OP_DELETERECORDS = 6   # rd_kafka_admin_op_t
-    RD_KAFKA_EVENT_DELETERECORDS_RESULT = 105 # rd_kafka_event_type_t
-
-    attach_function :rd_kafka_DeleteRecords, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_DeleteRecords_new, [:pointer], :pointer, blocking: true
-    attach_function :rd_kafka_DeleteRecords_destroy, [:pointer], :void, blocking: true
-    attach_function :rd_kafka_event_DeleteRecords_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteRecords_result_t*
-    attach_function :rd_kafka_DeleteRecords_result_offsets, [:pointer], :pointer, blocking: true # rd_kafka_DeleteRecords_result_t* => rd_kafka_topic_partition_list_t*
-
-    # List Consumer Groups
-    RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS = 12   # rd_kafka_admin_op_t
-    RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT = 0x2000 # rd_kafka_event_type_t
-
-    # Consumer group states (rd_kafka_consumer_group_state_t)
-    RD_KAFKA_CONSUMER_GROUP_STATE_UNKNOWN = 0
-    RD_KAFKA_CONSUMER_GROUP_STATE_PREPARING_REBALANCE = 1
-    RD_KAFKA_CONSUMER_GROUP_STATE_COMPLETING_REBALANCE = 2
-    RD_KAFKA_CONSUMER_GROUP_STATE_STABLE = 3
-    RD_KAFKA_CONSUMER_GROUP_STATE_DEAD = 4
-    RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY = 5
-
-    attach_function :rd_kafka_ListConsumerGroups, [:pointer, :pointer, :pointer], :void, blocking: true
-    attach_function :rd_kafka_event_ListConsumerGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_ListConsumerGroups_result_t*
-    attach_function :rd_kafka_ListConsumerGroups_result_valid, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_ConsumerGroupListing_t**
-    attach_function :rd_kafka_ListConsumerGroups_result_errors, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_error_t**
-    attach_function :rd_kafka_ConsumerGroupListing_group_id, [:pointer], :pointer, blocking: true # => const char*
-    attach_function :rd_kafka_ConsumerGroupListing_is_simple_consumer_group, [:pointer], :int, blocking: true
-    attach_function :rd_kafka_ConsumerGroupListing_state, [:pointer], :int, blocking: true
-    attach_function :rd_kafka_consumer_group_state_name, [:int], :pointer, blocking: true # => const char*
-
-    # Background Queue and Callback
-
-    attach_function :rd_kafka_conf_set_background_event_cb, [:pointer, :pointer], :void
-    attach_function :rd_kafka_queue_destroy, [:pointer], :void
-
-    # Admin Options
-
-    attach_function :rd_kafka_AdminOptions_new, [:pointer, :int32], :pointer
-    attach_function :rd_kafka_AdminOptions_set_opaque, [:pointer, :pointer], :void
-    attach_function :rd_kafka_AdminOptions_destroy, [:pointer], :void
-
-    # Extracting data from event types
-
-    attach_function :rd_kafka_event_type, [:pointer], :int32
-    attach_function :rd_kafka_event_opaque, [:pointer], :pointer
-    attach_function :rd_kafka_event_destroy, [:pointer], :void
-
-    # Extracting data from topic results
-
-    attach_function :rd_kafka_topic_result_error, [:pointer], :int32
-    attach_function :rd_kafka_topic_result_error_string, [:pointer], :pointer
-    attach_function :rd_kafka_topic_result_name, [:pointer], :pointer
-
-    # Create Acls
-    RD_KAFKA_ADMIN_OP_CREATEACLS = 9
-    RD_KAFKA_EVENT_CREATEACLS_RESULT = 1024
-
-    attach_function :rd_kafka_CreateAcls, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
-    attach_function :rd_kafka_event_CreateAcls_result, [:pointer], :pointer
-    attach_function :rd_kafka_CreateAcls_result_acls, [:pointer, :pointer], :pointer
-
-    # Delete Acls
-    RD_KAFKA_ADMIN_OP_DELETEACLS = 11
-    RD_KAFKA_EVENT_DELETEACLS_RESULT = 4096
-
-    attach_function :rd_kafka_DeleteAcls, [:pointer, :pointer, :size_t, :pointer, :pointer], :void
-    attach_function :rd_kafka_event_DeleteAcls_result, [:pointer], :pointer
-    attach_function :rd_kafka_DeleteAcls_result_responses, [:pointer, :pointer], :pointer
-    attach_function :rd_kafka_DeleteAcls_result_response_error, [:pointer], :pointer
-    attach_function :rd_kafka_DeleteAcls_result_response_matching_acls, [:pointer, :pointer], :pointer
-
-    # Describe Acls
-    RD_KAFKA_ADMIN_OP_DESCRIBEACLS = 10
-    RD_KAFKA_EVENT_DESCRIBEACLS_RESULT = 2048
-
-    attach_function :rd_kafka_DescribeAcls, [:pointer, :pointer, :pointer, :pointer], :void
-    attach_function :rd_kafka_event_DescribeAcls_result, [:pointer], :pointer
-    attach_function :rd_kafka_DescribeAcls_result_acls, [:pointer, :pointer], :pointer
-
-    # Acl Bindings
-
-    attach_function :rd_kafka_AclBinding_restype, [:pointer], :int32
-    attach_function :rd_kafka_AclBinding_name, [:pointer], :pointer
-    attach_function :rd_kafka_AclBinding_resource_pattern_type, [:pointer], :int32
-    attach_function :rd_kafka_AclBinding_principal, [:pointer], :pointer
-    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_destroy, [:pointer], :void
-
-    # rd_kafka_ResourceType_t -
-    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L7307
-    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/292d2a66b992/src/rdkafka.h#L7320
-    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/292d2a66b992/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_DESCRIBE_CONFIGS = 10
-    RD_KAFKA_ACL_OPERATION_ALTER_CONFIGS = 11
-    RD_KAFKA_ACL_OPERATION_IDEMPOTENT_WRITE = 12
-
-    # rd_kafka_AclPermissionType_t -
-    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/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
-
-    # Extracting error details from Acl results
-    attach_function :rd_kafka_acl_result_error, [:pointer], :pointer
-    attach_function :rd_kafka_error_code, [:pointer], :int32
-    attach_function :rd_kafka_error_string, [:pointer], :pointer
-    attach_function :rd_kafka_event_error, [:pointer], :int32
-    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
-    end
-
-    attach_function :rd_kafka_group_result_error, [:pointer], NativeError.by_ref # rd_kafka_group_result_t* => rd_kafka_error_t*
-    attach_function :rd_kafka_group_result_name, [:pointer], :pointer
-    attach_function :rd_kafka_group_result_partitions, [:pointer], :pointer # rd_kafka_group_result_t* => rd_kafka_topic_partition_list_t*
   end
 end
+
+require_relative "bindings/structs"
+require_relative "bindings/polling"
+require_relative "bindings/metadata"
+require_relative "bindings/messages"
+require_relative "bindings/errors"
+require_relative "bindings/configuration"
+require_relative "bindings/callbacks"
+require_relative "bindings/handle"
+require_relative "bindings/consumer"
+require_relative "bindings/share_consumer"
+require_relative "bindings/producer"
+require_relative "bindings/admin"