@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/deps/librdkafka/src/rdkafka_int.h

@@ -0,0 +1,1505 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ *               2023, Confluent Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _RDKAFKA_INT_H_
+#define _RDKAFKA_INT_H_
+
+#ifndef _WIN32
+#define _GNU_SOURCE /* for strndup() */
+#endif
+
+#ifdef _MSC_VER
+typedef int mode_t;
+#endif
+
+#include <fcntl.h>
+
+
+#include "rdsysqueue.h"
+
+#include "rdkafka.h"
+#include "rd.h"
+#include "rdlog.h"
+#include "rdtime.h"
+#include "rdaddr.h"
+#include "rdinterval.h"
+#include "rdavg.h"
+#include "rdlist.h"
+
+#if WITH_SSL
+#include <openssl/ssl.h>
+#endif
+
+
+
+#define rd_kafka_assert(rk, cond)                                              \
+        do {                                                                   \
+                if (unlikely(!(cond)))                                         \
+                        rd_kafka_crash(__FILE__, __LINE__, __FUNCTION__, (rk), \
+                                       "assert: " #cond);                      \
+        } while (0)
+
+
+void RD_NORETURN rd_kafka_crash(const char *file,
+                                int line,
+                                const char *function,
+                                rd_kafka_t *rk,
+                                const char *reason);
+
+
+/* Forward declarations */
+struct rd_kafka_s;
+struct rd_kafka_topic_s;
+struct rd_kafka_msg_s;
+struct rd_kafka_broker_s;
+struct rd_kafka_toppar_s;
+typedef struct rd_kafka_metadata_internal_s rd_kafka_metadata_internal_t;
+typedef struct rd_kafka_toppar_s rd_kafka_toppar_t;
+typedef struct rd_kafka_lwtopic_s rd_kafka_lwtopic_t;
+
+
+/**
+ * Protocol level sanity
+ */
+#define RD_KAFKAP_BROKERS_MAX    10000
+#define RD_KAFKAP_TOPICS_MAX     1000000
+#define RD_KAFKAP_PARTITIONS_MAX 100000
+
+
+#define RD_KAFKA_OFFSET_IS_LOGICAL(OFF) ((OFF) < 0)
+
+/**
+ * TODO KIP-932: Remove the check of RD_KAFKA_CONSUMER. Only
+ * checking for is_share_consumer should be sufficient.
+ */
+#define RD_KAFKA_IS_SHARE_CONSUMER(rk)                                         \
+        ((rk)->rk_type == RD_KAFKA_CONSUMER &&                                 \
+         (rk)->rk_conf.share.is_share_consumer)
+
+/**
+ * @struct Represents a fetch position:
+ *         an offset and an partition leader epoch (if known, else -1).
+ */
+typedef struct rd_kafka_fetch_pos_s {
+        int64_t offset;
+        int32_t leader_epoch;
+        rd_bool_t validated;
+} rd_kafka_fetch_pos_t;
+
+
+
+#include "rdkafka_op.h"
+#include "rdkafka_queue.h"
+#include "rdkafka_msg.h"
+#include "rdkafka_proto.h"
+#include "rdkafka_buf.h"
+#include "rdkafka_pattern.h"
+#include "rdkafka_conf.h"
+#include "rdkafka_transport.h"
+#include "rdkafka_timer.h"
+#include "rdkafka_assignor.h"
+#include "rdkafka_metadata.h"
+#include "rdkafka_mock.h"
+#include "rdkafka_partition.h"
+#include "rdkafka_assignment.h"
+#include "rdkafka_coord.h"
+#include "rdkafka_mock.h"
+
+/**
+ * Protocol level sanity
+ */
+#define RD_KAFKAP_BROKERS_MAX              10000
+#define RD_KAFKAP_TOPICS_MAX               1000000
+#define RD_KAFKAP_PARTITIONS_MAX           100000
+#define RD_KAFKAP_GROUPS_MAX               100000
+#define RD_KAFKAP_CONFIGS_MAX              10000
+#define RD_KAFKAP_ABORTED_TRANSACTIONS_MAX 1000000
+
+#define RD_KAFKA_OFFSET_IS_LOGICAL(OFF) ((OFF) < 0)
+
+
+
+/**
+ * @enum Idempotent Producer state
+ */
+typedef enum {
+        RD_KAFKA_IDEMP_STATE_INIT,        /**< Initial state */
+        RD_KAFKA_IDEMP_STATE_TERM,        /**< Instance is terminating */
+        RD_KAFKA_IDEMP_STATE_FATAL_ERROR, /**< A fatal error has been raised */
+        RD_KAFKA_IDEMP_STATE_REQ_PID,     /**< Request new PID */
+        RD_KAFKA_IDEMP_STATE_WAIT_TRANSPORT, /**< Waiting for coordinator to
+                                              *   become available. */
+        RD_KAFKA_IDEMP_STATE_WAIT_PID, /**< PID requested, waiting for reply */
+        RD_KAFKA_IDEMP_STATE_ASSIGNED, /**< New PID assigned */
+        RD_KAFKA_IDEMP_STATE_DRAIN_RESET,    /**< Wait for outstanding
+                                              *   ProduceRequests to finish
+                                              *   before resetting and
+                                              *   re-requesting a new PID. */
+        RD_KAFKA_IDEMP_STATE_DRAIN_BUMP,     /**< Wait for outstanding
+                                              *   ProduceRequests to finish
+                                              *   before bumping the current
+                                              *   epoch. */
+        RD_KAFKA_IDEMP_STATE_WAIT_TXN_ABORT, /**< Wait for transaction abort
+                                              *   to finish and trigger a
+                                              *   drain and reset or bump. */
+} rd_kafka_idemp_state_t;
+
+/**
+ * @returns the idemp_state_t string representation
+ */
+static RD_UNUSED const char *
+rd_kafka_idemp_state2str(rd_kafka_idemp_state_t state) {
+        static const char *names[] = {
+            "Init",    "Terminate", "FatalError", "RequestPID", "WaitTransport",
+            "WaitPID", "Assigned",  "DrainReset", "DrainBump",  "WaitTxnAbort"};
+        return names[state];
+}
+
+
+
+/**
+ * @enum Transactional Producer state
+ */
+typedef enum {
+        /**< Initial state */
+        RD_KAFKA_TXN_STATE_INIT,
+        /**< Awaiting PID to be acquired by rdkafka_idempotence.c */
+        RD_KAFKA_TXN_STATE_WAIT_PID,
+        /**< PID acquired, but application has not made a successful
+         *   init_transactions() call. */
+        RD_KAFKA_TXN_STATE_READY_NOT_ACKED,
+        /**< PID acquired, no active transaction. */
+        RD_KAFKA_TXN_STATE_READY,
+        /**< begin_transaction() has been called. */
+        RD_KAFKA_TXN_STATE_IN_TRANSACTION,
+        /**< commit_transaction() has been called. */
+        RD_KAFKA_TXN_STATE_BEGIN_COMMIT,
+        /**< commit_transaction() has been called and all outstanding
+         *   messages, partitions, and offsets have been sent. */
+        RD_KAFKA_TXN_STATE_COMMITTING_TRANSACTION,
+        /**< Transaction successfully committed but application has not made
+         *   a successful commit_transaction() call yet. */
+        RD_KAFKA_TXN_STATE_COMMIT_NOT_ACKED,
+        /**< begin_transaction() has been called. */
+        RD_KAFKA_TXN_STATE_BEGIN_ABORT,
+        /**< abort_transaction() has been called. */
+        RD_KAFKA_TXN_STATE_ABORTING_TRANSACTION,
+        /**< Transaction successfully aborted but application has not made
+         *   a successful abort_transaction() call yet. */
+        RD_KAFKA_TXN_STATE_ABORT_NOT_ACKED,
+        /**< An abortable error has occurred. */
+        RD_KAFKA_TXN_STATE_ABORTABLE_ERROR,
+        /* A fatal error has occured. */
+        RD_KAFKA_TXN_STATE_FATAL_ERROR
+} rd_kafka_txn_state_t;
+
+
+/**
+ * @returns the txn_state_t string representation
+ */
+static RD_UNUSED const char *
+rd_kafka_txn_state2str(rd_kafka_txn_state_t state) {
+        static const char *names[] = {"Init",
+                                      "WaitPID",
+                                      "ReadyNotAcked",
+                                      "Ready",
+                                      "InTransaction",
+                                      "BeginCommit",
+                                      "CommittingTransaction",
+                                      "CommitNotAcked",
+                                      "BeginAbort",
+                                      "AbortingTransaction",
+                                      "AbortedNotAcked",
+                                      "AbortableError",
+                                      "FatalError"};
+        return names[state];
+}
+
+/**
+ * @enum Telemetry States
+ */
+typedef enum {
+        /** Initial state, awaiting telemetry broker to be assigned */
+        RD_KAFKA_TELEMETRY_AWAIT_BROKER,
+        /** Telemetry broker assigned and GetSubscriptions scheduled */
+        RD_KAFKA_TELEMETRY_GET_SUBSCRIPTIONS_SCHEDULED,
+        /** GetSubscriptions request sent to the assigned broker */
+        RD_KAFKA_TELEMETRY_GET_SUBSCRIPTIONS_SENT,
+        /** PushTelemetry scheduled to send */
+        RD_KAFKA_TELEMETRY_PUSH_SCHEDULED,
+        /** PushTelemetry sent to the assigned broker */
+        RD_KAFKA_TELEMETRY_PUSH_SENT,
+        /** Client is being terminated and last PushTelemetry is scheduled to
+         *  send */
+        RD_KAFKA_TELEMETRY_TERMINATING_PUSH_SCHEDULED,
+        /** Client is being terminated and last PushTelemetry is sent */
+        RD_KAFKA_TELEMETRY_TERMINATING_PUSH_SENT,
+        /** Telemetry is terminated */
+        RD_KAFKA_TELEMETRY_TERMINATED,
+} rd_kafka_telemetry_state_t;
+
+
+static RD_UNUSED const char *
+rd_kafka_telemetry_state2str(rd_kafka_telemetry_state_t state) {
+        static const char *names[] = {"AwaitBroker",
+                                      "GetSubscriptionsScheduled",
+                                      "GetSubscriptionsSent",
+                                      "PushScheduled",
+                                      "PushSent",
+                                      "TerminatingPushScheduled",
+                                      "TerminatingPushSent",
+                                      "Terminated"};
+        return names[state];
+}
+
+static RD_UNUSED const char *rd_kafka_type2str(rd_kafka_type_t type) {
+        static const char *types[] = {
+            [RD_KAFKA_PRODUCER] = "producer",
+            [RD_KAFKA_CONSUMER] = "consumer",
+        };
+        return types[type];
+}
+
+/**
+ * Kafka handle, internal representation of the application's rd_kafka_t.
+ */
+
+struct rd_kafka_s {
+        rd_kafka_q_t *rk_rep; /* kafka -> application reply queue */
+        rd_kafka_q_t *rk_ops; /* any -> rdkafka main thread ops */
+
+        TAILQ_HEAD(, rd_kafka_broker_s) rk_brokers;
+        rd_list_t rk_broker_by_id; /* Fast id lookups. */
+        rd_atomic32_t rk_broker_cnt;
+        /**  Logical brokers count.
+         *   Used for calculating ERR__ALL_BROKERS_DOWN. */
+        rd_atomic32_t rk_logical_broker_cnt;
+        /**  Number of configured or learned brokers in state >= UP */
+        rd_atomic32_t rk_broker_up_cnt;
+        /**  Number of brokers that are down, only includes brokers
+         *   that have had at least one connection attempt
+         *   and are configured or learned. */
+        rd_atomic32_t rk_broker_down_cnt;
+        /**  Set to 1 when there's a re-bootstrap in progress.
+         *   Set to 0 when the re-bootstrap is done.
+         *   Accessed from the main thread and the broker threads. */
+        rd_atomic32_t rk_rebootstrap_in_progress;
+
+        /**< Additional bootstrap servers list.
+         *   contains all brokers added through rd_kafka_brokers_add().
+         *   Doesn't contain the initially configured bootstrap brokers. */
+        rd_list_t additional_brokerlists;
+
+        /** Decommissioned threads to await */
+        rd_list_t wait_decommissioned_thrds;
+        /** Decommissioned brokers to await */
+        rd_list_t wait_decommissioned_brokers;
+
+        mtx_t rk_internal_rkb_lock;
+        rd_kafka_broker_t *rk_internal_rkb;
+
+        /* Broadcasting of broker state changes to wake up
+         * functions waiting for a state change. */
+        cnd_t rk_broker_state_change_cnd;
+        mtx_t rk_broker_state_change_lock;
+        int rk_broker_state_change_version;
+        /* List of (rd_kafka_enq_once_t*) objects waiting for broker
+         * state changes. Protected by rk_broker_state_change_lock. */
+        rd_list_t rk_broker_state_change_waiters; /**< (rd_kafka_enq_once_t*) */
+
+        TAILQ_HEAD(, rd_kafka_topic_s) rk_topics;
+        int rk_topic_cnt;
+
+        struct rd_kafka_cgrp_s *rk_cgrp;
+
+        rd_kafka_share_t
+            *rk_rkshare; /**< Share consumer handle (if share
+                          *   consumer), NULL otherwise.
+                          *   Set when rd_kafka_share_consumer_new()
+                          *   is called, used to access inflight
+                          *   acks for building ack batches. */
+
+        /** Share consumer state. Only used when this rd_kafka_t handle
+         *  is a share consumer (rk_rkshare != NULL). */
+        /**
+         * TODO KIP-932: Change to rk_share when interface is finalized.
+         */
+        struct {
+                /** Runtime acknowledgement callback set via
+                 *  rd_kafka_share_set_acknowledgement_commit_cb().
+                 *  @locality APP THREAD ONLY (set in
+                 * set_share_acknowledgement_commit_cb).
+                 */
+                void (*share_acknowledgement_commit_cb)(
+                    rd_kafka_share_t *rkshare,
+                    rd_kafka_share_partition_offsets_list_t *partitions,
+                    rd_kafka_resp_err_t err,
+                    void *opaque);
+
+                /** Application opaque for acknowledgement callback.
+                 *  @locality APP THREAD ONLY. */
+                void *acknowledgement_commit_cb_opaque;
+
+                /** Reentrancy protection flag - set to true when inside
+                 *  callback.
+                 *  @locality APP THREAD ONLY. */
+                rd_bool_t in_callback;
+
+                /** Registration flag - whether callback is currently
+                 *  registered.
+                 *  Written via RD_KAFKA_OP_SHARE_ACK_COMMIT_CB_REGISTER op
+                 *  handler. Used by main thread to decide whether to
+                 *  enqueue callback ops.
+                 *  @locality MAIN THREAD ONLY. */
+                rd_bool_t acknowledgement_commit_cb_registered;
+
+                /** Single-thread access gate with re-entrant ownership.
+                 *
+                 *  Every public share consumer API calls
+                 *  rd_kafka_share_acquire() on entry and
+                 *  rd_kafka_share_release() before returning.
+                 *  The owning thread is recorded in
+                 *  @c current_owner_thread; concurrent entry from a
+                 *  different thread is rejected with
+                 *  RD_KAFKA_RESP_ERR__CONFLICT. The owning thread may
+                 *  re-enter (e.g. nested share calls), with @c ref_count
+                 *  tracking the nesting level — ownership is released
+                 *  only when @c ref_count returns to 0.
+                 *
+                 *  @c current_owner_thread holds a real per-thread
+                 *  identifier from thrd_current_id()
+                 *  (GetCurrentThreadId() on Windows, pthread_self()
+                 *  elsewhere); the unowned sentinel is
+                 *  RD_KAFKA_SHARE_NO_CURRENT_THREAD (-1) — a value no real
+                 *  thread id can take on any supported platform. 0 is
+                 *  deliberately *not* the sentinel so a missing init
+                 *  doesn't silently look "unowned" (a zero-initialised
+                 *  struct will fail acquire with __CONFLICT instead of
+                 *  letting two threads both pass through). The acquire
+                 *  path uses rd_atomic64_cas() so the
+                 *  first-caller-wins transition is race-free. */
+                rd_atomic64_t current_owner_thread; /**< Owning thread id; -1 =
+                                                       unowned. */
+                rd_atomic32_t
+                    ref_count; /**< Re-entrancy count for the owner. */
+        } rk_share_consumer;
+
+        rd_kafka_conf_t rk_conf;
+        rd_kafka_q_t *rk_logq; /* Log queue if `log.queue` set */
+        char rk_name[128];
+        rd_kafkap_str_t *rk_client_id;
+        rd_kafkap_str_t *rk_group_id; /* Consumer group id */
+
+        rd_atomic32_t rk_terminate; /**< Set to RD_KAFKA_DESTROY_F_..
+                                     *   flags instance
+                                     *   is being destroyed.
+                                     *   The value set is the
+                                     *   destroy flags from
+                                     *   rd_kafka_destroy*() and
+                                     *   the two internal flags shown
+                                     *   below.
+                                     *
+                                     * Order:
+                                     * 1. user_flags | .._F_DESTROY_CALLED
+                                     *    is set in rd_kafka_destroy*().
+                                     * 2. consumer_close() is called
+                                     *    for consumers.
+                                     * 3. .._F_TERMINATE is set to
+                                     *    signal all background threads
+                                     *    to terminate.
+                                     */
+
+#define RD_KAFKA_DESTROY_F_TERMINATE                                           \
+        0x1 /**< Internal flag to make sure                                    \
+             *   rk_terminate is set to non-zero                               \
+             *   value even if user passed                                     \
+             *   no destroy flags. */
+#define RD_KAFKA_DESTROY_F_DESTROY_CALLED                                      \
+        0x2 /**< Application has called                                        \
+             *  ..destroy*() and we've                                         \
+             * begun the termination                                           \
+             * process.                                                        \
+             * This flag is needed to avoid                                    \
+             * rk_terminate from being                                         \
+             * 0 when destroy_flags()                                          \
+             * is called with flags=0                                          \
+             * and prior to _F_TERMINATE                                       \
+             * has been set. */
+#define RD_KAFKA_DESTROY_F_IMMEDIATE                                           \
+        0x4 /**< Immediate non-blocking                                        \
+             *   destruction without waiting                                   \
+             *   for all resources                                             \
+             *   to be cleaned up.                                             \
+             *   WARNING: Memory and resource                                  \
+             *            leaks possible.                                      \
+             *   This flag automatically sets                                  \
+             *   .._NO_CONSUMER_CLOSE. */
+
+
+        rwlock_t rk_lock;
+        rd_kafka_type_t rk_type;
+        struct timeval rk_tv_state_change;
+
+        rd_atomic64_t rk_ts_last_poll; /**< Timestamp of last application
+                                        *   consumer_poll() call
+                                        *   (or equivalent).
+                                        *   Used to enforce
+                                        *   max.poll.interval.ms.
+                                        *   Set to INT64_MAX while polling
+                                        *   to avoid reaching
+                                        * max.poll.interval.ms. during that time
+                                        * frame. Only relevant for consumer. */
+
+        /* First fatal error. */
+        struct {
+                rd_atomic32_t err; /**< rd_kafka_resp_err_t */
+                char *errstr;      /**< Protected by rk_lock */
+                int cnt;           /**< Number of errors raised, only
+                                    *   the first one is stored. */
+        } rk_fatal;
+
+        rd_atomic32_t rk_last_throttle; /* Last throttle_time_ms value
+                                         * from broker. */
+
+        /* Locks: rd_kafka_*lock() */
+        rd_ts_t rk_ts_metadata; /* Timestamp of most recent
+                                 * metadata. */
+
+        rd_ts_t rk_ts_full_metadata;                      /* Timestamp of most
+                                                           * recent full
+                                                           * metadata */
+        struct rd_kafka_metadata_cache rk_metadata_cache; /* Metadata cache */
+
+        char *rk_clusterid;      /* ClusterId from metadata */
+        int32_t rk_controllerid; /* ControllerId from metadata */
+
+        /**< Producer: Delivery report mode */
+        enum {
+                RD_KAFKA_DR_MODE_NONE, /**< No delivery reports */
+                RD_KAFKA_DR_MODE_CB,   /**< Delivery reports through callback */
+                RD_KAFKA_DR_MODE_EVENT, /**< Delivery reports through event
+                                           API*/
+        } rk_drmode;
+
+        /* Simple consumer count:
+         *  >0: Running in legacy / Simple Consumer mode,
+         *   0: No consumers running
+         *  <0: Running in High level consumer mode */
+        rd_atomic32_t rk_simple_cnt;
+
+        /**
+         * Exactly Once Semantics and Idempotent Producer
+         *
+         * @locks rk_lock
+         */
+        struct {
+                /*
+                 * Idempotence
+                 */
+                rd_kafka_idemp_state_t idemp_state; /**< Idempotent Producer
+                                                     *   state */
+                rd_ts_t ts_idemp_state;             /**< Last state change */
+                rd_kafka_pid_t pid; /**< Current Producer ID and Epoch */
+                int epoch_cnt;      /**< Number of times pid/epoch changed */
+                rd_atomic32_t inflight_toppar_cnt; /**< Current number of
+                                                    *   toppars with inflight
+                                                    *   requests. */
+                rd_kafka_timer_t pid_tmr;          /**< PID FSM timer */
+
+                /*
+                 * Transactions
+                 *
+                 * All field access is from the rdkafka main thread,
+                 * unless a specific lock is mentioned in the doc string.
+                 *
+                 */
+                rd_atomic32_t txn_may_enq; /**< Transaction state allows
+                                            *   application to enqueue
+                                            *   (produce) messages. */
+
+                rd_kafkap_str_t *transactional_id; /**< transactional.id */
+                rd_kafka_txn_state_t txn_state;    /**< Transactional state.
+                                                    *   @locks rk_lock */
+                rd_ts_t ts_txn_state;              /**< Last state change.
+                                                    *   @locks rk_lock */
+                rd_kafka_broker_t *txn_coord;      /**< Transaction coordinator,
+                                                    *   this is a logical broker.*/
+                rd_kafka_broker_t *txn_curr_coord; /**< Current actual coord
+                                                    *   broker.
+                                                    *   This is only used to
+                                                    *   check if the coord
+                                                    *   changes. */
+                rd_kafka_broker_monitor_t txn_coord_mon; /**< Monitor for
+                                                          *   coordinator to
+                                                          *   take action when
+                                                          *   the broker state
+                                                          *   changes. */
+                rd_bool_t txn_requires_epoch_bump; /**< Coordinator epoch bump
+                                                    *   required to recover from
+                                                    *   idempotent producer
+                                                    *   fatal error. */
+
+                /**< Blocking transactional API application call
+                 *   currently being handled, its state, reply queue and how
+                 *   to handle timeout.
+                 *   Only one transactional API call is allowed at any time.
+                 *   Protected by the rk_lock. */
+                struct {
+                        char name[64];     /**< API name, e.g.,
+                                            *   send_offsets_to_transaction.
+                                            *   This is used to make sure
+                                            *   conflicting APIs are not
+                                            *   called simultaneously. */
+                        rd_bool_t calling; /**< API is being actively called.
+                                            *   I.e., application is blocking
+                                            *   on a txn API call.
+                                            *   This is used to make sure
+                                            *   no concurrent API calls are
+                                            *   being made. */
+                        rd_kafka_error_t *error; /**< Last error from background
+                                                  *   processing. This is only
+                                                  *   set if the application's
+                                                  *   API call timed out.
+                                                  *   It will be returned on
+                                                  *   the next call. */
+                        rd_bool_t has_result;    /**< Indicates whether an API
+                                                  *   result (possibly
+                                                  *   intermediate) has been set.
+                                                  */
+                        cnd_t cnd;               /**< Application thread will
+                                                  *   block on this cnd waiting
+                                                  *   for a result to be set. */
+                        mtx_t lock;              /**< Protects all fields of
+                                                  *   txn_curr_api. */
+                } txn_curr_api;
+
+
+                int txn_req_cnt; /**< Number of transaction
+                                  *   requests sent.
+                                  *   This is incremented when a
+                                  *   AddPartitionsToTxn or
+                                  *   AddOffsetsToTxn request
+                                  *   has been sent for the
+                                  *   current transaction,
+                                  *   to keep track of
+                                  *   whether the broker is
+                                  *   aware of the current
+                                  *   transaction and thus
+                                  *   requires an EndTxn request
+                                  *   on abort or not. */
+
+                /**< Timer to trigger registration of pending partitions */
+                rd_kafka_timer_t txn_register_parts_tmr;
+
+                /**< Lock for txn_pending_rktps and txn_waitresp_rktps */
+                mtx_t txn_pending_lock;
+
+                /**< Partitions pending being added to transaction. */
+                rd_kafka_toppar_tqhead_t txn_pending_rktps;
+
+                /**< Partitions in-flight added to transaction. */
+                rd_kafka_toppar_tqhead_t txn_waitresp_rktps;
+
+                /**< Partitions added and registered to transaction. */
+                rd_kafka_toppar_tqhead_t txn_rktps;
+
+                /**< Number of messages that failed delivery.
+                 *   If this number is >0 on transaction_commit then an
+                 *   abortable transaction error will be raised.
+                 *   Is reset to zero on each begin_transaction(). */
+                rd_atomic64_t txn_dr_fails;
+
+                /**< Current transaction error. */
+                rd_kafka_resp_err_t txn_err;
+
+                /**< Current transaction error string, if any. */
+                char *txn_errstr;
+
+                /**< Last InitProducerIdRequest error. */
+                rd_kafka_resp_err_t txn_init_err;
+
+                /**< Waiting for transaction coordinator query response */
+                rd_bool_t txn_wait_coord;
+
+                /**< Transaction coordinator query timer */
+                rd_kafka_timer_t txn_coord_tmr;
+        } rk_eos;
+
+        rd_atomic32_t rk_flushing; /**< Application is calling flush(). */
+
+        /**
+         * Consumer state
+         *
+         * @locality rdkafka main thread
+         * @locks_required none
+         */
+        struct {
+                /** Application consumer queue for messages, events and errors.
+                 *  (typically points to rkcg_q) */
+                rd_kafka_q_t *q;
+                /** Current assigned partitions through assign() et.al. */
+                rd_kafka_assignment_t assignment;
+                /** Waiting for this number of commits to finish. */
+                int wait_commit_cnt;
+        } rk_consumer;
+
+        /**<
+         * Coordinator cache.
+         *
+         * @locks none
+         * @locality rdkafka main thread
+         */
+        rd_kafka_coord_cache_t rk_coord_cache; /**< Coordinator cache */
+
+        TAILQ_HEAD(, rd_kafka_coord_req_s)
+        rk_coord_reqs; /**< Coordinator
+                        *   requests */
+
+
+        struct {
+                mtx_t lock;           /* Protects acces to this struct */
+                cnd_t cnd;            /* For waking up blocking injectors */
+                unsigned int cnt;     /* Current message count */
+                size_t size;          /* Current message size sum */
+                unsigned int max_cnt; /* Max limit */
+                size_t max_size;      /* Max limit */
+        } rk_curr_msgs;
+
+        rd_kafka_timers_t rk_timers;
+
+        /** Metadata refresh timer */
+        rd_kafka_timer_t metadata_refresh_tmr;
+        /** 1s interval timer */
+        rd_kafka_timer_t one_s_tmr;
+        /** Rebootstrap timer.
+         *  Will add bootstrap brokers again
+         *  when it's fired. */
+        rd_kafka_timer_t rebootstrap_tmr;
+
+        thrd_t rk_thread;
+
+        int rk_initialized; /**< Will be > 0 when the rd_kafka_t
+                             *   instance has been fully initialized. */
+
+        int rk_init_wait_cnt; /**< Number of background threads that
+                               *   need to finish initialization. */
+        cnd_t rk_init_cnd;    /**< Cond-var used to wait for main thread
+                               *   to finish its initialization before
+                               *   before rd_kafka_new() returns. */
+        mtx_t rk_init_lock;   /**< Lock for rk_init_wait and _cmd */
+
+        rd_ts_t rk_ts_created; /**< Timestamp (monotonic clock) of
+                                *   rd_kafka_t creation. */
+
+        /**
+         * Background thread and queue,
+         * enabled by setting `background_event_cb()`.
+         */
+        struct {
+                rd_kafka_q_t *q; /**< Queue served by background thread. */
+                thrd_t thread;   /**< Background thread. */
+                int calling;     /**< Indicates whether the event callback
+                                  *   is being called, reset back to 0
+                                  *   when the callback returns.
+                                  *   This can be used for troubleshooting
+                                  *   purposes. */
+        } rk_background;
+
+
+        /*
+         * Logs, events or actions to rate limit / suppress
+         */
+        struct {
+                /**< Log: No brokers support Idempotent Producer */
+                rd_interval_t no_idemp_brokers;
+
+                /**< Sparse connections: randomly select broker
+                 *   to bring up. This interval should allow
+                 *   for a previous connection to be established,
+                 *   which varies between different environments:
+                 *   Use 10 < reconnect.backoff.jitter.ms / 2 < 1000.
+                 */
+                rd_interval_t sparse_connect_random;
+
+                /**  Sparse connection timer: fires after remaining time of
+                 *   `sparse_connect_random` interval + 1ms.
+                 */
+                rd_kafka_timer_t sparse_connect_random_tmr;
+
+                /**< Lock for sparse_connect_random */
+                mtx_t sparse_connect_lock;
+
+                /**< Broker metadata refresh interval:
+                 *   this is rate-limiting the number of topic-less
+                 *   broker/cluster metadata refreshes when there are no
+                 *   topics to refresh.
+                 *   Will be refreshed every topic.metadata.refresh.interval.ms
+                 *   but no more often than every 10s.
+                 *   No locks: only accessed by rdkafka main thread. */
+                rd_interval_t broker_metadata_refresh;
+
+                /**< Suppression for allow.auto.create.topics=false not being
+                 *   supported by the broker. */
+                rd_interval_t allow_auto_create_topics;
+        } rk_suppress;
+
+        struct {
+                void *handle; /**< Provider-specific handle struct pointer.
+                               *   Typically assigned in provider's .init() */
+                rd_kafka_q_t *callback_q; /**< SASL callback queue, if any. */
+        } rk_sasl;
+
+        struct {
+                /* Fields for the control flow - unless guarded by lock, only
+                 * accessed from main thread. */
+                /**< Current state of the telemetry state machine. */
+                rd_kafka_telemetry_state_t state;
+                /**< Preferred broker for sending telemetry (Lock protected). */
+                rd_kafka_broker_t *preferred_broker;
+                /**< Timer for all the requests we schedule. */
+                rd_kafka_timer_t request_timer;
+                /**< Lock for preferred telemetry broker and state. */
+                mtx_t lock;
+                /**< Used to wait for termination (Lock protected). */
+                cnd_t termination_cnd;
+
+                /* Fields obtained from broker as a result of GetSubscriptions -
+                 * only accessed from main thread.
+                 */
+                rd_kafka_Uuid_t client_instance_id;
+                int32_t subscription_id;
+                rd_kafka_compression_t *accepted_compression_types;
+                size_t accepted_compression_types_cnt;
+                int32_t push_interval_ms;
+                int32_t telemetry_max_bytes;
+                rd_bool_t delta_temporality;
+                char **requested_metrics;
+                size_t requested_metrics_cnt;
+                /* TODO: Use rd_list_t to store the metrics */
+                int *matched_metrics;
+                size_t matched_metrics_cnt;
+
+                struct {
+                        rd_ts_t ts_last;  /**< Timestamp of last push */
+                        rd_ts_t ts_start; /**< Timestamp from when collection
+                                           *   started */
+                        /** Total rebalance latency (ms) up to previous push */
+                        uint64_t rebalance_latency_total;
+                        /** Total share fetch requests up to previous push */
+                        int64_t share_fetch_total;
+                        /** Total share bytes consumed up to previous push */
+                        int64_t share_bytes_consumed_total;
+                        /** Total acknowledgements sent up to previous push */
+                        int64_t acknowledgements_send_total;
+                        /** Total ShareGroupHeartbeat responses up to previous
+                         * push */
+                        int64_t heartbeat_total;
+                } rk_historic_c;
+
+                struct {
+                        rd_avg_t rk_avg_poll_idle_ratio;
+                        rd_avg_t rk_avg_commit_latency; /**< Current commit
+                                                         *   latency avg */
+                        rd_avg_t
+                            rk_avg_rebalance_latency; /**< Current rebalance
+                                                       *   latency avg */
+                        rd_avg_t rk_avg_share_poll_idle_ratio;
+                        rd_avg_t
+                            rk_avg_share_time_between_poll; /**< Current time
+                                                               between two
+                                                               share_consume_batch
+                                                             */
+                } rd_avg_current;
+
+                struct {
+                        rd_avg_t rk_avg_poll_idle_ratio;
+                        rd_avg_t rk_avg_commit_latency; /**< Rolled over commit
+                                                         *   latency avg */
+                        rd_avg_t
+                            rk_avg_rebalance_latency; /**< Rolled over rebalance
+                                                       *   latency avg */
+                        rd_avg_t rk_avg_share_poll_idle_ratio;
+                        rd_avg_t
+                            rk_avg_share_time_between_poll; /**< Rolled over
+                                                               time between two
+                                                               share_consume_batch
+                                                             */
+                } rd_avg_rollover;
+
+                /* Share consumer poll/batch tracking */
+                struct {
+                        rd_ts_t ts_last_poll_start;
+                        rd_ts_t ts_poll_start;
+                        rd_ts_t time_since_last_poll;
+                } rk_share_poll;
+
+                /* Share consumer fetch-RPC counter */
+                rd_atomic64_t share_fetch_total;
+
+                /* Share consumer total bytes consumed */
+                rd_atomic64_t share_bytes_consumed_total;
+
+                /* Share consumer record-level acknowledgements sent counter */
+                rd_atomic64_t acknowledgements_send_total;
+
+                /* Share consumer ShareGroupHeartbeat response counter */
+                rd_atomic64_t heartbeat_total;
+        } rk_telemetry;
+
+        /* Test mocks */
+        struct {
+                rd_kafka_mock_cluster_t *cluster; /**< Mock cluster, created
+                                                   *   by test.mock.num.brokers
+                                                   */
+                rd_atomic32_t cluster_cnt;        /**< Total number of mock
+                                                   *   clusters, created either
+                                                   *   through
+                                                   *   test.mock.num.brokers
+                                                   *   or mock_cluster_new().
+                                                   */
+
+        } rk_mock;
+};
+
+/**
+ * @brief Map type for tracking inflight share acknowledgements.
+ *        Key: topic-partition, Value: ack batches for that partition.
+ */
+typedef RD_MAP_TYPE(const rd_kafka_topic_partition_t *,
+                    rd_kafka_share_ack_batches_t *)
+    rd_kafka_share_inflight_map_t;
+
+struct rd_kafka_share_s {
+        rd_kafka_t *rkshare_rk; /**< The shared rd_kafka_t instance */
+
+        /**
+         * TODO KIP-932: Decide whether we want to keep this here
+         * or move it in rd_kafka_t.
+         */
+        /** Map of inflight acknowledgements per topic-partition.
+         *  Key: rd_kafka_topic_partition_t*
+         *  Value: rd_kafka_share_ack_batches_t*
+         */
+        rd_kafka_share_inflight_map_t rkshare_inflight_acks;
+
+        /** Total number of unacknowledged messages across all partitions. */
+        int64_t rkshare_unacked_cnt;
+
+        /** Set when a FANOUT with fetch_more_records=true is sent.
+         *  Reset when records are received in the consumer queue.
+         *  Prevents duplicate fetch FANOUTs while one is in flight. */
+        rd_bool_t rkshare_fetch_more_records_requested;
+
+        /**
+         * Set to true when the consumer is closing. Will be used to:
+         * * prevent any new API call from the app.
+         * * check if SHARE_FETCH_RESPONSE is received to poll_cb only
+         * while closing
+         */
+        rd_bool_t rkshare_consumer_closing;
+
+        /** True when the consumer has an active subscription (i.e.
+         *  rd_kafka_share_subscribe() succeeded with a non-empty list
+         *  and rd_kafka_share_unsubscribe() has not been called since).
+         *  Written only on the app thread under rkshare_acquire/release;
+         *  read only in consume_batch while the same lock is held.
+         *  @locality app thread */
+        rd_bool_t rkshare_subscribed;
+};
+
+/**
+ * @brief Opaque message list returned by rd_kafka_share_poll().
+ *
+ * The struct is allocated as a flexible array sized to the exact message
+ * count returned by a single poll. The caller releases the list and all
+ * contained messages via rd_kafka_messages_destroy().
+ */
+/**
+ * TODO KIP-932: GA: Fix this to use FAM with message struct not
+ * pointer to messages.
+ */
+struct rd_kafka_messages_s {
+        size_t cnt;                  /**< Number of messages. */
+        rd_kafka_message_t *elems[]; /**< Message pointer array. */
+};
+
+rd_kafka_messages_t *rd_kafka_messages_new(size_t cnt);
+
+#define rd_kafka_wrlock(rk)   rwlock_wrlock(&(rk)->rk_lock)
+#define rd_kafka_rdlock(rk)   rwlock_rdlock(&(rk)->rk_lock)
+#define rd_kafka_rdunlock(rk) rwlock_rdunlock(&(rk)->rk_lock)
+#define rd_kafka_wrunlock(rk) rwlock_wrunlock(&(rk)->rk_lock)
+
+
+/**
+ * @brief Add \p cnt messages and of total size \p size bytes to the
+ *        internal bookkeeping of current message counts.
+ *        If the total message count or size after add would exceed the
+ *        configured limits \c queue.buffering.max.messages and
+ *        \c queue.buffering.max.kbytes then depending on the value of
+ *        \p block the function either blocks until enough space is available
+ *        if \p block is 1, else immediately returns
+ *        RD_KAFKA_RESP_ERR__QUEUE_FULL.
+ *
+ * @param rdmtx If non-null and \p block is set and blocking is to ensue,
+ *              then unlock this mutex for the duration of the blocking
+ *              and then reacquire with a read-lock.
+ */
+static RD_INLINE RD_UNUSED rd_kafka_resp_err_t
+rd_kafka_curr_msgs_add(rd_kafka_t *rk,
+                       unsigned int cnt,
+                       size_t size,
+                       int block,
+                       rwlock_t *rdlock) {
+
+        if (rk->rk_type != RD_KAFKA_PRODUCER)
+                return RD_KAFKA_RESP_ERR_NO_ERROR;
+
+        mtx_lock(&rk->rk_curr_msgs.lock);
+        while (
+            unlikely((rk->rk_curr_msgs.max_cnt > 0 &&
+                      rk->rk_curr_msgs.cnt + cnt > rk->rk_curr_msgs.max_cnt) ||
+                     (unsigned long long)(rk->rk_curr_msgs.size + size) >
+                         (unsigned long long)rk->rk_curr_msgs.max_size)) {
+                if (!block) {
+                        mtx_unlock(&rk->rk_curr_msgs.lock);
+                        return RD_KAFKA_RESP_ERR__QUEUE_FULL;
+                }
+
+                if (rdlock)
+                        rwlock_rdunlock(rdlock);
+
+                cnd_wait(&rk->rk_curr_msgs.cnd, &rk->rk_curr_msgs.lock);
+
+                if (rdlock)
+                        rwlock_rdlock(rdlock);
+        }
+
+        rk->rk_curr_msgs.cnt += cnt;
+        rk->rk_curr_msgs.size += size;
+        mtx_unlock(&rk->rk_curr_msgs.lock);
+
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+/**
+ * @brief Subtract \p cnt messages of total size \p size from the
+ *        current bookkeeping and broadcast a wakeup on the condvar
+ *        for any waiting & blocking threads.
+ */
+static RD_INLINE RD_UNUSED void
+rd_kafka_curr_msgs_sub(rd_kafka_t *rk, unsigned int cnt, size_t size) {
+        int broadcast = 0;
+
+        if (rk->rk_type != RD_KAFKA_PRODUCER)
+                return;
+
+        mtx_lock(&rk->rk_curr_msgs.lock);
+        rd_kafka_assert(NULL, rk->rk_curr_msgs.cnt >= cnt &&
+                                  rk->rk_curr_msgs.size >= size);
+
+        /* If the subtraction would pass one of the thresholds
+         * broadcast a wake-up to any waiting listeners. */
+        if ((rk->rk_curr_msgs.cnt - cnt == 0) ||
+            (rk->rk_curr_msgs.cnt >= rk->rk_curr_msgs.max_cnt &&
+             rk->rk_curr_msgs.cnt - cnt < rk->rk_curr_msgs.max_cnt) ||
+            (rk->rk_curr_msgs.size >= rk->rk_curr_msgs.max_size &&
+             rk->rk_curr_msgs.size - size < rk->rk_curr_msgs.max_size))
+                broadcast = 1;
+
+        rk->rk_curr_msgs.cnt -= cnt;
+        rk->rk_curr_msgs.size -= size;
+
+        if (unlikely(broadcast))
+                cnd_broadcast(&rk->rk_curr_msgs.cnd);
+
+        mtx_unlock(&rk->rk_curr_msgs.lock);
+}
+
+static RD_INLINE RD_UNUSED void
+rd_kafka_curr_msgs_get(rd_kafka_t *rk, unsigned int *cntp, size_t *sizep) {
+        if (rk->rk_type != RD_KAFKA_PRODUCER) {
+                *cntp  = 0;
+                *sizep = 0;
+                return;
+        }
+
+        mtx_lock(&rk->rk_curr_msgs.lock);
+        *cntp  = rk->rk_curr_msgs.cnt;
+        *sizep = rk->rk_curr_msgs.size;
+        mtx_unlock(&rk->rk_curr_msgs.lock);
+}
+
+static RD_INLINE RD_UNUSED int rd_kafka_curr_msgs_cnt(rd_kafka_t *rk) {
+        int cnt;
+        if (rk->rk_type != RD_KAFKA_PRODUCER)
+                return 0;
+
+        mtx_lock(&rk->rk_curr_msgs.lock);
+        cnt = rk->rk_curr_msgs.cnt;
+        mtx_unlock(&rk->rk_curr_msgs.lock);
+
+        return cnt;
+}
+
+/**
+ * @brief Wait until \p tspec for curr_msgs to reach 0.
+ *
+ * @returns rd_true if zero is reached, or rd_false on timeout.
+ *          The remaining messages are returned in \p *curr_msgsp
+ */
+static RD_INLINE RD_UNUSED rd_bool_t
+rd_kafka_curr_msgs_wait_zero(rd_kafka_t *rk,
+                             int timeout_ms,
+                             unsigned int *curr_msgsp) {
+        unsigned int cnt;
+        rd_ts_t abs_timeout = rd_timeout_init(timeout_ms);
+
+        mtx_lock(&rk->rk_curr_msgs.lock);
+        while ((cnt = rk->rk_curr_msgs.cnt) > 0) {
+                if (cnd_timedwait_abs(&rk->rk_curr_msgs.cnd,
+                                      &rk->rk_curr_msgs.lock,
+                                      abs_timeout) == thrd_timedout)
+                        break;
+        }
+        mtx_unlock(&rk->rk_curr_msgs.lock);
+
+        *curr_msgsp = cnt;
+        return cnt == 0;
+}
+
+void rd_kafka_decommissioned_broker_thread_join(rd_kafka_t *rk,
+                                                void *rkb_decommissioned);
+
+void rd_kafka_destroy_final(rd_kafka_t *rk);
+
+void rd_kafka_global_init(void);
+
+/**
+ * @returns true if \p rk handle is terminating.
+ *
+ * @remark If consumer_close() is called from destroy*() it will be
+ *         called prior to _F_TERMINATE being set and will thus not
+ *         be able to use rd_kafka_terminating() to know it is shutting down.
+ *         That code should instead just check that rk_terminate is non-zero
+ *         (the _F_DESTROY_CALLED flag will be set).
+ */
+#define rd_kafka_terminating(rk)                                               \
+        (rd_atomic32_get(&(rk)->rk_terminate) & RD_KAFKA_DESTROY_F_TERMINATE)
+
+/**
+ * @returns the destroy flags set matching \p flags, which might be
+ *          a subset of the flags.
+ */
+#define rd_kafka_destroy_flags_check(rk, flags)                                \
+        (rd_atomic32_get(&(rk)->rk_terminate) & (flags))
+
+/**
+ * @returns true if no consumer callbacks, or standard consumer_close
+ *          behaviour, should be triggered. */
+#define rd_kafka_destroy_flags_no_consumer_close(rk)                           \
+        rd_kafka_destroy_flags_check(rk, RD_KAFKA_DESTROY_F_NO_CONSUMER_CLOSE)
+
+#define rd_kafka_is_simple_consumer(rk)                                        \
+        (rd_atomic32_get(&(rk)->rk_simple_cnt) > 0)
+int rd_kafka_simple_consumer_add(rd_kafka_t *rk);
+
+
+/**
+ * @returns true if idempotency is enabled (producer only).
+ */
+#define rd_kafka_is_idempotent(rk) ((rk)->rk_conf.eos.idempotence)
+
+/**
+ * @returns true if the producer is transactional (producer only).
+ */
+#define rd_kafka_is_transactional(rk)                                          \
+        ((rk)->rk_conf.eos.transactional_id != NULL)
+
+
+#define RD_KAFKA_PURGE_F_ABORT_TXN                                             \
+        0x100 /**< Internal flag used when                                     \
+               *   aborting transaction */
+#define RD_KAFKA_PURGE_F_MASK 0x107
+const char *rd_kafka_purge_flags2str(int flags);
+
+
+#include "rdkafka_topic.h"
+#include "rdkafka_partition.h"
+
+
+
+/**
+ * Debug contexts
+ */
+#define RD_KAFKA_DBG_GENERIC     0x1
+#define RD_KAFKA_DBG_BROKER      0x2
+#define RD_KAFKA_DBG_TOPIC       0x4
+#define RD_KAFKA_DBG_METADATA    0x8
+#define RD_KAFKA_DBG_FEATURE     0x10
+#define RD_KAFKA_DBG_QUEUE       0x20
+#define RD_KAFKA_DBG_MSG         0x40
+#define RD_KAFKA_DBG_PROTOCOL    0x80
+#define RD_KAFKA_DBG_CGRP        0x100
+#define RD_KAFKA_DBG_SECURITY    0x200
+#define RD_KAFKA_DBG_FETCH       0x400
+#define RD_KAFKA_DBG_INTERCEPTOR 0x800
+#define RD_KAFKA_DBG_PLUGIN      0x1000
+#define RD_KAFKA_DBG_CONSUMER    0x2000
+#define RD_KAFKA_DBG_ADMIN       0x4000
+#define RD_KAFKA_DBG_EOS         0x8000
+#define RD_KAFKA_DBG_MOCK        0x10000
+#define RD_KAFKA_DBG_ASSIGNOR    0x20000
+#define RD_KAFKA_DBG_CONF        0x40000
+#define RD_KAFKA_DBG_TELEMETRY   0x80000
+#define RD_KAFKA_DBG_ALL         0xfffff
+#define RD_KAFKA_DBG_NONE        0x0
+
+/* Jitter Percent for exponential retry backoff */
+#define RD_KAFKA_RETRY_JITTER_PERCENT 20
+
+void rd_kafka_log0(const rd_kafka_conf_t *conf,
+                   const rd_kafka_t *rk,
+                   const char *extra,
+                   int level,
+                   int ctx,
+                   const char *fac,
+                   const char *fmt,
+                   ...) RD_FORMAT(printf, 7, 8);
+
+#define rd_kafka_log(rk, level, fac, ...)                                      \
+        rd_kafka_log0(&rk->rk_conf, rk, NULL, level, RD_KAFKA_DBG_NONE, fac,   \
+                      __VA_ARGS__)
+
+#define rd_kafka_conf_is_dbg(conf, ctx)                                        \
+        unlikely((conf).debug &(RD_KAFKA_DBG_##ctx))
+
+#define rd_kafka_is_dbg(rk, ctx) (rd_kafka_conf_is_dbg(rk->rk_conf, ctx))
+
+#define rd_kafka_dbg(rk, ctx, fac, ...)                                        \
+        do {                                                                   \
+                if (rd_kafka_is_dbg(rk, ctx))                                  \
+                        rd_kafka_log0(&rk->rk_conf, rk, NULL, LOG_DEBUG,       \
+                                      (RD_KAFKA_DBG_##ctx), fac, __VA_ARGS__); \
+        } while (0)
+
+/* dbg() not requiring an rk, just the conf object, for early logging */
+#define rd_kafka_dbg0(conf, ctx, fac, ...)                                     \
+        do {                                                                   \
+                if (rd_kafka_conf_is_dbg(*conf, ctx))                          \
+                        rd_kafka_log0(conf, NULL, NULL, LOG_DEBUG,             \
+                                      (RD_KAFKA_DBG_##ctx), fac, __VA_ARGS__); \
+        } while (0)
+
+/* NOTE: The local copy of _logname is needed due rkb_logname_lock lock-ordering
+ *       when logging another broker's name in the message. */
+#define rd_rkb_log0(rkb, level, ctx, fac, ...)                                 \
+        do {                                                                   \
+                char _logname[RD_KAFKA_NODENAME_SIZE];                         \
+                mtx_lock(&(rkb)->rkb_logname_lock);                            \
+                rd_strlcpy(_logname, rkb->rkb_logname, sizeof(_logname));      \
+                mtx_unlock(&(rkb)->rkb_logname_lock);                          \
+                rd_kafka_log0(&(rkb)->rkb_rk->rk_conf, (rkb)->rkb_rk,          \
+                              _logname, level, ctx, fac, __VA_ARGS__);         \
+        } while (0)
+
+#define rd_rkb_log(rkb, level, fac, ...)                                       \
+        rd_rkb_log0(rkb, level, RD_KAFKA_DBG_NONE, fac, __VA_ARGS__)
+
+#define rd_rkb_is_dbg(rkb, ctx) rd_kafka_is_dbg((rkb)->rkb_rk, ctx)
+
+#define rd_rkb_dbg(rkb, ctx, fac, ...)                                         \
+        do {                                                                   \
+                if (rd_rkb_is_dbg(rkb, ctx)) {                                 \
+                        rd_rkb_log0(rkb, LOG_DEBUG, (RD_KAFKA_DBG_##ctx), fac, \
+                                    __VA_ARGS__);                              \
+                }                                                              \
+        } while (0)
+
+
+
+extern rd_kafka_resp_err_t RD_TLS rd_kafka_last_error_code;
+
+static RD_UNUSED RD_INLINE rd_kafka_resp_err_t
+rd_kafka_set_last_error(rd_kafka_resp_err_t err, int errnox) {
+        if (errnox) {
+                /* MSVC:
+                 * This is the correct way to set errno on Windows,
+                 * but it is still pointless due to different errnos in
+                 * in different runtimes:
+                 * https://social.msdn.microsoft.com/Forums/vstudio/en-US/b4500c0d-1b69-40c7-9ef5-08da1025b5bf/setting-errno-from-within-a-dll?forum=vclanguage/
+                 * errno is thus highly deprecated, and buggy, on Windows
+                 * when using librdkafka as a dynamically loaded DLL. */
+                rd_set_errno(errnox);
+        }
+        rd_kafka_last_error_code = err;
+        return err;
+}
+
+
+int rd_kafka_set_fatal_error0(rd_kafka_t *rk,
+                              rd_dolock_t do_lock,
+                              rd_kafka_resp_err_t err,
+                              const char *fmt,
+                              ...) RD_FORMAT(printf, 4, 5);
+#define rd_kafka_set_fatal_error(rk, err, fmt, ...)                            \
+        rd_kafka_set_fatal_error0(rk, RD_DO_LOCK, err, fmt, __VA_ARGS__)
+
+rd_kafka_error_t *rd_kafka_get_fatal_error(rd_kafka_t *rk);
+
+#define rd_kafka_producer_can_have_fatal_errors(rk)                            \
+        (rk->rk_type == RD_KAFKA_PRODUCER && rk->rk_conf.eos.idempotence)
+
+#define rd_kafka_consumer_can_have_fatal_errors(rk)                            \
+        (rk->rk_type == RD_KAFKA_CONSUMER &&                                   \
+         (rk->rk_conf.group_instance_id ||                                     \
+          rk->rk_conf.group_protocol == RD_KAFKA_GROUP_PROTOCOL_CONSUMER))
+
+static RD_INLINE RD_UNUSED rd_kafka_resp_err_t
+rd_kafka_fatal_error_code(rd_kafka_t *rk) {
+        /* This is an optimization to avoid an atomic read which are costly
+         * on some platforms:
+         * Fatal errors are currently raised by:
+         * 1) the idempotent producer
+         * 2) static consumers (group.instance.id)
+         * 3) Group using consumer protocol (Introduced in KIP-848). See exact
+         *    errors in rd_kafka_cgrp_handle_ConsumerGroupHeartbeat() */
+        if (rd_kafka_producer_can_have_fatal_errors(rk) ||
+            rd_kafka_consumer_can_have_fatal_errors(rk))
+                return rd_atomic32_get(&rk->rk_fatal.err);
+
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+extern rd_atomic32_t rd_kafka_thread_cnt_curr;
+extern char RD_TLS rd_kafka_thread_name[64];
+
+void rd_kafka_set_thread_name(const char *fmt, ...) RD_FORMAT(printf, 1, 2);
+void rd_kafka_set_thread_sysname(const char *fmt, ...) RD_FORMAT(printf, 1, 2);
+void rd_kafka_thread_srand(rd_kafka_t *rk, rd_bool_t internal_thread);
+
+int rd_kafka_path_is_dir(const char *path);
+rd_bool_t rd_kafka_dir_is_empty(const char *path);
+
+rd_kafka_op_res_t rd_kafka_poll_cb(rd_kafka_t *rk,
+                                   rd_kafka_q_t *rkq,
+                                   rd_kafka_op_t *rko,
+                                   rd_kafka_q_cb_type_t cb_type,
+                                   void *opaque);
+
+rd_kafka_resp_err_t rd_kafka_subscribe_rkt(rd_kafka_topic_t *rkt);
+
+
+/**
+ * @returns the number of milliseconds the maximum poll interval
+ *          was exceeded, or 0 if not exceeded.
+ *
+ * @remark Only relevant for high-level consumer.
+ *
+ * @locality any
+ * @locks none
+ */
+static RD_INLINE RD_UNUSED int rd_kafka_max_poll_exceeded(rd_kafka_t *rk) {
+        rd_ts_t last_poll;
+        int exceeded;
+
+        if (rk->rk_type != RD_KAFKA_CONSUMER)
+                return 0;
+
+        last_poll = rd_atomic64_get(&rk->rk_ts_last_poll);
+
+        /* Application is blocked in librdkafka function, see
+         * rd_kafka_app_poll_start(). */
+        if (last_poll == INT64_MAX)
+                return 0;
+
+        exceeded = (int)((rd_clock() - last_poll) / 1000ll) -
+                   rk->rk_conf.max_poll_interval_ms;
+
+        if (unlikely(exceeded > 0))
+                return exceeded;
+
+        return 0;
+}
+
+/**
+ * @brief Call on entry to blocking polling function to indicate
+ *        that the application is blocked waiting for librdkafka
+ *        and that max.poll.interval.ms should not be enforced.
+ *
+ *        Call app_polled() Upon return from the function calling
+ *        this function to register the application's last time of poll.
+ *
+ * @remark Only relevant for high-level consumer.
+ *
+ * @locality any
+ * @locks none
+ */
+static RD_INLINE RD_UNUSED void rd_kafka_app_poll_start(rd_kafka_t *rk,
+                                                        rd_kafka_q_t *rkq,
+                                                        rd_ts_t now,
+                                                        rd_bool_t is_blocking) {
+        if (rk->rk_type != RD_KAFKA_CONSUMER || RD_KAFKA_IS_SHARE_CONSUMER(rk))
+                return;
+
+        if (!now)
+                now = rd_clock();
+        if (is_blocking)
+                rd_atomic64_set(&rk->rk_ts_last_poll, INT64_MAX);
+        if (rkq->rkq_ts_last_poll_end) {
+                int64_t poll_idle_ratio = 0;
+                rd_ts_t poll_interval   = now - rkq->rkq_ts_last_poll_start;
+                if (poll_interval) {
+                        rd_ts_t idle_interval = rkq->rkq_ts_last_poll_end -
+                                                rkq->rkq_ts_last_poll_start;
+                        poll_idle_ratio =
+                            idle_interval * 1000000 / poll_interval;
+                }
+                rd_avg_add(
+                    &rk->rk_telemetry.rd_avg_current.rk_avg_poll_idle_ratio,
+                    poll_idle_ratio);
+                rkq->rkq_ts_last_poll_start = now;
+                rkq->rkq_ts_last_poll_end   = 0;
+        }
+}
+
+/**
+ * @brief Set the last application poll time to now.
+ *
+ * @remark Only relevant for high-level consumer.
+ *
+ * @locality any
+ * @locks none
+ */
+static RD_INLINE RD_UNUSED void rd_kafka_app_polled(rd_kafka_t *rk,
+                                                    rd_kafka_q_t *rkq) {
+        if (rk->rk_type == RD_KAFKA_CONSUMER &&
+            !RD_KAFKA_IS_SHARE_CONSUMER(rk)) {
+                rd_ts_t now = rd_clock();
+                rd_atomic64_set(&rk->rk_ts_last_poll, now);
+                if (unlikely(rk->rk_cgrp &&
+                             rk->rk_cgrp->rkcg_group_protocol ==
+                                 RD_KAFKA_GROUP_PROTOCOL_CONSUMER &&
+                             rk->rk_cgrp->rkcg_flags &
+                                 RD_KAFKA_CGRP_F_MAX_POLL_EXCEEDED)) {
+                        rd_kafka_cgrp_consumer_expedite_next_heartbeat(
+                            rk->rk_cgrp,
+                            "app polled after poll interval exceeded");
+                }
+                if (!rkq->rkq_ts_last_poll_end)
+                        rkq->rkq_ts_last_poll_end = now;
+                rd_dassert(rkq->rkq_ts_last_poll_end >=
+                           rkq->rkq_ts_last_poll_start);
+        }
+}
+
+
+
+void rd_kafka_term_sig_handler(int sig);
+
+/**
+ * rdkafka_background.c
+ */
+int rd_kafka_background_thread_main(void *arg);
+rd_kafka_resp_err_t rd_kafka_background_thread_create(rd_kafka_t *rk,
+                                                      char *errstr,
+                                                      size_t errstr_size);
+
+void rd_kafka_rebootstrap(rd_kafka_t *rk);
+
+void rd_kafka_rebootstrap_tmr_start_maybe(rd_kafka_t *rk);
+
+int rd_kafka_rebootstrap_tmr_stop(rd_kafka_t *rk);
+
+void rd_kafka_reset_any_broker_down_reported(rd_kafka_t *rk);
+
+rd_kafka_op_res_t rd_kafka_share_fetch_fanout_op(rd_kafka_t *rk,
+                                                 rd_kafka_q_t *rkq,
+                                                 rd_kafka_op_t *rko);
+
+/**
+ * @brief Return an error object if the share consumer is closed or closing.
+ * @returns a newly-allocated error (owned by caller) or NULL if usable.
+ */
+rd_kafka_error_t *
+rd_kafka_share_consumer_closed_error(rd_kafka_share_t *rkshare);
+
+/**
+ * @brief Return a response-error code if the share consumer is closed or
+ *        closing.
+ * @returns RD_KAFKA_RESP_ERR__STATE if closed/closing, else
+ *          RD_KAFKA_RESP_ERR_NO_ERROR.
+ */
+rd_kafka_resp_err_t
+rd_kafka_share_consumer_closed_err(rd_kafka_share_t *rkshare);
+
+/**
+ * @brief Sentinel value stored in rk_share_consumer.current_owner_thread
+ *        when the gate is unowned. Chosen to never collide with a real
+ *        thread id on any supported platform. A zero-initialised struct
+ *        does NOT look unowned, which is intentional: a missing
+ *        init causes acquire to fail with __CONFLICT rather than
+ *        silently letting two threads pass.
+ */
+#define RD_KAFKA_SHARE_NO_CURRENT_THREAD ((int64_t)(-1))
+
+/**
+ * @brief Acquire single-thread ownership of the share consumer.
+ *
+ * Every public share consumer API must call this on entry and pair
+ * it with rd_kafka_share_release() on every return path. The owning
+ * thread may re-enter (nested share calls bump the ref_count counter
+ * and release decrements it).
+ *
+ * @returns NULL on success, or a newly-allocated rd_kafka_error_t (owned
+ *          by the caller) on rejection:
+ *           - RD_KAFKA_RESP_ERR__STATE on NULL rkshare, or when called
+ *             from inside the user-defined acknowledgement commit
+ *             callback.
+ *           - RD_KAFKA_RESP_ERR__CONFLICT on concurrent entry from a
+ *             different application thread.
+ */
+rd_kafka_error_t *rd_kafka_share_acquire(rd_kafka_share_t *rkshare);
+
+/**
+ * @brief Release ownership acquired by rd_kafka_share_acquire().
+ *
+ * Tolerates NULL rkshare (no-op) so error paths can call it
+ * unconditionally.
+ */
+void rd_kafka_share_release(rd_kafka_share_t *rkshare);
+
+void rd_kafka_share_enqueue_fetch_op(rd_kafka_t *rk,
+                                     rd_kafka_broker_t *rkb,
+                                     rd_bool_t should_fetch,
+                                     rd_bool_t should_leave);
+
+#endif /* _RDKAFKA_INT_H_ */