libcouchbase 1.2.8 → 1.3.0

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

@@ -97,8 +97,8 @@ public:
     /**
      * @brief Get the mechanism employed for authentication
      * @param info pointer retrieved via mc_sasl_get()
-     * @return A string indicating the mechanism used. This may be `PLAIN` or
-     * `CRAM-MD5`.
+     * @return A string indicating the mechanism used. This may be `PLAIN`,
+     * `CRAM-MD5`, `SCRAM-SHA1`, `SCRAM-SHA256` or `SCRAM-SHA512` .
      */
     const std::string& get_mech() const {
         return mech;

data/ext/libcouchbase/src/mctx-helper.h

@@ -25,11 +25,17 @@ protected:
     virtual lcb_error_t MCTX_addcmd(const lcb_CMDBASE* cmd) = 0;
     virtual lcb_error_t MCTX_done(const void *cookie) = 0;
     virtual void MCTX_fail() = 0;
+#ifdef LCB_TRACING
+    virtual void MCTX_setspan(lcbtrace_SPAN *span) = 0;
+#endif
 
     MultiCmdContext() {
         lcb_MULTICMD_CTX::addcmd = dispatch_mctx_addcmd;
         lcb_MULTICMD_CTX::done = dispatch_mctx_done;
         lcb_MULTICMD_CTX::fail = dispatch_mctx_fail;
+#ifdef LCB_TRACING
+        lcb_MULTICMD_CTX::setspan = dispatch_mctx_setspan;
+#endif
     }
 
     virtual ~MultiCmdContext() {}
@@ -44,6 +50,11 @@ private:
     static void dispatch_mctx_fail(lcb_MULTICMD_CTX* ctx) {
         static_cast<MultiCmdContext*>(ctx)->MCTX_fail();
     }
+#ifdef LCB_TRACING
+    static void dispatch_mctx_setspan(lcb_MULTICMD_CTX* ctx, lcbtrace_SPAN *span) {
+        static_cast<MultiCmdContext*>(ctx)->MCTX_setspan(span);
+    }
+#endif
 };
 
 }

data/ext/libcouchbase/src/metrics.cc

@@ -0,0 +1,132 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "internal.h"
+#include <libcouchbase/metrics.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace lcbmetrics {
+
+class MetricsEntry : public lcb_SERVERMETRICS {
+public:
+    std::string m_hostport;
+    MetricsEntry(const std::string key) : m_hostport(key) {
+        memset(static_cast<lcb_SERVERMETRICS*>(this), 0, sizeof (lcb_SERVERMETRICS));
+        iometrics.hostport = m_hostport.c_str();
+    }
+
+private:
+    MetricsEntry();
+    MetricsEntry(const MetricsEntry&);
+};
+
+class Metrics : public lcb_METRICS {
+public:
+    std::vector<MetricsEntry *> entries;
+    std::vector<lcb_SERVERMETRICS *> raw_entries;
+
+    Metrics() {
+        memset(static_cast<lcb_METRICS*>(this), 0, sizeof (lcb_METRICS));
+    }
+
+    ~Metrics() {
+        for (size_t ii = 0; ii < entries.size(); ++ii) {
+            delete entries[ii];
+        }
+    }
+
+    MetricsEntry *get(const char *host, const char *port, int create) {
+        std::string key;
+        key.append(host).append(":").append(port);
+        for (size_t ii = 0; ii < entries.size(); ++ii) {
+            if (entries[ii]->m_hostport == key) {
+                return entries[ii];
+            }
+        }
+
+        if (!create) {
+            return NULL;
+        }
+
+        MetricsEntry *ent = new MetricsEntry(key);
+        entries.push_back(ent);
+        raw_entries.push_back(ent);
+        nservers = entries.size();
+        servers = (const lcb_SERVERMETRICS**) &raw_entries[0];
+        return ent;
+    }
+
+    static Metrics *from(lcb_METRICS *metrics) {
+        return static_cast<Metrics*>(metrics);
+    }
+};
+}
+
+using namespace lcbmetrics;
+
+extern "C" {
+lcb_METRICS *
+lcb_metrics_new(void)
+{
+    return new Metrics();
+}
+
+void
+lcb_metrics_destroy(lcb_METRICS *metrics)
+{
+    delete Metrics::from(metrics);
+}
+
+lcb_SERVERMETRICS *
+lcb_metrics_getserver(lcb_METRICS *metrics, const char *h, const char *p, int c)
+{
+    return Metrics::from(metrics)->get(h, p, c);
+}
+
+void
+lcb_metrics_dumpio(const lcb_IOMETRICS *metrics, FILE *fp)
+{
+    fprintf(fp, "Bytes sent: %lu\n", (unsigned long int)metrics->bytes_sent);
+    fprintf(fp, "Bytes received: %lu\n", (unsigned long int)metrics->bytes_received);
+    fprintf(fp, "IO Close: %lu\n", (unsigned long int)metrics->io_close);
+    fprintf(fp, "IO Error: %lu\n", (unsigned long int)metrics->io_error);
+}
+
+void
+lcb_metrics_dumpserver(const lcb_SERVERMETRICS *metrics, FILE *fp)
+{
+    lcb_metrics_dumpio(&metrics->iometrics, fp);
+    fprintf(fp, "Packets queued: %lu\n", (unsigned long int)metrics->packets_queued);
+    fprintf(fp, "Bytes queued: %lu\n", (unsigned long int)metrics->bytes_queued);
+    fprintf(fp, "Packets sent: %lu\n", (unsigned long int)metrics->packets_sent);
+    fprintf(fp, "Packets received: %lu\n", (unsigned long int)metrics->packets_read);
+    fprintf(fp, "Packets errored: %lu\n", (unsigned long int)metrics->packets_errored);
+    fprintf(fp, "Packets NMV: %lu\n", (unsigned long int)metrics->packets_nmv);
+    fprintf(fp, "Packets timeout: %lu\n", (unsigned long int)metrics->packets_timeout);
+    fprintf(fp, "Packets orphaned: %lu", (unsigned long int)metrics->packets_ownerless);
+}
+
+void
+lcb_metrics_reset_pipeline_gauges(lcb_SERVERMETRICS *metrics)
+{
+    metrics->packets_queued = 0;
+    metrics->bytes_queued = 0;
+}
+
+}

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

