@platformatic/rdkafka 4.0.0

package/deps/librdkafka/src/rdaddr.h

@@ -0,0 +1,203 @@
+/*
+ * librd - Rapid Development C library
+ *
+ * Copyright (c) 2012-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.
+ */
+
+#ifndef _RDADDR_H_
+#define _RDADDR_H_
+
+#ifndef _WIN32
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#else
+#define WIN32_MEAN_AND_LEAN
+#include <winsock2.h>
+#include <ws2ipdef.h>
+#endif
+
+#if defined(__FreeBSD__) || defined(_AIX) || defined(__OpenBSD__)
+#include <sys/socket.h>
+#endif
+
+/**
+ * rd_sockaddr_inx_t is a union for either ipv4 or ipv6 sockaddrs.
+ * It provides conveniant abstraction of AF_INET* agnostic operations.
+ */
+typedef union {
+        struct sockaddr_in in;
+        struct sockaddr_in6 in6;
+} rd_sockaddr_inx_t;
+#define sinx_family in.sin_family
+#define sinx_addr   in.sin_addr
+#define RD_SOCKADDR_INX_LEN(sinx)                                              \
+        ((sinx)->sinx_family == AF_INET                                        \
+             ? sizeof(struct sockaddr_in)                                      \
+             : (sinx)->sinx_family == AF_INET6 ? sizeof(struct sockaddr_in6)   \
+                                               : sizeof(rd_sockaddr_inx_t))
+#define RD_SOCKADDR_INX_PORT(sinx)                                             \
+        ((sinx)->sinx_family == AF_INET                                        \
+             ? (sinx)->in.sin_port                                             \
+             : (sinx)->sinx_family == AF_INET6 ? (sinx)->in6.sin6_port : 0)
+
+#define RD_SOCKADDR_INX_PORT_SET(sinx, port)                                   \
+        do {                                                                   \
+                if ((sinx)->sinx_family == AF_INET)                            \
+                        (sinx)->in.sin_port = port;                            \
+                else if ((sinx)->sinx_family == AF_INET6)                      \
+                        (sinx)->in6.sin6_port = port;                          \
+        } while (0)
+
+
+
+/**
+ * Returns a thread-local temporary string (may be called up to 32 times
+ * without buffer wrapping) containing the human string representation
+ * of the sockaddr (which should be AF_INET or AF_INET6 at this point).
+ * If the RD_SOCKADDR2STR_F_PORT is provided the port number will be
+ * appended to the string.
+ * IPv6 address enveloping ("[addr]:port") will also be performed
+ * if .._F_PORT is set.
+ */
+#define RD_SOCKADDR2STR_F_PORT 0x1 /* Append the port. */
+#define RD_SOCKADDR2STR_F_RESOLVE                                              \
+        0x2                          /* Try to resolve address to hostname.    \
+                                      */
+#define RD_SOCKADDR2STR_F_FAMILY 0x4 /* Prepend address family. */
+#define RD_SOCKADDR2STR_F_NICE       /* Nice and friendly output */            \
+        (RD_SOCKADDR2STR_F_PORT | RD_SOCKADDR2STR_F_RESOLVE)
+const char *rd_sockaddr2str(const void *addr, int flags);
+
+
+/**
+ * Splits a node:service definition up into their node and svc counterparts
+ * suitable for passing to getaddrinfo().
+ * Returns NULL on success (and temporarily available pointers in '*node'
+ * and '*svc') or error string on failure.
+ *
+ * Thread-safe but returned buffers in '*node' and '*svc' are only
+ * usable until the next call to rd_addrinfo_prepare() in the same thread.
+ */
+const char *rd_addrinfo_prepare(const char *nodesvc, char **node, char **svc);
+
+
+
+typedef struct rd_sockaddr_list_s {
+        int rsal_cnt;
+        int rsal_curr;
+        rd_sockaddr_inx_t rsal_addr[];
+} rd_sockaddr_list_t;
+
+
+/**
+ * Returns the next address from a sockaddr list and updates
+ * the current-index to point to it.
+ *
+ * Typical usage is for round-robin connection attempts or similar:
+ *   while (1) {
+ *       rd_sockaddr_inx_t *sinx = rd_sockaddr_list_next(my_server_list);
+ *       if (do_connect((struct sockaddr *)sinx) == -1) {
+ *          sleep(1);
+ *          continue;
+ *       }
+ *       ...
+ *   }
+ *
+ */
+
+static RD_INLINE rd_sockaddr_inx_t *
+rd_sockaddr_list_next(rd_sockaddr_list_t *rsal) RD_UNUSED;
+static RD_INLINE rd_sockaddr_inx_t *
+rd_sockaddr_list_next(rd_sockaddr_list_t *rsal) {
+        rsal->rsal_curr = (rsal->rsal_curr + 1) % rsal->rsal_cnt;
+        return &rsal->rsal_addr[rsal->rsal_curr];
+}
+
+
+#define RD_SOCKADDR_LIST_FOREACH(sinx, rsal)                                   \
+        for ((sinx) = &(rsal)->rsal_addr[0];                                   \
+             (sinx) < &(rsal)->rsal_addr[(rsal)->rsal_cnt]; (sinx)++)
+
+/**
+ * Wrapper for getaddrinfo(3) that performs these additional tasks:
+ *  - Input is a combined "<node>[:<svc>]" string, with support for
+ *    IPv6 enveloping ("[addr]:port").
+ *  - Returns a rd_sockaddr_list_t which must be freed with
+ *    rd_sockaddr_list_destroy() when done with it.
+ *  - Automatically shuffles the returned address list to provide
+ *    round-robin (unless RD_AI_NOSHUFFLE is provided in 'flags').
+ *
+ * Thread-safe.
+ */
+#define RD_AI_NOSHUFFLE                                                        \
+        0x10000000 /* Dont shuffle returned address list.                      \
+                    * FIXME: Guessing non-used bits like this                  \
+                    *        is a bad idea. */
+
+struct addrinfo;
+
+rd_sockaddr_list_t *
+rd_getaddrinfo(const char *nodesvc,
+               const char *defsvc,
+               int flags,
+               int family,
+               int socktype,
+               int protocol,
+               int (*resolve_cb)(const char *node,
+                                 const char *service,
+                                 const struct addrinfo *hints,
+                                 struct addrinfo **res,
+                                 void *opaque),
+               void *opaque,
+               const char **errstr);
+
+
+
+/**
+ * Frees a sockaddr list.
+ *
+ * Thread-safe.
+ */
+void rd_sockaddr_list_destroy(rd_sockaddr_list_t *rsal);
+
+
+
+/**
+ * Returns the human readable name of a socket family.
+ */
+static const char *rd_family2str(int af) RD_UNUSED;
+static const char *rd_family2str(int af) {
+        switch (af) {
+        case AF_INET:
+                return "inet";
+        case AF_INET6:
+                return "inet6";
+        default:
+                return "af?";
+        };
+}
+
+#endif /* _RDADDR_H_ */

