@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/examples/elect_leaders.c

@@ -0,0 +1,317 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2024, 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 SH 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.
+ */
+
+/**
+ * Example utility that shows how to use Elect Leaders (AdminAPI)
+ * to trigger preffered or unclean elections for
+ * one or more topic partitions.
+ */
+
+#include <signal.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#ifdef _WIN32
+#include "../win32/wingetopt.h"
+#else
+#include <getopt.h>
+#endif
+
+/* Typical include path would be <librdkafka/rdkafka.h>, but this program
+ * is builtin from within the librdkafka source tree and thus differs. */
+#include "rdkafka.h"
+
+const char *argv0;
+
+static rd_kafka_queue_t *queue = NULL; /** Admin result queue.
+                                        *  This is a global so we can
+                                        *  yield in stop() */
+static volatile sig_atomic_t run = 1;
+
+/**
+ * @brief Signal termination of program
+ */
+static void stop(int sig) {
+        if (!run) {
+                fprintf(stderr, "%% Forced termination\n");
+                exit(2);
+        }
+        run = 0;
+        if (queue)
+                rd_kafka_queue_yield(queue);
+}
+
+static void usage(const char *reason, ...) {
+
+        fprintf(stderr,
+                "Elect Leaders usage examples\n"
+                "\n"
+                "Usage: %s <options> <election_type> "
+                "<topic1> <partition1> ...\n"
+                "\n"
+                "Options:\n"
+                "   -b <brokers>    Bootstrap server list to connect to.\n"
+                "   -X <prop=val>   Set librdkafka configuration property.\n"
+                "                   See CONFIGURATION.md for full list.\n"
+                "   -d <dbg,..>     Enable librdkafka debugging (%s).\n"
+                "\n",
+                argv0, rd_kafka_get_debug_contexts());
+
+        if (reason) {
+                va_list ap;
+                char reasonbuf[512];
+
+                va_start(ap, reason);
+                vsnprintf(reasonbuf, sizeof(reasonbuf), reason, ap);
+                va_end(ap);
+
+                fprintf(stderr, "ERROR: %s\n", reasonbuf);
+        }
+
+        exit(reason ? 1 : 0);
+}
+
+
+#define fatal(...)                                                             \
+        do {                                                                   \
+                fprintf(stderr, "ERROR: ");                                    \
+                fprintf(stderr, __VA_ARGS__);                                  \
+                fprintf(stderr, "\n");                                         \
+                exit(2);                                                       \
+        } while (0)
+
+
+/**
+ * @brief Set config property. Exit on failure.
+ */
+static void conf_set(rd_kafka_conf_t *conf, const char *name, const char *val) {
+        char errstr[512];
+
+        if (rd_kafka_conf_set(conf, name, val, errstr, sizeof(errstr)) !=
+            RD_KAFKA_CONF_OK)
+                fatal("Failed to set %s=%s: %s", name, val, errstr);
+}
+
+static void
+print_elect_leaders_result(const rd_kafka_ElectLeaders_result_t *result) {
+        const rd_kafka_topic_partition_result_t **results;
+        size_t results_cnt;
+        size_t i;
+
+        results = rd_kafka_ElectLeaders_result_partitions(result, &results_cnt);
+        printf("ElectLeaders response has %zu partition(s):\n", results_cnt);
+        for (i = 0; i < results_cnt; i++) {
+                const rd_kafka_topic_partition_t *partition =
+                    rd_kafka_topic_partition_result_partition(results[i]);
+                const rd_kafka_error_t *err =
+                    rd_kafka_topic_partition_result_error(results[i]);
+                if (rd_kafka_error_code(err)) {
+                        printf("%% ElectLeaders failed for %s [%" PRId32
+                               "] : %s\n",
+                               partition->topic, partition->partition,
+                               rd_kafka_error_string(err));
+                } else {
+                        printf("%% ElectLeaders succeeded for %s [%" PRId32
+                               "]\n",
+                               partition->topic, partition->partition);
+                }
+        }
+}
+
+/**
+ * @brief Parse an integer or fail.
+ */
+int64_t parse_int(const char *what, const char *str) {
+        char *end;
+        unsigned long n = strtoull(str, &end, 0);
+
+        if (end != str + strlen(str)) {
+                fprintf(stderr, "%% Invalid input for %s: %s: not an integer\n",
+                        what, str);
+                exit(1);
+        }
+
+        return (int64_t)n;
+}
+
+static void cmd_elect_leaders(rd_kafka_conf_t *conf, int argc, char **argv) {
+        rd_kafka_t *rk;
+        char errstr[512];
+        rd_kafka_AdminOptions_t *options;
+        rd_kafka_event_t *event                     = NULL;
+        rd_kafka_topic_partition_list_t *partitions = NULL;
+        rd_kafka_ElectionType_t election_type;
+        rd_kafka_ElectLeaders_t *elect_leaders;
+        int i;
+        int retval = 0;
+
+        if ((argc - 1) % 2 != 0) {
+                usage("Invalid number of arguments");
+        }
+
+        election_type = parse_int("election_type", argv[0]);
+
+        argc--;
+        argv++;
+        if (argc > 0) {
+                partitions = rd_kafka_topic_partition_list_new(argc / 2);
+                for (i = 0; i < argc; i += 2) {
+                        rd_kafka_topic_partition_list_add(
+                            partitions, argv[i],
+                            parse_int("partition", argv[i + 1]));
+                }
+        }
+
+        elect_leaders = rd_kafka_ElectLeaders_new(election_type, partitions);
+
+        if (partitions) {
+                rd_kafka_topic_partition_list_destroy(partitions);
+        }
+
+        /*
+         * Create consumer instance
+         * NOTE: rd_kafka_new() takes ownership of the conf object
+         *       and the application must not reference it again after
+         *       this call.
+         */
+        rk = rd_kafka_new(RD_KAFKA_CONSUMER, conf, errstr, sizeof(errstr));
+        if (!rk)
+                fatal("Failed to create new consumer: %s", errstr);
+
+        /*
+         * Elect Leaders
+         */
+        queue = rd_kafka_queue_new(rk);
+
+        /* Signal handler for clean shutdown */
+        signal(SIGINT, stop);
+
+
+        options = rd_kafka_AdminOptions_new(rk, RD_KAFKA_ADMIN_OP_ELECTLEADERS);
+
+        if (rd_kafka_AdminOptions_set_request_timeout(
+                options, 30 * 1000 /* 30s */, errstr, sizeof(errstr))) {
+                fprintf(stderr, "%% Failed to set timeout: %s\n", errstr);
+                goto exit;
+        }
+
+        if (rd_kafka_AdminOptions_set_operation_timeout(
+                options, 30 * 1000 /* 30s */, errstr, sizeof(errstr))) {
+                fprintf(stderr, "%% Failed to set operation timeout: %s\n",
+                        errstr);
+                goto exit;
+        }
+
+        rd_kafka_ElectLeaders(rk, elect_leaders, options, queue);
+
+        rd_kafka_ElectLeaders_destroy(elect_leaders);
+        rd_kafka_AdminOptions_destroy(options);
+
+        /* Wait for results */
+        event = rd_kafka_queue_poll(queue, -1 /* indefinitely but limited by
+                                               * the request timeout set
+                                               * above  */);
+
+        if (!event) {
+                /* User hit Ctrl-C,
+                 * see yield call in stop() signal handler */
+                fprintf(stderr, "%% Cancelled by user\n");
+
+        } else if (rd_kafka_event_error(event)) {
+                rd_kafka_resp_err_t err = rd_kafka_event_error(event);
+                /* ElectLeaders request failed */
+                fprintf(stderr, "%% ElectLeaders failed[%" PRId32 "]: %s\n",
+                        err, rd_kafka_event_error_string(event));
+                retval = 1;
+                goto exit;
+        } else {
+                /* ElectLeaders request succeeded */
+                const rd_kafka_ElectLeaders_result_t *result;
+                result = rd_kafka_event_ElectLeaders_result(event);
+                print_elect_leaders_result(result);
+        }
+
+
+exit:
+        if (event)
+                rd_kafka_event_destroy(event);
+
+        rd_kafka_queue_destroy(queue);
+        /* Destroy the client instance */
+        rd_kafka_destroy(rk);
+
+        exit(retval);
+}
+
+
+int main(int argc, char **argv) {
+        rd_kafka_conf_t *conf; /**< Client configuration object */
+        int opt;
+        argv0 = argv[0];
+
+        /*
+         * Create Kafka client configuration place-holder
+         */
+        conf = rd_kafka_conf_new();
+
+        /*
+         * Parse common options
+         */
+        while ((opt = getopt(argc, argv, "b:X:d:")) != -1) {
+                switch (opt) {
+                case 'b':
+                        conf_set(conf, "bootstrap.servers", optarg);
+                        break;
+
+                case 'X': {
+                        char *name = optarg, *val;
+
+                        if (!(val = strchr(name, '=')))
+                                fatal("-X expects a name=value argument");
+
+                        *val = '\0';
+                        val++;
+
+                        conf_set(conf, name, val);
+                        break;
+                }
+
+                case 'd':
+                        conf_set(conf, "debug", optarg);
+                        break;
+
+                default:
+                        usage("Unknown option %c", (char)opt);
+                }
+        }
+
+        cmd_elect_leaders(conf, argc - optind, &argv[optind]);
+
+        return 0;
+}

