libcouchbase 1.2.8 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57c24a3675fadb2c90585132fad12c9c096d0954
-  data.tar.gz: 29ddf992c956f4ae85486e7b7bd95665b125eb16
+  metadata.gz: 7e84d37abd4f01d3b311fa83fb9e16ce72bd6915
+  data.tar.gz: c4ad09758711a1d26e27a41182f06c4100e023d9
 SHA512:
-  metadata.gz: 5fd06f34047dced44d9a717e0a66101c2f279f9ff904fb52fe1d30afd98e63fa0f0f00cf6186e84f8a32cbb6b9e9609c8572b506359b74701927faa82816c5d0
-  data.tar.gz: 85df59fdd0db12c889bf91bd6774a1f929a67f4ad13d913a3f392f7ea524f4f1091f80cee3a28130e5c2f5c9174e94f41b6b1e61dc230879603698044cdc11ef
+  metadata.gz: 771464b5f1b88f5f4e123628639a3fd8dfb3adaecd55645f8cdf4b69888b7cf2ab38aace66c45105c2e9af6905a4b90a46455055e158d75e89f66f1c47ff117d
+  data.tar.gz: 74f4262314b368ade557710421460d7a13e382e3f828ccf9fb0481aa86aea0153e5d581a064d9241baa0eae85800d2f2137255eca39a900eca2615ed4bb3a10d

data/.travis.yml

@@ -6,7 +6,7 @@ rvm:
   - jruby-9.1.13.0
   - jruby-head
   - rubinius
-  - rubinius-3.86
+  - rubinius-3.103
 branches:
   only:
     - master
@@ -14,8 +14,8 @@ before_install:
   - git submodule update --init --recursive
   - gem install ffi
   - sudo apt-get install libev-dev python-httplib2
-  - sudo wget https://packages.couchbase.com/releases/5.0.0/couchbase-server-enterprise_5.0.0-ubuntu14.04_amd64.deb
-  - sudo dpkg -i couchbase-server-enterprise_5.0.0-ubuntu14.04_amd64.deb
+  - sudo wget https://packages.couchbase.com/releases/5.1.0/couchbase-server-enterprise_5.1.0-ubuntu14.04_amd64.deb
+  - sudo dpkg -i couchbase-server-enterprise_5.1.0-ubuntu14.04_amd64.deb
   - sleep 8
   - sudo service couchbase-server status
   - /opt/couchbase/bin/couchbase-cli cluster-init -c 127.0.0.1:8091 --cluster-username=admin --cluster-password=password --cluster-ramsize=320 --cluster-index-ramsize=256 --cluster-fts-ramsize=256 --services=data,index,query,fts
@@ -33,6 +33,6 @@ matrix:
     - rvm: jruby-head
     - rvm: ruby-head
     - rvm: rubinius
-    - rvm: rubinius-3.86
+    - rvm: rubinius-3.103
 sudo: required
 dist: trusty

data/README.md