@@ -736,7 +736,8 @@ WatchIndexCtx::do_poll()
     lcb_CMDN1XMGMT cmd;
     memset(&cmd, 0, sizeof cmd);
     cmd.callback = cb_watch_gotlist;
-    lcb_log(LOGARGS(this, DEBUG), LOGFMT "Will check for index readiness of %lu indexes. %lu completed", LOGID(this), m_defspend.size(), m_defsok.size());
+    lcb_log(LOGARGS(this, DEBUG), LOGFMT "Will check for index readiness of %lu indexes. %lu completed",
+            LOGID(this), (unsigned long int)m_defspend.size(), (unsigned long int)m_defsok.size());
     return lcb_n1x_list(m_instance, this, &cmd);
 }
 

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

@@ -1,3 +1,20 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/n1ql.h>
 #include <jsparse/parser.h>
@@ -171,6 +188,10 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     /** Is this query to Analytics (CBAS) service */
     bool is_cbas;
 
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
+
     lcb_N1QLCACHE& cache() { return *instance->n1ql_cache; }
 
     /**
@@ -424,6 +445,27 @@ lcb_N1QLREQ::~lcb_N1QLREQ()
         invoke_row(&resp, 1);
     }
 
+#ifdef LCB_TRACING
+    if (span) {
+        if (htreq) {
+            lcbio_CTX *ctx = htreq->ioctx;
+            if (ctx) {
+                std::string remote;
+                if (htreq->ipv6) {
+                    remote = "[" + std::string(htreq->host) + "]:" + std::string(htreq->port);
+                } else {
+                    remote = std::string(htreq->host) + ":" + std::string(htreq->port);
+                }
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, remote.c_str());
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_LOCAL_ADDRESS,
+                                          lcbio__inet_ntop(&ctx->sock->info->sa_local).c_str());
+            }
+        }
+        lcbtrace_span_finish(span, LCBTRACE_NOW);
+        span = NULL;
+    }
+#endif
+
     if (parser) {
         delete parser;
     }
@@ -609,6 +651,9 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
       cookie(user_cookie), callback(cmd->callback), instance(obj),
       lasterr(LCB_SUCCESS), flags(cmd->cmdflags), timeout(0),
       nrows(0), prepare_req(NULL), was_retried(false), is_cbas(false)
+#ifdef LCB_TRACING
+    , span(NULL)
+#endif
 {
     if (cmd->handle) {
         *cmd->handle = this;
@@ -675,6 +720,15 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
             curCreds["pass"] = ii->second;
         }
     }
+#ifdef LCB_TRACING
+    if (instance->settings->tracer) {
+        char id[20] = {0};
+        snprintf(id, sizeof(id), "%p", (void *)this);
+        span = lcbtrace_span_start(instance->settings->tracer, LCBTRACE_OP_DISPATCH_TO_SERVER, LCBTRACE_NOW, NULL);
+        lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, id);
+        lcbtrace_span_add_system_tags(span, instance->settings, is_cbas ? LCBTRACE_TAG_SERVICE_ANALYTICS : LCBTRACE_TAG_SERVICE_N1QL);
+    }
+#endif
 }
 
 LIBCOUCHBASE_API
@@ -753,3 +807,15 @@ lcb_n1ql_cancel(lcb_t instance, lcb_N1QLHANDLE handle)
     }
     handle->callback = NULL;
 }
+
+#ifdef LCB_TRACING
+
+LIBCOUCHBASE_API
+void lcb_n1ql_set_parent_span(lcb_t, lcb_N1QLHANDLE handle, lcbtrace_SPAN *span)
+{
+    if (handle) {
+        lcbtrace_span_set_parent(handle->span, span);
+    }
+}
+
+#endif

data/ext/libcouchbase/src/newconfig.cc

@@ -24,8 +24,12 @@
 #define LOGARGS(instance, lvl) (instance)->settings, "newconfig", LCB_LOG_##lvl, __FILE__, __LINE__
 #define LOG(instance, lvlbase, msg) lcb_log(instance->settings, "newconfig", LCB_LOG_##lvlbase, __FILE__, __LINE__, msg)
 
-#define SERVER_FMT "%s:%s (%p)"
-#define SERVER_ARGS(s) (s)->get_host().host, (s)->get_host().port, (void *)s
+#define SERVER_FMT LCB_LOG_SPEC("%s:%s") " (%p)"
+#define SERVER_ARGS(s)                                          \
+    (s)->settings->log_redaction ? LCB_LOG_SD_OTAG : "",       \
+        (s)->get_host().host, (s)->get_host().port,             \
+        (s)->settings->log_redaction ? LCB_LOG_SD_CTAG : "",   \
+        (void *)s
 
 typedef struct lcb_GUESSVB_st {
     time_t last_update; /**< Last time this vBucket was heuristically set */
