mt-libcouchbase 1.4.0

data/ext/libcouchbase/cmake/libcouchbase.stp.in

@@ -0,0 +1,829 @@
+/* -*- mode: systemtap; -*-
+ *
+ *     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.
+ */
+
+/*
+ * SystemTap tapset to make it easier to trace libcouchbase
+ *
+ * All probes provided by libcouchbase can be listed using following command:
+ *
+ * stap -L 'process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("*")'
+ */
+
+
+/**
+ * Convert opcode from couchbase KV protocol to string representation
+ */
+function libcouchbase_opcode:string(opcode:long)
+{
+    if (opcode == 0x00) return "GET"
+    else if (opcode == 0x01) return "SET"
+    else if (opcode == 0x02) return "ADD"
+    else if (opcode == 0x03) return "REPLACE"
+    else if (opcode == 0x04) return "DELETE"
+    else if (opcode == 0x05) return "INCREMENT"
+    else if (opcode == 0x06) return "DECREMENT"
+    else if (opcode == 0x08) return "FLUSH"
+    else if (opcode == 0x09) return "GETQ"
+    else if (opcode == 0x0a) return "NOOP"
+    else if (opcode == 0x0b) return "VERSION"
+    else if (opcode == 0x0e) return "APPEND"
+    else if (opcode == 0x0f) return "PREPEND"
+    else if (opcode == 0x10) return "STAT"
+    else if (opcode == 0x1b) return "VERBOSITY"
+    else if (opcode == 0x1c) return "TOUCH"
+    else if (opcode == 0x1d) return "GAT"
+    else if (opcode == 0x1f) return "HELLO"
+    else if (opcode == 0x20) return "SASL_LIST_MECHS"
+    else if (opcode == 0x21) return "SASL_AUTH"
+    else if (opcode == 0x22) return "SASL_STEP"
+    else if (opcode == 0x83) return "GET_REPLICA"
+    else if (opcode == 0x89) return "SELECT_BUCKET"
+    else if (opcode == 0x91) return "OBSERVE_SEQNO"
+    else if (opcode == 0x92) return "OBSERVE"
+    else if (opcode == 0x94) return "GET_LOCKED"
+    else if (opcode == 0x95) return "UNLOCK_KEY"
+    else if (opcode == 0xb5) return "GET_CLUSTER_CONFIG"
+    else if (opcode == 0xc5) return "SUBDOC_GET"
+    else if (opcode == 0xc6) return "SUBDOC_EXISTS"
+    else if (opcode == 0xc7) return "SUBDOC_DICT_ADD"
+    else if (opcode == 0xc8) return "SUBDOC_DICT_UPSERT"
+    else if (opcode == 0xc9) return "SUBDOC_DELETE"
+    else if (opcode == 0xca) return "SUBDOC_REPLACE"
+    else if (opcode == 0xcb) return "SUBDOC_ARRAY_PUSH_LAST"
+    else if (opcode == 0xcc) return "SUBDOC_ARRAY_PUSH_FIRST"
+    else if (opcode == 0xcd) return "SUBDOC_ARRAY_INSERT"
+    else if (opcode == 0xce) return "SUBDOC_ARRAY_ADD_UNIQUE"
+    else if (opcode == 0xcf) return "SUBDOC_COUNTER"
+    else if (opcode == 0xd0) return "SUBDOC_MULTI_LOOKUP"
+    else if (opcode == 0xd1) return "SUBDOC_MULTI_MUTATION"
+    else if (opcode == 0xd2) return "SUBDOC_GET_COUNT"
+    else if (opcode == 0xfe) return "GET_ERROR_MAP"
+    else return "UNKNOWN"
+}
+
+/**
+ * Convert HTTP request type to string representation
+ */
+function libcouchbase_http_type:string(type:long)
+{
+    if (type == 0) return "VIEW"
+    else if (type == 1) return "MANAGEMENT"
+    else if (type == 2) return "RAW"
+    else if (type == 3) return "N1QL"
+    else if (type == 4) return "FTS"
+    else if (type == 5) return "CBAS"
+    else return "UNKNOWN"
+}
+
+/**
+ * Convert HTTP request method to string representation
+ */
+function libcouchbase_http_method:string(method:long)
+{
+    if (method == 0) return "GET"
+    else if (method == 1) return "POST"
+    else if (method == 2) return "PUT"
+    else if (method == 3) return "DELETE"
+    else return "UNKNOWN"
+}
+
+/**
+ * probe libcouchbase.kv.get.begin - start of GET/GETL/GAT operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @key: document id
+ * @expiration: document expiration (0 when should not expire)
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.get.begin {
+ *     printf("[%p] opcode: %s, vbucket: %d, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), vbucket, key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc get foo"
+ *   foo                  CAS=0x150268ca90610000, Flags=0x0, Size=13, Datatype=0x01(JSON)
+ *   {"foo":"bar"}
+ *   [0xf20d90] opcode: GET, vbucket: 115, key: foo
+ */
+probe libcouchbase.kv.get.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("get_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    vbucket = $arg3
+    opcode = $arg4
+    key = user_string_n($arg5, $arg6)
+    expiration = $arg7
+}
+
+/**
+ * probe libcouchbase.kv.get.end - end of GET/GETL/GAT operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ * @bytes: document body
+ * @flags: document flags
+ * @cas: document CAS
+ * @datatype: document datatype, see memcached/protocol_binary.h
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.get.end {
+ *     printf("[%p] opcode: %s, rc: %d, cas: 0x%x, key: %s, value: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), rc, cas, key, bytes)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc get foo"
+ *   foo                  CAS=0x150268ca90610000, Flags=0x0, Size=13, Datatype=0x01(JSON)
+ *   {"foo":"bar"}
+ *   [0x1b58dd0] opcode: GET, rc: 0, cas: 0x150268ca90610000, key: foo, value: {"foo":"bar"}
+ */
+probe libcouchbase.kv.get.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("get_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+    bytes = user_string_n($arg8, $arg9)
+    flags = $arg10
+    cas = $arg11
+    datatype = $arg12
+}
+
+/**
+ * probe libcouchbase.kv.arithmetic.begin - start of INCR/DECR operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @key: document id
+ * @delta: the 64 bit value to change the counter
+ * @initial: the value to use, when document is not exist
+ * @expiration: document expiration (0 when should not expire)
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.arithmetic.begin {
+ *     printf("[%p] opcode: %s, delta: %d, initial: %d, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), delta, initial, key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc incr --initial 42 --delta 3 cnt"
+ *   cnt                 Current value is 42. CAS=0x15026eea18850000
+ *   [0x117bdd0] opcode: INCREMENT, delta: 3, initial: 42, key: cnt
+ */
+probe libcouchbase.kv.arithmetic.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("arithmetic_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    vbucket = $arg3
+    opcode = $arg4
+    key = user_string_n($arg5, $arg6)
+    delta = $arg7
+    initial = $arg8
+    expiration = $arg9
+}
+
+/**
+ * probe libcouchbase.kv.arithmetic.end - end of INCR/DECR operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ * @value: current value of the counter (as 64bit number)
+ * @cas: document CAS
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.arithmetic.end {
+ *     printf("[%p] opcode: %s, rc: %d, cas: 0x%x, key: %s, value: %d\n",
+ *         lcb, libcouchbase_opcode(opcode), rc, cas, key, value)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc decr --delta 3 cnt"
+ *   cnt                 Current value is 42. CAS=0x15026f100ece0000
+ *   [0x6cf0b0] opcode: DECREMENT, rc: 0, cas: 0x15026f100ece0000, key: cnt, value: 42
+ */
+probe libcouchbase.kv.arithmetic.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("arithmetic_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+    value = $arg8
+    cas = $arg9
+}
+
+/**
+ * probe libcouchbase.kv.remove.begin - start of DELETE operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @key: document id
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.remove.begin {
+ *     printf("[%p] opcode: %s, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc rm cnt"
+ *   cnt                 Deleted. CAS=0x15026f2ec2c90000
+ *   [0x9280c0] opcode: DELETE, key: cnt
+ */
+probe libcouchbase.kv.remove.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("remove_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    vbucket = $arg3
+    opcode = $arg4
+    key = user_string_n($arg5, $arg6)
+}
+
+/**
+ * probe libcouchbase.kv.remove.end - end of DELETE operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ * @cas: document CAS
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.remove.end {
+ *     printf("[%p] opcode: %s, rc: %d, cas: 0x%x, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), rc, cas, key)
+ *   }
+
+ *
+ *   $ stap  test.stp  -c "cbc rm cnt"
+ *   cnt                 Deleted. CAS=0x15026f2ec2c90000
+ *   [0x9280c0] opcode: DELETE, rc: 0, cas: 0x15026f2ec2c90000, key: cnt
+ */
+probe libcouchbase.kv.remove.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("remove_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+    cas = $arg8
+}
+
+/**
+ * probe libcouchbase.kv.store.begin - start of SET/ADD/REPLACE/APPEND/PREPEND operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @key: document id
+ * @bytes: document body
+ * @flags: document flags
+ * @cas: document CAS
+ * @datatype: document datatype, see memcached/protocol_binary.h
+ * @expiration: document expiration (0 when should not expire)
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.store.begin {
+ *     printf("[%p] opcode: %s, key: %s, value: %s, expiration: %d\n",
+ *         lcb, libcouchbase_opcode(opcode), key, bytes, expiration)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc cp -e 30 foo"
+ *   foo                 Stored. CAS=0x15026f8450790000
+ *   [0x7e0070] opcode: SET, key: foo, value: {"foo":"bar"}, expiration: 30
+ */
+probe libcouchbase.kv.store.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("store_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    vbucket = $arg3
+    opcode = $arg4
+    key = user_string_n($arg5, $arg6)
+    bytes = user_string_n($arg7, $arg8)
+    flags = $arg9
+    cas = $arg10
+    datatype = $arg11
+    expiration = $arg12
+}
+
+/**
+ * probe libcouchbase.kv.store.end - end of SET/ADD/REPLACE/APPEND/PREPEND operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ * @cas: document CAS
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.store.end {
+ *     printf("[%p] opcode: %s, rc: %d, cas: 0x%x, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), rc, cas, key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc cp -e 30 foo"
+ *   foo                 Stored. CAS=0x15026f8450790000
+ *   [0x7e0070] opcode: SET, rc: 0, cas: 0x15026f8450790000, key: foo
+ */
+probe libcouchbase.kv.store.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("store_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+    cas = $arg8
+}
+
+/**
+ * probe libcouchbase.kv.unlock.begin - start of UNLOCK operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @key: document id
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.unlock.begin {
+ *     printf("[%p] opcode: %s, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc unlock foo 0x15028f7bafc20000"
+ *   foo                  Unlocked
+ *   [0x20d7100] opcode: UNLOCK_KEY, key: foo
+ */
+probe libcouchbase.kv.unlock.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("unlock_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    vbucket = $arg3
+    opcode = $arg4
+    key = user_string_n($arg5, $arg6)
+}
+
+/**
+ * probe libcouchbase.kv.unlock.end - end of UNLOCK operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.unlock.end {
+ *     printf("[%p] opcode: %s, rc: %d, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), rc, key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc unlock foo 0x15028f7bafc20000"
+ *   foo                  Unlocked
+ *   [0x20d7100] opcode: UNLOCK_KEY, rc: 0, key: foo
+ */
+probe libcouchbase.kv.unlock.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("unlock_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+}
+
+/**
+ * probe libcouchbase.kv.touch.begin - start of TOUCH operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @key: document id
+ * @expiration: document expiration (0 when should not expire)
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.touch.begin {
+ *     printf("[%p] opcode: %s, key: %s, expiration: %d\n",
+ *         lcb, libcouchbase_opcode(opcode), key, expiration)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc touch -e 10 foo"
+ *   foo                 Touched. CAS=0x150290b309ad0000
+ *   [0x141edb0] opcode: TOUCH, rc: 0, cas: 0x150290b309ad0000, key: foo
+ */
+probe libcouchbase.kv.touch.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("touch_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    vbucket = $arg3
+    opcode = $arg4
+    key = user_string_n($arg5, $arg6)
+    expiration = $arg7
+}
+
+/**
+ * probe libcouchbase.kv.touch.end - end of TOUCH operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ * @cas: document CAS
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.touch.end {
+ *     printf("[%p] opcode: %s, rc: %d, cas: 0x%x, key: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), rc, cas, key)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc touch -e 10 foo"
+ *   foo                 Touched. CAS=0x150290b309ad0000
+ *   [0x141edb0] opcode: TOUCH, rc: 0, cas: 0x150290b309ad0000, key: foo
+ */
+probe libcouchbase.kv.touch.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("touch_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+    cas = $arg8
+}
+
+/*
+ * probe libcouchbase.kv.observe.begin - start of OBSERVE operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @bytes: pointer to payload (as long)
+ * @nbytes: size of payload
+ *
+ * libcouchbase.observe.begin probe intended to be parsed in the handler.
+ * the bytes argument is a blob with nbytes length:
+ *
+ * +---------+---------+------------+----
+ * | 16 bits | 16 bits | nkey bytes | ...
+ * +---------+---------+------------+----
+ * | vbucket |   nkey  |    key     | ...
+ * +---------+---------+------------+----
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.observe.begin {
+ *     printf("[%p] opcode: %d, opaque: %d\n", lcb, libcouchbase_opcode(opcode), opaque)
+ *     while (nbytes > 0) {
+ *       vbucket = ntohs(user_uint16(bytes))
+ *       nbytes -= 2
+ *       bytes += 2
+ *       nkey = ntohs(user_uint16(bytes))
+ *       nbytes -= 2
+ *       bytes += 2
+ *       key = user_string_n(bytes, nkey)
+ *       nbytes -= nkey
+ *       bytes += nkey
+ *       printf("    vbucket: %d, nkey: %d, key: %s\n", vbucket, nkey, key)
+ *     }
+ *   }
+ *
+ *
+ * The following command executed on cluster with 4 nodes, and replication factor 3.
+ *
+ *   $ stap  test.stp  -c "cbc observe foo bar"
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Master] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Master] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 0
+ *      vbucket: 115, nkey: 3, key: foo
+ *      vbucket: 767, nkey: 3, key: bar
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 1
+ *      vbucket: 115, nkey: 3, key: foo
+ *      vbucket: 767, nkey: 3, key: bar
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 2
+ *      vbucket: 115, nkey: 3, key: foo
+ *      vbucket: 767, nkey: 3, key: bar
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 3
+ *      vbucket: 115, nkey: 3, key: foo
+ *      vbucket: 767, nkey: 3, key: bar
+ */
+probe libcouchbase.kv.observe.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("observe_begin")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg4
+    bytes = $arg5
+    nbytes = $arg6
+}
+
+/**
+ * probe libcouchbase.kv.observe.progress - intermediate response of OBSERVE operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @vbucket: number of partition
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ * @key: document id
+ * @status: observe status: FOUND = 0x00, PERSISTED = 0x01, NOT_FOUND = 0x80
+ * @master: whether response from master node (zero if from replica)
+ * @ttp: time to persist
+ * @ttr: time to replicate
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.observe.progress {
+ *     printf("[%p] opcode: %s, opaque: %d, rc: %d, key: %s, status: %d, master: %s\n",
+ *         lcb, libcouchbase_opcode(opcode), opaque, rc, key, status, master ? "true" : "false")
+ *   }
+ *
+ *
+ * The following command executed on cluster with 4 nodes, and replication factor 3.
+ *
+ *   $ stap  test.stp  -c "cbc observe foo bar"
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Master] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Master] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 0, rc: 0, key: foo, status: 1, master: false
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 0, rc: 0, key: bar, status: 1, master: false
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 3, rc: 0, key: foo, status: 1, master: false
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 3, rc: 0, key: bar, status: 1, master: true
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 1, rc: 0, key: foo, status: 1, master: false
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 1, rc: 0, key: bar, status: 1, master: false
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 2, rc: 0, key: foo, status: 1, master: true
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 2, rc: 0, key: bar, status: 1, master: false
+ */
+probe libcouchbase.kv.observe.progress =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("observe_progress")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+    key = user_string_n($arg6, $arg7)
+    cas = $arg8
+    status = $arg9
+    master = $arg10
+    ttp = $arg11
+    ttr = $arg12
+}
+
+/**
+ * probe libcouchbase.kv.observe.end - end of OBSERVE operation
+ *
+ * @lcb: client instance
+ * @opaque: unique number for this request (visible on network, returned by server back)
+ * @opcode: opcode, see memcached/protocol_binary.h
+ * @latency_ns: time from schedule to dispatch of the command
+ * @rc: return code from the library see libcouchbase/error.h
+ *
+ * Example:
+ *
+ *   probe libcouchbase.kv.observe.end {
+ *     printf("[%p] opcode: %s, opaque, rc: %d\n",
+ *         lcb, libcouchbase_opcode(opcode), opaque, rc)
+ *   }
+ *
+ *
+ * The following command executed on cluster with 4 nodes, and replication factor 3.
+ *
+ *   $ stap  test.stp  -c "cbc observe foo bar"
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Master] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Replica] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   foo                  [Master] Status=0x1, CAS=0x1502952004ed0000
+ *   bar                  [Replica] Status=0x1, CAS=0x1502951fe0040000
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 0, rc: 0
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 3, rc: 0
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 1, rc: 0
+ *   [0xb33dc0] opcode: OBSERVE, opaque: 2, rc: 0
+ */
+probe libcouchbase.kv.observe.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("observe_end")
+{
+    lcb = $arg1
+    opaque = $arg2
+    opcode = $arg3
+    latency_ns = $arg4
+    rc = $arg5
+}
+
+/**
+ * probe libcouchbase.http.begin - start of HTTP request
+ *
+ * @lcb: client instance
+ * @req: pointer to request
+ * @type: type of request, see enum lcb_http_type_t in libcouchbase/couchbase.h
+ * @method: HTTP method of request, see enum lcb_http_method_t in libcouchbase/couchbase.h
+ * @url: request URL (including schema, host and port)
+ * @host: target hostname
+ * @port: target port
+ *
+ * Example:
+ *
+ *   probe libcouchbase.http.begin {
+ *     printf("[%p] req: %p, type: %s, url: %s, host: %s, port: %s\n",
+ *         lcb, req, libcouchbase_http_type(type), url, host, port)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc n1ql 'select 1'"
+ *   ---> Encoded query: {"statement":"select 1"}
+ *
+ *   {"$1":1},
+ *   ---> Query response finished
+ *   {
+ *   "requestID": "c36facda-b37e-43b5-a958-7f31afb8468f",
+ *   "signature": {"$1":"number"},
+ *   "results": [
+ *   ],
+ *   "status": "success",
+ *   "metrics": {"elapsedTime": "380.883µs","executionTime": "360.955µs","resultCount": 1,"resultSize": 8}
+ *   }
+ *
+ *   [0x1af6de0] req: 0x1b12250, type: N1QL, url: http://192.168.1.104:8093/query/service, host: 192.168.1.104, port: 8093
+ */
+probe libcouchbase.http.begin =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("http_begin")
+{
+    lcb = $arg1
+    req = $arg2
+    type = $arg3
+    method = $arg4
+    url = user_string($arg5)
+    host = user_string($arg6)
+    port = user_string($arg7)
+}
+
+/**
+ * probe libcouchbase.http.end - start of HTTP request
+ *
+ * @lcb: client instance
+ * @req: pointer to request
+ * @type: type of request, see enum lcb_http_type_t in libcouchbase/couchbase.h
+ * @method: HTTP method of request, see enum lcb_http_method_t in libcouchbase/couchbase.h
+ * @url: request URL (including schema, host and port)
+ * @host: target hostname
+ * @port: target port
+ * @rc: return code from the library see libcouchbase/error.h
+ * @status: HTTP status code (number)
+ * @latency_ns: time from schedule to dispatch of the request
+ *
+ * Example:
+ *
+ *   probe libcouchbase.http.end {
+ *     printf("[%p] req: %p, type: %s, url: %s, host: %s, port: %s, rc: %d, status: %d\n",
+ *         lcb, req, libcouchbase_http_type(type), url, host, port, rc, status)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc n1ql 'select 1'"
+ *   ---> Encoded query: {"statement":"select 1"}
+ *
+ *   {"$1":1},
+ *   ---> Query response finished
+ *   {
+ *   "requestID": "c36facda-b37e-43b5-a958-7f31afb8468f",
+ *   "signature": {"$1":"number"},
+ *   "results": [
+ *   ],
+ *   "status": "success",
+ *   "metrics": {"elapsedTime": "380.883µs","executionTime": "360.955µs","resultCount": 1,"resultSize": 8}
+ *   }
+ *
+ *   [0x1af6de0] req: 0x1b12250, type: N1QL, url: http://192.168.1.104:8093/query/service, host: 192.168.1.104, port: 8093, rc: 0, status: 200
+ */
+probe libcouchbase.http.end =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("http_end")
+{
+    lcb = $arg1
+    req = $arg2
+    type = $arg3
+    method = $arg4
+    url = user_string($arg5)
+    host = user_string($arg6)
+    port = user_string($arg7)
+    rc = $arg8
+    status = $arg9
+    latency_us = $arg10
+}
+
+/**
+ * probe libcouchbase.config.new - new configuration applied to the lcb_t instance
+ *
+ * @lcb: client instance
+ * @revid: configuration revision
+ * @bucket_name: name of the bucket
+ * @bucket_uuid: UUID of the bucket
+ *
+ * Example:
+ *
+ *   probe libcouchbase.config.new {
+ *     printf("[%p] NEW CONFIG revid: %d, bucket: %s, uuid: %s\n",
+ *         lcb, revid, bucket_name, bucket_uuid)
+ *   }
+ *
+ *
+ *   $ stap  test.stp  -c "cbc hash foo"
+ *   foo: [vBucket=115, Index=0] Server: 127.0.0.1:11210, CouchAPI: http://127.0.0.1:8092/default
+ *   Replica #0: Index=-1, Host=N/A
+ *   [0xd2e790] NEW CONFIG revid: 14, bucket: default, uuid: 44bb7edf04fd3aa86d00a644b2794eea
+ */
+probe libcouchbase.config.new =
+    process("${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libcouchbase.so.${LCB_SONAME_FULL}").mark("new_config")
+{
+    lcb = $arg1
+    revid = $arg2
+    bucket_name = user_string($arg3)
+    bucket_uuid = user_string($arg4)
+}