libcouchbase 1.2.8 → 1.3.0

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

@@ -46,11 +46,26 @@ lcb_urldecode(const char *in, char *out, lcb_SSIZE n);
 /**
  * Base64 encode a string into an output buffer.
  * @param src string to encode
+ * @param len size of source buffer
  * @param dst destination buffer
  * @param sz size of destination buffer
  * @return 0 if success, -1 if the destination buffer isn't big enough
  */
-int lcb_base64_encode(const char *src, char *dst, lcb_size_t sz);
+int lcb_base64_encode(const char *src, lcb_SIZE len, char *dst, lcb_SIZE sz);
+
+/**
+ * Base64 encode a string into an output buffer.
+ * @param src string to encode
+ * @param len size of source buffer
+ * @param dst destination buffer
+ * @param sz size of destination buffer
+ * @return 0 if success, -1 if function wasn't able to allocate enough memory
+ */
+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);
 
 /**
  * Encodes a string suitable for being passed as either a key or value in an

data/ext/libcouchbase/src/trace.h

@@ -38,70 +38,77 @@
 #define TRACE(probe)
 #endif
 
-#define TRACE_BEGIN_COMMON(TGT, req, cmd,  ...) \
-    TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-    (const char *)((cmd)->key.contig.bytes), (cmd)->key.contig.nbytes, ## __VA_ARGS__)
+#define TRACE_BEGIN_COMMON(TGT, instance, req, cmd, ...)                                                               \
+    TGT(instance, (req)->request.opaque, lcb_ntohs((req)->request.vbucket), (req)->request.opcode,                     \
+        (const char *)((cmd)->key.contig.bytes), (cmd)->key.contig.nbytes, ##__VA_ARGS__)
 
-#define TRACE_BEGIN_SIMPLE(TGT, req, cmd) \
-    TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
+#define TRACE_BEGIN_SIMPLE(TGT, instance, req, cmd)                                                                    \
+    TGT(instance, (req)->request.opaque, lcb_ntohs((req)->request.vbucket), (req)->request.opcode,                     \
         (const char *)(cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
 
-#define TRACE_END_COMMON(TGT, mcresp, resp, ...) \
-    TGT(mcresp->opaque(), 0, mcresp->opcode(), (resp)->rc, (const char *)(resp)->key, (resp)->nkey, \
-        ## __VA_ARGS__)
-
-#define TRACE_END_SIMPLE(TGT, mcresp, resp) \
-    TGT(mcresp->opaque(), 0, mcresp->opcode(), (resp)->rc, (const char *)(resp)->key, (resp)->nkey)
-
-#define TRACE_GET_BEGIN(req, cmd) \
-    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_GET_BEGIN, req, cmd, (cmd)->exptime))
-
-#define TRACE_GET_END(mcresp, resp) \
-    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_GET_END, mcresp, resp, \
-        (const char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
-        mcresp->datatype()))
-
-#define TRACE_UNLOCK_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_UNLOCK_BEGIN, req, cmd))
-#define TRACE_UNLOCK_END(mcresp, resp) TRACE(TRACE_END_SIMPLE(LIBCOUCHBASE_UNLOCK_END, mcresp, resp))
-
-#define TRACE_STORE_BEGIN(req, cmd) \
-    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_STORE_BEGIN, req, cmd, \
-        (const char *)( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
-        ( (cmd)->value.vtype == LCB_KV_IOV ? 0 : (cmd)->value.u_buf.contig.nbytes ),\
-        (cmd)->flags, (cmd)->cas, (req)->request.datatype, (cmd)->exptime))
-
-#define TRACE_STORE_END(mcresp, resp) TRACE(TRACE_END_COMMON(LIBCOUCHBASE_STORE_END, mcresp, resp, (resp)->cas))
-
-#define TRACE_ARITHMETIC_BEGIN(req, cmd) \
-    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_ARITHMETIC_BEGIN, req, cmd, \
-        (cmd)->delta, (cmd)->initial, (cmd)->exptime))
-
-#define TRACE_ARITHMETIC_END(mcresp, resp) \
-    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_ARITHMETIC_END, mcresp, resp, (resp)->value, (resp)->cas))
-
-#define TRACE_TOUCH_BEGIN(req, cmd) \
-    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_TOUCH_BEGIN, req, cmd, (cmd)->exptime))
-#define TRACE_TOUCH_END(mcresp, resp) \
-    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_TOUCH_END, mcresp, resp, (resp)->cas))
-
-#define TRACE_REMOVE_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_REMOVE_BEGIN, req, cmd))
-#define TRACE_REMOVE_END(mcresp, resp) \
-    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_REMOVE_END, mcresp, resp, (resp)->cas))
-
-#define TRACE_OBSERVE_BEGIN(req, body) \
-    TRACE(LIBCOUCHBASE_OBSERVE_BEGIN(\
-        (req)->request.opaque, 0, (req)->request.opcode, body, \
-        ntohl( (req)->request.bodylen) ))
-
-#define TRACE_OBSERVE_PROGRESS(mcresp, resp) \
-    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_OBSERVE_PROGRESS,mcresp,resp, \
-        (resp)->cas, (resp)->status, (resp)->ismaster, (resp)->ttp, (resp)->ttr))
-
-#define TRACE_OBSERVE_END(mcresp) \
-    TRACE(LIBCOUCHBASE_OBSERVE_END(mcresp->opaque(), 0, mcresp->opcode(), LCB_SUCCESS))
-
-#define TRACE_HTTP_BEGIN(req) TRACE(LIBCOUCHBASE_HTTP_BEGIN((req)->url, (req)->nurl, (req)->method))
-#define TRACE_HTTP_END(req, rc, resp) TRACE(LIBCOUCHBASE_HTTP_END((req)->url, (req)->nurl, (req)->method, (resp)->rc, (resp)->htstatus
+#define TRACE_END_COMMON(TGT, instance, pkt, mcresp, resp, ...)                                                        \
+    TGT(instance, mcresp->opaque(), mcresp->opcode(),                                                                  \
+        (MCREQ_PKT_RDATA(pkt)->dispatch) - (MCREQ_PKT_RDATA(pkt)->start), (resp)->rc, (const char *)(resp)->key,       \
+        (resp)->nkey, ##__VA_ARGS__)
+
+#define TRACE_END_SIMPLE(TGT, instance, pkt, mcresp, resp)                                                             \
+    TGT(instance, mcresp->opaque(), mcresp->opcode(), MCREQ_PKT_RDATA(pkt)->dispatch - MCREQ_PKT_RDATA(pkt)->start,    \
+        (resp)->rc, (const char *)(resp)->key, (resp)->nkey)
+
+#define TRACE_GET_BEGIN(instance, req, cmd)                                                                            \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_GET_BEGIN, instance, req, cmd, (cmd)->exptime))
+#define TRACE_GET_END(instance, pkt, mcresp, resp)                                                                     \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_GET_END, instance, pkt, mcresp, resp, (const char *)(resp)->value,             \
+                           (resp)->nvalue, (resp)->itmflags, (resp)->cas, mcresp->datatype()))
+
+#define TRACE_UNLOCK_BEGIN(instance, req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_UNLOCK_BEGIN, instance, req, cmd))
+#define TRACE_UNLOCK_END(instance, pkt, mcresp, resp)                                                                  \
+    TRACE(TRACE_END_SIMPLE(LIBCOUCHBASE_UNLOCK_END, instance, pkt, mcresp, resp))
+
+#define TRACE_STORE_BEGIN(instance, req, cmd)                                                                          \
+    TRACE(                                                                                                             \
+        TRACE_BEGIN_COMMON(LIBCOUCHBASE_STORE_BEGIN, instance, req, cmd,                                               \
+                           (const char *)((cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes),  \
+                           ((cmd)->value.vtype == LCB_KV_IOV ? 0 : (cmd)->value.u_buf.contig.nbytes), (cmd)->flags,    \
+                           (cmd)->cas, (req)->request.datatype, (cmd)->exptime))
+
+#define TRACE_STORE_END(instance, pkt, mcresp, resp)                                                                   \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_STORE_END, instance, pkt, mcresp, resp, (resp)->cas))
+
+#define TRACE_ARITHMETIC_BEGIN(instance, req, cmd)                                                                     \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_ARITHMETIC_BEGIN, instance, req, cmd, (cmd)->delta, (cmd)->initial,          \
+                             (cmd)->exptime))
+#define TRACE_ARITHMETIC_END(instance, pkt, mcresp, resp)                                                              \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_ARITHMETIC_END, instance, pkt, mcresp, resp, (resp)->value, (resp)->cas))
+
+#define TRACE_TOUCH_BEGIN(instance, req, cmd)                                                                          \
+    TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_TOUCH_BEGIN, instance, req, cmd, (cmd)->exptime))
+#define TRACE_TOUCH_END(instance, pkt, mcresp, resp)                                                                   \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_TOUCH_END, instance, pkt, mcresp, resp, (resp)->cas))
+
+#define TRACE_REMOVE_BEGIN(instance, req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_REMOVE_BEGIN, instance, req, cmd))
+#define TRACE_REMOVE_END(instance, pkt, mcresp, resp)                                                                  \
+    TRACE(TRACE_END_COMMON(LIBCOUCHBASE_REMOVE_END, instance, pkt, mcresp, resp, (resp)->cas))
+
+#define TRACE_OBSERVE_BEGIN(instance, req, body)                                                                       \
+    TRACE(LIBCOUCHBASE_OBSERVE_BEGIN(instance, (req)->request.opaque, (req)->request.opcode, body,                     \
+                                     ntohl((req)->request.bodylen)))
+#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(),                                       \
+                                   MCREQ_PKT_RDATA(pkt)->dispatch - MCREQ_PKT_RDATA(pkt)->start, LCB_SUCCESS))
+
+#define TRACE_HTTP_BEGIN(req)                                                                                          \
+    TRACE(LIBCOUCHBASE_HTTP_BEGIN((req)->instance, (req), (req)->reqtype, (req)->method, (req)->url.c_str(),           \
+                                  (req)->host.c_str(), (req)->port.c_str()))
+#define TRACE_HTTP_END(req, rc, htstatus)                                                                              \
+    TRACE(LIBCOUCHBASE_HTTP_END((req)->instance, (req), (req)->reqtype, (req)->method, (req)->url.c_str(),             \
+                                (req)->host.c_str(), (req)->port.c_str(), rc, htstatus, (gethrtime() - (req)->start)))
+
+#define TRACE_NEW_CONFIG(instance, config)                                                                             \
+    TRACE(LIBCOUCHBASE_NEW_CONFIG(instance, (config)->vbc->revid, (config)->vbc->bname, (config)->vbc->buuid, (config)))
 
 #ifdef __clang__
 #pragma GCC diagnostic pop

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

@@ -0,0 +1,289 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017 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"
+#ifdef HAVE__FTIME64_S
+#include <sys/timeb.h>
+#endif
+
+LIBCOUCHBASE_API
+uint64_t lcbtrace_now()
+{
+    uint64_t ret;
+#ifdef HAVE__FTIME64_S
+    struct __timeb64 tb;
+    _ftime64_s(&tb);
+    ret = (uint64_t)tb.time * 1000000; /* sec */
+    ret += (uint64_t)tb.millitm * 1000;
+#else
+    struct timeval tv;
+    if (gettimeofday(&tv, NULL) == -1) {
+        return -1;
+    }
+    ret = (uint64_t)tv.tv_sec * 1000000;
+    ret += (uint64_t)tv.tv_usec;
+#endif
+    return ret;
+}
+
+LIBCOUCHBASE_API
+void lcbtrace_span_finish(lcbtrace_SPAN *span, uint64_t now)
+{
+    if (!span) {
+        return;
+    }
+
+    span->finish(now);
+    delete span;
+}
+
+LIBCOUCHBASE_API
+void lcbtrace_span_add_tag_str(lcbtrace_SPAN *span, const char *name, const char *value)
+{
+    if (!span) {
+        return;
+    }
+    span->add_tag(name, value);
+}
+
+LIBCOUCHBASE_API
+void lcbtrace_span_add_tag_uint64(lcbtrace_SPAN *span, const char *name, uint64_t value)
+{
+    if (!span) {
+        return;
+    }
+    span->add_tag(name, (Json::Value::UInt64)value);
+}
+
+LIBCOUCHBASE_API
+void lcbtrace_span_add_tag_double(lcbtrace_SPAN *span, const char *name, double value)
+{
+    if (!span) {
+        return;
+    }
+    span->add_tag(name, value);
+}
+
+LIBCOUCHBASE_API
+void lcbtrace_span_add_tag_bool(lcbtrace_SPAN *span, const char *name, int value)
+{
+    if (!span) {
+        return;
+    }
+    span->add_tag(name, value);
+}
+
+LCB_INTERNAL_API
+void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings, const char *service)
+{
+    if (!span) {
+        return;
+    }
+    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_SERVICE, 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());
+    if (settings->bucket) {
+        lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_DB_INSTANCE, settings->bucket);
+    }
+}
+
+LIBCOUCHBASE_API
+lcbtrace_SPAN *lcbtrace_span_get_parent(lcbtrace_SPAN *span)
+{
+    if (!span) {
+        return NULL;
+    }
+    return span->m_parent;
+}
+
+LCB_INTERNAL_API
+void lcbtrace_span_set_parent(lcbtrace_SPAN *span, lcbtrace_SPAN *parent)
+{
+    if (!span) {
+        return;
+    }
+    span->m_parent = parent;
+}
+
+LIBCOUCHBASE_API
+uint64_t lcbtrace_span_get_start_ts(lcbtrace_SPAN *span)
+{
+    if (!span) {
+        return 0;
+    }
+    return span->m_start;
+}
+
+LIBCOUCHBASE_API
+uint64_t lcbtrace_span_get_finish_ts(lcbtrace_SPAN *span)
+{
+    if (!span) {
+        return 0;
+    }
+    return span->m_finish;
+}
+
+LIBCOUCHBASE_API
+int lcbtrace_span_is_orphaned(lcbtrace_SPAN *span)
+{
+    return span && span->m_orphaned;
+}
+
+LCB_INTERNAL_API
+void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val)
+{
+    if (!span) {
+        return;
+    }
+    span->m_orphaned = (val != 0);
+}
+
+LIBCOUCHBASE_API
+uint64_t lcbtrace_span_get_span_id(lcbtrace_SPAN *span)
+{
+    if (!span) {
+        return 0;
+    }
+    return span->m_span_id;
+}
+
+LIBCOUCHBASE_API
+const char *lcbtrace_span_get_operation(lcbtrace_SPAN *span)
+{
+    if (!span) {
+        return NULL;
+    }
+    return span->m_opname.c_str();
+}
+
+LIBCOUCHBASE_API
+uint64_t lcbtrace_span_get_trace_id(lcbtrace_SPAN *span)
+{
+    if (!span) {
+        return 0;
+    }
+    if (span->m_parent) {
+        return span->m_parent->m_span_id;
+    }
+    return span->m_span_id;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcbtrace_span_get_tag_str(lcbtrace_SPAN *span, const char *name, char **value, size_t *nvalue)
+{
+    if (!span) {
+        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();
+            }
+        } else {
+            *nvalue = str.size();
+            *value = (char *)calloc(*nvalue, sizeof(char));
+        }
+        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) {
+        return LCB_EINVAL;
+    }
+    Json::Value &val = span->tags[name];
+    if (val.isNumeric()) {
+        *value = val.asUInt64();
+        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) {
+        return LCB_EINVAL;
+    }
+    Json::Value &val = span->tags[name];
+    if (val.isNumeric()) {
+        *value = val.asDouble();
+        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) {
+        return LCB_EINVAL;
+    }
+    Json::Value &val = span->tags[name];
+    if (val.isBool()) {
+        *value = val.asBool();
+        return LCB_SUCCESS;
+    }
+    return LCB_KEY_ENOENT;
+}
+
+LIBCOUCHBASE_API int lcbtrace_span_has_tag(lcbtrace_SPAN *span, const char *name)
+{
+    if (!span) {
+        return 0;
+    }
+    return span->tags.isMember(name);
+}
+
+using namespace lcb::trace;
+
+Span::Span(lcbtrace_TRACER *tracer, const char *opname, uint64_t start, lcbtrace_REF_TYPE ref, lcbtrace_SPAN *other)
+    : m_tracer(tracer), m_opname(opname)
+{
+    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");
+
+    if (other != NULL && ref == LCBTRACE_REF_CHILD_OF) {
+        m_parent = other;
+    } else {
+        m_parent = NULL;
+    }
+}
+
+void Span::finish(uint64_t now)
+{
+    m_finish = now ? now : lcbtrace_now();
+    if (m_tracer && m_tracer->version == 0 && m_tracer->v.v0.report) {
+        m_tracer->v.v0.report(m_tracer, this);
+    }
+}
+
+template < typename T > void Span::add_tag(const char *name, T value)
+{
+    tags[name] = value;
+}