libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/src/mc/compress.h

@@ -16,6 +16,7 @@
  */
 
 #include "mcreq.h"
+#include "settings.h"
 #ifndef LCB_MCCOMPRESS_H
 #define LCB_MCCOMPRESS_H
 
@@ -28,11 +29,12 @@ extern "C" {
  * @param pl The pipeline which hosts the packet
  * @param pkt The packet which hosts the value
  * @param vbuf The user input to be compressed
+ * @param settings The instance settings
+ * @param should_compress The pointer, which stores zero if the value is not compressed
  * @return 0 if successful, nonzero on error.
  */
-int
-mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_CONTIGBUF *vbuf);
-
+int mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_VALBUF *vbuf, lcb_settings *settings,
+                         int *should_compress);
 
 /**
  * Inflate a compressed value
@@ -45,15 +47,8 @@ mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_CONTIGBUF *vbuf)
  * longer required.
  * @return 0 if successful, nonzero on error.
  */
-int
-mcreq_inflate_value(const void *compressed, lcb_SIZE ncompressed,
-    const void **bytes, lcb_SIZE *nbytes, void **freeptr);
-
-#ifndef LCB_NO_SNAPPY
-#define mcreq_compression_supported() 1
-#else
-#define mcreq_compression_supported() 0
-#endif
+int mcreq_inflate_value(const void *compressed, lcb_SIZE ncompressed, const void **bytes, lcb_SIZE *nbytes,
+                        void **freeptr);
 
 #ifdef __cplusplus
 }

data/ext/libcouchbase/src/mc/mcreq-flush-inl.h

@@ -67,6 +67,11 @@ mcreq__pktflush_callback(void *p, nb_SIZE hint, void *arg)
     if (pkt->flags & MCREQ_F_INVOKED) {
         mcreq_packet_done(info->pl, pkt);
     }
+    if (info->pl->metrics) {
+        info->pl->metrics->packets_sent++;
+        info->pl->metrics->packets_queued--;
+        info->pl->metrics->bytes_queued -= pktsize;
+    }
     return pktsize;
 }
 
@@ -89,7 +94,6 @@ mcreq_flush_done_ex(mc_PIPELINE *pl,
 {
     if (nflushed) {
         mc__FLUSHINFO info = { pl, now };
-
         netbuf_end_flush2(&pl->nbmgr, nflushed,
                           mcreq__pktflush_callback,
                           offsetof(mc_PACKET, sl_flushq), &info);

data/ext/libcouchbase/src/mc/mcreq.c

@@ -206,6 +206,7 @@ mcreq_enqueue_packet(mc_PIPELINE *pipeline, mc_PACKET *packet)
     nb_SPAN *vspan = &packet->u_value.single;
     sllist_append(&pipeline->requests, &packet->slnode);
     netbuf_enqueue_span(&pipeline->nbmgr, &packet->kh_span);
+    MC_INCR_METRIC(pipeline, bytes_queued, packet->kh_span.size);
 
     if (!(packet->flags & MCREQ_F_HASVALUE)) {
         goto GT_ENQUEUE_PDU;
@@ -216,14 +217,17 @@ mcreq_enqueue_packet(mc_PIPELINE *pipeline, mc_PACKET *packet)
         lcb_FRAGBUF *multi = &packet->u_value.multi;
         for (ii = 0; ii < multi->niov; ii++) {
             netbuf_enqueue(&pipeline->nbmgr, (nb_IOV *)multi->iov + ii);
+            MC_INCR_METRIC(pipeline, bytes_queued, multi->iov[ii].iov_len);
         }
 
     } else if (vspan->size) {
+        MC_INCR_METRIC(pipeline, bytes_queued, vspan->size);
         netbuf_enqueue_span(&pipeline->nbmgr, vspan);
     }
 
     GT_ENQUEUE_PDU:
     netbuf_pdu_enqueue(&pipeline->nbmgr, packet, offsetof(mc_PACKET, sl_flushq));
+    MC_INCR_METRIC(pipeline, packets_queued, 1);
 }
 
 void
@@ -275,6 +279,9 @@ mcreq_allocate_packet(mc_PIPELINE *pipeline)
     ret->flags = 0;
     ret->retries = 0;
     ret->opaque = pipeline->parent->seq++;
+#ifdef LCB_TRACING
+    ret->u_rdata.reqdata.span = NULL;
+#endif
     return ret;
 }
 
@@ -568,6 +575,7 @@ mcreq_pipeline_init(mc_PIPELINE *pipeline)
     /** Initialize request pool */
     settings.data_basealloc = sizeof(mc_PACKET) * 32;
     netbuf_init(&pipeline->reqpool, &settings);;
+    pipeline->metrics = NULL;
     return 0;
 }
 
