couchbase 3.2.0 → 3.2.4

package/src/constants.cpp

@@ -67,6 +67,8 @@ NAN_MODULE_INIT(Init)
     X(LCB_ERR_SCOPE_NOT_FOUND)
     X(LCB_ERR_INDEX_NOT_FOUND)
     X(LCB_ERR_INDEX_EXISTS)
+    X(LCB_ERR_RATE_LIMITED)
+    X(LCB_ERR_QUOTA_LIMITED)
     X(LCB_ERR_DOCUMENT_NOT_FOUND)
     X(LCB_ERR_DOCUMENT_UNRETRIEVABLE)
     X(LCB_ERR_DOCUMENT_LOCKED)
@@ -183,6 +185,7 @@ NAN_MODULE_INIT(Init)
     X(LCB_HTTP_TYPE_QUERY)
     X(LCB_HTTP_TYPE_SEARCH)
     X(LCB_HTTP_TYPE_ANALYTICS)
+    X(LCB_HTTP_TYPE_EVENTING)
 
     X(LCB_HTTP_METHOD_GET)
     X(LCB_HTTP_METHOD_POST)

package/src/instance.cpp

@@ -0,0 +1,235 @@
+#include "instance.h"
+#include "connection.h"
+
+#include "error.h"
+#include "logger.h"
+
+namespace couchnode
+{
+
+Instance::Instance(lcb_INSTANCE *instance, Logger *logger,
+                   RequestTracer *tracer, Meter *meter)
+    : _connection(nullptr)
+    , _instance(instance)
+    , _logger(logger)
+    , _tracer(tracer)
+    , _meter(meter)
+    , _clientStringCache(nullptr)
+    , _bootstrapCookie(nullptr)
+    , _openCookie(nullptr)
+{
+    _parent = addondata::Get();
+    _parent->add_instance(this);
+
+    _flushWatch = new uv_prepare_t();
+    uv_prepare_init(Nan::GetCurrentEventLoop(), _flushWatch);
+    _flushWatch->data = this;
+
+    _shutdownProc = new uv_check_t();
+    uv_check_init(Nan::GetCurrentEventLoop(), _shutdownProc);
+    _shutdownProc->data = this;
+
+    lcb_set_cookie(instance, reinterpret_cast<void *>(this));
+    lcb_set_bootstrap_callback(instance, &lcbBootstapHandler);
+    lcb_set_open_callback(instance, &lcbOpenHandler);
+    lcb_install_callback(
+        instance, LCB_CALLBACK_GET,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbGetRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_EXISTS,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbExistsRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_GETREPLICA,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbGetReplicaRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_STORE,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbStoreRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_COUNTER,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbCounterRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_REMOVE,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbRemoveRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_TOUCH,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbTouchRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_UNLOCK,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbUnlockRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_SDLOOKUP,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbLookupRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_SDMUTATE,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbMutateRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_PING,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbPingRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_DIAG,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbDiagRespHandler));
+    lcb_install_callback(
+        instance, LCB_CALLBACK_HTTP,
+        reinterpret_cast<lcb_RESPCALLBACK>(&lcbHttpDataHandler));
+}
+
+Instance::~Instance()
+{
+    if (_connection) {
+        _connection->_instance = nullptr;
+        _connection = nullptr;
+    }
+
+    if (_parent) {
+        _parent->remove_instance(this);
+        _parent = nullptr;
+    }
+
+    if (_flushWatch) {
+        uv_prepare_stop(_flushWatch);
+        uv_close(reinterpret_cast<uv_handle_t *>(_flushWatch),
+                 [](uv_handle_t *handle) { delete handle; });
+        _flushWatch = nullptr;
+    }
+
+    if (_shutdownProc) {
+        uv_check_stop(_shutdownProc);
+        uv_close(reinterpret_cast<uv_handle_t *>(_shutdownProc),
+                 [](uv_handle_t *handle) { delete handle; });
+        _shutdownProc = nullptr;
+    }
+
+    if (_instance) {
+        lcb_destroy(_instance);
+        _instance = nullptr;
+    }
+
+    // If there is a custom hooks registered, we need to deactivate them here
+    // since the GC might be the one invoking us, which will cause problems
+    // as we can't call into v8 during garbage collection.
+    if (_logger) {
+        _logger->disconnect();
+    }
+    if (_tracer) {
+        _tracer->disconnect();
+    }
+    if (_meter) {
+        _meter->disconnect();
+    }
+
+    if (_logger) {
+        delete _logger;
+        _logger = nullptr;
+    }
+    // tracer is destroyed by libcouchbase
+    // meter is destroyed by libcouchbase
+
+    if (_clientStringCache) {
+        delete[] _clientStringCache;
+        _clientStringCache = nullptr;
+    }
+    if (_bootstrapCookie) {
+        delete _bootstrapCookie;
+        _bootstrapCookie = nullptr;
+    }
+    if (_openCookie) {
+        delete _openCookie;
+        _openCookie = nullptr;
+    }
+}
+
+void Instance::uvShutdownHandler(uv_check_t *handle)
+{
+    delete reinterpret_cast<Instance *>(handle->data);
+}
+
+void Instance::shutdown()
+{
+    uv_check_start(_shutdownProc, &uvShutdownHandler);
+}
+
+const char *Instance::bucketName()
+{
+    const char *value = nullptr;
+    lcb_cntl(_instance, LCB_CNTL_GET, LCB_CNTL_BUCKETNAME, &value);
+    return value;
+}
+
+const char *Instance::clientString()
+{
+    // Check to see if our cache is already populated
+    if (_clientStringCache) {
+        return _clientStringCache;
+    }
+
+    // Fetch from libcouchbase if we have not done that yet.
+    const char *lcbClientString;
+    lcb_cntl(_instance, LCB_CNTL_GET, LCB_CNTL_CLIENT_STRING, &lcbClientString);
+    if (!lcbClientString) {
+        // Backup string in case something goes wrong
+        lcbClientString = "couchbase-nodejs-sdk";
+    }
+
+    // Copy it to memory we own.
+    int lcbClientStringLen = strlen(lcbClientString);
+    char *allocString = new char[lcbClientStringLen + 1];
+    memcpy(allocString, lcbClientString, lcbClientStringLen + 1);
+
+    if (_clientStringCache) {
+        delete[] _clientStringCache;
+        _clientStringCache = nullptr;
+    }
+    _clientStringCache = allocString;
+
+    return _clientStringCache;
+}
+
+void Instance::uvFlushHandler(uv_prepare_t *handle)
+{
+    Instance *me = reinterpret_cast<Instance *>(handle->data);
+    lcb_sched_flush(me->_instance);
+}
+
+void Instance::lcbBootstapHandler(lcb_INSTANCE *instance, lcb_STATUS err)
+{
+    Instance *me = Instance::fromLcbInst(instance);
+
+    if (err != 0) {
+        lcb_set_bootstrap_callback(instance, [](lcb_INSTANCE *, lcb_STATUS) {});
+        lcb_destroy_async(instance, NULL);
+        me->_instance = nullptr;
+    } else {
+        uv_prepare_start(me->_flushWatch, &uvFlushHandler);
+
+        int flushMode = 0;
+        lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_SCHED_IMPLICIT_FLUSH,
+                 &flushMode);
+    }
+
+    if (me->_bootstrapCookie) {
+        Nan::HandleScope scope;
+
+        Local<Value> args[] = {Error::create(err)};
+        me->_bootstrapCookie->Call(1, args);
+
+        delete me->_bootstrapCookie;
+        me->_bootstrapCookie = nullptr;
+    }
+}
+
+void Instance::lcbOpenHandler(lcb_INSTANCE *instance, lcb_STATUS err)
+{
+    Instance *me = Instance::fromLcbInst(instance);
+
+    if (me->_openCookie) {
+        Nan::HandleScope scope;
+
+        Local<Value> args[] = {Error::create(err)};
+        me->_openCookie->Call(1, args);
+
+        delete me->_openCookie;
+        me->_openCookie = nullptr;
+    }
+}
+
+} // namespace couchnode

