libcouchbase 1.2.8 → 1.3.0

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

@@ -74,7 +74,8 @@ lcb_get3(lcb_t instance, const void *cookie, const lcb_CMDGET *cmd)
 
     memcpy(SPAN_BUFFER(&pkt->kh_span), gcmd.bytes, MCREQ_PKT_BASESIZE + extlen);
     LCB_SCHED_ADD(instance, pl, pkt);
-    TRACE_GET_BEGIN(hdr, cmd);
+    LCBTRACE_KV_START(instance->settings, cmd, LCBTRACE_OP_GET, pkt->opaque, rdata->span);
+    TRACE_GET_BEGIN(instance, hdr, cmd);
 
     return LCB_SUCCESS;
 }
@@ -144,8 +145,9 @@ lcb_unlock3(lcb_t instance, const void *cookie, const lcb_CMDUNLOCK *cmd)
     hdr.request.cas = lcb_htonll(cmd->cas);
 
     memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
-    TRACE_UNLOCK_BEGIN(&hdr, cmd);
     LCB_SCHED_ADD(instance, pl, pkt);
+    LCBTRACE_KV_START(instance->settings, cmd, LCBTRACE_OP_UNLOCK, pkt->opaque, rd->span);
+    TRACE_UNLOCK_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;
 }
 

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

@@ -50,6 +50,7 @@ lcb_observe_seqno3(lcb_t instance, const void *cookie, const lcb_CMDOBSEQNO *cmd
     uuid = lcb_htonll(cmd->uuid);
     memcpy(SPAN_BUFFER(&pkt->u_value.single), &uuid, sizeof uuid);
     LCB_SCHED_ADD(instance, server, pkt);
+    LCBTRACE_KV_START(instance->settings, cmd, LCBTRACE_OP_OBSERVE_SEQNO, pkt->opaque, MCREQ_PKT_RDATA(pkt)->span);
     return LCB_SUCCESS;
 }
 

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

@@ -19,50 +19,61 @@
 #include "durability_internal.h"
 #include "trace.h"
 #include "mctx-helper.h"
+#include "sllist-inl.h"
 