@@ -866,8 +874,10 @@ do_fallback_flush(mc_PIPELINE *pipeline)
 void
 mcreq_set_fallback_handler(mc_CMDQUEUE *cq, mcreq_fallback_cb handler)
 {
+    mc_FALLBACKPL *fallback;
     assert(!cq->fallback);
-    cq->fallback = calloc(1, sizeof (mc_FALLBACKPL));
+    fallback = calloc(1, sizeof (mc_FALLBACKPL));
+    cq->fallback = (mc_PIPELINE *)fallback;
     mcreq_pipeline_init(cq->fallback);
     cq->fallback->parent = cq;
     cq->fallback->index = cq->npipelines;

data/ext/libcouchbase/src/mc/mcreq.h

@@ -22,6 +22,7 @@
 #include <libcouchbase/api3.h>
 #include <libcouchbase/vbucket.h>
 #include <memcached/protocol_binary.h>
+#include <libcouchbase/metrics.h>
 #include "netbuf/netbuf.h"
 #include "sllist.h"
 #include "config.h"
@@ -141,9 +142,17 @@ extern "C" {
 #define MCREQ_PKT_BASESIZE 24
 
 /** @brief Embedded user data for a simple request. */
-typedef struct {
+typedef struct mc_REQDATA {
     const void *cookie; /**< User pointer to place in callbacks */
     hrtime_t start; /**< Time of the initial request. Used for timeouts */
+    /**
+     * Time when dispatching response has begun for the command.
+     * Used for metrics/tracing. Might be zero, when tracing is not enabled.
+     */
+    hrtime_t dispatch;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
 } mc_REQDATA;
 
 struct mc_packet_st;
@@ -182,12 +191,24 @@ typedef struct {
 typedef struct mc_REQDATAEX {
     const void *cookie; /**< User data */
     hrtime_t start; /**< Start time */
+    /**
+     * Time when dispatching response has begun for the command.
+     * Used for metrics/tracing. Might be zero, when tracing is not enabled.
+     */
+    hrtime_t dispatch;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
     const mc_REQDATAPROCS *procs; /**< Common routines for the packet */
 
     #ifdef __cplusplus
-    mc_REQDATAEX(const void *cookie_,
-                const mc_REQDATAPROCS &procs_, hrtime_t start_)
-        : cookie(cookie_), start(start_), procs(&procs_) {
+    mc_REQDATAEX(const void *cookie_, const mc_REQDATAPROCS &procs_, hrtime_t start_)
+        : cookie(cookie_), start(start_), dispatch(0),
+#ifdef LCB_TRACING
+        span(NULL),
+#endif
+        procs(&procs_)
+    {
     }
     #endif
 } mc_REQDATAEX;
@@ -400,6 +421,9 @@ typedef struct mc_pipeline_st {
 
     /** Allocator for packet structures */
     nb_MGR reqpool;
+
+    /** Optional metrics structure for server */
+    struct lcb_SERVERMETRICS_st *metrics;
 } mc_PIPELINE;
 
 typedef struct mc_cmdqueue_st {
@@ -976,6 +1000,13 @@ mcreq_dump_chain(const mc_PIPELINE *pipeline, FILE *fp, mcreq_payload_dump_fn du
         SLLIST_IS_EMPTY(&(pipeline)->requests) ? NULL : \
                 SLLIST_ITEM(SLLIST_FIRST(&(pipeline)->requests), mc_PACKET, slnode)
 
+/* Increment a metric */
+#define MC_INCR_METRIC(pipeline, metric, amount) do { \
+        if ((pipeline)->metrics) { \
+            (pipeline)->metrics->metric += amount; \
+        } \
+} while (0)
+
 /**@}*/
 
 #ifdef __cplusplus

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

@@ -28,11 +28,11 @@
 #define LOGARGS(c, lvl) (c)->settings, "server", LCB_LOG_##lvl, __FILE__, __LINE__
 #define LOGARGS_T(lvl) LOGARGS(this, lvl)
 
-#define LOGFMT "<%s:%s> (SRV=%p,IX=%d) "
+#define LOGFMT CTX_LOGFMT_PRE ",SRV=%p,IX=%d) "
 #define PKTFMT "OP=0x%x, RC=0x%x, SEQ=%u"
 #define PKTARGS(pkt) (pkt).opcode(), (pkt).status(), (pkt).opaque()
 
-#define LOGID(server) get_ctx_host(server->connctx), get_ctx_port(server->connctx), (void*)server, server->index
+#define LOGID(server) CTX_LOGID(server->connctx), (void *)server, server->index
 #define LOGID_T() LOGID(this)
 
 #define MCREQ_MAXIOV 32
@@ -125,6 +125,8 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
     lcb::clconfig::Provider *cccp =
             instance->confmon->get_provider(lcb::clconfig::CLCONFIG_CCCP);
 
+    MC_INCR_METRIC(this, packets_nmv, 1);
+
     mcreq_read_hdr(oldpkt, &hdr);
     vbid = ntohs(hdr.request.vbucket);
     lcb_log(LOGARGS_T(WARN), LOGFMT "NOT_MY_VBUCKET. Packet=%p (S=%u). VBID=%u", LOGID_T(), (void*)oldpkt, oldpkt->opaque, vbid);
@@ -132,8 +134,8 @@ Server::handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt)
     /* Notify of new map */
     lcb_vbguess_remap(instance, vbid, index);
 
-    if (resinfo.bodylen() && cccp->enabled) {
-        std::string s(resinfo.body<const char*>(), resinfo.vallen());
+    if (resinfo.vallen() && cccp->enabled) {
+        std::string s(resinfo.value(), resinfo.vallen());
         err = lcb::clconfig::cccp_update(cccp, curhost->host, s.c_str());
     }
 
@@ -334,6 +336,8 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
         RETURN_NEED_MORE(pktsize)
     }
 
+    MC_INCR_METRIC(this, packets_read, 1);
+
     /* copy bytes into the info structure */
     rdb_copyread(ior, mcresp.hdrbytes(), mcresp.hdrsize());
 
@@ -352,6 +356,7 @@ Server::try_read(lcbio_CTX *ctx, rdb_IOROPE *ior)
     }
 
     if (!request) {
+        MC_INCR_METRIC(this, packets_ownerless, 1);
         lcb_log(LOGARGS_T(WARN), LOGFMT "Server sent us reply for a timed-out command. (OP=0x%x, RC=0x%x, SEQ=%u)", LOGID_T(), mcresp.opcode(), mcresp.status(), mcresp.opaque());
         rdb_consumed(ior, pktsize);
         return PKT_READ_COMPLETE;
@@ -494,6 +499,9 @@ void Server::purge_single(mc_PACKET *pkt, lcb_error_t err) {
                            hdr.request.opaque,
                            PROTOCOL_BINARY_RESPONSE_EINVAL);
 
+#ifdef LCB_TRACING
+    lcbtrace_span_set_orphaned(MCREQ_PKT_RDATA(pkt)->span, true);
+#endif
     lcb_log(LOGARGS_T(WARN), LOGFMT "Failing command (pkt=%p, opaque=%lu, opcode=0x%x) with error %s", LOGID_T(), (void*)pkt, (unsigned long)pkt->opaque, hdr.request.opcode, lcb_strerror_short(err));
     int rv = mcreq_dispatch_response(this, pkt, &resp, err);
     lcb_assert(rv == 0);
@@ -514,6 +522,7 @@ Server::purge(lcb_error_t error, hrtime_t thresh, hrtime_t *next,
         affected = -1;
     }
 
+    MC_INCR_METRIC(this, packets_errored, affected);
     if (policy == REFRESH_NEVER) {
         return affected;
     }
@@ -569,6 +578,7 @@ void Server::io_timeout()
     int npurged = purge(LCB_ETIMEDOUT, min_valid, &next_ns,
                         Server::REFRESH_ONFAILED);
     if (npurged) {
+        MC_INCR_METRIC(this, packets_timeout, npurged);
         lcb_log(LOGARGS_T(ERR), LOGFMT "Server timed out. Some commands have failed", LOGID_T());
     }
 
@@ -619,6 +629,7 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
 
     if (err != LCB_SUCCESS) {
         lcb_log(LOGARGS_T(ERR), LOGFMT "Connection attempt failed. Received %s from libcouchbase, received %d from operating system", LOGID_T(), lcb_strerror_short(err), syserr);
+        MC_INCR_METRIC(this, iometrics.io_error, 1);
         if (!maybe_reconnect_on_fake_timeout(err)) {
             socket_failed(err);
         }
@@ -626,6 +637,9 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
     }
 
     lcb_assert(sock);
+    if (metrics) {
+        lcbio_set_metrics(sock, &metrics->iometrics);
+    }
 
     /** Do we need sasl? */
     SessionInfo* sessinfo = SessionInfo::get(sock);
@@ -635,7 +649,8 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
             sock, settings, default_timeout(), on_connected, this);
         return;
     } else {
-        compsupport = sessinfo->has_feature(PROTOCOL_BINARY_FEATURE_DATATYPE);
+        jsonsupport = sessinfo->has_feature(PROTOCOL_BINARY_FEATURE_JSON);
+        compsupport = sessinfo->has_feature(PROTOCOL_BINARY_FEATURE_SNAPPY);
         mutation_tokens = sessinfo->has_feature(PROTOCOL_BINARY_FEATURE_MUTATION_SEQNO);
     }
 
@@ -646,6 +661,7 @@ Server::handle_connected(lcbio_SOCKET *sock, lcb_error_t err, lcbio_OSERR syserr
     procs.cb_flush_ready = on_flush_ready;
     connctx = lcbio_ctx_new(sock, this, &procs);
     connctx->subsys = "memcached";
+    sock->service = LCBIO_SERVICE_KV;
     flush_start = (mcreq_flushstart_fn)mcserver_flush;
 
     uint32_t tmo = next_timeout();
@@ -675,6 +691,7 @@ Server::Server(lcb_t instance_, int ix)
       instance(instance_),
       settings(lcb_settings_ref2(instance_->settings)),
       compsupport(0),
+      jsonsupport(0),
       mutation_tokens(0),
       connctx(NULL),
       curhost(new lcb_host_t())
@@ -694,11 +711,17 @@ Server::Server(lcb_t instance_, int ix)
     if (datahost) {
         lcb_host_parsez(curhost, datahost, LCB_CONFIG_MCD_PORT);
     }
+
+    if (settings->metrics) {
+        /** Allocate / reinitialize the metrics here */
+        metrics = lcb_metrics_getserver(settings->metrics, curhost->host, curhost->port, 1);
+        lcb_metrics_reset_pipeline_gauges(metrics);
+    }
 }
 
 Server::Server()
     : state(S_TEMPORARY),
-      io_timer(NULL), instance(NULL), settings(NULL), compsupport(0),
+      io_timer(NULL), instance(NULL), settings(NULL), compsupport(0), jsonsupport(0),
       mutation_tokens(0), connctx(NULL), connreq(NULL), curhost(NULL)
 {
 }
@@ -829,7 +852,7 @@ Server::finalize_errored_ctx()
         return;
     }
 
-    lcb_log(LOGARGS_T(DEBUG), LOGFMT "Finalizing ctx %p", LOGID_T(), (void*)connctx);
+    lcb_log(LOGARGS_T(DEBUG), LOGFMT "Finalizing context", LOGID_T());
 
     /* Always close the existing context. */
     lcbio_ctx_close(connctx, close_cb, NULL);

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

@@ -110,6 +110,10 @@ public:
         return compsupport;
     }
 
+    bool supports_json() const {
+        return jsonsupport;
+    }
+
     bool is_connected() const {
         return connctx != NULL;
     }
@@ -200,6 +204,9 @@ public:
     /** Whether compression is supported */
     short compsupport;
 
+    /** Whether JSON datatype is supported */
+    short jsonsupport;
+
     /** Whether extended 'UUID' and 'seqno' are available for each mutation */
     short mutation_tokens;
 

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

@@ -37,12 +37,12 @@ using namespace lcb;
 #define LOGARGS(ctx, lvl) ctx->settings, "negotiation", LCB_LOG_##lvl, __FILE__, __LINE__
 static void cleanup_negotiated(SessionInfo* info);
 static void handle_ioerr(lcbio_CTX *ctx, lcb_error_t err);
-#define SESSREQ_LOGFMT "<%s:%s> (SASLREQ=%p) "
 
+#define LOGFMT CTX_LOGFMT_PRE ",SASLREQ=%p) "
+#define LOGID(s) CTX_LOGID(s->ctx), (void *)s
 
 static void timeout_handler(void *arg);
 
-#define SESSREQ_LOGID(s) get_ctx_host(s->ctx), get_ctx_port(s->ctx), (void*)s
 
 static void
 close_cb(lcbio_SOCKET *s, int reusable, void *arg)
@@ -67,8 +67,10 @@ public:
         const lcb::Authenticator& auth);
     void start(lcbio_SOCKET *sock);
     void send_list_mechs();