package/src/instance.h

@@ -0,0 +1,102 @@
+#pragma once
+#ifndef INSTANCE_H
+#define INSTANCE_H
+
+#include "addondata.h"
+#include "cookie.h"
+#include "logger.h"
+#include "metrics.h"
+#include "tracing.h"
+#include "valueparser.h"
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/libuv_io_opts.h>
+#include <nan.h>
+#include <node.h>
+
+namespace couchnode
+{
+
+using namespace v8;
+
+class Instance
+{
+public:
+    static inline Instance *fromLcbInst(lcb_INSTANCE *instance)
+    {
+        void *cookie = const_cast<void *>(lcb_get_cookie(instance));
+        Instance *inst = reinterpret_cast<Instance *>(cookie);
+        return inst;
+    }
+
+    Instance(lcb_INSTANCE *instance, Logger *logger, RequestTracer *tracer,
+             Meter *meter);
+    ~Instance();
+
+    lcb_INSTANCE *lcbHandle() const
+    {
+        return _instance;
+    }
+
+    void shutdown();
+
+    const char *bucketName();
+    const char *clientString();
+
+    static void uvFlushHandler(uv_prepare_t *handle);
+    static void uvShutdownHandler(uv_check_t *handle);
+    static void lcbRegisterCallbacks(lcb_INSTANCE *instance);
+    static void lcbBootstapHandler(lcb_INSTANCE *instance, lcb_STATUS err);
+    static void lcbOpenHandler(lcb_INSTANCE *instance, lcb_STATUS err);
+    static void lcbGetRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                  const lcb_RESPGET *resp);
+    static void lcbExistsRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPEXISTS *resp);
+    static void lcbGetReplicaRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                         const lcb_RESPGETREPLICA *resp);
+    static void lcbUnlockRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPUNLOCK *resp);
+    static void lcbRemoveRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPREMOVE *resp);
+    static void lcbTouchRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPTOUCH *resp);
+    static void lcbStoreRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPSTORE *resp);
+    static void lcbCounterRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                      const lcb_RESPCOUNTER *resp);
+    static void lcbLookupRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPSUBDOC *resp);
+    static void lcbMutateRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPSUBDOC *resp);
+    static void lcbViewDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPVIEW *resp);
+    static void lcbQueryDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPQUERY *resp);
+    static void lcbAnalyticsDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                        const lcb_RESPANALYTICS *resp);
+    static void lcbSearchDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPSEARCH *resp);
+    static void lcbPingRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPPING *resp);
+    static void lcbDiagRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPDIAG *resp);
+    static void lcbHttpDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPHTTP *resp);
+
+    AddonData *_parent;
+    class Connection *_connection;
+    lcb_INSTANCE *_instance;
+    Logger *_logger;
+    RequestTracer *_tracer;
+    Meter *_meter;
+    uv_prepare_t *_flushWatch;
+    uv_check_t *_shutdownProc;
+    const char *_clientStringCache;
+
+    Cookie *_bootstrapCookie;
+    Cookie *_openCookie;
+};
+
+} // namespace couchnode
+
+#endif // CONNECTION_H

