libcouchbase 1.3.0 → 1.3.2

data/ext/libcouchbase/src/mcserver/negotiate.cc

@@ -290,7 +290,7 @@ SessionRequestImpl::set_chosen_mech(std::string& mechlist,
             return MECH_UNAVAILABLE;
         }
         mechlist.assign(forcemech);
-        if (memcmp(forcemech, "SCRAM-SHA", sizeof("SCRAM-SHA") - 1) == 0) {
+        if (strncmp(forcemech, "SCRAM-SHA", sizeof("SCRAM-SHA") - 1) == 0) {
             allow_scram_sha = 1;
         }
     }
@@ -385,7 +385,7 @@ SessionRequestImpl::check_auth(const lcb::MemcachedResponse& packet)
     cbsasl_error_t saslerr;
 
     saslerr = cbsasl_client_check(sasl_client,
-        packet.body<const char*>(), packet.bodylen());
+        packet.value(), packet.vallen());
 
     if (saslerr != SASL_OK) {
         set_error(LCB_AUTH_ERROR, "Invalid SASL check");
@@ -428,12 +428,17 @@ SessionRequestImpl::send_hello()
     hdr.sizes(0, agent.size(), (sizeof features[0]) * nfeatures);
     lcbio_ctx_put(ctx, hdr.data(), hdr.size());
     lcbio_ctx_put(ctx, agent.c_str(), agent.size());
-    lcb_log(LOGARGS(this, DEBUG), LOGFMT "HELLO identificator: %.*s", LOGID(this), (int)agent.size(), agent.c_str());
+
+    std::string fstr;
     for (size_t ii = 0; ii < nfeatures; ii++) {
+        char buf[50] = { 0 };
         lcb_U16 tmp = htons(features[ii]);
         lcbio_ctx_put(ctx, &tmp, sizeof tmp);
-        lcb_log(LOGARGS(this, DEBUG), LOGFMT "Request feature: 0x%x (%s)", LOGID(this), features[ii], protocol_feature_2_text(features[ii]));
+        snprintf(buf, sizeof(buf), "%s0x%02x (%s)", ii > 0 ? ", " : "", features[ii], protocol_feature_2_text(features[ii]));
+        fstr.append(buf);
     }
+    lcb_log(LOGARGS(this, DEBUG), LOGFMT "HELO identificator: %.*s, features: %s", LOGID(this), (int)agent.size(),
+            agent.c_str(), fstr.c_str());
 
     lcbio_ctx_rwant(ctx, 24);
     return true;
@@ -454,13 +459,18 @@ SessionRequestImpl::read_hello(const lcb::MemcachedResponse& resp)
     const char *cur;
     const char *payload = resp.value();
     const char *limit = payload + resp.vallen();
-    for (cur = payload; cur < limit; cur += 2) {
+    size_t ii;
+    std::string fstr;
+    for (ii = 0, cur = payload; cur < limit; cur += 2, ii++) {
         lcb_U16 tmp;
+        char buf[50] = { 0 };
         memcpy(&tmp, cur, sizeof(tmp));
         tmp = ntohs(tmp);
-        lcb_log(LOGARGS(this, DEBUG), LOGFMT "Server supports feature: 0x%x (%s)", LOGID(this), tmp, protocol_feature_2_text(tmp));
         info->server_features.push_back(tmp);
+        snprintf(buf, sizeof(buf), "%s0x%02x (%s)", ii > 0 ? ", " : "", tmp, protocol_feature_2_text(tmp));
+        fstr.append(buf);
     }
+    lcb_log(LOGARGS(this, DEBUG), LOGFMT "Server supports features: %s", LOGID(this), fstr.c_str());
     return true;
 }
 
@@ -633,7 +643,7 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
             completed = true;
         } else if (status == PROTOCOL_BINARY_RESPONSE_EACCESS) {
-            set_error(LCB_AUTH_ERROR, "Provided credentials not allowed for bucket", &resp);
+            set_error(LCB_AUTH_ERROR, "Provided credentials not allowed for bucket or bucket does not exist", &resp);
         } else {
             lcb_log(LOGARGS(this, ERROR), LOGFMT "Unexpected status 0x%x received for SELECT_BUCKET", LOGID(this), status);
             set_error(LCB_PROTOCOL_ERROR, "Other auth error", &resp);

data/ext/libcouchbase/src/n1ql/n1ql.cc

@@ -185,7 +185,7 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     /** Whether we're retrying this */
     bool was_retried;
 
-    /** Is this query to Analytics (CBAS) service */
+    /** Is this query to Analytics for N1QL service */
     bool is_cbas;
 
 #ifdef LCB_TRACING
@@ -341,9 +341,18 @@ N1QLREQ::has_retriable_error(const Json::Value& root)
         unsigned code = 0;
         if (jcode.isNumeric()) {
             code = jcode.asUInt();
-            if (code == 4050 || code == 4070) {
+            switch (code) {
+                /* n1ql */
+            case 4050:
+            case 4070:
+                /* analytics */
+            case 23000:
+            case 23003:
+            case 23007:
                 lcb_log(LOGARGS(this, TRACE), LOGFMT "Will retry request. code: %d", LOGID(this), code);
                 return true;
+            default:
+                break;
             }
         }
         if (jmsg.isString()) {
@@ -666,7 +675,7 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
         return;
     }
 
-    if (flags & LCB_CMDN1QL_F_CBASQUERY) {
+    if (flags & LCB_CMDN1QL_F_ANALYTICSQUERY) {
         is_cbas = true;
     }
     if (is_cbas && (flags & LCB_CMDN1QL_F_PREPCACHE)) {

data/ext/libcouchbase/src/newconfig.cc

@@ -145,8 +145,9 @@ static int
 find_new_data_index(lcbvb_CONFIG *oldconfig, lcbvb_CONFIG* newconfig,
     lcb::Server *server)
 {
+    lcbvb_SVCMODE mode = LCBT_SETTING_SVCMODE(server->get_instance());
     const char *old_datahost = lcbvb_get_hostport(oldconfig,
-        server->get_index(), LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_PLAIN);
+        server->get_index(), LCBVB_SVCTYPE_DATA, mode);
 
     if (!old_datahost) {
         /* Old server had no data service */
@@ -155,7 +156,7 @@ find_new_data_index(lcbvb_CONFIG *oldconfig, lcbvb_CONFIG* newconfig,
 
     for (size_t ii = 0; ii < LCBVB_NSERVERS(newconfig); ii++) {
         const char *new_datahost = lcbvb_get_hostport(newconfig, ii,
-            LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_PLAIN);
+            LCBVB_SVCTYPE_DATA, mode);
         if (new_datahost && strcmp(new_datahost, old_datahost) == 0) {
             return ii;
         }
@@ -353,7 +354,7 @@ void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config)
     instance->ht_nodes->clear();
     for (size_t ii = 0; ii < LCBVB_NSERVERS(config->vbc); ++ii) {
         const char *hp = lcbvb_get_hostport(config->vbc, ii,
-            LCBVB_SVCTYPE_MGMT, LCBVB_SVCMODE_PLAIN);
+            LCBVB_SVCTYPE_MGMT, LCBT_SETTING_SVCMODE(instance));
         if (hp) {
             instance->ht_nodes->add(hp, LCB_CONFIG_HTTP_PORT);
         }

data/ext/libcouchbase/src/nodeinfo.cc

@@ -59,15 +59,9 @@ LIBCOUCHBASE_API
 const char *
 lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
 {
-    lcbvb_SVCMODE mode;
+    lcbvb_SVCMODE mode = LCBT_SETTING_SVCMODE(instance);
     lcbvb_CONFIG *vbc = LCBT_VBCONFIG(instance);
 
-    if (LCBT_SETTING(instance, sslopts) & LCB_SSL_ENABLED) {
-        mode = LCBVB_SVCMODE_SSL;
-    } else {
-        mode = LCBVB_SVCMODE_PLAIN;
-    }
-
     if (type & LCB_NODE_HTCONFIG) {
         if (type & LCB_NODE_CONNECTED) {
             const lcb_host_t *host = lcb::clconfig::http_get_host(instance->confmon);

data/ext/libcouchbase/src/operations/observe.cc

@@ -133,6 +133,7 @@ static void handle_observe_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t
     }
     opc->remaining--;
     if (opc->remaining == 0) {
+        TRACE_OBSERVE_END(instance, pkt);
         delete opc;
     }
 }

data/ext/libcouchbase/src/operations/ping.cc

@@ -315,8 +315,7 @@ lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd)
     }
 
     lcbvb_CONFIG *cfg = LCBT_VBCONFIG(instance);
-    const lcbvb_SVCMODE mode = LCBT_SETTING(instance, sslopts) ?
-            LCBVB_SVCMODE_SSL : LCBVB_SVCMODE_PLAIN;
+    const lcbvb_SVCMODE mode = LCBT_SETTING_SVCMODE(instance);
     if (cmd->services & LCB_PINGSVC_F_KV) {
         for (ii = 0; ii < cq->npipelines; ii++) {
             unsigned port = lcbvb_get_port(cfg, ii, LCBVB_SVCTYPE_DATA, mode);
@@ -362,7 +361,7 @@ lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd)
                          ipv6 ? "[" : "", srv->hostname, ipv6 ? "]" : "", port, PATH); \
                 htcmd.host = buf; \
                 htcmd.method = LCB_HTTP_METHOD_GET; \
-                htcmd.type = LCB_HTTP_TYPE_RAW; \
+                htcmd.type = LCB_HTTP_TYPE_PING; \
                 htcmd.reqhandle = &htreq; \
                 const lcb::Authenticator& auth = *instance->settings->auth; \
                 htcmd.username = auth.username_for(NULL, NULL, LCBT_SETTING(instance, bucket)).c_str(); \
@@ -385,6 +384,9 @@ lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd)
         if (cmd->services & LCB_PINGSVC_F_FTS) {
             PING_HTTP(LCBVB_SVCTYPE_FTS, "/api/ping", http_timeout, handle_fts);
         }
+        if (cmd->services & LCB_PINGSVC_F_ANALYTICS) {
+            PING_HTTP(LCBVB_SVCTYPE_ANALYTICS, "/admin/ping", n1ql_timeout, handle_n1ql);
+        }
 #undef PING_HTTP
     }
 

data/ext/libcouchbase/src/retryq.cc

@@ -355,6 +355,28 @@ RetryQueue::add(mc_EXPACKET *pkt, const lcb_error_t err,
     }
 }
 
+bool
+RetryQueue::empty(bool ignore_cfgreq) const
+{
+    bool is_empty = LCB_LIST_IS_EMPTY(&schedops);
+    if (is_empty) {
+        return true;
+    }
+    if (ignore_cfgreq) {
+        lcb_list_t *ll, *llnext;
+        LCB_LIST_SAFE_FOR(ll, llnext, &schedops) {
+            protocol_binary_request_header hdr  = {};
+            RetryOp *op = from_schednode(ll);
+            mcreq_read_hdr(op->pkt, &hdr);
+            if (hdr.request.opcode != PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
 void
 RetryQueue::nmvadd(mc_EXPACKET *detchpkt)
 {

data/ext/libcouchbase/src/retryq.h

@@ -115,9 +115,10 @@ public:
 
     /**
      * @brief Check if there are operations to retry
+     * @param ignore_cfgreq if true, consider queue with single 0xb5 request as empty
      * @return nonzero if there are pending operations
      */
-    bool empty() const { return LCB_LIST_IS_EMPTY(&schedops); }
+    bool empty(bool ignore_cfgreq = false) const;
 
     /**
      * @brief Reset all timeouts on the retry queue.

data/ext/libcouchbase/src/rnd.cc

@@ -18,15 +18,10 @@
 #include "rnd.h"
 #include "internal.h"
 
-#if !defined(COMPILER_SUPPORTS_CXX11) || (defined(_MSC_VER) && _MSC_VER < 1600)
-static volatile int rnd_initialized = 0;
+#if !defined(COMPILER_SUPPORTS_CXX11) || (defined(_MSC_VER) && _MSC_VER < 1600) || defined(__APPLE__)
 LCB_INTERNAL_API
 void lcb_rnd_global_init(void)
 {
-    if (rnd_initialized) {
-        return;
-    }
-    rnd_initialized = 1;
     if (lcb_getenv_boolean("LCB_NO_SRAND")) {
         return;
     }
@@ -51,18 +46,16 @@ lcb_U64 lcb_next_rand64(void)
 LCB_INTERNAL_API
 lcb_U32 lcb_next_rand32(void)
 {
-    static std::random_device rd;
-    static std::mt19937 gen(rd());
-    static std::uniform_int_distribution< lcb_U32 > dis;
+    static thread_local std::mt19937 gen { std::random_device { } () };
+    std::uniform_int_distribution< lcb_U32 > dis;
     return dis(gen);
 }
 
 LCB_INTERNAL_API
 lcb_U64 lcb_next_rand64(void)
 {
-    static std::random_device rd;
-    static std::mt19937 gen(rd());
-    static std::uniform_int_distribution< lcb_U64 > dis;
+    static thread_local std::mt19937 gen { std::random_device { } () };
+    std::uniform_int_distribution< lcb_U64 > dis;
     return dis(gen);
 }
 #endif

data/ext/libcouchbase/src/settings.c

@@ -67,7 +67,8 @@ void lcb_default_settings(lcb_settings *settings)
     settings->use_errmap = 1;
     settings->use_collections = 0;
     settings->log_redaction = 0;
-    settings->use_tracing = 0;
+    settings->use_tracing = 1;
+    settings->network = NULL;
 #ifdef LCB_TRACING
     settings->tracer_orphaned_queue_flush_interval = LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL;
     settings->tracer_orphaned_queue_size = LCBTRACE_DEFAULT_ORPHANED_QUEUE_SIZE;
@@ -79,6 +80,7 @@ void lcb_default_settings(lcb_settings *settings)
     settings->tracer_threshold[LCBTRACE_THRESHOLD_FTS] =  LCBTRACE_DEFAULT_THRESHOLD_FTS;
     settings->tracer_threshold[LCBTRACE_THRESHOLD_ANALYTICS] =  LCBTRACE_DEFAULT_THRESHOLD_ANALYTICS;
 #endif
+    settings->wait_for_config = 0;
 }
 
 LCB_INTERNAL_API
@@ -105,6 +107,7 @@ lcb_settings_unref(lcb_settings *settings)
     free(settings->certpath);
     free(settings->keypath);
     free(settings->client_string);
+    free(settings->network);
 
     lcbauth_unref(settings->auth);
     lcb_errmap_free(settings->errmap);
@@ -115,12 +118,6 @@ lcb_settings_unref(lcb_settings *settings)
     if (settings->metrics) {
         lcb_metrics_destroy(settings->metrics);
     }
-#ifdef LCB_TRACING
-    if (settings->tracer) {
-        lcbtrace_destroy(settings->tracer);
-        settings->tracer = NULL;
-    }
-#endif
     if (settings->dtorcb) {
         settings->dtorcb(settings->dtorarg);
     }

data/ext/libcouchbase/src/settings.h

@@ -99,9 +99,9 @@
 /* 50 ms */
 #define LCB_CONFIG_POLL_INTERVAL_FLOOR LCB_MS2US(50)
 
-#define LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL LCB_MS2US(10000)
 #define LCBTRACE_DEFAULT_ORPHANED_QUEUE_SIZE 128
-#define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_FLUSH_INTERVAL LCB_MS2US(3000)
+#define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_FLUSH_INTERVAL LCB_MS2US(10000)
 #define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_SIZE 128
 #define LCBTRACE_DEFAULT_THRESHOLD_KV  LCB_MS2US(500)
 #define LCBTRACE_DEFAULT_THRESHOLD_N1QL LCB_MS2US(1000)
@@ -192,6 +192,9 @@ typedef struct lcb_settings_st {
     unsigned use_tracing : 1;
     /** Do not use remap vbuckets (do not use fast forward map, or any other heuristics) */
     unsigned vb_noremap : 1;
+    /** Do not wait for GET_CLUSTER_CONFIG request to finish in lcb_wait(),
+     * when it is the only request in retry queue */
+    unsigned wait_for_config : 1;
 
     short max_redir;
     unsigned refcount;
@@ -224,6 +227,7 @@ typedef struct lcb_settings_st {
 #endif
     lcb_U32 compress_min_size;
     float compress_min_ratio;
+    char *network; /** network resolution, AKA "Multi Network Configurations" */
 } lcb_settings;
 
 LCB_INTERNAL_API

data/ext/libcouchbase/src/strcodecs/base64.c

@@ -136,6 +136,65 @@ int lcb_base64_encode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *nds
     return rc;
 }
 
+void lcb_base64_encode_iov(lcb_IOV *iov, unsigned niov, unsigned nb, char **dst, int *ndst)
+{
+    lcb_SIZE nsrc = 0;
+    lcb_SIZE len;
+    char *ptr;
+    lcb_SIZE io;
+
+
+    for (io = 0; io < niov; io++) {
+        nsrc += iov[io].iov_len;
+    }
+    if (nb < nsrc) {
+        nsrc = nb;
+    }
+    len = (nsrc / 3 + 1) * 4 + 1;
+    ptr = calloc(len, sizeof(char));
+
+    {
+        lcb_SIZE triplets = nsrc / 3;
+        lcb_SIZE rest = nsrc % 3;
+        lcb_uint8_t *out = (lcb_uint8_t *)ptr;
+        lcb_SIZE iop, ii;
+        lcb_uint8_t triplet[3];
+
+        io = 0;
+        iop = 0;
+
+
+        for (ii = 0; ii < triplets; ii++) {
+            int tt;
+
+            for (tt = 0; tt < 3; tt++) {
+                if (iop >= iov[io].iov_len) {
+                    io++;
+                    iop = 0;
+                }
+                triplet[tt] = ((const lcb_uint8_t *)iov[io].iov_base)[iop++];
+            }
+            encode_triplet(triplet, out);
+            out += 4;
+        }
+
+        if (rest > 0) {
+            for (ii = 0; ii < rest; ii++) {
+                if (iop >= iov[io].iov_len) {
+                    io++;
+                    iop = 0;
+                }
+                triplet[ii] = ((const lcb_uint8_t *)iov[io].iov_base)[iop++];
+            }
+            encode_rest(triplet, out, rest);
+        }
+        *out = '\0';
+    }
+
+    *ndst = strlen(ptr);
+    *dst = ptr;
+}
+
 static int code2val(char c)
 {
     if (c >= 'A' && c <= 'Z') {

data/ext/libcouchbase/src/strcodecs/strcodecs.h

@@ -67,6 +67,8 @@ int lcb_base64_encode2(const char *src, lcb_SIZE len, char **dst, lcb_SIZE *sz);
 lcb_SSIZE lcb_base64_decode(const char *src, lcb_SIZE nsrc, char *dst, lcb_SIZE ndst);
 lcb_SSIZE lcb_base64_decode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *ndst);
 
+void lcb_base64_encode_iov(lcb_IOV *iov, unsigned niov, unsigned nb, char **dst, int *ndst);
+
 /**
  * Encodes a string suitable for being passed as either a key or value in an
  * "HTTP Form" per application/x-www-form-urlencoded

data/ext/libcouchbase/src/trace.h

@@ -96,8 +96,8 @@
 #define TRACE_OBSERVE_PROGRESS(instance, pkt, mcresp, resp)                                                            \
     TRACE(TRACE_END_COMMON(LIBCOUCHBASE_OBSERVE_PROGRESS, instance, pkt, mcresp, resp, (resp)->cas, (resp)->status,    \
                            (resp)->ismaster, (resp)->ttp, (resp)->ttr))
-#define TRACE_OBSERVE_END(instance, pkt, mcresp)                                                                       \
-    TRACE(LIBCOUCHBASE_OBSERVE_END(instance, mcresp->opaque(), mcresp->opcode(),                                       \
+#define TRACE_OBSERVE_END(instance, pkt)                                                                               \
+    TRACE(LIBCOUCHBASE_OBSERVE_END(instance, pkt->opaque, PROTOCOL_BINARY_CMD_OBSERVE,                                 \
                                    MCREQ_PKT_RDATA(pkt)->dispatch - MCREQ_PKT_RDATA(pkt)->start, LCB_SUCCESS))
 
 #define TRACE_HTTP_BEGIN(req)                                                                                          \

data/ext/libcouchbase/src/tracing/span.cc

@@ -16,10 +16,30 @@
  */
 
 #include "internal.h"
+#include "sllist-inl.h"
 #ifdef HAVE__FTIME64_S
 #include <sys/timeb.h>
 #endif
 
+typedef enum { TAGVAL_STRING, TAGVAL_UINT64, TAGVAL_DOUBLE, TAGVAL_BOOL } tag_type;
+typedef struct tag_value {
+    sllist_node slnode;
+    struct {
+        char *p;
+        int need_free;
+    } key;
+    tag_type t;
+    union {
+        struct {
+            char *p;
+            size_t l;
+        } s;
+        lcb_U64 u64;
+        double d;
+        int b;
+    } v;
+} tag_value;
+
 LIBCOUCHBASE_API
 uint64_t lcbtrace_now()
 {
@@ -54,37 +74,37 @@ void lcbtrace_span_finish(lcbtrace_SPAN *span, uint64_t now)
 LIBCOUCHBASE_API
 void lcbtrace_span_add_tag_str(lcbtrace_SPAN *span, const char *name, const char *value)
 {
-    if (!span) {
+    if (!span || name == NULL || value == NULL) {
         return;
     }
-    span->add_tag(name, value);
+    span->add_tag(name, 1, value);
 }
 
 LIBCOUCHBASE_API
 void lcbtrace_span_add_tag_uint64(lcbtrace_SPAN *span, const char *name, uint64_t value)
 {
-    if (!span) {
+    if (!span || name == NULL) {
         return;
     }
-    span->add_tag(name, (Json::Value::UInt64)value);
+    span->add_tag(name, 1, value);
 }
 
 LIBCOUCHBASE_API
 void lcbtrace_span_add_tag_double(lcbtrace_SPAN *span, const char *name, double value)
 {
-    if (!span) {
+    if (!span || name == NULL) {
         return;
     }
-    span->add_tag(name, value);
+    span->add_tag(name, 1, value);
 }
 
 LIBCOUCHBASE_API
 void lcbtrace_span_add_tag_bool(lcbtrace_SPAN *span, const char *name, int value)
 {
-    if (!span) {
+    if (!span || name == NULL) {
         return;
     }
-    span->add_tag(name, value);
+    span->add_tag(name, 1, (bool)value);
 }
 
 LCB_INTERNAL_API
@@ -93,15 +113,15 @@ void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings,
     if (!span) {
         return;
     }
-    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_SERVICE, service);
+    span->add_tag(LCBTRACE_TAG_SERVICE, 0, service);
     std::string client_string(LCB_CLIENT_ID);
     if (settings->client_string) {
         client_string += " ";
         client_string += settings->client_string;
     }
-    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_COMPONENT, client_string.c_str());
+    span->add_tag(LCBTRACE_TAG_COMPONENT, 0, client_string.c_str(), client_string.size());
     if (settings->bucket) {
-        lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_DB_INSTANCE, settings->bucket);
+        span->add_tag(LCBTRACE_TAG_DB_INSTANCE, 0, settings->bucket);
     }
 }
 
@@ -189,72 +209,108 @@ uint64_t lcbtrace_span_get_trace_id(lcbtrace_SPAN *span)
 LIBCOUCHBASE_API
 lcb_error_t lcbtrace_span_get_tag_str(lcbtrace_SPAN *span, const char *name, char **value, size_t *nvalue)
 {
-    if (!span) {
+    if (!span || name == NULL || nvalue == NULL || value == NULL) {
         return LCB_EINVAL;
     }
-    Json::Value &val = span->tags[name];
-    if (val.isString()) {
-        std::string str = val.asString();
-        if (*nvalue) {
-            /* string has been pre-allocated */
-            if (str.size() < *nvalue) {
-                *nvalue = str.size();
+
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&span->m_tags, &iter)
+    {
+        tag_value *val = SLLIST_ITEM(iter.cur, tag_value, slnode);
+        if (strcmp(name, val->key.p) == 0) {
+            if (val->t != TAGVAL_STRING) {
+                return LCB_EINVAL;
             }
-        } else {
-            *nvalue = str.size();
-            *value = (char *)calloc(*nvalue, sizeof(char));
+            *value = val->v.s.p;
+            *nvalue = val->v.s.l;
+            return LCB_SUCCESS;
         }
-        str.copy(*value, *nvalue, 0);
-        return LCB_SUCCESS;
     }
+
     return LCB_KEY_ENOENT;
 }
 
 LIBCOUCHBASE_API lcb_error_t lcbtrace_span_get_tag_uint64(lcbtrace_SPAN *span, const char *name, uint64_t *value)
 {
-    if (!span) {
+    if (!span || name == NULL || value == NULL) {
         return LCB_EINVAL;
     }
-    Json::Value &val = span->tags[name];
-    if (val.isNumeric()) {
-        *value = val.asUInt64();
-        return LCB_SUCCESS;
+
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&span->m_tags, &iter)
+    {
+        tag_value *val = SLLIST_ITEM(iter.cur, tag_value, slnode);
+        if (strcmp(name, val->key.p) == 0) {
+            if (val->t != TAGVAL_UINT64) {
+                return LCB_EINVAL;
+            }
+            *value = val->v.u64;
+            return LCB_SUCCESS;
+        }
     }
+
     return LCB_KEY_ENOENT;
 }
 
 LIBCOUCHBASE_API lcb_error_t lcbtrace_span_get_tag_double(lcbtrace_SPAN *span, const char *name, double *value)
 {
-    if (!span) {
+    if (!span || name == NULL || value == NULL) {
         return LCB_EINVAL;
     }
-    Json::Value &val = span->tags[name];
-    if (val.isNumeric()) {
-        *value = val.asDouble();
-        return LCB_SUCCESS;
+
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&span->m_tags, &iter)
+    {
+        tag_value *val = SLLIST_ITEM(iter.cur, tag_value, slnode);
+        if (strcmp(name, val->key.p) == 0) {
+            if (val->t != TAGVAL_DOUBLE) {
+                return LCB_EINVAL;
+            }
+            *value = val->v.d;
+            return LCB_SUCCESS;
+        }
     }
+
     return LCB_KEY_ENOENT;
 }
 
 LIBCOUCHBASE_API lcb_error_t lcbtrace_span_get_tag_bool(lcbtrace_SPAN *span, const char *name, int *value)
 {
-    if (!span) {
+    if (!span || name == NULL || value == NULL) {
         return LCB_EINVAL;
     }
-    Json::Value &val = span->tags[name];
-    if (val.isBool()) {
-        *value = val.asBool();
-        return LCB_SUCCESS;
+
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&span->m_tags, &iter)
+    {
+        tag_value *val = SLLIST_ITEM(iter.cur, tag_value, slnode);
+        if (strcmp(name, val->key.p) == 0) {
+            if (val->t != TAGVAL_BOOL) {
+                return LCB_EINVAL;
+            }
+            *value = val->v.b;
+            return LCB_SUCCESS;
+        }
     }
+
     return LCB_KEY_ENOENT;
 }
 
 LIBCOUCHBASE_API int lcbtrace_span_has_tag(lcbtrace_SPAN *span, const char *name)
 {
-    if (!span) {
+    if (!span || name == NULL) {
         return 0;
     }
-    return span->tags.isMember(name);
+
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&span->m_tags, &iter)
+    {
+        tag_value *val = SLLIST_ITEM(iter.cur, tag_value, slnode);
+        if (strcmp(name, val->key.p) == 0) {
+            return 1;
+        }
+    }
+    return 0;
 }
 
 using namespace lcb::trace;
@@ -265,8 +321,9 @@ Span::Span(lcbtrace_TRACER *tracer, const char *opname, uint64_t start, lcbtrace
     m_start = start ? start : lcbtrace_now();
     m_span_id = lcb_next_rand64();
     m_orphaned = false;
-    add_tag(LCBTRACE_TAG_DB_TYPE, "couchbase");
-    add_tag(LCBTRACE_TAG_SPAN_KIND, "client");
+    memset(&m_tags, 0, sizeof(m_tags));
+    add_tag(LCBTRACE_TAG_DB_TYPE, 0, "couchbase");
+    add_tag(LCBTRACE_TAG_SPAN_KIND, 0, "client");
 
     if (other != NULL && ref == LCBTRACE_REF_CHILD_OF) {
         m_parent = other;
@@ -275,6 +332,23 @@ Span::Span(lcbtrace_TRACER *tracer, const char *opname, uint64_t start, lcbtrace
     }
 }
 
+Span::~Span()
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&m_tags, &iter)
+    {
+        tag_value *val = SLLIST_ITEM(iter.cur, tag_value, slnode);
+        sllist_iter_remove(&m_tags, &iter);
+        if (val->key.need_free) {
+            free(val->key.p);
+        }
+        if (val->t == TAGVAL_STRING) {
+            free(val->v.s.p);
+        }
+        free(val);
+    }
+}
+
 void Span::finish(uint64_t now)
 {
     m_finish = now ? now : lcbtrace_now();
@@ -283,7 +357,65 @@ void Span::finish(uint64_t now)
     }
 }
 
-template < typename T > void Span::add_tag(const char *name, T value)
+void Span::add_tag(const char *name, int copy, const char *value)
+{
+    add_tag(name, copy, value, strlen(value));
+}
+
+void Span::add_tag(const char *name, int copy, const char *value, size_t value_len)
+{
+    tag_value *val = (tag_value *)calloc(1, sizeof(tag_value));
+    val->t = TAGVAL_STRING;
+    val->key.need_free = copy;
+    if (copy) {
+        val->key.p = strdup(name);
+    } else {
+        val->key.p = (char *)name;
+    }
+    val->v.s.p = (char *)calloc(value_len, sizeof(char));
+    val->v.s.l = value_len;
+    memcpy(val->v.s.p, value, value_len);
+    sllist_append(&m_tags, &val->slnode);
+}
+
+void Span::add_tag(const char *name, int copy, uint64_t value)
 {
-    tags[name] = value;
+    tag_value *val = (tag_value *)calloc(1, sizeof(tag_value));
+    val->t = TAGVAL_UINT64;
+    val->key.need_free = copy;
+    if (copy) {
+        val->key.p = strdup(name);
+    } else {
+        val->key.p = (char *)name;
+    }
+    val->v.u64 = value;
+    sllist_append(&m_tags, &val->slnode);
+}
+
+void Span::add_tag(const char *name, int copy, double value)
+{
+    tag_value *val = (tag_value *)calloc(1, sizeof(tag_value));
+    val->t = TAGVAL_DOUBLE;
+    val->key.need_free = copy;
+    if (copy) {
+        val->key.p = strdup(name);
+    } else {
+        val->key.p = (char *)name;
+    }
+    val->v.d = value;
+    sllist_append(&m_tags, &val->slnode);
+}
+
+void Span::add_tag(const char *name, int copy, bool value)
+{
+    tag_value *val = (tag_value *)calloc(1, sizeof(tag_value));
+    val->t = TAGVAL_BOOL;
+    val->key.need_free = copy;
+    if (copy) {
+        val->key.p = strdup(name);
+    } else {
+        val->key.p = (char *)name;
+    }
+    val->v.b = value;
+    sllist_append(&m_tags, &val->slnode);
 }