@@ -93,6 +97,9 @@ lcb_vbguess_newconfig(lcb_t instance, lcbvb_CONFIG *cfg, lcb_GUESSVB *guesses)
 int
 lcb_vbguess_remap(lcb_t instance, int vbid, int bad)
 {
+    if (LCBT_SETTING(instance, vb_noremap)) {
+        return -1;
+    }
 
     if (LCBT_SETTING(instance, vb_noguess)) {
         int newix = lcbvb_nmv_remap_ex(LCBT_VBCONFIG(instance), vbid, bad, 0);

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

@@ -72,7 +72,8 @@ lcb_counter3(
     }
 
     memcpy(SPAN_BUFFER(&packet->kh_span), acmd.bytes, sizeof(acmd.bytes));
-    TRACE_ARITHMETIC_BEGIN(hdr, cmd);
+    LCBTRACE_KV_START(instance->settings, cmd, LCBTRACE_OP_COUNTER, packet->opaque, rdata->span);
+    TRACE_ARITHMETIC_BEGIN(instance, hdr, cmd);
     LCB_SCHED_ADD(instance, pipeline, packet);
     return LCB_SUCCESS;
 }

data/ext/libcouchbase/src/operations/durability-cas.cc

@@ -186,6 +186,17 @@ CasDurset::poll_impl()
         cmd.servers_ = servers;
         cmd.nservers_ = nservers;
 
+#ifdef LCB_TRACING
+        if (instance->settings->tracer) {
+            lcbtrace_REF ref;
+            ref.type = LCBTRACE_REF_CHILD_OF;
+            ref.span = span;
+            lcbtrace_SPAN *child =
+                lcbtrace_span_start(instance->settings->tracer, LCBTRACE_OP_OBSERVE_CAS_ROUND, LCBTRACE_NOW, &ref);
+            lcbtrace_span_add_system_tags(child, instance->settings, LCBTRACE_TAG_SERVICE_KV);
+            mctx->setspan(mctx, child);
+        }
+#endif
         err = mctx->addcmd(mctx, (lcb_CMDBASE *)&cmd);
         if (err != LCB_SUCCESS) {
             mctx->fail(mctx);

data/ext/libcouchbase/src/operations/durability-seqno.cc

@@ -120,6 +120,9 @@ SeqnoDurset::poll_impl()
         for (size_t jj = 0; jj < nservers; jj++) {
             lcb_error_t err;
             cmd.server_index = servers[jj];
+#ifdef LCB_TRACING
+            LCB_CMD_SET_TRACESPAN(&cmd, span);
+#endif
             err = lcb_observe_seqno3(instance, &ent.callback, &cmd);
             if (err == LCB_SUCCESS) {
                 waiting++;

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

@@ -158,7 +158,7 @@ Item::update(int flags, int srvix)
     bool is_master = lcbvb_vbmaster(LCBT_VBCONFIG(instance), vbid) == srvix;
     const lcb::Server *server = instance->get_server(srvix);
 
-    memset(info, 0, sizeof(*info));
+    info->clear();
     info->server = server;
 
     if (flags & UPDATE_PERSISTED) {
@@ -249,6 +249,13 @@ Durset::on_poll_done()
 
     if (nremaining > 0) {
         switch_state(STATE_OBSPOLL);
+#ifdef LCB_TRACING
+    } else {
+        if (span) {
+            lcbtrace_span_finish(span, LCBTRACE_NOW);
+            span = NULL;
+        }
+#endif
     }
     decref();
 }
@@ -326,6 +333,13 @@ lcb_durability_validate(lcb_t instance,
 
 }
 
+#ifdef LCB_TRACING
+void Durset::MCTX_setspan(lcbtrace_SPAN *span_)
+{
+    span = span_;
+}
+#endif
+
 lcb_error_t Durset::MCTX_addcmd(const lcb_CMDBASE *cmd) {
     if (LCB_KEYBUF_IS_EMPTY(&cmd->key)) {
         return LCB_EMPTY_KEY;
@@ -339,7 +353,6 @@ lcb_error_t Durset::MCTX_addcmd(const lcb_CMDBASE *cmd) {
         MCREQ_PKT_BASESIZE, &vbid, &srvix);
 
     /* ok. now let's initialize the entry..*/
-    memset(&ent, 0, sizeof (ent));
     ent.res().nkey = cmd->key.contig.nbytes;
     ent.reqcas = cmd->cas;
     ent.parent = this;
@@ -384,6 +397,12 @@ Durset::MCTX_done(const void *cookie_) {
 }
 
 void Durset::MCTX_fail() {
+#ifdef LCB_TRACING
+    if (span) {
+        lcbtrace_span_finish(span, LCBTRACE_NOW);
+        span = NULL;
+    }
+#endif
     delete this;
 }
 
@@ -426,6 +445,9 @@ Durset::Durset(lcb_t instance_, const lcb_durability_opts_t *options)
       nremaining(0), waiting(0), refcnt(0), next_state(STATE_OBSPOLL),
       lasterr(LCB_SUCCESS), is_durstore(false), cookie(NULL),
       ns_timeout(0), timer(NULL), instance(instance_)
+#ifdef LCB_TRACING
+    , span(NULL)
+#endif
 {
     const lcb_DURABILITYOPTSv0 *opts_in = &options->v.v0;
 

data/ext/libcouchbase/src/operations/durability_internal.h

@@ -102,11 +102,24 @@ struct Durset;
 // For use in conjunction with MCREQ_F_PRIVCALLBACK
 struct CallbackCookie {
     lcb_RESPCALLBACK callback;
+
+    CallbackCookie() : callback(NULL) {}
 };
 
 /**Information a single entry in a durability set. Each entry contains a single
  * key */
 struct Item : public CallbackCookie {
+    Item():
+        reqcas(0),
+        reqseqno(0),
+        uuid(0),
+        result(),
+        parent(NULL),
+        vbid(0),
+        done(0)
+    {
+    }
+
     /**
      * Returns true if the entry is complete, false otherwise. This only assumes
      * successful entries.
@@ -253,6 +266,9 @@ struct Durset : public MultiCmdContext {
     lcb_error_t MCTX_done(const void *cookie);
     lcb_error_t MCTX_addcmd(const lcb_CMDBASE *cmd);
     void MCTX_fail();
+#ifdef LCB_TRACING
+    void MCTX_setspan(lcbtrace_SPAN *span);
+#endif
 
     /**
      * This function calls poll_impl(). The implementation should then call
@@ -279,6 +295,9 @@ struct Durset : public MultiCmdContext {
     hrtime_t ns_timeout; /**< Timestamp of next timeout */
     void *timer;
     lcb_t instance;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
 };
 
 } // namespace durability