package/src/{connection_callbacks.cpp → instance_callbacks.cpp}

@@ -8,8 +8,8 @@
 namespace couchnode
 {
 
-void Connection::lcbGetRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                   const lcb_RESPGET *resp)
+void Instance::lcbGetRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                 const lcb_RESPGET *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPGET, &lcb_respget_cookie> rdr(instance, resp);
@@ -37,8 +37,8 @@ void Connection::lcbGetRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, casVal, valueVal);
 }
 
-void Connection::lcbExistsRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPEXISTS *resp)
+void Instance::lcbExistsRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPEXISTS *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPEXISTS, &lcb_respexists_cookie> rdr(instance, resp);
@@ -64,8 +64,8 @@ void Connection::lcbExistsRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, casVal, existsVal);
 }
 
-void Connection::lcbGetReplicaRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                          const lcb_RESPGETREPLICA *resp)
+void Instance::lcbGetReplicaRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                        const lcb_RESPGETREPLICA *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPGETREPLICA, &lcb_respgetreplica_cookie> rdr(instance,
@@ -106,8 +106,8 @@ void Connection::lcbGetReplicaRespHandler(lcb_INSTANCE *instance, int cbtype,
     }
 }
 
-void Connection::lcbUnlockRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPUNLOCK *resp)
+void Instance::lcbUnlockRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPUNLOCK *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPUNLOCK, &lcb_respunlock_cookie> rdr(instance, resp);
@@ -118,8 +118,8 @@ void Connection::lcbUnlockRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal);
 }
 