@@ -92,16 +92,16 @@ bucket = Libcouchbase::Bucket.new(hosts: '127.0.0.1', bucket: 'default', passwor
 bucket = Libcouchbase::Bucket.new(hosts: ['cb1.org', 'cb2.org'], bucket: 'app_data', password: 'goodluck')
 ```
 
-By default connections use `:quiet` mode. This mean it won't raise
+Connections can be configured to use `:quiet` mode. This mean it won't raise
 exceptions when the given key does not exist:
 
 ```ruby
+bucket.quiet = true
 bucket.get(:missing_key)            #=> nil
 ```
 
-It could be useful when you are trying to make you code a bit efficient
-by avoiding exception handling. (See `#add` and `#replace` operations).
-You can turn on these exceptions by passing `:quiet => false` when you
+It could be useful avoiding exception handling. (See `#add` and `#replace` operations).
+You can turn off these exceptions by passing `:quiet => true` when you
 are instantiating the connection or change corresponding attribute:
 
 ```ruby
@@ -187,8 +187,17 @@ bucket.touch(:foo, expire_at: (Time.now + 30))
 
 ### Set
 
-The add command will fail if the key already exists. It accepts the same
-options as set command above.
+The set command will unconditionally store an object in couchbase.
+
+```ruby
+bucket.add("foo", "bar")
+bucket.add("foo", "bar", ttl: 30)
+```
+
+
+### Add
+
+The add command will fail if the key already exists.
 
 ```ruby
 bucket.add("foo", "bar")
@@ -198,8 +207,7 @@ bucket.add("foo", "bar", ttl: 30)
 
 ### Replace
 
-The replace command will fail if the key already exists. It accepts the same
-options as set command above.
+The replace command will fail if the key doesn't already exist.
 
 ```ruby
 bucket.replace("foo", "bar")

data/ext/libcouchbase/CMakeLists.txt

@@ -1,3 +1,5 @@
+# -*- mode: cmake; cmake-tab-width: 4; indent-tabs-mode: nil -*-
+#
 # libcouchbase
 # Copyright (C) 2013 Couchbase, Inc
 # All rights reserved.
@@ -21,7 +23,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8.9)
 # These variables can be modified as needed
 
 # Couchbase mock path to download
-SET(COUCHBASE_MOCK_VERSION CouchbaseMock-1.5.12.jar)
+SET(COUCHBASE_MOCK_VERSION CouchbaseMock-1.5.19.jar)
 # Maven repository where ${COUCHBASE_MOCK_VERSION} is to be found
 SET(COUCHBASE_MOCK_DLSERVER http://packages.couchbase.com/clients/c/mock)
 project(libcouchbase)
@@ -34,10 +36,8 @@ OPTION(LCB_BUILD_LIBEV "Build the libev plugin (if available)" ON)
 OPTION(LCB_BUILD_LIBUV "Build the libuv plugin (if available)" ON)
 OPTION(LCB_MAINTAINER_MODE "Enables maintainer mode" OFF)
 OPTION(LCB_NO_SSL "Do not compile SSL support" OFF)
-OPTION(LCB_NO_SNAPPY "Do not compile snappy support" ON)
 OPTION(LCB_USE_ASAN "Use AddressSanitizer support (Requires Clang)" OFF)
 OPTION(LCB_USE_COVERAGE "Build with code coverage support" OFF)
-OPTION(LCB_STATIC_SNAPPY "Use the bundled libsnappy. Do not link with system snappy" ${WIN32})
 OPTION(LCB_USE_ARCHLIBDIR "Use architecture-prefixed library installation directory, if possible" OFF)
 OPTION(LCB_BUILD_EXAMPLES "Build example applications" OFF)
 OPTION(LCB_NO_MOCK "Don't run tests which depend on the mock" OFF)
@@ -45,6 +45,7 @@ OPTION(LCB_BUILD_DTRACE "Build DTrace instrumentation, if available on platform"
 OPTION(LCB_EMBED_PLUGIN_LIBEVENT "Embed the libevent plugin" OFF)
 OPTION(LCB_STATIC_LIBEVENT "Link static libevent (only applicable if EMBED_PLUGIN_LIBEVENT is ON" OFF)
 OPTION(LCB_USE_HDR_HISTOGRAM "Use HdrHistogram for statistics recording" OFF)
+OPTION(LCB_TRACING "Enable builtin tracing" ON)
 
 ### END CONFIGURABLES ###
 IF(MSVC)
@@ -203,6 +204,7 @@ ENDMACRO()
 ADD_LIBRARY(netbuf OBJECT ${LCB_NETBUF_SRC})
 ADD_LIBRARY(netbuf-malloc OBJECT ${LCB_NETBUF_SRC})
 ADD_LIBRARY(mcreq OBJECT ${LCB_MC_SRC})
+ADD_LIBRARY(mcreq-cxx OBJECT ${LCB_MC_CXXSRC})
 ADD_LIBRARY(rdb OBJECT ${LCB_RDB_SRC})
 ADD_LIBRARY(lcbio OBJECT ${LCB_IO_SRC})
 ADD_LIBRARY(lcbio-cxx OBJECT ${LCB_IO_CXXSRC})
@@ -218,24 +220,41 @@ LCB_UTIL(lcbio)
 LCB_CXXUTIL(lcbio-cxx)
 LCB_UTIL(couchbase_utils)
 LCB_UTIL(mcreq)
+LCB_CXXUTIL(mcreq-cxx)
 LCB_UTIL(lcbht)
 LCB_UTIL(lcbcore)
 LCB_CXXUTIL(lcbcore-cxx)
 
+IF(LCB_NO_SSL)
+    MESSAGE(STATUS "SSL support will be disabled")
+    ADD_DEFINITIONS(-DLCB_NO_SSL=1)
+ELSE()
+    IF(APPLE)
+        IF(NOT OpenSSL_DIR)
+            EXECUTE_PROCESS(COMMAND brew --prefix openssl
+                OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+            MESSAGE(STATUS "Found OpenSSL Prefix: ${OPENSSL_ROOT_DIR}")
+        ENDIF()
+    ENDIF()
+    FIND_PACKAGE(OpenSSL)
+    IF(OPENSSL_FOUND)
+        MESSAGE(STATUS "SSL Found")
+    ELSE()
+        MESSAGE(STATUS "SSL Not Found")
+    ENDIF()
+ENDIF()
+
 ADD_SUBDIRECTORY(src/vbucket)
 ADD_SUBDIRECTORY(contrib/cbsasl)
 ADD_SUBDIRECTORY(contrib/cliopts)
 ADD_SUBDIRECTORY(src/ssl)
 ADD_SUBDIRECTORY(contrib/lcb-jsoncpp)
+ADD_SUBDIRECTORY(contrib/snappy)
 IF(LCB_BUILD_EXAMPLES)
     ADD_SUBDIRECTORY(example)
 ENDIF()
 
-IF(LCB_NO_SSL)
-    MESSAGE(STATUS "SSL support will be disabled")
-    ADD_DEFINITIONS(-DLCB_NO_SSL=1)
-ENDIF()
-
 IF(LCB_BUILD_STATIC)
     SET(_lcb_linkspec STATIC)
 ELSE()
@@ -251,13 +270,16 @@ FILE(GLOB LCB_JSPARSE_SRC src/jsparse/*.cc)
 ADD_LIBRARY(lcb_jsparse OBJECT ${LCB_JSPARSE_SRC})
 LCB_CXXUTIL(lcb_jsparse)
 
+INCLUDE_DIRECTORIES(contrib/snappy)
+
 SET(LCB_CORE_OBJS
     $<TARGET_OBJECTS:couchbase_select>
     $<TARGET_OBJECTS:couchbase_utils>
-    $<TARGET_OBJECTS:vbucket>
+    $<TARGET_OBJECTS:vbucket-lcb>
     $<TARGET_OBJECTS:mcreq>
+    $<TARGET_OBJECTS:mcreq-cxx>
     $<TARGET_OBJECTS:netbuf>
-    $<TARGET_OBJECTS:cbsasl>
+    $<TARGET_OBJECTS:cbsasl-lcb>
     $<TARGET_OBJECTS:lcbio>
     $<TARGET_OBJECTS:lcbio-cxx>
     $<TARGET_OBJECTS:rdb>
@@ -266,6 +288,7 @@ SET(LCB_CORE_OBJS
     $<TARGET_OBJECTS:lcbcore-cxx>
     $<TARGET_OBJECTS:lcb_jsparse>
     $<TARGET_OBJECTS:lcb_jsoncpp>
+    $<TARGET_OBJECTS:lcb_snappy>
     ${LCB_DTRACE_OBJECT}
     ${lcb_plat_objs}
     ${lcb_ssl_objs})
@@ -305,30 +328,9 @@ ELSE()
         DESTINATION ${CMAKE_INSTALL_LIBDIR})
 ENDIF()
 
-
-IF(NOT LCB_NO_SNAPPY)
-    IF(LCB_STATIC_SNAPPY)
-        MESSAGE(STATUS "Will use embedded libsnappy")
-        ADD_SUBDIRECTORY(contrib/snappy)
-        SET(LCB_SNAPPY_LINK lcbsnappy)
-    ELSE()
-        INCLUDE(cmake/Modules/FindCouchbaseSnappy.cmake)
-        IF(NOT SNAPPY_FOUND)
-            MESSAGE(FATAL_ERROR "Snappy not found and building with dynamic snappy requested")
-        ELSE()
-            SET(LCB_SNAPPY_LINK ${SNAPPY_LIBRARIES})
-            INCLUDE_DIRECTORIES(${SNAPPY_INCLUDES})
-        ENDIF()
-    ENDIF()
-ELSE()
-    MESSAGE(STATUS "Compression support will be disabled")
-    ADD_DEFINITIONS(-DLCB_NO_SNAPPY=1)
-    SET(LCB_SNAPPY_LINK "")
-ENDIF()
-
 SET_TARGET_PROPERTIES(couchbase PROPERTIES PREFIX "lib")
 SET_TARGET_PROPERTIES(couchbase PROPERTIES IMPORT_PREFIX "lib")
-SET(LCB_LINK_DEPS ${lcb_plat_libs} ${lcb_ssl_libs} ${LCB_SNAPPY_LINK} ${LCB_HDR_HISTOGRAM_LINK})
+SET(LCB_LINK_DEPS ${lcb_plat_libs} ${lcb_ssl_libs} ${LCB_HDR_HISTOGRAM_LINK})
 IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     SET(LCB_LINK_DEPS ${LCB_LINK_DEPS} rt)
 ENDIF()

data/ext/libcouchbase/RELEASE_NOTES.markdown

@@ -1,5 +1,271 @@
 # Release Notes
 
+## 2.8.7 (May 2 2018)
+
+* [CCBC-917](https://issues.couchbase.com/browse/CCBC-917): Add tracing for
+  observe. So now the library will group all CAS-observe operations, and in
+  general will nest observe operations under common parent when
+  `lcb_storedur3` API used.
+
+* [CCBC-918](https://issues.couchbase.com/browse/CCBC-918): Don't ping KV on
+  nodes without DATA service.
+
+* [CCBC-685](https://issues.couchbase.com/browse/CCBC-685): Implementation of
+  SCRAM-SHA{1,256,512} authentication mechanisms for KV service. Support for
+  SCRAM-SHA* SASL auth is disabled by default, because it is not portable, and
+  not every Couchbase service supports it. But if it is necessary, it could be
+  enabled using `lcb_cntl(..., LCB_CNTL_FORCE_SASL_MECH, ...)` operation, or
+  `"force_sasl_mech=SCRAM-SHA512"` option in connection string.
+
+* [CCBC-919](https://issues.couchbase.com/browse/CCBC-919): More granular
+  settings for compression. Now it is possible to specify minimum size of the
+  value to be considered for compression, and also the minimal ratio
+  `(compressed / original)`. See `LCB_CNTL_COMPRESSION_MIN_SIZE` (or
+  `"compression_min_size=100"` in bytes), and `LCB_CNTL_COMPRESSION_MIN_RATIO`
+  (or `"compression=0.9"`).
+
+* [CCBC-916](https://issues.couchbase.com/browse/CCBC-916): Do not set JSON
+  datatype if server didn't ack it. Fixes behavior where old server rejecting
+  commands as invalid when compression is enabled.
+
+* [CCBC-923](https://issues.couchbase.com/browse/CCBC-923): Allow to disable
+  fast-forward map for NMV handler. See `LCB_CNTL_VB_NOREMAP`
+  (`"vb_noremap=true"`). This option is disabled by default.
+
+Build improvements:
+
+* [CCBC-915](https://issues.couchbase.com/browse/CCBC-915): Fix builds
+  where DEBUG macro is defined
+
+* [CBD-2405](https://issues.couchbase.com/browse/CBD-2405): Change
+  target names in conflict with Server targets
+
+## 2.8.6 (April 5 2018)
+
+* [CCBC-888](https://issues.couchbase.com/browse/CCBC-888): Add threshold
+  logging tracer, which tracks and reports above threshold and orphaned operations.
+  This is beta functionality, which is disabled by default. To enable it, use
+  `enable_tracing=on` in the connection string.
+
+* [CCBC-910](https://issues.couchbase.com/browse/CCBC-910): Field encryption
+  API. The `lcbcrypto_*` functions abstracts encrypted field layout from actual
+  crypto implementations (OpenSSL, libsodium, etc.). The wrapper or application
+  using libcouchbase is expected to connect their own crypto and key providers, while
+  libcouchbase provides transformation of the encrypted data. See
+  sample crypto provider in [example/crypto](example/crypto).
+
+* [CCBC-904](https://issues.couchbase.com/browse/CCBC-904): Remove trailing
+  comma in `lcb_KVBUFTYPE` enum. Fixes build on some older
+  compilers.
+
+* [CCBC-907](https://issues.couchbase.com/browse/CCBC-907): cbc-n1qlback: Do
+  not require trailing empty line for input.
+
+* [CCBC-908](https://issues.couchbase.com/browse/CCBC-908): cbc-n1qlback:
+  Report number of loaded queries.
+
+* Add ability to write OPS/SEC from cbc-pillowfight to a file
+
+      cbc-pillowfight 2> /tmp/stats.txt
+
+  or, when writing to terminal required
+
+      cbc-pillowfight 2>&1 | tee /tmp/stats.txt
+
+* Build improvements for easier integration into with server manifest (and TLM project).
+
+## 2.8.5 (February 23 2018)
+
+* [CCBC-883](https://issues.couchbase.com/browse/CCBC-883): Always use built-in compression.
+  It is not possible to unbundle the Snappy library, as libcouchbase uses the C++ API which is not
+  exported in the headers. Also, compression can now work on all types of buffers, including
+  `LCB_KV_IOV` and `LCB_KV_IOVCOPY`. This fixes compression in `cbc-pillowfight` tool.
+
+* [CCBC-895](https://issues.couchbase.com/browse/CCBC-895): Fix typo in rendering IPv6 addresses
+  in `lcb_diag`.
+
+* [CCBC-879](https://issues.couchbase.com/browse/CCBC-879): Implement log redaction. When
+  `log_redaction=on` is specified in the connection string, the library will wrap sensitive
+  data in the logs in special tags, which can be processed by the
+  `cblogredaction` tool from the server distribution.
+
+* [CCBC-893](https://issues.couchbase.com/browse/CCBC-894): Updated list of subdoc error codes.
+
+* [CCBC-892](https://issues.couchbase.com/browse/CCBC-892): Enable the SSL trust store to be in
+  a separate file. Trust store has to be specified with option `truststorepath=…`, otherwise
+  the library will expect it to be stored with the certificate in `certpath=`.
+
+* [CCBC-888](https://issues.couchbase.com/browse/CCBC-888): Per operation tracing. When
+  compiled with tracing support (`cmake -DLCB_TRACING=ON`), the library will expose the tracing
+  API, which allows to measure time of every data operation, and include some extra information.
+  The API is modeled after OpenTracing and allows one to write custom tracers to consume this
+  information. For more information, see an example in
+  [example/tracing/tracing.c](example/tracing/tracing.c).  This is uncommitted API at this time.
+
+  Also this feature includes support for new type of the server responses, which include
+  time spent to execute the KV command on the server. This feature controlled by `enable_tracing`
+  option in connection string or `lcb_cntl(..., LCB_CNTL_ENABLE_TRACING, ...)`.
+
+* Added basic support of JSON datatype. The library will negotiate a mode, in which the
+  application will see `LCB_VALUE_F_JSON` flag on datatype field of the response in the
+  operation callback, if the cluster  detected the content of the document to be valid JSON.
+  Also the application can send this flag on the outgoing documents to notify the server
+  about payload format.
+
+* Refresh dtrace/systemtap integration. Also adds tapset for SystemTap to simplify access to
+  trace points.
+
+* cbc-pillowfight improvements and changes:
+  * dump diagnostics on `SIGQUIT` (CTRL-\ in terminal).
+  * with `-J`/`--json`, the JSON datatype will be sent on the documents.
+  * enable randomized document bodies with `-R`/`--random-body` switch.
+  * durability checks for pillowfight with `--persist-to`/`--replicate-to`.
+  * pessimistic locking of keys before updating with `--lock`.
+  * when requesting timings with `-T`/`--timings`, the application will no longer dump them
+    periodically.Instead it will await for the user to signal `SIGQUIT` and also dump
+    them on exit. The old mode of reporting regularly is enabled by repeating the switch more than
+    once (e.g. `-TT`).
+
+* Added the cbc-watch command to monitor server stats. By default it tracks `cmd_total_ops`,
+  `cmd_total_gets` and `cmd_total_sets` updating stats once a second, and displaying
+  diff with the previous value.
+
+
+## 2.8.4 (December 20 2017)
+
+* [CCBC-880](https://issues.couchbase.com/browse/CCBC-880): Implement x.509 client
+  certificate authentication. Connection string must use TLS-enabled scheme
+  (`couchbases://` or `https://`) and set options `certpath` and `keypath`. For example,
+
+        couchbases://127.0.0.1?certpath=/path/to/chain.pem&keypath=/path/to/client.key
+
+  Read more at server docs: https://developer.couchbase.com/documentation/server/5.0/security/security-x509certsintro.html
+
+* [CCBC-883](https://issues.couchbase.com/browse/CCBC-883): Revisit builtin compression
+  implementation (snappy). Add compression to cbc tools (see `--compress`, `-y` options).
+  Future versions of Couchbase Server will have end-to-end compression.
+
+* [CCBC-885](https://issues.couchbase.com/browse/CCBC-885): Do not skip HTTP Basic
+  authentication when password is empty.
+
+* [CCBC-876](https://issues.couchbase.com/browse/CCBC-876): Make sure that server
+  authority is always specified.  In some cases, when libcouchbase generates vbucket
+  configuration or data service is not available, the authority of the server might be
+  NULL.  This could cause issues, as we compare servers from configs using their authority
+  fields.
+
+* [CCBC-878](https://issues.couchbase.com/browse/CCBC-878): Support collections in
+  cbc-pillowfight.
+
+  Note that this change does not expose anything related to Collections API for
+  libcouchbase. It defines hidden switches for pillowfight tool to allow benchmark of
+  collections. The switches are not documented and might be removed in the future. Use
+  with care.
+
+  Generate only `beer:<seqno>` keys:
+
+        cbc pillowfight --separator : --collection beer
+
+  Using many --collection will alternate in generating `beer:<seqno>`, `brewery:<seqno>`
+  keys (default separator is ":"):
+
+        cbc pillowfight --collection beer --collection brewery
+
+* [CCBC-801](https://issues.couchbase.com/browse/CCBC-801): Expose information about
+  network IO for monitoring. The diagnostics exposed as string with encoded JSON object.
+
+        void diag_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+        {
+            const lcb_RESPDIAG *resp = (const lcb_RESPDIAG *)rb;
+            if (resp->rc != LCB_SUCCESS) {
+                fprintf(stderr, "failed: %s ", lcb_strerror(NULL, resp->rc));
+            } else {
+                if (resp->njson) {
+                    fprintf(stderr, "%.*s", (int)resp->njson, resp->json);
+                }
+            }
+        }
+
+        lcb_install_callback3(instance, LCB_CALLBACK_DIAG, diag_callback);
+        lcb_CMDDIAG cmd = { 0 };
+        lcb_diag(instance, NULL, &cmd);
+        lcb_wait(instance);
+
+* [CCBC-874](https://issues.couchbase.com/browse/CCBC-874): Dynamic authenticator. Note
+  that this feature should not be considered at public interface. To use it, application
+  have to define two callbacks, which will return username and password dependending on
+  bucket name and hostname/port of the endpoint.
+
+        std::map< std::string, std::string > credentials = {
+            {"protected", "secret"}
+        };
+        extern "C" {
+          static const char *get_username(void *cookie,
+                                          const char *host,
+                                          const char *port,
+                                          const char *bucket)
+          {
+              return bucket;
+          }
+
+          static const char *get_password(void *cookie,
+                                          const char *host,
+                                          const char *port,
+                                          const char *bucket)
+          {
+              std::map< std::string, std::string > *credentials =
+                  static_cast<std::map< std::string, std::string > *>(cookie);
+              return (*credentials)[bucket].c_str();
+          }
+        }
+
+
+   and later pass these callbacks to authenticator like this:
+
+
+        lcb_AUTHENTICATOR *auth = lcbauth_new();
+        lcbauth_set_callbacks(auth, &credentials, get_username, get_password);
+        lcbauth_set_mode(auth, LCBAUTH_MODE_DYNAMIC);
+        lcb_set_auth(instance, auth);
+
+* Include platform/compiler into client id, which included into HELLO and HTTP requests.
+
+* Fix parallel build on Linux when dtrace enabled
+
+* cbc-proxy: proxy N1QL, FTS and Analytics queries using STAT command.
+
+## 2.8.3 (November 21 2017)
+
+* [CCBC-415](https://issues.couchbase.com/browse/CCBC-415): Fixes in IPv6 support.
+  To use IPv6 addresses, the application should connect to IPv6-enabled Couchbase Server,
+  and explicitly switch on option via connection string `ipv6=allow` or `ipv6=only`,
+  where first variant permits the library to use both IPv6 and IPv4, and the second --
+  disables IPv4. Alternatively this setting controlled with `LCB_CNTL_IP6POLICY` and
+  `lcb_cntl`.
+
+* [CCBC-872](https://issues.couchbase.com/browse/CCBC-872): Metrics management
+  These metrics are intended at providing information on libcouchbase operations performed
+  over the lifetime of the current `lcb_t` instance (processed request packets, processed
+  response packets, request packets pending emission, server errors, server timeouts,
+  misrouted operations, retried operations).
+
+  Metrics collection is currently disabled by default. To enable metrics collection,
+  the user should call:
+
+        int activate = 1;
+        lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_METRICS, &activate);
+
+  Access to the collected metrics is done using:
+
+        lcb_METRICS* my_metrics;
+        lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_METRICS, &my_metrics);
+
+* [CCBC-870](https://issues.couchbase.com/browse/CCBC-870): Fix updating URL on retry. When retrying HTTP request, instead of replacing just `host:port` part of the old URL, the library inserted full URL.
+
+* [CCBC-547](https://issues.couchbase.com/browse/CCBC-547): Detect dead sockets under libuv.
+
+* Ensure macros safe by surrounding values with parentheses
+
 ## 2.8.2 (October 17 2017)
 
 * [CCBC-833](https://issues.couchbase.com/browse/CCBC-833), [CCBC-834](https://issues.couchbase.com/browse/CCBC-834):
@@ -1723,7 +1989,7 @@ These changes extend existing features with enhanced APIs
 
 * [major] Add interface attributes to all API calls
   This properly documents all API calls with a certain API stability level
-  such as _committed_ (for stable APIs), _uncomitted_ for APIs which may, but
+  such as _committed_ (for stable APIs), _uncommitted_ for APIs which may, but
   are not likely to change, and _volatile_ for APIs which are likely to be
   changed or removed.
 
@@ -1917,7 +2183,8 @@ These changes extend existing features with enhanced APIs
 
     lcb_error_t rc = lcb_create(&instance, &options);
     if (rc != LCB_SUCCESS) {
-        fprintf(stderr, "Failed to create instance: %s\n", lcb_strerror(instance, rc));
+        fprintf(stderr, "Failed to create instance: %s
+", lcb_strerror(instance, rc));
     }
 
   The above snippet will configure a client to _always_ use the `CCCP` protocol
@@ -1977,7 +2244,8 @@ These changes extend existing features with enhanced APIs
         node.v.v1.index = 0; /* first node */
         lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_MEMDNODE_INFO, &node);
         if (node.v.v1.sasl_mech) {
-            printf("authenticated via SASL '%s'\n",
+            printf("authenticated via SASL '%s'
+",
                    node.v.v1.sasl_mech);
         }
 
@@ -2013,9 +2281,11 @@ These changes extend existing features with enhanced APIs
       int is_loaded;
       lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_CONFIG_CACHE_LOADED, &is_loaded);
       if (is_loaded) {
-          printf("Configuration cache saved us a trip to the config server\n");
+          printf("Configuration cache saved us a trip to the config server
+");
       } else {
-          printf("We had to contact the configuration server for some reason\n");
+          printf("We had to contact the configuration server for some reason
+");
       }
 
 * [major] CCBC-278 Use common config retry mechanism for bad
@@ -2043,7 +2313,8 @@ These changes extend existing features with enhanced APIs
       lcb_error_t user_map_error(lcb_t instance, lcb_uint16_t in)
       {
         if (in == PROTOCOL_BINARY_RESPONSE_ETMPFAIL) {
-          fprintf(stderr, "temporary failure on server\n");
+          fprintf(stderr, "temporary failure on server
+");
         }
         return default_callback(instance, in);
       }