package/deps/librdkafka/src/rdatomic.h

@@ -0,0 +1,226 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2014-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.
+ */
+#ifndef _RDATOMIC_H_
+#define _RDATOMIC_H_
+
+#include "tinycthread.h"
+
+typedef struct {
+        int32_t val;
+#if !defined(_WIN32) && !HAVE_ATOMICS_32
+        mtx_t lock;
+#endif
+} rd_atomic32_t;
+
+typedef struct {
+        int64_t val;
+#if !defined(_WIN32) && !HAVE_ATOMICS_64
+        mtx_t lock;
+#endif
+} rd_atomic64_t;
+
+
+static RD_INLINE RD_UNUSED void rd_atomic32_init(rd_atomic32_t *ra, int32_t v) {
+        ra->val = v;
+#if !defined(_WIN32) && !HAVE_ATOMICS_32
+        mtx_init(&ra->lock, mtx_plain);
+#endif
+}
+
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_add(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_32_nv(&ra->val, v);
+#elif defined(_WIN32)
+        return InterlockedAdd((LONG *)&ra->val, v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        ra->val += v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(add, fetch, &ra->val, v);
+#endif
+}
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_sub(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_32_nv(&ra->val, -v);
+#elif defined(_WIN32)
+        return InterlockedAdd((LONG *)&ra->val, -v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        ra->val -= v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(sub, fetch, &ra->val, v);
+#endif
+}
+
+/**
+ * @warning The returned value is the nominal value and will be outdated
+ *          by the time the application reads it.
+ *          It should not be used for exact arithmetics, any correlation
+ *          with other data is unsynchronized, meaning that two atomics,
+ *          or one atomic and a mutex-protected piece of data have no
+ *          common synchronization and can't be relied on.
+ */
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
+#if defined(_WIN32) || defined(__SUNPRO_C)
+        return ra->val;
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(fetch, add, &ra->val, 0);
+#endif
+}
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef _WIN32
+        return InterlockedExchange((LONG *)&ra->val, v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val = v;
+        mtx_unlock(&ra->lock);
+        return r;
+#elif HAVE_ATOMICS_32_ATOMIC
+        __atomic_store_n(&ra->val, v, __ATOMIC_SEQ_CST);
+        return v;
+#elif HAVE_ATOMICS_32_SYNC
+        (void)__sync_lock_test_and_set(&ra->val, v);
+        return v;
+#else
+        return ra->val = v;  // FIXME
+#endif
+}
+
+
+
+static RD_INLINE RD_UNUSED void rd_atomic64_init(rd_atomic64_t *ra, int64_t v) {
+        ra->val = v;
+#if !defined(_WIN32) && !HAVE_ATOMICS_64
+        mtx_init(&ra->lock, mtx_plain);
+#endif
+}
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_add(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_64_nv(&ra->val, v);
+#elif defined(_WIN32)
+        return InterlockedAdd64(&ra->val, v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val += v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(add, fetch, &ra->val, v);
+#endif
+}
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_sub(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_64_nv(&ra->val, -v);
+#elif defined(_WIN32)
+        return InterlockedAdd64(&ra->val, -v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val -= v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(sub, fetch, &ra->val, v);
+#endif
+}
+
+/**
+ * @warning The returned value is the nominal value and will be outdated
+ *          by the time the application reads it.
+ *          It should not be used for exact arithmetics, any correlation
+ *          with other data is unsynchronized, meaning that two atomics,
+ *          or one atomic and a mutex-protected piece of data have no
+ *          common synchronization and can't be relied on.
+ *          Use with care.
+ */
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
+#if defined(_WIN32) || defined(__SUNPRO_C)
+        return InterlockedCompareExchange64(&ra->val, 0, 0);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(fetch, add, &ra->val, 0);
+#endif
+}
+
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_set(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef _WIN32
+        return InterlockedExchange64(&ra->val, v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val = v;
+        r       = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#elif HAVE_ATOMICS_64_ATOMIC
+        __atomic_store_n(&ra->val, v, __ATOMIC_SEQ_CST);
+        return v;
+#elif HAVE_ATOMICS_64_SYNC
+        (void)__sync_lock_test_and_set(&ra->val, v);
+        return v;
+#else
+        return ra->val = v;  // FIXME
+#endif
+}
+
+#endif /* _RDATOMIC_H_ */

package/deps/librdkafka/src/rdavg.h

@@ -0,0 +1,259 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2018-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.
+ */
+
+#ifndef _RDAVG_H_
+#define _RDAVG_H_
+
+
+#if WITH_HDRHISTOGRAM
+#include "rdhdrhistogram.h"
+#endif
+
+typedef struct rd_avg_s {
+        struct {
+                int64_t maxv;
+                int64_t minv;
+                int64_t avg;
+                int64_t sum;
+                int cnt;
+                rd_ts_t start;
+        } ra_v;
+        mtx_t ra_lock;
+        int ra_enabled;
+        enum { RD_AVG_GAUGE,
+               RD_AVG_COUNTER,
+        } ra_type;
+#if WITH_HDRHISTOGRAM
+        rd_hdr_histogram_t *ra_hdr;
+#endif
+        /* Histogram results, calculated for dst in rollover().
+         * Will be all zeroes if histograms are not supported. */
+        struct {
+                /* Quantiles */
+                int64_t p50;
+                int64_t p75;
+                int64_t p90;
+                int64_t p95;
+                int64_t p99;
+                int64_t p99_99;
+
+                int64_t oor;     /**< Values out of range */
+                int32_t hdrsize; /**< hdr.allocatedSize */
+                double stddev;
+                double mean;
+        } ra_hist;
+} rd_avg_t;
+
+
+/**
+ * @brief Add value \p v to averager \p ra.
+ */
+static RD_UNUSED void rd_avg_add(rd_avg_t *ra, int64_t v) {
+        mtx_lock(&ra->ra_lock);
+        if (!ra->ra_enabled) {
+                mtx_unlock(&ra->ra_lock);
+                return;
+        }
+        if (v > ra->ra_v.maxv)
+                ra->ra_v.maxv = v;
+        if (ra->ra_v.minv == 0 || v < ra->ra_v.minv)
+                ra->ra_v.minv = v;
+        ra->ra_v.sum += v;
+        ra->ra_v.cnt++;
+#if WITH_HDRHISTOGRAM
+        rd_hdr_histogram_record(ra->ra_hdr, v);
+#endif
+        mtx_unlock(&ra->ra_lock);
+}
+
+
+/**
+ * @brief Calculate the average
+ */
+static RD_UNUSED void rd_avg_calc(rd_avg_t *ra, rd_ts_t now) {
+        if (ra->ra_type == RD_AVG_GAUGE) {
+                if (ra->ra_v.cnt)
+                        ra->ra_v.avg = ra->ra_v.sum / ra->ra_v.cnt;
+                else
+                        ra->ra_v.avg = 0;
+        } else {
+                rd_ts_t elapsed = now - ra->ra_v.start;
+
+                if (elapsed)
+                        ra->ra_v.avg = (ra->ra_v.sum * 1000000llu) / elapsed;
+                else
+                        ra->ra_v.avg = 0;
+
+                ra->ra_v.start = elapsed;
+        }
+}
+
+
+/**
+ * @returns the quantile \q for \p ra, or 0 if histograms are not supported
+ *          in this build.
+ *
+ * @remark ra will be not locked by this function.
+ */
+static RD_UNUSED int64_t rd_avg_quantile(const rd_avg_t *ra, double q) {
+#if WITH_HDRHISTOGRAM
+        return rd_hdr_histogram_quantile(ra->ra_hdr, q);
+#else
+        return 0;
+#endif
+}
+
+/**
+ * @brief Rolls over statistics in \p src and stores the average in \p dst.
+ * \p src is cleared and ready to be reused.
+ *
+ * Caller must free avg internal members by calling rd_avg_destroy()
+ * on the \p dst.
+ */
+static RD_UNUSED void rd_avg_rollover(rd_avg_t *dst, rd_avg_t *src) {
+        rd_ts_t now;
+
+        mtx_lock(&src->ra_lock);
+        if (!src->ra_enabled) {
+                memset(dst, 0, sizeof(*dst));
+                dst->ra_type = src->ra_type;
+                mtx_unlock(&src->ra_lock);
+                return;
+        }
+
+        mtx_init(&dst->ra_lock, mtx_plain);
+        dst->ra_type = src->ra_type;
+        dst->ra_v    = src->ra_v;
+#if WITH_HDRHISTOGRAM
+        dst->ra_hdr = NULL;
+
+        dst->ra_hist.stddev  = rd_hdr_histogram_stddev(src->ra_hdr);
+        dst->ra_hist.mean    = rd_hdr_histogram_mean(src->ra_hdr);
+        dst->ra_hist.oor     = src->ra_hdr->outOfRangeCount;
+        dst->ra_hist.hdrsize = src->ra_hdr->allocatedSize;
+        dst->ra_hist.p50     = rd_hdr_histogram_quantile(src->ra_hdr, 50.0);
+        dst->ra_hist.p75     = rd_hdr_histogram_quantile(src->ra_hdr, 75.0);
+        dst->ra_hist.p90     = rd_hdr_histogram_quantile(src->ra_hdr, 90.0);
+        dst->ra_hist.p95     = rd_hdr_histogram_quantile(src->ra_hdr, 95.0);
+        dst->ra_hist.p99     = rd_hdr_histogram_quantile(src->ra_hdr, 99.0);
+        dst->ra_hist.p99_99  = rd_hdr_histogram_quantile(src->ra_hdr, 99.99);
+#else
+        memset(&dst->ra_hist, 0, sizeof(dst->ra_hist));
+#endif
+        memset(&src->ra_v, 0, sizeof(src->ra_v));
+
+        now             = rd_clock();
+        src->ra_v.start = now;
+
+#if WITH_HDRHISTOGRAM
+        /* Adapt histogram span to fit future out of range entries
+         * from this period. */
+        if (src->ra_hdr->totalCount > 0) {
+                int64_t vmin = src->ra_hdr->lowestTrackableValue;
+                int64_t vmax = src->ra_hdr->highestTrackableValue;
+                int64_t mindiff, maxdiff;
+
+                mindiff = src->ra_hdr->lowestTrackableValue -
+                          src->ra_hdr->lowestOutOfRange;
+
+                if (mindiff > 0) {
+                        /* There were low out of range values, grow lower
+                         * span to fit lowest out of range value + 20%. */
+                        vmin = src->ra_hdr->lowestOutOfRange +
+                               (int64_t)((double)mindiff * 0.2);
+                }
+
+                maxdiff = src->ra_hdr->highestOutOfRange -
+                          src->ra_hdr->highestTrackableValue;
+
+                if (maxdiff > 0) {
+                        /* There were high out of range values, grow higher
+                         * span to fit highest out of range value + 20%. */
+                        vmax = src->ra_hdr->highestOutOfRange +
+                               (int64_t)((double)maxdiff * 0.2);
+                }
+
+                if (vmin == src->ra_hdr->lowestTrackableValue &&
+                    vmax == src->ra_hdr->highestTrackableValue) {
+                        /* No change in min,max, use existing hdr */
+                        rd_hdr_histogram_reset(src->ra_hdr);
+
+                } else {
+                        int sigfigs = (int)src->ra_hdr->significantFigures;
+                        /* Create new hdr for adapted range */
+                        rd_hdr_histogram_destroy(src->ra_hdr);
+                        src->ra_hdr = rd_hdr_histogram_new(vmin, vmax, sigfigs);
+                }
+
+        } else {
+                /* No records, no need to reset. */
+        }
+#endif
+
+        mtx_unlock(&src->ra_lock);
+
+        rd_avg_calc(dst, now);
+}
+
+
+/**
+ * Initialize an averager
+ */
+static RD_UNUSED void rd_avg_init(rd_avg_t *ra,
+                                  int type,
+                                  int64_t exp_min,
+                                  int64_t exp_max,
+                                  int sigfigs,
+                                  int enable) {
+        memset(ra, 0, sizeof(*ra));
+        mtx_init(&ra->ra_lock, 0);
+        ra->ra_enabled = enable;
+        if (!enable)
+                return;
+        ra->ra_type    = type;
+        ra->ra_v.start = rd_clock();
+#if WITH_HDRHISTOGRAM
+        /* Start off the histogram with expected min,max span,
+         * we'll adapt the size on each rollover. */
+        ra->ra_hdr = rd_hdr_histogram_new(exp_min, exp_max, sigfigs);
+#endif
+}
+
+
+/**
+ * Destroy averager
+ */
+static RD_UNUSED void rd_avg_destroy(rd_avg_t *ra) {
+#if WITH_HDRHISTOGRAM
+        if (ra->ra_hdr)
+                rd_hdr_histogram_destroy(ra->ra_hdr);
+#endif
+        mtx_destroy(&ra->ra_lock);
+}
+
+#endif /* _RDAVG_H_ */