-void Connection::lcbRemoveRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPREMOVE *resp)
+void Instance::lcbRemoveRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPREMOVE *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPREMOVE, &lcb_respremove_cookie> rdr(instance, resp);
@@ -137,8 +137,8 @@ void Connection::lcbRemoveRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, casVal);
 }
 
-void Connection::lcbTouchRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPTOUCH *resp)
+void Instance::lcbTouchRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPTOUCH *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPTOUCH, &lcb_resptouch_cookie> rdr(instance, resp);
@@ -156,8 +156,8 @@ void Connection::lcbTouchRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, casVal);
 }
 
-void Connection::lcbStoreRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPSTORE *resp)
+void Instance::lcbStoreRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPSTORE *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPSTORE, &lcb_respstore_cookie> rdr(instance, resp);
@@ -177,8 +177,8 @@ void Connection::lcbStoreRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, casVal, tokenVal);
 }
 
-void Connection::lcbCounterRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                       const lcb_RESPCOUNTER *resp)
+void Instance::lcbCounterRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                     const lcb_RESPCOUNTER *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPCOUNTER, &lcb_respcounter_cookie> rdr(instance, resp);
@@ -200,8 +200,8 @@ void Connection::lcbCounterRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, casVal, tokenVal, valueVal);
 }
 
-void Connection::lcbLookupRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPSUBDOC *resp)
+void Instance::lcbLookupRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPSUBDOC *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPSUBDOC, &lcb_respsubdoc_cookie> rdr(instance, resp);
@@ -245,8 +245,8 @@ void Connection::lcbLookupRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, resVal);
 }
 
-void Connection::lcbMutateRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPSUBDOC *resp)
+void Instance::lcbMutateRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPSUBDOC *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPSUBDOC, &lcb_respsubdoc_cookie> rdr(instance, resp);
@@ -300,8 +300,8 @@ void Connection::lcbMutateRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, resVal);
 }
 
-void Connection::lcbViewDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPVIEW *resp)
+void Instance::lcbViewDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                  const lcb_RESPVIEW *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPVIEW, &lcb_respview_cookie> rdr(instance, resp);
@@ -326,8 +326,8 @@ void Connection::lcbViewDataHandler(lcb_INSTANCE *instance, int cbtype,
     }
 }
 
-void Connection::lcbQueryDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPQUERY *resp)
+void Instance::lcbQueryDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                   const lcb_RESPQUERY *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPQUERY, &lcb_respquery_cookie> rdr(instance, resp);
@@ -350,8 +350,8 @@ void Connection::lcbQueryDataHandler(lcb_INSTANCE *instance, int cbtype,
     }
 }
 
-void Connection::lcbAnalyticsDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                         const lcb_RESPANALYTICS *resp)
+void Instance::lcbAnalyticsDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                       const lcb_RESPANALYTICS *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPANALYTICS, &lcb_respanalytics_cookie> rdr(instance,
@@ -375,8 +375,8 @@ void Connection::lcbAnalyticsDataHandler(lcb_INSTANCE *instance, int cbtype,
     }
 }
 
-void Connection::lcbSearchDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPSEARCH *resp)
+void Instance::lcbSearchDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                    const lcb_RESPSEARCH *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPSEARCH, &lcb_respsearch_cookie> rdr(instance, resp);
@@ -399,8 +399,8 @@ void Connection::lcbSearchDataHandler(lcb_INSTANCE *instance, int cbtype,
     }
 }
 
-void Connection::lcbHttpDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPHTTP *resp)
+void Instance::lcbHttpDataHandler(lcb_INSTANCE *instance, int cbtype,
+                                  const lcb_RESPHTTP *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPHTTP, &lcb_resphttp_cookie> rdr(instance, resp);
@@ -445,8 +445,8 @@ void Connection::lcbHttpDataHandler(lcb_INSTANCE *instance, int cbtype,
     }
 }
 