+    std::string generate_agent_json();
     bool send_hello();
     bool send_step(const lcb::MemcachedResponse& packet);
+    bool check_auth(const lcb::MemcachedResponse& packet);
     bool read_hello(const lcb::MemcachedResponse& packet);
     void send_auth(const char *sasl_data, unsigned ndata);
     void handle_read(lcbio_CTX *ioctx);
@@ -144,12 +146,12 @@ public:
                 }
                 emsg << "context: \"" << err_ctx << "\"";
             }
-            lcb_log(LOGARGS(this, ERR), SESSREQ_LOGFMT "Error: 0x%x, %s (%s)",
-                    SESSREQ_LOGID(this), error, msg, emsg.str().c_str());
+            lcb_log(LOGARGS(this, ERR), LOGFMT "Error: 0x%x, %s (%s)",
+                    LOGID(this), error, msg, emsg.str().c_str());
             free(err_ref);
             free(err_ctx);
         } else {
-            lcb_log(LOGARGS(this, ERR), SESSREQ_LOGFMT "Error: 0x%x, %s", SESSREQ_LOGID(this), error, msg);
+            lcb_log(LOGARGS(this, ERR), LOGFMT "Error: 0x%x, %s", LOGID(this), error, msg);
         }
         if (last_err == LCB_SUCCESS) {
             last_err = error;
@@ -236,8 +238,8 @@ SessionRequestImpl::setup(const lcbio_NAMEINFO& nistrs, const lcb_host_t& host,
     }
 
     // Get the credentials
-    username = auth.username_for(settings->bucket);
-    const std::string& pass = auth.password_for(settings->bucket);
+    username = auth.username_for(host.host, host.port, settings->bucket);
+    const std::string pass = auth.password_for(host.host, host.port, settings->bucket);
 
     if (!pass.empty()) {
         size_t maxlen = sizeof(u_auth.buffer) - offsetof(cbsasl_secret_t, data);
@@ -273,6 +275,13 @@ SessionRequestImpl::set_chosen_mech(std::string& mechlist,
     const char **data, unsigned int *ndata)
 {
     cbsasl_error_t saslerr;
+    int allow_scram_sha = 0;
+
+    if (mechlist.empty()) {
+        lcb_log(LOGARGS(this, WARN), LOGFMT "Server does not support SASL (no mechanisms supported)", LOGID(this));
+        return MECH_NOT_NEEDED;
+    }
+
     if (settings->sasl_mech_force) {
         char *forcemech = settings->sasl_mech_force;
         if (mechlist.find(forcemech) == std::string::npos) {
@@ -281,21 +290,22 @@ SessionRequestImpl::set_chosen_mech(std::string& mechlist,
             return MECH_UNAVAILABLE;
         }
         mechlist.assign(forcemech);
+        if (memcmp(forcemech, "SCRAM-SHA", sizeof("SCRAM-SHA") - 1) == 0) {
+            allow_scram_sha = 1;
+        }
     }
 
     const char *chosenmech;
-    saslerr = cbsasl_client_start(sasl_client, mechlist.c_str(),
-                                  NULL, data, ndata, &chosenmech);
+    saslerr = cbsasl_client_start(sasl_client, mechlist.c_str(), NULL, data, ndata, &chosenmech, allow_scram_sha);
     switch (saslerr) {
     case SASL_OK:
         info->mech.assign(chosenmech);
         return MECH_OK;
     case SASL_NOMECH:
-        lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "Server does not support SASL (no mechanisms supported)", SESSREQ_LOGID(this));
-        return MECH_NOT_NEEDED;
-        break;
+        lcb_log(LOGARGS(this, WARN), LOGFMT "Server does not support SASL (no mechanisms supported)", LOGID(this));
+        return MECH_UNAVAILABLE;
     default:
-        lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "cbsasl_client_start returned %d", SESSREQ_LOGID(this), saslerr);
+        lcb_log(LOGARGS(this, ERROR), LOGFMT "cbsasl_client_start returned %d", LOGID(this), saslerr);
         set_error(LCB_EINTERNAL, "Couldn't start SASL client");
         return MECH_UNAVAILABLE;
     }
@@ -323,8 +333,7 @@ SessionRequestImpl::send_step(const lcb::MemcachedResponse& packet)
     const char *step_data;
     unsigned int ndata;
 
-    saslerr = cbsasl_client_step(sasl_client,
-        packet.body<const char*>(), packet.bodylen(), NULL, &step_data, &ndata);
+    saslerr = cbsasl_client_step(sasl_client, packet.value(), packet.vallen(), NULL, &step_data, &ndata);
 
     if (saslerr != SASL_CONTINUE) {
         set_error(LCB_EINTERNAL, "Unable to perform SASL STEP");
@@ -340,8 +349,50 @@ SessionRequestImpl::send_step(const lcb::MemcachedResponse& packet)
     return true;
 }
 
-#define LCB_HELLO_DEFL_STRING "libcouchbase/" LCB_VERSION_STRING
-#define LCB_HELLO_DEFL_LENGTH (sizeof(LCB_HELLO_DEFL_STRING)-1)
+std::string
+SessionRequestImpl::generate_agent_json()
+{
+    std::string client_string(LCB_CLIENT_ID);
+    if (settings->client_string) {
+        client_string += " ";
+        client_string += settings->client_string;
+    }
+    if (client_string.size() > 200) {
+        client_string.resize(200);
+    }
+    char id[34] = {};
+    snprintf(id, sizeof(id), "%016" PRIx64 "/%016" PRIx64, (lcb_U64)settings->iid, ctx->sock->id);
+
+    Json::Value ua;
+    ua["a"] = client_string;
+    ua["i"] = id;
+    Json::FastWriter w;
+    std::string res = w.write(ua);
+    if (res[res.size() - 1] == '\n') {
+        res.resize(res.size() - 1);
+    }
+    return res;
+}
+
+/**
+ * Final step for SASL authentication: in SCRAM-SHA mechanisms,
+ * we have to validate the server signature returned in the final
+ * message.
+ */
+bool
+SessionRequestImpl::check_auth(const lcb::MemcachedResponse& packet)
+{
+    cbsasl_error_t saslerr;
+
+    saslerr = cbsasl_client_check(sasl_client,
+        packet.body<const char*>(), packet.bodylen());
+
+    if (saslerr != SASL_OK) {
+        set_error(LCB_AUTH_ERROR, "Invalid SASL check");
+        return false;
+    }
+    return true;
+}
 
 bool
 SessionRequestImpl::send_hello()
@@ -351,6 +402,7 @@ SessionRequestImpl::send_hello()
     unsigned nfeatures = 0;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TLS;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XATTR;
+    features[nfeatures++] = PROTOCOL_BINARY_FEATURE_JSON;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_SELECT_BUCKET;
     if (settings->use_errmap) {
         features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XERROR;
@@ -358,38 +410,29 @@ SessionRequestImpl::send_hello()
     if (settings->tcp_nodelay) {
         features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TCPNODELAY;
     }
-
-#ifndef LCB_NO_SNAPPY
     if (settings->compressopts != LCB_COMPRESS_NONE) {
-        features[nfeatures++] = PROTOCOL_BINARY_FEATURE_DATATYPE;
+        features[nfeatures++] = PROTOCOL_BINARY_FEATURE_SNAPPY;
     }
-#endif
-
     if (settings->fetch_mutation_tokens) {
         features[nfeatures++] = PROTOCOL_BINARY_FEATURE_MUTATION_SEQNO;
     }
-
-    std::string client_string;
-    const char *clistr = LCB_HELLO_DEFL_STRING;
-    size_t nclistr = LCB_HELLO_DEFL_LENGTH;
-
-    if (settings->client_string) {
-        client_string.assign(LCB_HELLO_DEFL_STRING);
-        client_string += ", ";
-        client_string += settings->client_string;
-
-        clistr = client_string.c_str();
-        nclistr = client_string.size();
+    if (settings->use_collections) {
+        features[nfeatures++] = PROTOCOL_BINARY_FEATURE_COLLECTIONS;
+    }
+    if (settings->use_tracing) {
+        features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TRACING;
     }
 
+    std::string agent = generate_agent_json();
     lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_HELLO);
-    hdr.sizes(0, nclistr, (sizeof features[0]) * nfeatures);
-
+    hdr.sizes(0, agent.size(), (sizeof features[0]) * nfeatures);
     lcbio_ctx_put(ctx, hdr.data(), hdr.size());
-    lcbio_ctx_put(ctx, clistr, nclistr);
+    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());
     for (size_t ii = 0; ii < nfeatures; ii++) {
         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]));
     }
 
     lcbio_ctx_rwant(ctx, 24);
@@ -409,13 +452,13 @@ SessionRequestImpl::read_hello(const lcb::MemcachedResponse& resp)
 {
     /* some caps */
     const char *cur;
-    const char *payload = resp.body<const char*>();
-    const char *limit = payload + resp.bodylen();
+    const char *payload = resp.value();
+    const char *limit = payload + resp.vallen();
     for (cur = payload; cur < limit; cur += 2) {
         lcb_U16 tmp;
         memcpy(&tmp, cur, sizeof(tmp));
         tmp = ntohs(tmp);
-        lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server supports feature: 0x%x (%s)", SESSREQ_LOGID(this), tmp, protocol_feature_2_text(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);
     }
     return true;
@@ -442,8 +485,7 @@ SessionRequestImpl::update_errmap(const lcb::MemcachedResponse& resp)
 
     std::string errmsg;
     ErrorMap& mm = *settings->errmap;
-    ErrorMap::ParseStatus status = mm.parse(
-        resp.body<const char*>(), resp.bodylen(), errmsg);
+    ErrorMap::ParseStatus status = mm.parse(resp.value(), resp.vallen(), errmsg);
 
     if (status != ErrorMap::UPDATED && status != ErrorMap::NOT_UPDATED) {
         errmsg = "Couldn't update error map: " + errmsg;
@@ -464,12 +506,12 @@ SessionRequestImpl::maybe_select_bucket() {
     }
 
     if (!settings->select_bucket) {
-        lcb_log(LOGARGS(this, WARN), SESSREQ_LOGFMT "SELECT_BUCKET Disabled by application", SESSREQ_LOGID(this));
+        lcb_log(LOGARGS(this, WARN), LOGFMT "SELECT_BUCKET Disabled by application", LOGID(this));
         return false;
     }
 
     // send the SELECT_BUCKET command:
-    lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "Sending SELECT_BUCKET", SESSREQ_LOGID(this));
+    lcb_log(LOGARGS(this, DEBUG), LOGFMT "Sending SELECT_BUCKET", LOGID(this));
     lcb::MemcachedRequest req(PROTOCOL_BINARY_CMD_SELECT_BUCKET);
     req.sizes(0, strlen(settings->bucket), 0);
     lcbio_ctx_put(ctx, req.data(), req.size());
@@ -507,7 +549,7 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
     case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS: {
         const char *mechlist_data;
         unsigned int nmechlist_data;
-        std::string mechs(resp.body<const char*>(), resp.bodylen());
+        std::string mechs(resp.value(), resp.vallen());
 
         MechStatus mechrc = set_chosen_mech(mechs, &mechlist_data, &nmechlist_data);
         if (mechrc == MECH_OK) {
@@ -534,10 +576,10 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
     }
 
     case PROTOCOL_BINARY_CMD_SASL_STEP: {
-        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS && check_auth(resp)) {
             completed = !maybe_select_bucket();
         } else {
-            lcb_log(LOGARGS(this, WARN), SESSREQ_LOGFMT "SASL auth failed with STATUS=0x%x", SESSREQ_LOGID(this), status);
+            lcb_log(LOGARGS(this, WARN), LOGFMT "SASL auth failed with STATUS=0x%x", LOGID(this), status);
             set_error(LCB_AUTH_ERROR, "SASL Step failed", &resp);
         }
         break;
@@ -550,9 +592,9 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
                 break;
             }
         } else if (isUnsupported(status)) {
-            lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support HELLO", SESSREQ_LOGID(this));
+            lcb_log(LOGARGS(this, DEBUG), LOGFMT "Server does not support HELLO", LOGID(this));
         } else {
-            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for HELLO", SESSREQ_LOGID(this), status);
+            lcb_log(LOGARGS(this, ERROR), LOGFMT "Unexpected status 0x%x received for HELLO", LOGID(this), status);
             set_error(LCB_PROTOCOL_ERROR, "Hello response unexpected", &resp);
             break;
         }
@@ -560,11 +602,15 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
         if (info->has_feature(PROTOCOL_BINARY_FEATURE_XERROR)) {
             request_errmap();
         } else {
-            lcb_log(LOGARGS(this, TRACE), SESSREQ_LOGFMT "GET_ERRORMAP unsupported/disabled", SESSREQ_LOGID(this));
+            lcb_log(LOGARGS(this, TRACE), LOGFMT "GET_ERRORMAP unsupported/disabled", LOGID(this));
         }
 
-        // In any event, it's also time to send the LIST_MECHS request
-        send_list_mechs();
+        if (settings->keypath) {
+            completed = !maybe_select_bucket();
+        } else {
+            // In any event, it's also time to send the LIST_MECHS request
+            send_list_mechs();
+        }
         break;
     }
 
@@ -573,9 +619,9 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
             if (!update_errmap(resp)) {
             }
         } else if (isUnsupported(status)) {
-            lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support GET_ERRMAP (0x%x)", SESSREQ_LOGID(this), status);
+            lcb_log(LOGARGS(this, DEBUG), LOGFMT "Server does not support GET_ERRMAP (0x%x)", LOGID(this), status);
         } else {
-            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for GET_ERRMAP", SESSREQ_LOGID(this), status);
+            lcb_log(LOGARGS(this, ERROR), LOGFMT "Unexpected status 0x%x received for GET_ERRMAP", LOGID(this), status);
             set_error(LCB_PROTOCOL_ERROR, "GET_ERRMAP response unexpected", &resp);
         }
         // Note, there is no explicit state transition here. LIST_MECHS is
@@ -589,14 +635,14 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
         } else if (status == PROTOCOL_BINARY_RESPONSE_EACCESS) {
             set_error(LCB_AUTH_ERROR, "Provided credentials not allowed for bucket", &resp);
         } else {
-            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for SELECT_BUCKET", SESSREQ_LOGID(this), status);
+            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);
         }
         break;
     }
 
     default: {
-        lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Received unknown response. OP=0x%x. RC=0x%x", SESSREQ_LOGID(this), resp.opcode(), resp.status());
+        lcb_log(LOGARGS(this, ERROR), LOGFMT "Received unknown response. OP=0x%x. RC=0x%x", LOGID(this), resp.opcode(), resp.status());
         set_error(LCB_NOT_SUPPORTED, "Received unknown response", &resp);
         break;
     }
@@ -658,7 +704,7 @@ SessionRequestImpl::start(lcbio_SOCKET *sock) {
     if (settings->send_hello) {
         send_hello();
     } else {
-        lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "HELLO negotiation disabled by user", SESSREQ_LOGID(this));
+        lcb_log(LOGARGS(this, WARN), LOGFMT "HELLO negotiation disabled by user", LOGID(this));
         send_list_mechs();
     }
     LCBIO_CTX_RSCHEDULE(ctx, 24);