-struct ObserveCtx : mc_REQDATAEX, lcb::MultiCmdContext {
-    void clear_requests() { requests.clear(); }
+struct ObserveCtx : lcb::MultiCmdContext {
+    void clear_requests()
+    {
+        requests.clear();
+        num_requests.clear();
+    }
     ObserveCtx(lcb_t instance_);
 
     // Overrides
-    lcb_error_t MCTX_addcmd(const lcb_CMDBASE*);
+    lcb_error_t MCTX_addcmd(const lcb_CMDBASE *);
     lcb_error_t MCTX_done(const void *);
     void MCTX_fail();
+#ifdef LCB_TRACING
+    void MCTX_setspan(lcbtrace_SPAN *span);
+#endif
 
     lcb_t instance;
     size_t remaining;
     unsigned oflags;
 
-    typedef std::vector<uint8_t> ServerBuf;
+    typedef std::vector< uint8_t > ServerBuf;
     /* requests array contains one buffer per server. nrequest essentially
      * says how many elements (and thus how many servers) */
-    std::vector<ServerBuf> requests;
+    std::vector< ServerBuf > requests;
+    std::vector< size_t > num_requests;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
+};
+
+struct OperationCtx : mc_REQDATAEX {
+    OperationCtx(ObserveCtx *parent_, size_t remaining_);
+
+    ObserveCtx *parent;
+    size_t remaining;
 };
 
-typedef enum {
-    F_DURABILITY = 0x01,
-    F_DESTROY = 0x02,
-    F_SCHEDFAILED = 0x04
-} obs_flags;
+typedef enum { F_DURABILITY = 0x01, F_DESTROY = 0x02, F_SCHEDFAILED = 0x04 } obs_flags;
 
 // TODO: Move this to a common file
-template <typename ContainerType, typename ValueType>
-void add_to_buf(ContainerType& c, ValueType v) {
-    typename ContainerType::value_type *p =
-            reinterpret_cast<typename ContainerType::value_type*>(&v);
+template < typename ContainerType, typename ValueType > void add_to_buf(ContainerType &c, ValueType v)
+{
+    typename ContainerType::value_type *p = reinterpret_cast< typename ContainerType::value_type * >(&v);
     c.insert(c.end(), p, p + sizeof(ValueType));
 }
 
-static void
-handle_observe_callback(mc_PIPELINE *pl,
-    mc_PACKET *pkt, lcb_error_t err, const void *arg)
+static void handle_observe_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_error_t err, const void *arg)
 {
-    ObserveCtx *oc = static_cast<ObserveCtx*>(pkt->u_rdata.exdata);
-    lcb_RESPOBSERVE *resp = reinterpret_cast<lcb_RESPOBSERVE*>(const_cast<void*>(arg));
+    OperationCtx *opc = static_cast< OperationCtx * >(pkt->u_rdata.exdata);
+    ObserveCtx *oc = opc->parent;
+    lcb_RESPOBSERVE *resp = reinterpret_cast< lcb_RESPOBSERVE * >(const_cast< void * >(arg));
     lcb_t instance = oc->instance;
 
-    (void)pl;
-
     if (resp == NULL) {
         int nfailed = 0;
         /** We need to fail the request manually.. */
@@ -70,7 +81,7 @@ handle_observe_callback(mc_PIPELINE *pl,
         const char *end = ptr + pkt->u_value.single.size;
         while (ptr < end) {
             lcb_uint16_t nkey;
-            lcb_RESPOBSERVE cur = { 0 };
+            lcb_RESPOBSERVE cur = {0};
             cur.rflags = LCB_RESP_F_CLIENTGEN;
 
             ptr += 2;
@@ -81,7 +92,7 @@ handle_observe_callback(mc_PIPELINE *pl,
             memset(&cur, 0, sizeof(cur));
             cur.key = ptr;
             cur.nkey = nkey;
-            cur.cookie = (void *)oc->cookie;
+            cur.cookie = (void *)opc->cookie;
             cur.rc = err;
             handle_observe_callback(NULL, pkt, err, &cur);
             ptr += nkey;
@@ -91,11 +102,18 @@ handle_observe_callback(mc_PIPELINE *pl,
         return;
     }
 
-    resp->cookie = (void *)oc->cookie;
+    resp->cookie = (void *)opc->cookie;
     resp->rc = err;
+    oc->remaining--;
+#ifdef LCB_TRACING
+    if (oc->remaining == 0 && oc->span) {
+        lcbtrace_span_finish(oc->span, LCBTRACE_NOW);
+        oc->span = NULL;
+    }
+#endif
     if (oc->oflags & F_DURABILITY) {
         resp->ttp = pl ? pl->index : -1;
-        lcbdur_cas_update(instance, (void*)MCREQ_PKT_COOKIE(pkt), err, resp);
+        lcbdur_cas_update(instance, (void *)MCREQ_PKT_COOKIE(pkt), err, resp);
 
     } else if ((oc->oflags & F_SCHEDFAILED) == 0) {
         lcb_RESPCALLBACK callback = lcb_find_callback(instance, LCB_CALLBACK_OBSERVE);
@@ -105,27 +123,35 @@ handle_observe_callback(mc_PIPELINE *pl,
     if (oc->oflags & F_DESTROY) {
         return;
     }
-
-    if (--oc->remaining) {
-        return;
-    } else {
-        lcb_RESPOBSERVE resp2 = { 0 };
+    if (oc->remaining == 0) {
+        lcb_RESPOBSERVE resp2 = {0};
         resp2.rc = err;
-        resp2.rflags = LCB_RESP_F_CLIENTGEN|LCB_RESP_F_FINAL;
+        resp2.rflags = LCB_RESP_F_CLIENTGEN | LCB_RESP_F_FINAL;
         oc->oflags |= F_DESTROY;
         handle_observe_callback(NULL, pkt, err, &resp2);
         delete oc;
     }
+    opc->remaining--;
+    if (opc->remaining == 0) {
+        delete opc;
+    }
 }
 
-static void
-handle_schedfail(mc_PACKET *pkt)
+static void handle_schedfail(mc_PACKET *pkt)
 {
-    ObserveCtx *oc = static_cast<ObserveCtx*>(pkt->u_rdata.exdata);
+    OperationCtx *opc = static_cast< OperationCtx * >(pkt->u_rdata.exdata);
+    ObserveCtx *oc = opc->parent;
     oc->oflags |= F_SCHEDFAILED;
     handle_observe_callback(NULL, pkt, LCB_SCHEDFAIL_INTERNAL, NULL);
 }
 
+#ifdef LCB_TRACING
+void ObserveCtx::MCTX_setspan(lcbtrace_SPAN *span_)
+{
+    span = span_;
+}
+#endif
+
 lcb_error_t ObserveCtx::MCTX_addcmd(const lcb_CMDBASE *cmdbase)
 {
     int vbid, srvix_dummy;
@@ -182,22 +208,18 @@ lcb_error_t ObserveCtx::MCTX_addcmd(const lcb_CMDBASE *cmdbase)
 
         lcb_assert(ix < requests.size());
 
-        ServerBuf& rr = requests[ix];
+        ServerBuf &rr = requests[ix];
         add_to_buf(rr, uint16_t(htons(vbid)));
         add_to_buf(rr, uint16_t(htons(cmd->key.contig.nbytes)));
-        rr.insert(rr.end(),
-            reinterpret_cast<const uint8_t*>(cmd->key.contig.bytes),
-            reinterpret_cast<const uint8_t*>(cmd->key.contig.bytes) +
-            cmd->key.contig.nbytes);
+        rr.insert(rr.end(), reinterpret_cast< const uint8_t * >(cmd->key.contig.bytes),
+                  reinterpret_cast< const uint8_t * >(cmd->key.contig.bytes) + cmd->key.contig.nbytes);
         remaining++;
+        num_requests[ii]++;
     }
     return LCB_SUCCESS;
 }
 
-static mc_REQDATAPROCS obs_procs = {
-        handle_observe_callback,
-        handle_schedfail
-};
+static mc_REQDATAPROCS obs_procs = {handle_observe_callback, handle_schedfail};
 
 lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
 {
@@ -208,7 +230,7 @@ lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
         protocol_binary_request_header hdr;
         mc_PACKET *pkt;
         mc_PIPELINE *pipeline;
-        ServerBuf& rr = requests[ii];
+        ServerBuf &rr = requests[ii];
         pipeline = cq->pipelines[ii];
 
         if (rr.empty()) {
@@ -234,15 +256,30 @@ lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
         memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
         memcpy(SPAN_BUFFER(&pkt->u_value.single), &rr[0], rr.size());
 
+        OperationCtx *ctx = new OperationCtx(this, this->num_requests[ii]);
+        ctx->start = gethrtime();
+        ctx->cookie = cookie_;
+
         pkt->flags |= MCREQ_F_REQEXT;
-        pkt->u_rdata.exdata = this;
+        pkt->u_rdata.exdata = ctx;
+#ifdef LCB_TRACING
+        if (instance->settings->tracer) {
+            lcbtrace_REF ref;
+            char opid[20] = {};
+            snprintf(opid, sizeof(opid), "0x%x", (int)pkt->opaque);
+            ref.type = LCBTRACE_REF_CHILD_OF;
+            ref.span = span;
+            MCREQ_PKT_RDATA(pkt)->span =
+                lcbtrace_span_start(instance->settings->tracer, LCBTRACE_OP_OBSERVE_CAS, LCBTRACE_NOW, &ref);
+            lcbtrace_span_add_tag_str(MCREQ_PKT_RDATA(pkt)->span, LCBTRACE_TAG_OPERATION_ID, opid);
+            lcbtrace_span_add_system_tags(MCREQ_PKT_RDATA(pkt)->span, instance->settings, LCBTRACE_TAG_SERVICE_KV);
+        }
+#endif
+
         mcreq_sched_add(pipeline, pkt);
-        TRACE_OBSERVE_BEGIN(&hdr, SPAN_BUFFER(&pkt->u_value.single));
+        TRACE_OBSERVE_BEGIN(instance, &hdr, SPAN_BUFFER(&pkt->u_value.single));
     }
 
-    start = gethrtime();
-    cookie = cookie_;
-
     if (requests.size() == 0 || remaining == 0) {
         delete this;
         return LCB_EINVAL;
@@ -252,35 +289,49 @@ lcb_error_t ObserveCtx::MCTX_done(const void *cookie_)
     }
 }
 
-void ObserveCtx::MCTX_fail() {
+void ObserveCtx::MCTX_fail()
+{
+#ifdef LCB_TRACING
+    if (span) {
+        lcbtrace_span_finish(span, LCBTRACE_NOW);
+        span = NULL;
+    }
+#endif
     delete this;
 }
 
 ObserveCtx::ObserveCtx(lcb_t instance_)
-    : mc_REQDATAEX(NULL, obs_procs, 0),
-      instance(instance_),
-      remaining(0),
-      oflags(0) {
-
+    : instance(instance_), remaining(0), oflags(0)
+#ifdef LCB_TRACING
+      ,
+      span(NULL)
+#endif
+{
     requests.resize(LCBT_NSERVERS(instance));
+    num_requests.resize(requests.size());
+}
+
+OperationCtx::OperationCtx(ObserveCtx *parent_, size_t remaining_)
+    : mc_REQDATAEX(NULL, obs_procs, 0), parent(parent_), remaining(remaining_)
+{
 }
 
 LIBCOUCHBASE_API
-lcb_MULTICMD_CTX * lcb_observe3_ctxnew(lcb_t instance) {
+lcb_MULTICMD_CTX *lcb_observe3_ctxnew(lcb_t instance)
+{
     return new ObserveCtx(instance);
 }
 
-lcb_MULTICMD_CTX *
-lcb_observe_ctx_dur_new(lcb_t instance) {
+lcb_MULTICMD_CTX *lcb_observe_ctx_dur_new(lcb_t instance)
+{
     ObserveCtx *ctx = new ObserveCtx(instance);
     ctx->oflags |= F_DURABILITY;
     return ctx;
 }
 
 LIBCOUCHBASE_API
-lcb_error_t lcb_observe(lcb_t instance,
-    const void *command_cookie, lcb_size_t num,
-    const lcb_observe_cmd_t *const *items)
+lcb_error_t lcb_observe(lcb_t instance, const void *command_cookie, lcb_size_t num,
+                        const lcb_observe_cmd_t *const *items)
 {
     unsigned ii;
     lcb_error_t err;
@@ -294,7 +345,7 @@ lcb_error_t lcb_observe(lcb_t instance,
     }
 
     for (ii = 0; ii < num; ii++) {
-        lcb_CMDOBSERVE cmd = { 0 };
+        lcb_CMDOBSERVE cmd = {0};
         const lcb_observe_cmd_t *src = items[ii];
         if (src->version == 1 && (src->v.v1.options & LCB_OBSERVE_MASTER_ONLY)) {
             cmd.cmdflags |= LCB_CMDOBSERVE_F_MASTER_ONLY;

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

@@ -32,6 +32,7 @@ struct PingCookie : mc_REQDATAEX {
     int remaining;
     int options;
     std::list<lcb_PINGSVC> responses;
+    std::string id;
 
     PingCookie(const void *cookie_, int _options)
         : mc_REQDATAEX(cookie_, ping_procs, gethrtime()),
@@ -41,8 +42,12 @@ struct PingCookie : mc_REQDATAEX {
     ~PingCookie() {
         for (std::list<lcb_PINGSVC>::iterator it = responses.begin(); it != responses.end(); it++) {
             if (it->server) {
-                free(it->server);
+                free((void *)it->server);
                 it->server = NULL;
+                free((void *)it->local);
+                it->local = NULL;
+                free((void *)it->id);
+                it->id = NULL;
             }
         }
     }
@@ -73,23 +78,6 @@ refcnt_dtor_ping(mc_PACKET *pkt)
     }
 }
 
-static std::string latency_to_string(lcb_U64 latency)
-{
-    std::stringstream ss;
-    ss.precision(3);
-    ss.setf(std::ios::fixed);
-    if (latency < 1000) {
-        ss << latency << "ns";
-    } else if (latency < LCB_US2NS(1000)) {
-        ss << (latency / (double)LCB_US2NS(1)) << "us";
-    } else if (latency < LCB_MS2NS(1000)) {
-        ss << (latency / (double)LCB_MS2NS(1)) << "ms";
-    } else {
-        ss << (latency / (double)LCB_S2NS(1)) << "s";
-    }
-    return ss.str();
-}
-
 static const char* svc_to_string(lcb_PINGSVCTYPE type)
 {
     switch (type) {
@@ -107,21 +95,55 @@ static const char* svc_to_string(lcb_PINGSVCTYPE type)
 }
 
 static void
-build_ping_json(lcb_RESPPING &ping, Json::Value &root, bool details)
+build_ping_json(lcb_t instance, lcb_RESPPING &ping, Json::Value &root, PingCookie *ck)
 {
     Json::Value services;
     for (size_t ii = 0; ii < ping.nservices; ii++) {
         lcb_PINGSVC &svc = ping.services[ii];
         Json::Value service;
-        service["server"] = svc.server;
-        service["latency"] = latency_to_string(svc.latency);
-        service["status"] = svc.status;
-        if (details) {
-            service["details"] = lcb_strerror(NULL, svc.status);
+        service["remote"] = svc.server;
+        if (svc.local) {
+            service["local"] = svc.local;
+        }
+        if (svc.id) {
+            service["id"] = svc.id;
+        }
+        if (svc.scope) {
+            service["scope"] = svc.scope;
+        }
+
+        service["latency_us"] = (Json::Value::UInt64)LCB_NS2US(svc.latency);
+        switch (svc.status) {
+        case LCB_PINGSTATUS_OK:
+            service["status"] = "ok";
+            break;
+        case LCB_PINGSTATUS_TIMEOUT:
+            service["status"] = "timeout";
+            break;
+        default:
+            service["status"] = "error";
+            if (ck->needDetails()) {
+                service["details"] = lcb_strerror_long(svc.rc);
+            }
         }
         services[svc_to_string(svc.type)].append(service);
     }
     root["services"] = services;
+    root["version"] = 1;
+
+    std::string sdk("libcouchbase/" LCB_VERSION_STRING);
+    if (LCBT_SETTING(instance, client_string)) {
+        sdk.append(" ").append(LCBT_SETTING(instance, client_string));
+    }
+    root["sdk"] = sdk.c_str();
+    root["id"] = ck->id;
+
+    int config_rev = -1;
+    if (instance->cur_configinfo) {
+        lcb::clconfig::ConfigInfo *cfg = instance->cur_configinfo;
+        config_rev = cfg->vbc->revid;
+    }
+    root["config_rev"] = config_rev;
 }
 
 static void
@@ -139,7 +161,7 @@ invoke_ping_callback(lcb_t instance, PingCookie *ck)
         }
         if (ck->needJSON()) {
             Json::Value root;
-            build_ping_json(ping, root, ck->needDetails());
+            build_ping_json(instance, ping, root, ck);
             Json::Writer *w;
             if (ck->needPretty()) {
                 w = new Json::StyledWriter();
@@ -169,15 +191,38 @@ handle_ping(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t err, const void *
     PingCookie *ck = (PingCookie *)req->u_rdata.exdata;
 
     if (ck->needMetrics()) {
-        std::string hh(server->get_host().host);
-        hh.append(":");
-        hh.append(server->get_host().port);
-
-        lcb_PINGSVC svc;
+        const lcb_host_t &remote = server->get_host();
+        std::string hh;
+        if (remote.ipv6) {
+            hh.append("[").append(remote.host).append("]:").append(remote.port);
+        } else {
+            hh.append(remote.host).append(":").append(remote.port);
+        }
+        lcb_PINGSVC svc = {};
         svc.type = LCB_PINGSVC_KV;
         svc.server = strdup(hh.c_str());
         svc.latency = gethrtime() - MCREQ_PKT_RDATA(req)->start;
-        svc.status = err;
+        svc.rc = err;
+        switch (err) {
+        case LCB_ETIMEDOUT:
+            svc.status = LCB_PINGSTATUS_TIMEOUT;
+            break;
+        case LCB_SUCCESS:
+            svc.status = LCB_PINGSTATUS_OK;
+            break;
+        default:
+            svc.status = LCB_PINGSTATUS_ERROR;
+            break;
+        }
+        lcbio_CTX *ctx = server->connctx;
+        if (ctx) {
+            char id[20] = {0};
+            svc.local = strdup(lcbio__inet_ntop(&ctx->sock->info->sa_local).c_str());
+            snprintf(id, sizeof(id), "%p", (void *)ctx->sock);
+            svc.id = strdup(id);
+        }
+        svc.scope = server->get_instance()->get_bucketname();
+
         ck->responses.push_back(svc);
     }
 
@@ -196,11 +241,35 @@ static void handle_http(lcb_t instance, lcb_PINGSVCTYPE type, const lcb_RESPHTTP
     lcb::http::Request *htreq = reinterpret_cast<lcb::http::Request*>(resp->_htreq);
 
     if (ck->needMetrics()) {
-        lcb_PINGSVC svc;
+        lcb_PINGSVC svc = {};
         svc.type = type;
-        svc.server = strdup((htreq->host + ":" + htreq->port).c_str());
+        std::string hh;
+        if (htreq->ipv6) {
+            hh = "[" + std::string(htreq->host) + "]:" + std::string(htreq->port);
+        } else {
+            hh = std::string(htreq->host) + ":" + std::string(htreq->port);
+        }
+        svc.server = strdup(hh.c_str());
         svc.latency = gethrtime() - htreq->start;
-        svc.status = resp->rc;
+        svc.rc = resp->rc;
+        switch (resp->rc) {
+        case LCB_ETIMEDOUT:
+            svc.status = LCB_PINGSTATUS_TIMEOUT;
+            break;
+        case LCB_SUCCESS:
+            svc.status = LCB_PINGSTATUS_OK;
+            break;
+        default:
+            svc.status = LCB_PINGSTATUS_ERROR;
+            break;
+        }
+        lcbio_CTX *ctx = htreq->ioctx;
+        if (ctx) {
+            char id[20] = {0};
+            snprintf(id, sizeof(id), "%p", (void *)ctx->sock);
+            svc.id = strdup(id);
+            svc.local = strdup(lcbio__inet_ntop(&ctx->sock->info->sa_local).c_str());
+        }
         ck->responses.push_back(svc);
     }
     if (--ck->remaining) {
@@ -236,9 +305,25 @@ lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd)
     }
 
     PingCookie *ckwrap = new PingCookie(cookie, cmd->options);
+    {
+        char id[20] = {0};
+        snprintf(id, sizeof(id), "%p", (void *)instance);
+        ckwrap->id = id;
+        if (cmd->id) {
+            ckwrap->id.append("/").append(cmd->id);
+        }
+    }
 
+    lcbvb_CONFIG *cfg = LCBT_VBCONFIG(instance);
+    const lcbvb_SVCMODE mode = LCBT_SETTING(instance, sslopts) ?
+            LCBVB_SVCMODE_SSL : LCBVB_SVCMODE_PLAIN;
     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);
+            if (!port) {
+                continue;
+            }
+
             mc_PIPELINE *pl = cq->pipelines[ii];
             mc_PACKET *pkt = mcreq_allocate_packet(pl);
             protocol_binary_request_header hdr;
@@ -262,46 +347,43 @@ 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;
     for (int idx = 0; idx < (int)LCBVB_NSERVERS(cfg); idx++) {
-#define PING_HTTP(SVC, QUERY, TMO, CB)                                  \
-        do {                                                            \
-            lcb_error_t rc;                                             \
-            struct lcb_http_request_st *htreq;                          \
-            lcb_CMDHTTP htcmd = {0};                                    \
-            htcmd.host = lcbvb_get_resturl(cfg, idx, SVC, mode);        \
-            if (htcmd.host == NULL) {                                   \
-                continue;                                               \
-            }                                                           \
-            htcmd.body = QUERY;                                         \
-            htcmd.nbody = strlen(htcmd.body);                           \
-            htcmd.content_type = "application/json";                    \
-            htcmd.method = LCB_HTTP_METHOD_POST;                        \
-            htcmd.type = LCB_HTTP_TYPE_RAW;                             \
-            htcmd.reqhandle = &htreq;                                   \
-            const lcb::Authenticator& auth = *instance->settings->auth; \
-            htcmd.username = auth.username_for(LCBT_SETTING(instance, bucket)).c_str(); \
-            htcmd.password = auth.password_for(LCBT_SETTING(instance, bucket)).c_str(); \
-            htcmd.cmdflags = LCB_CMDHTTP_F_CASTMO;                      \
-            htcmd.cas = LCBT_SETTING(instance, TMO);                    \
-            rc = lcb_http3(instance, ckwrap, &htcmd);                   \
-            if (rc == LCB_SUCCESS) {                                    \
-                htreq->set_callback(CB);                                \
-            }                                                           \
-            ckwrap->remaining++;                                        \
-        } while (0);
+#define PING_HTTP(SVC, PATH, TMO, CB) \
+            lcb_error_t rc; \
+            struct lcb_http_request_st *htreq; \
+            lcb_CMDHTTP htcmd = {0}; \
+            char buf[1024] = {0}; \
+            unsigned port; \
+            port = lcbvb_get_port(cfg, idx, SVC, mode); \
+            if (port) { \
+                lcbvb_SERVER *srv = LCBVB_GET_SERVER(cfg, idx); \
+                bool ipv6 = strchr(srv->hostname, ':'); \
+                snprintf(buf, sizeof(buf), "%s://%s%s%s:%d%s", (mode == LCBVB_SVCMODE_PLAIN) ? "http" : "https", \
+                         ipv6 ? "[" : "", srv->hostname, ipv6 ? "]" : "", port, PATH); \
+                htcmd.host = buf; \
+                htcmd.method = LCB_HTTP_METHOD_GET; \
+                htcmd.type = LCB_HTTP_TYPE_RAW; \
+                htcmd.reqhandle = &htreq; \
+                const lcb::Authenticator& auth = *instance->settings->auth; \
+                htcmd.username = auth.username_for(NULL, NULL, LCBT_SETTING(instance, bucket)).c_str(); \
+                htcmd.password = auth.password_for(NULL, NULL, LCBT_SETTING(instance, bucket)).c_str(); \
+                htcmd.cmdflags = LCB_CMDHTTP_F_CASTMO; \
+                htcmd.cas = LCBT_SETTING(instance, TMO); \
+                rc = lcb_http3(instance, ckwrap, &htcmd); \
+                if (rc == LCB_SUCCESS) { \
+                    htreq->set_callback(CB); \
+                    ckwrap->remaining++; \
+                } \
+            }
 
         if (cmd->services & LCB_PINGSVC_F_N1QL) {
-            PING_HTTP(LCBVB_SVCTYPE_N1QL, "{\"statement\":\"select 1\"}",
-                      n1ql_timeout, handle_n1ql);
+            PING_HTTP(LCBVB_SVCTYPE_N1QL, "/admin/ping", n1ql_timeout, handle_n1ql);
         }
         if (cmd->services & LCB_PINGSVC_F_VIEWS) {
-            PING_HTTP(LCBVB_SVCTYPE_VIEWS, "", views_timeout, handle_views);
+            PING_HTTP(LCBVB_SVCTYPE_VIEWS, "/", views_timeout, handle_views);
         }
         if (cmd->services & LCB_PINGSVC_F_FTS) {
-            PING_HTTP(LCBVB_SVCTYPE_FTS, "", n1ql_timeout, handle_fts);
+            PING_HTTP(LCBVB_SVCTYPE_FTS, "/api/ping", http_timeout, handle_fts);
         }
 #undef PING_HTTP
     }
@@ -313,3 +395,100 @@ lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd)
     MAYBE_SCHEDLEAVE(instance);
     return LCB_SUCCESS;
 }
+
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_diag(lcb_t instance, const void *cookie, const lcb_CMDDIAG *cmd)
+{
+    Json::Value root;
+    hrtime_t now = LCB_NS2US(gethrtime());
+
+    root["version"] = 1;
+
+    std::string sdk("libcouchbase/" LCB_VERSION_STRING);
+    if (LCBT_SETTING(instance, client_string)) {
+        sdk.append(" ").append(LCBT_SETTING(instance, client_string));
+    }
+    root["sdk"] = sdk.c_str();
+    {
+        char id[20] = {0};
+        snprintf(id, sizeof(id), "%p", (void *)instance);
+        std::string idstr(id);
+        if (cmd->id) {
+            idstr.append("/").append(cmd->id);
+        }
+        root["id"] = idstr;
+    }
+
+    size_t ii;
+    Json::Value kv;
+    for (ii = 0; ii < instance->cmdq.npipelines; ii++) {
+        lcb::Server *server = static_cast<lcb::Server*>(instance->cmdq.pipelines[ii]);
+        lcbio_CTX *ctx = server->connctx;
+        if (ctx) {
+            Json::Value endpoint;
+            char id[20] = {0};
+            snprintf(id, sizeof(id), "%016" PRIx64, ctx->sock ? ctx->sock->id : (lcb_U64)0);
+            endpoint["id"] = id;
+            if (server->curhost->ipv6) {
+                endpoint["remote"] = "[" + std::string(server->curhost->host) + "]:" + std::string(server->curhost->port);
+            } else {
+                endpoint["remote"] = std::string(server->curhost->host) + ":" + std::string(server->curhost->port);
+            }
+            endpoint["local"] = lcbio__inet_ntop(&ctx->sock->info->sa_local);
+            endpoint["last_activity_us"] = (Json::Value::UInt64)(now > ctx->sock->atime ? now - ctx->sock->atime : 0);
+            endpoint["status"] = "connected";
+            root[lcbio_svcstr(ctx->sock->service)].append(endpoint);
+        }
+    }
+    instance->memd_sockpool->toJSON(now, root);
+    instance->http_sockpool->toJSON(now, root);
+    {
+        Json::Value cur;
+        lcb_ASPEND_SETTYPE::iterator it;
+        lcb_ASPEND_SETTYPE *pendq;
+        if ((pendq = instance->pendops.items[LCB_PENDTYPE_HTTP])) {
+            for (it = pendq->begin(); it != pendq->end(); ++it) {
+                lcb::http::Request *htreq = reinterpret_cast<lcb::http::Request*>(*it);
+                lcbio_CTX *ctx = htreq->ioctx;
+                if (ctx) {
+                    Json::Value endpoint;
+                    char id[20] = {0};
+                    snprintf(id, sizeof(id), "%016" PRIx64, ctx->sock ? ctx->sock->id : (lcb_U64)0);
+                    endpoint["id"] = id;
+                    if (htreq->ipv6) {
+                        endpoint["remote"] = "[" + std::string(htreq->host) + "]:" + std::string(htreq->port);
+                    } else {
+                        endpoint["remote"] = std::string(htreq->host) + ":" + std::string(htreq->port);
+                    }
+                    endpoint["local"] = lcbio__inet_ntop(&ctx->sock->info->sa_local);
+                    endpoint["last_activity_us"] = (Json::Value::UInt64)(now > ctx->sock->atime ? now - ctx->sock->atime : 0);
+                    endpoint["status"] = "connected";
+                    root[lcbio_svcstr(ctx->sock->service)].append(endpoint);
+                }
+            }
+        }
+    }
+
+    Json::Writer *w;
+    if (cmd->options & LCB_PINGOPT_F_JSONPRETTY) {
+        w = new Json::StyledWriter();
+    } else {
+        w = new Json::FastWriter();
+    }
+    std::string json = w->write(root);
+    delete w;
+
+    lcb_RESPDIAG resp = {0};
+    lcb_RESPCALLBACK callback;
+
+    resp.njson = json.size();
+    resp.json = json.c_str();
+
+    callback = lcb_find_callback(instance, LCB_CALLBACK_DIAG);
+    resp.cookie = const_cast<void*>(cookie);
+    callback(instance, LCB_CALLBACK_DIAG, (lcb_RESPBASE *)&resp);
+
+    return LCB_SUCCESS;
+}