package/deps/librdkafka/examples/globals.json

@@ -0,0 +1,11 @@
+{"VerifiableConsumer":
+ {
+     "class": "kafkatest.services.verifiable_client.VerifiableClientApp",
+     "exec_cmd": "/vagrant/tests/c/kafkatest_verifiable_client --consumer --debug cgrp,topic,protocol,broker"
+ },
+ "VerifiableProducer":
+ {
+     "class": "kafkatest.services.verifiable_client.VerifiableClientApp",
+     "exec_cmd": "/vagrant/tests/c/kafkatest_verifiable_client --producer --debug topic,broker"
+ }
+}

package/deps/librdkafka/examples/idempotent_producer.c

@@ -0,0 +1,344 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2019-2022, Magnus Edenhill
+ * 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.
+ */
+
+/**
+ * Idempotent Producer example.
+ *
+ * The idempotent producer provides strict ordering and
+ * exactly-once producing guarantees.
+ *
+ * From the application developer's perspective, the only difference
+ * from a standard producer is the enabling of the feature by setting
+ * the `enable.idempotence` configuration property to `true`, and
+ * handling fatal (RD_KAFKA_RESP_ERR__FATAL) errors which are raised when
+ * the idempotent guarantees can't be satisfied.
+ */
+
+#define _DEFAULT_SOURCE /* avoid glibc deprecation warning of _BSD_SOURCE */
+#define _BSD_SOURCE     /* vsnprintf() */
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+
+
+/* Typical include path would be <librdkafka/rdkafka.h>, but this program
+ * is builtin from within the librdkafka source tree and thus differs. */
+#include "rdkafka.h"
+
+
+static volatile sig_atomic_t run = 1;
+
+/**
+ * @brief Signal termination of program
+ */
+static void stop(int sig) {
+        run = 0;
+}
+
+
+static int deliveredcnt = 0;
+static int msgerrcnt    = 0;
+
+/**
+ * @brief Message delivery report callback.
+ *
+ * This callback is called exactly once per message, indicating if
+ * the message was succesfully delivered
+ * (rkmessage->err == RD_KAFKA_RESP_ERR_NO_ERROR) or permanently
+ * failed delivery (rkmessage->err != RD_KAFKA_RESP_ERR_NO_ERROR).
+ *
+ * The callback is triggered from rd_kafka_poll() or rd_kafka_flush() and
+ * executes on the application's thread.
+ */
+static void
+dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *rkmessage, void *opaque) {
+        if (rkmessage->err) {
+                fprintf(stderr, "%% Message delivery failed: %s\n",
+                        rd_kafka_err2str(rkmessage->err));
+                msgerrcnt++;
+        } else {
+                fprintf(stderr,
+                        "%% Message delivered (%zd bytes, topic %s, "
+                        "partition %" PRId32 ", offset %" PRId64 ")\n",
+                        rkmessage->len, rd_kafka_topic_name(rkmessage->rkt),
+                        rkmessage->partition, rkmessage->offset);
+                deliveredcnt++;
+        }
+
+        /* The rkmessage is destroyed automatically by librdkafka */
+}
+
+
+/**
+ * @brief Generic error handling callback.
+ *
+ * This callback is triggered by rd_kafka_poll() or rd_kafka_flush()
+ * for client instance-level errors, such as broker connection failures,
+ * authentication issues, etc.
+ *
+ * These errors should generally be considered informational as
+ * the underlying client will automatically try to recover from
+ * any errors encountered, the application does not need to take
+ * action on them.
+ *
+ * But with idempotence truly fatal errors can be raised when
+ * the idempotence guarantees can't be satisfied, these errors
+ * are identified by a the `RD_KAFKA_RESP_ERR__FATAL` error code.
+ */
+static void
+error_cb(rd_kafka_t *rk, int err, const char *reason, void *opaque) {
+        rd_kafka_resp_err_t orig_err;
+        char errstr[512];
+
+        fprintf(stderr, "%% Error: %s: %s\n", rd_kafka_err2name(err), reason);
+
+        if (err != RD_KAFKA_RESP_ERR__FATAL)
+                return;
+
+        /* Fatal error handling.
+         *
+         * When a fatal error is detected by the producer instance,
+         * it will trigger an error_cb with ERR__FATAL set.
+         * The application should use rd_kafka_fatal_error() to extract
+         * the actual underlying error code and description, propagate it
+         * to the user (for troubleshooting), and then terminate the
+         * producer since it will no longer accept any new messages to
+         * produce().
+         *
+         * Note:
+         *   After a fatal error has been raised, rd_kafka_produce*() will
+         *   fail with the original error code.
+         *
+         * Note:
+         *   As an alternative to an error_cb, the application may call
+         *   rd_kafka_fatal_error() at any time to check if a fatal error
+         *   has occurred, typically after a failing rd_kafka_produce*() call.
+         */
+
+        orig_err = rd_kafka_fatal_error(rk, errstr, sizeof(errstr));
+        fprintf(stderr, "%% FATAL ERROR: %s: %s\n", rd_kafka_err2name(orig_err),
+                errstr);
+
+        /* Clean termination to get delivery results (from rd_kafka_flush())
+         * for all outstanding/in-transit/queued messages. */
+        fprintf(stderr, "%% Terminating on fatal error\n");
+        run = 0;
+}
+
+
+int main(int argc, char **argv) {
+        rd_kafka_t *rk;          /* Producer instance handle */
+        rd_kafka_conf_t *conf;   /* Temporary configuration object */
+        char errstr[512];        /* librdkafka API error reporting buffer */
+        rd_kafka_resp_err_t err; /* librdkafka API error code */
+        const char *brokers;     /* Argument: broker list */
+        const char *topic;       /* Argument: topic to produce to */
+        int msgcnt = 0;          /* Number of messages produced */
+
+        /*
+         * Argument validation
+         */
+        if (argc != 3) {
+                fprintf(stderr, "%% Usage: %s <broker> <topic>\n", argv[0]);
+                return 1;
+        }
+
+        brokers = argv[1];
+        topic   = argv[2];
+
+
+        /*
+         * Create Kafka client configuration place-holder
+         */
+        conf = rd_kafka_conf_new();
+
+        /* Set bootstrap broker(s) as a comma-separated list of
+         * host or host:port (default port 9092).
+         * librdkafka will use the bootstrap brokers to acquire the full
+         * set of brokers from the cluster. */
+        if (rd_kafka_conf_set(conf, "bootstrap.servers", brokers, errstr,
+                              sizeof(errstr)) != RD_KAFKA_CONF_OK) {
+                fprintf(stderr, "%s\n", errstr);
+                rd_kafka_conf_destroy(conf);
+                return 1;
+        }
+
+        /* Enable the idempotent producer */
+        if (rd_kafka_conf_set(conf, "enable.idempotence", "true", errstr,
+                              sizeof(errstr)) != RD_KAFKA_CONF_OK) {
+                fprintf(stderr, "%s\n", errstr);
+                rd_kafka_conf_destroy(conf);
+                return 1;
+        }
+
+        /* Set the delivery report callback.
+         * This callback will be called once per message to inform
+         * the application if delivery succeeded or failed.
+         * See dr_msg_cb() above. */
+        rd_kafka_conf_set_dr_msg_cb(conf, dr_msg_cb);
+
+        /* Set an error handler callback to catch generic instance-level
+         * errors.
+         *
+         * See the `error_cb()` handler above for how to handle the
+         * fatal errors.
+         */
+        rd_kafka_conf_set_error_cb(conf, error_cb);
+
+
+        /*
+         * Create producer instance.
+         *
+         * NOTE: rd_kafka_new() takes ownership of the conf object
+         *       and the application must not reference it again after
+         *       this call.
+         */
+        rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr));
+        if (!rk) {
+                fprintf(stderr, "%% Failed to create new producer: %s\n",
+                        errstr);
+                return 1;
+        }
+
+        /* Signal handler for clean shutdown */
+        signal(SIGINT, stop);
+
+        fprintf(stderr, "%% Running producer loop. Press Ctrl-C to exit\n");
+
+        while (run) {
+                char buf[64];
+
+                snprintf(buf, sizeof(buf),
+                         "Idempotent Producer example message #%d", msgcnt);
+
+                /*
+                 * Produce message.
+                 * This is an asynchronous call, on success it will only
+                 * enqueue the message on the internal producer queue.
+                 * The actual delivery attempts to the broker are handled
+                 * by background threads.
+                 * The previously registered delivery report callback
+                 * (dr_msg_cb) is used to signal back to the application
+                 * when the message has been delivered (or failed),
+                 * and is triggered when the application calls
+                 * rd_kafka_poll() or rd_kafka_flush().
+                 */
+        retry:
+                err = rd_kafka_producev(
+                    rk, RD_KAFKA_V_TOPIC(topic),
+                    RD_KAFKA_V_VALUE(buf, strlen(buf)),
+                    /* Copy the message payload so the `buf` can
+                     * be reused for the next message. */
+                    RD_KAFKA_V_MSGFLAGS(RD_KAFKA_MSG_F_COPY), RD_KAFKA_V_END);
+
+                if (err) {
+                        /**
+                         * Failed to *enqueue* message for producing.
+                         */
+                        fprintf(stderr,
+                                "%% Failed to produce to topic %s: %s\n", topic,
+                                rd_kafka_err2str(err));
+
+                        if (err == RD_KAFKA_RESP_ERR__QUEUE_FULL) {
+                                /* If the internal queue is full, wait for
+                                 * messages to be delivered and then retry.
+                                 * The internal queue represents both
+                                 * messages to be sent and messages that have
+                                 * been sent or failed, awaiting their
+                                 * delivery report callback to be called.
+                                 *
+                                 * The internal queue is limited by the
+                                 * configuration property
+                                 * queue.buffering.max.messages and
+                                 * queue.buffering.max.kbytes */
+                                rd_kafka_poll(rk,
+                                              1000 /*block for max 1000ms*/);
+                                goto retry;
+                        } else {
+                                /* Produce failed, most likely due to a
+                                 * fatal error (will be handled by error_cb()),
+                                 * bail out. */
+
+                                /* Instead of using the error_cb(), an
+                                 * application may check for fatal errors here
+                                 * by calling rd_kafka_fatal_error(). */
+                                break;
+                        }
+                }
+
+                /* A producer application should continually serve
+                 * the delivery report queue by calling rd_kafka_poll()
+                 * at frequent intervals.
+                 * Either put the poll call in your main loop, or in a
+                 * dedicated thread, or call it after or before every
+                 * rd_kafka_produce*() call.
+                 * Just make sure that rd_kafka_poll() is still called
+                 * during periods where you are not producing any messages
+                 * to make sure previously produced messages have their
+                 * delivery report callback served (and any other callbacks
+                 * you register). */
+                rd_kafka_poll(rk, 0 /*non-blocking*/);
+
+                msgcnt++;
+
+                /* Since fatal errors can't be triggered in practice,
+                 * use the test API to trigger a fabricated error after
+                 * some time. */
+                if (msgcnt == 13)
+                        rd_kafka_test_fatal_error(
+                            rk, RD_KAFKA_RESP_ERR_OUT_OF_ORDER_SEQUENCE_NUMBER,
+                            "This is a fabricated error to test the "
+                            "fatal error handling");
+
+                /* Short sleep to rate-limit this example.
+                 * A real application should not do this. */
+                usleep(500 * 1000); /* 500ms */
+        }
+
+
+        /* Wait for final messages to be delivered or fail.
+         * rd_kafka_flush() is an abstraction over rd_kafka_poll() which
+         * waits for all messages to be delivered. */
+        fprintf(stderr, "%% Flushing outstanding messages..\n");
+        rd_kafka_flush(rk, 10 * 1000 /* wait for max 10 seconds */);
+        fprintf(stderr, "%% %d message(s) produced, %d delivered, %d failed\n",
+                msgcnt, deliveredcnt, msgerrcnt);
+
+        /* Save fatal error prior for using with exit status below. */
+        err = rd_kafka_fatal_error(rk, NULL, 0);
+
+        /* Destroy the producer instance */
+        rd_kafka_destroy(rk);
+
+        /* Exit application with an error (1) if there was a fatal error. */
+        if (err)
+                return 1;
+        else
+                return 0;
+}