-void Connection::lcbPingRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPPING *resp)
+void Instance::lcbPingRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                  const lcb_RESPPING *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPPING, &lcb_respping_cookie> rdr(instance, resp);
@@ -464,8 +464,8 @@ void Connection::lcbPingRespHandler(lcb_INSTANCE *instance, int cbtype,
     rdr.invokeCallback(errVal, dataVal);
 }
 
-void Connection::lcbDiagRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPDIAG *resp)
+void Instance::lcbDiagRespHandler(lcb_INSTANCE *instance, int cbtype,
+                                  const lcb_RESPDIAG *resp)
 {
     Nan::HandleScope scope;
     RespReader<lcb_RESPDIAG, &lcb_respdiag_cookie> rdr(instance, resp);

package/src/logger.cpp

@@ -4,7 +4,8 @@ namespace couchnode
 {
 
 Logger::Logger(Local<Function> callback)
-    : _callback(callback)
+    : _enabled(true)
+    , _callback(callback)
     , _logBuffer(nullptr)
     , _logBufferLen(0)
 {
@@ -23,10 +24,19 @@ const lcb_LOGGER *Logger::lcbProcs() const
     return _lcbLogger;
 }
 
+void Logger::disconnect()
+{
+    _enabled = false;
+}
+
 void Logger::handler(unsigned int iid, const char *subsys, int severity,
                      const char *srcfile, int srcline, const char *fmt,
                      va_list ap)
 {
+    if (!_enabled) {
+        return;
+    }
+
     Nan::HandleScope scope;
     va_list apCopy;
 

package/src/logger.h

@@ -19,6 +19,8 @@ public:
 
     const lcb_LOGGER *lcbProcs() const;
 
+    void disconnect();
+
 private:
     void handler(unsigned int iid, const char *subsys, int severity,
                  const char *srcfile, int srcline, const char *fmt, va_list ap);
@@ -28,6 +30,7 @@ private:
                            const char *srcfile, int srcline, const char *fmt,
                            va_list ap);
 
+    bool _enabled;
     lcb_LOGGER *_lcbLogger;
     Nan::Callback _callback;
     char *_logBuffer;

package/src/metrics.cpp

@@ -59,6 +59,7 @@ void lcbValueRecorderRecordValue(const lcbmetrics_VALUERECORDER *procs,
 }
 
 Meter::Meter(Local<Object> impl)
+    : _enabled(true)
 {
     lcbmetrics_meter_create(&_lcbMeter, this);
     lcbmetrics_meter_dtor_callback(_lcbMeter, &lcbMeterDtor);
@@ -84,6 +85,11 @@ const lcbmetrics_METER *Meter::lcbProcs() const
     return _lcbMeter;
 }
 
+void Meter::disconnect()
+{
+    _enabled = false;
+}
+
 void Meter::destroy(const Meter *meter)
 {
     delete meter;
@@ -93,6 +99,10 @@ const lcbmetrics_VALUERECORDER *Meter::valueRecorder(const char *name,
                                                      const lcbmetrics_TAG *tags,
                                                      size_t ntags) const
 {
+    if (!_enabled) {
+        return nullptr;
+    }
+
     // We don't perform any cacheing to avoid calls into v8 here as libcouchbase
     // already contractually provides cacheing to reduce the calls to this
     // method.

package/src/metrics.h

@@ -24,7 +24,10 @@ public:
                                                   const lcbmetrics_TAG *tags,
                                                   size_t ntags) const;
 
+    void disconnect();
+
 protected:
+    bool _enabled;
     lcbmetrics_METER *_lcbMeter;
     Nan::Persistent<Object> _impl;
     Nan::Persistent<Function> _valueRecorderImpl;

package/src/mutationtoken.h

@@ -2,6 +2,7 @@
 #ifndef TOKEN_H
 #define TOKEN_H
 
+#include "addondata.h"
 #include <libcouchbase/couchbase.h>
 #include <nan.h>
 #include <node.h>
@@ -24,8 +25,7 @@ public:
 
     static inline Nan::Persistent<Function> &constructor()
     {
-        static Nan::Persistent<Function> class_constructor;
-        return class_constructor;
+        return addondata::Get()->_mutationtokenConstructor;
     }
 
 private: