traceview 3.0.0

data/ext/oboe_metal/src/bson/platform_hacks.h

@@ -0,0 +1,91 @@
+/* platform_hacks.h */
+/*    Copyright 2009, 2010 10gen 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.
+ */
+
+
+/* all platform-specific ifdefs should go here */
+
+#ifndef _PLATFORM_HACKS_H_
+#define _PLATFORM_HACKS_H_
+
+#ifdef __GNUC__
+#define MONGO_INLINE static __inline__
+#else
+#define MONGO_INLINE static
+#endif
+
+#ifdef __cplusplus
+#define MONGO_EXTERN_C_START extern "C" {
+#define MONGO_EXTERN_C_END }
+#else
+#define MONGO_EXTERN_C_START
+#define MONGO_EXTERN_C_END
+#endif
+
+
+#if defined(MONGO_HAVE_STDINT) || __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+#elif defined(MONGO_HAVE_UNISTD)
+#include <unistd.h>
+#elif defined(MONGO_USE__INT64)
+typedef __int64 int64_t;
+#elif defined(MONGO_USE_LONG_LONG_INT)
+typedef long long int int64_t;
+#else
+#error must have a 64bit int type
+#endif
+
+/* big endian is only used for OID generation. little is used everywhere else */
+#ifdef MONGO_BIG_ENDIAN
+#define bson_little_endian64(out, in) ( bson_swap_endian64(out, in) )
+#define bson_little_endian32(out, in) ( bson_swap_endian32(out, in) )
+#define bson_big_endian64(out, in) ( memcpy(out, in, 8) )
+#define bson_big_endian32(out, in) ( memcpy(out, in, 4) )
+#else
+#define bson_little_endian64(out, in) ( memcpy(out, in, 8) )
+#define bson_little_endian32(out, in) ( memcpy(out, in, 4) )
+#define bson_big_endian64(out, in) ( bson_swap_endian64(out, in) )
+#define bson_big_endian32(out, in) ( bson_swap_endian32(out, in) )
+#endif
+
+MONGO_EXTERN_C_START
+
+MONGO_INLINE void bson_swap_endian64(void* outp, const void* inp){
+    const char *in = (const char*)inp;
+    char *out = (char*)outp;
+
+    out[0] = in[7];
+    out[1] = in[6];
+    out[2] = in[5];
+    out[3] = in[4];
+    out[4] = in[3];
+    out[5] = in[2];
+    out[6] = in[1];
+    out[7] = in[0];
+
+}
+MONGO_INLINE void bson_swap_endian32(void* outp, const void* inp){
+    const char *in = (const char*)inp;
+    char *out = (char*)outp;
+
+    out[0] = in[3];
+    out[1] = in[2];
+    out[2] = in[1];
+    out[3] = in[0];
+}
+
+MONGO_EXTERN_C_END
+
+#endif

data/ext/oboe_metal/src/oboe.h

@@ -0,0 +1,275 @@
+#ifndef LIBOBOE_H
+#define LIBOBOE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <inttypes.h>
+#include "bson/bson.h"
+
+#define OBOE_SAMPLE_RATE_DEFAULT 300000 // 30%
+#define OBOE_SAMPLE_RESOLUTION 1000000
+
+#define OBOE_MAX_TASK_ID_LEN 20
+#define OBOE_MAX_OP_ID_LEN 8
+#define OBOE_MAX_METADATA_PACK_LEN 512
+
+#define XTR_CURRENT_VERSION 1
+#define XTR_UDP_PORT 7831
+
+
+// structs
+
+typedef struct oboe_ids {
+    uint8_t task_id[OBOE_MAX_TASK_ID_LEN];
+    uint8_t op_id[OBOE_MAX_OP_ID_LEN];
+} oboe_ids_t;
+
+typedef struct oboe_metadata {
+    oboe_ids_t  ids;
+    size_t      task_len;
+    size_t      op_len;
+} oboe_metadata_t;
+
+typedef struct oboe_event {
+    oboe_metadata_t metadata;
+    bson_buffer     bbuf;
+    char *          bb_str;
+} oboe_event_t;
+
+
+// oboe_metadata
+
+int oboe_metadata_init      (oboe_metadata_t *);
+int oboe_metadata_destroy   (oboe_metadata_t *);
+
+int oboe_metadata_is_valid   (const oboe_metadata_t *);
+
+void oboe_metadata_copy     (oboe_metadata_t *, const oboe_metadata_t *);
+
+void oboe_metadata_random   (oboe_metadata_t *);
+
+int oboe_metadata_set_lengths   (oboe_metadata_t *, size_t, size_t);
+int oboe_metadata_create_event  (const oboe_metadata_t *, oboe_event_t *);
+
+int oboe_metadata_tostr     (const oboe_metadata_t *, char *, size_t);
+int oboe_metadata_fromstr   (oboe_metadata_t *, const char *, size_t);
+
+
+// oboe_event
+
+int oboe_event_init     (oboe_event_t *, const oboe_metadata_t *);
+int oboe_event_destroy  (oboe_event_t *);
+
+int oboe_event_add_info (oboe_event_t *, const char *, const char *);
+int oboe_event_add_info_binary (oboe_event_t *, const char *, const char *, size_t);
+int oboe_event_add_info_int64 (oboe_event_t *, const char *, const int64_t);
+int oboe_event_add_info_double (oboe_event_t *, const char *, const double);
+int oboe_event_add_info_bool (oboe_event_t *, const char *, const int);
+int oboe_event_add_info_fmt (oboe_event_t *, const char *key, const char *fmt, ...);
+int oboe_event_add_info_bson (oboe_event_t *, const char *key, const bson *val);
+int oboe_event_add_edge (oboe_event_t *, const oboe_metadata_t *);
+int oboe_event_add_edge_fromstr(oboe_event_t *, const char *, size_t);
+
+
+// oboe_context
+
+oboe_metadata_t *oboe_context_get();
+void oboe_context_set(oboe_metadata_t *);
+int oboe_context_set_fromstr(const char *, size_t);
+
+void oboe_context_clear();
+
+int oboe_context_is_valid();
+
+
+// oboe_reporter
+
+typedef ssize_t (*reporter_send)(void *, const char *, size_t);
+typedef int (*reporter_destroy)(void *);
+
+typedef struct oboe_reporter {
+    void *              descriptor;
+    reporter_send       send;
+    reporter_destroy    destroy;
+} oboe_reporter_t;
+
+int oboe_reporter_udp_init  (oboe_reporter_t *, const char *, const char *);
+int oboe_reporter_file_init (oboe_reporter_t *, const char *);
+
+int oboe_reporter_send(oboe_reporter_t *, oboe_metadata_t *, oboe_event_t *);
+int oboe_reporter_destroy(oboe_reporter_t *);
+ssize_t oboe_reporter_udp_send(void *desc, const char *data, size_t len);
+
+
+// initialization
+
+void oboe_init();
+
+
+// Settings interface
+
+#define OBOE_SETTINGS_VERSION 1
+#define OBOE_SETTINGS_MAGIC_NUMBER 0x6f626f65
+#define OBOE_SETTINGS_TYPE_SKIP 0
+#define OBOE_SETTINGS_TYPE_STOP 1
+#define OBOE_SETTINGS_TYPE_DEFAULT_SAMPLE_RATE 2
+#define OBOE_SETTINGS_TYPE_LAYER_SAMPLE_RATE 3
+#define OBOE_SETTINGS_TYPE_LAYER_APP_SAMPLE_RATE 4
+#define OBOE_SETTINGS_TYPE_LAYER_HTTPHOST_SAMPLE_RATE 5
+#define OBOE_SETTINGS_TYPE_CONFIG_STRING 6
+#define OBOE_SETTINGS_TYPE_CONFIG_INT 7
+#define OBOE_SETTINGS_FLAG_OK             0x0
+#define OBOE_SETTINGS_FLAG_INVALID        0x1
+#define OBOE_SETTINGS_FLAG_OVERRIDE       0x2
+#define OBOE_SETTINGS_FLAG_SAMPLE_START   0x4
+#define OBOE_SETTINGS_FLAG_SAMPLE_THROUGH 0x8
+#define OBOE_SETTINGS_FLAG_SAMPLE_THROUGH_ALWAYS 0x10
+#define OBOE_SETTINGS_FLAG_SAMPLE_AVW_ALWAYS     0x20
+#define OBOE_SETTINGS_MAX_STRLEN 256
+
+#define OBOE_SETTINGS_UNSET -1
+#define OBOE_SETTINGS_MIN_REFRESH_INTERVAL 30
+
+// Value for "SampleSource" info key
+// where was the sample rate specified? (oboe settings, config file, hard-coded default, etc)
+#define OBOE_SAMPLE_RATE_SOURCE_FILE 1
+#define OBOE_SAMPLE_RATE_SOURCE_DEFAULT 2
+#define OBOE_SAMPLE_RATE_SOURCE_OBOE 3
+#define OBOE_SAMPLE_RATE_SOURCE_LAST_OBOE 4
+#define OBOE_SAMPLE_RATE_SOURCE_DEFAULT_MISCONFIGURED 5
+#define OBOE_SAMPLE_RATE_SOURCE_OBOE_DEFAULT 6 
+
+#define OBOE_SAMPLE_RESOLUTION 1000000
+
+// Used to convert to settings flags:
+#define OBOE_TRACE_NEVER   0
+#define OBOE_TRACE_ALWAYS  1
+#define OBOE_TRACE_THROUGH 2
+
+typedef struct {
+    volatile uint32_t magic;
+    volatile uint32_t timestamp;
+    volatile uint16_t type;
+    volatile uint16_t flags;
+    volatile uint32_t value;
+    uint32_t _pad;
+    char layer[OBOE_SETTINGS_MAX_STRLEN];
+    char arg[OBOE_SETTINGS_MAX_STRLEN];
+} __attribute__((packed)) oboe_settings_t;
+
+// Current settings configuration:
+typedef struct {
+    int tracing_mode;          // loaded from config file
+    int sample_rate;           // loaded from config file
+    int default_sample_rate;   // default sample rate (fallback)
+    oboe_settings_t *settings; // cached settings, updated by tracelyzer (init to NULL)
+    int last_auto_sample_rate; // stores last known automatic sampling rate 
+    uint16_t last_auto_flags;  // stores last known flags associated with above 
+    uint32_t last_auto_timestamp; // timestamp from last *settings lookup
+    uint32_t last_refresh;        // last refresh time
+} oboe_settings_cfg_t;
+
+oboe_settings_t* oboe_settings_get(uint16_t type, const char* layer, const char* arg);
+oboe_settings_t* oboe_settings_get_layer_tracing_mode(const char* layer);
+oboe_settings_t* oboe_settings_get_layer_sample_rate(const char* layer);
+oboe_settings_t* oboe_settings_get_layer_app_sample_rate(const char* layer, const char* app);
+uint32_t oboe_settings_get_latest_timestamp(const char* layer);
+int oboe_settings_get_value(oboe_settings_t *s, int *outval, unsigned short *outflags, uint32_t *outtimestamp);
+
+oboe_settings_cfg_t* oboe_settings_cfg_get();
+void oboe_settings_cfg_init(oboe_settings_cfg_t *cfg);
+void oboe_settings_cfg_tracing_mode_set(int new_mode);
+void oboe_settings_cfg_sample_rate_set(int new_rate);
+
+/**
+ * Check if this request should be sampled (deprecated - use oboe_sample_layer() instead).
+ *
+ * @param layer Layer name as used in oboe_settings_t.layer (may be NULL to use default settings)
+ * @param xtrace X-Trace ID string from an HTTP request or higher layer (NULL or empty string if not present).
+ * @param cfg The settings configuration to use for this evaluation.
+ * @param sample_rate_out The sample rate used to check if this request should be sampled
+ *          (output - may be zero if not used).
+ * @param sample_source_out The OBOE_SAMPLE_RATE_SOURCE used to check if this request
+ *          should be sampled (output - may be zero if not used).
+ * @return Non-zero if the given layer should be sampled.
+ */
+int oboe_sample_request(const char *layer, const char *in_xtrace, oboe_settings_cfg_t *cfg,
+                      int *sample_rate_out, int *sample_source_out);
+int oboe_rand_get_value();
+
+/**
+ * Check if this request should be sampled.
+ *
+ * Checks for sample rate flags and settings for the specified layer, considers any
+ * special features in the X-Trace and X-TV-Meta HTTP headers, and, if appropriate,
+ * rolls the virtual dice to decide if this request should be sampled.
+ *
+ * This replaces oboe_sample_request with a version that uses the settings
+ * configuration kept in thread-local storage and takes the X-TV-Meta HTTP
+ * header value in order to support AppView Web integration.
+ *
+ * @param layer Layer name as used in oboe_settings_t.layer (may be NULL to use default settings)
+ * @param xtrace X-Trace ID string from an HTTP request or higher layer (NULL or empty string if not present).
+ * @param tv_meta AppView Web ID from X-TV-Meta HTTP header or higher layer (NULL or empty string if not present).
+ * @param sample_rate_out The sample rate used to check if this request should be sampled
+ *          (output - may be zero if not used).
+ * @param sample_source_out The OBOE_SAMPLE_RATE_SOURCE used to check if this request
+ *          should be sampled (output - may be zero if not used).
+ * @return Non-zero if the given layer should be sampled.
+ */
+int oboe_sample_layer(
+    const char *layer,
+    const char *xtrace,
+    const char *tv_meta,
+    int *sample_rate_out,
+    int *sample_source_out
+);
+
+/* Oboe configuration interface. */
+
+/**
+ * Check if the Oboe library is compatible with a given version.revision.
+ *
+ * This will succeed if the library is at least as recent as specified and if no
+ * definitions have been removed since that revision.
+ *
+ * @param version The library's version number which increments every time the API changes.
+ * @param revision The revision of the current version of the library.
+ * @return Non-zero if the Oboe library is considered compatible with the specified revision.
+ */
+extern int oboe_config_check_version(int version, int revision);
+
+/**
+ * Get the Oboe library version number.
+ *
+ * This number increments whenever the API is changed.
+ *
+ * @return The library's version number or -1 if the version is not known.
+ */
+extern int oboe_config_get_version();
+
+/**
+ * Get the Oboe library revision number.
+ *
+ * This is the revision of the current version which is updated whenever
+ * compatible changes are made to the API/ABI (ie. additions).
+ *
+ * @return The library's revision number or -1 if not known.
+ */
+extern int oboe_config_get_revision();
+
+/*
+ * Get the Oboe library version as a string.
+ *
+ * Returns the complete VERSION string or null
+ */
+const char* oboe_config_get_version_string();
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // LIBOBOE_H

data/ext/oboe_metal/src/oboe.hpp

@@ -0,0 +1,352 @@
+#ifndef OBOE_HPP
+#define OBOE_HPP
+
+#include <string>
+#include <oboe.h>
+
+
+class Event;
+
+class Metadata : private oboe_metadata_t {
+    friend class UdpReporter;
+    friend class FileReporter;
+    friend class Context;
+
+public:
+    Metadata(oboe_metadata_t *md) {
+        oboe_metadata_copy(this, md);
+    }
+
+    ~Metadata() {
+        oboe_metadata_destroy(this);
+    }
+
+    static Metadata* fromString(std::string s) {
+        oboe_metadata_t md;
+        oboe_metadata_fromstr(&md, s.data(), s.size());
+        return new Metadata(&md); // copies md
+    }
+
+    // these new objects are managed by SWIG %newobject
+    Event *createEvent();
+
+    static Metadata *makeRandom() {
+        oboe_metadata_t md;
+        oboe_metadata_init(&md);
+        oboe_metadata_random(&md);
+        return new Metadata(&md); // copies md
+    }
+
+    Metadata *copy() {
+        return new Metadata(this);
+    }
+
+    bool isValid() {
+        return oboe_metadata_is_valid(this);
+    }
+
+#ifdef SWIGJAVA
+    std::string toStr() {
+#else
+    std::string toString() {
+#endif
+        char buf[OBOE_MAX_METADATA_PACK_LEN];
+
+        int rc = oboe_metadata_tostr(this, buf, sizeof(buf) - 1);
+        if (rc == 0) {
+            return std::string(buf);
+        } else {
+            return std::string(); // throw exception?
+        }
+    }
+
+};
+
+class Context {
+public:
+    /**
+     * Set the tracing mode.
+     *
+     * @param newMode One of
+     * - OBOE_TRACE_NEVER(0) to disable tracing,
+     * - OBOE_TRACE_ALWAYS(1) to start a new trace if needed, or
+     * - OBOE_TRACE_THROUGH(2) to only add to an existing trace.
+     */
+    static void setTracingMode(int newMode) {
+        oboe_settings_cfg_tracing_mode_set(newMode);
+    }
+
+    /**
+     * Set the default sample rate.
+     *
+     * This rate is used until overridden by the TraceView servers.  If not set then the
+     * value 300,000 will be used (ie. 30%).
+     *
+     * The rate is interpreted as a ratio out of OBOE_SAMPLE_RESOLUTION (currently 1,000,000).
+     *
+     * @param newRate A number between 0 (none) and OBOE_SAMPLE_RESOLUTION (a million)
+     */
+    static void setDefaultSampleRate(int newRate) {
+        oboe_settings_cfg_sample_rate_set(newRate);
+    }
+
+    /**
+     * Check if the current request should be traced based on the current settings.
+     *
+     * If xtrace is empty, or if it is identified as a foreign (ie. cross customer)
+     * trace, then sampling will be considered as a new trace.
+     * Otherwise sampling will be considered as adding to the current trace.
+     * Different layers may have special rules.  Also special rules for AppView
+     * Web synthetic traces apply if in_tv_meta is given a non-empty string.
+     *
+     * This is designed to be called once per layer per request.
+     *
+     * @param layer Name of the layer being considered for tracing
+     * @param in_xtrace Incoming X-Trace ID (NULL or empty string if not present)
+     * @param in_tv_meta AppView Web ID from X-TV-Meta HTTP header or higher layer (NULL or empty string if not present).
+     * @return Zero to not trace; otherwise return the sample rate used in the low order
+     *         bytes 0 to 2 and the sample source in the higher-order byte 3.
+     */
+    static int sampleRequest(
+        std::string layer,
+        std::string in_xtrace,
+        std::string in_tv_meta)
+    {
+        int sample_rate = 0;
+        int sample_source = 0;
+        int rc = (oboe_sample_layer(layer.c_str(), in_xtrace.c_str(), in_tv_meta.c_str(), &sample_rate, &sample_source));
+
+        return (rc == 0 ? 0 : (((sample_source & 0xFF) << 24) | (sample_rate & 0xFFFFFF)));
+    }
+
+    // returns pointer to current context (from thread-local storage)
+    static oboe_metadata_t *get() {
+        return oboe_context_get();
+    }
+
+#ifdef SWIGJAVA
+    static std::string toStr() {
+#else
+    static std::string toString() {
+#endif
+        char buf[OBOE_MAX_METADATA_PACK_LEN];
+
+        oboe_metadata_t *md = Context::get();
+        int rc = oboe_metadata_tostr(md, buf, sizeof(buf) - 1);
+        if (rc == 0) {
+            return std::string(buf);
+        } else {
+            return std::string(); // throw exception?
+        }
+    }
+
+    static void set(oboe_metadata_t *md) {
+        oboe_context_set(md);
+    }
+
+    static void fromString(std::string s) {
+        oboe_context_set_fromstr(s.data(), s.size());
+    }
+
+    // this new object is managed by SWIG %newobject
+    static Metadata *copy() {
+        return new Metadata(Context::get());
+    }
+
+    static void clear() {
+        oboe_context_clear();
+    }
+
+    static bool isValid() {
+        return oboe_context_is_valid();
+    }
+
+    static void init() {
+        oboe_init();
+    }
+
+    // these new objects are managed by SWIG %newobject
+    static Event *createEvent();
+    static Event *startTrace();
+};
+
+class Event : private oboe_event_t {
+    friend class UdpReporter;
+    friend class FileReporter;
+    friend class Context;
+    friend class Metadata;
+
+private:
+    Event() {
+        oboe_event_init(this, Context::get());
+    }
+
+    Event(const oboe_metadata_t *md, bool addEdge=true) {
+        // both methods copy metadata from md -> this
+        if (addEdge) {
+            // create_event automatically adds edge in event to md
+            oboe_metadata_create_event(md, this);
+        } else {
+            // initializes new Event with this md's task_id & new random op_id; no edges set
+            oboe_event_init(this, md);
+        }
+    }
+
+public:
+    ~Event() {
+        oboe_event_destroy(this);
+    }
+
+    // called e.g. from Python e.addInfo("Key", None) & Ruby e.addInfo("Key", nil)
+    bool addInfo(char *key, void* val) {
+        // oboe_event_add_info(evt, key, NULL) does nothing
+        (void) key;
+        (void) val;
+        return true;
+    }
+
+    bool addInfo(char *key, const std::string& val) {
+        if (memchr(val.data(), '\0', val.size())) {
+            return oboe_event_add_info_binary(this, key, val.data(), val.size()) == 0;
+        } else {
+            return oboe_event_add_info(this, key, val.data()) == 0;
+        }
+    }
+
+    bool addInfo(char *key, long val) {
+        int64_t val_ = val;
+        return oboe_event_add_info_int64(this, key, val_) == 0;
+    }
+
+    bool addInfo(char *key, double val) {
+        return oboe_event_add_info_double(this, key, val) == 0;
+    }
+
+    bool addEdge(oboe_metadata_t *md) {
+        return oboe_event_add_edge(this, md) == 0;
+    }
+
+    bool addEdgeStr(const std::string& val) {
+        return oboe_event_add_edge_fromstr(this, val.c_str(), val.size()) == 0;
+    }
+
+    Metadata* getMetadata() {
+        return new Metadata(&this->metadata);
+    }
+
+    std::string metadataString() {
+        char buf[OBOE_MAX_METADATA_PACK_LEN];
+
+        int rc = oboe_metadata_tostr(&this->metadata, buf, sizeof(buf) - 1);
+        if (rc == 0) {
+            return std::string(buf);
+        } else {
+            return std::string(); // throw exception?
+        }
+    }
+
+    static Event* startTrace(const oboe_metadata_t *md);
+
+};
+
+Event *Context::createEvent() {
+    return new Event(Context::get());
+}
+
+Event *Metadata::createEvent() {
+    return new Event(this);
+}
+
+Event *Context::startTrace() {
+    oboe_metadata_t *md = Context::get();
+    oboe_metadata_random(md);
+    return new Event();
+}
+
+Event *Event::startTrace(const oboe_metadata_t *md) {
+    return new Event(md, false);
+}
+
+class UdpReporter : private oboe_reporter_t {
+public:
+    UdpReporter(const char *addr, const char *port=NULL) {
+        if (port == NULL)
+            port = "7831";
+
+        oboe_reporter_udp_init(this, addr, port);
+    }
+
+    ~UdpReporter() {
+        oboe_reporter_destroy(this);
+    }
+
+    bool sendReport(Event *evt) {
+        return oboe_reporter_send(this, Context::get(), evt) >= 0;
+    }
+
+    bool sendReport(Event *evt, oboe_metadata_t *md) {
+        return oboe_reporter_send(this, md, evt) >= 0;
+    }
+};
+
+class FileReporter : private oboe_reporter_t {
+public:
+    FileReporter(const char *file) {
+        oboe_reporter_file_init(this, file);
+    }
+
+    ~FileReporter() {
+        oboe_reporter_destroy(this);
+    }
+
+    bool sendReport(Event *evt) {
+        return oboe_reporter_send(this, Context::get(), evt) >= 0;
+    }
+
+    bool sendReport(Event *evt, oboe_metadata_t *md) {
+        return oboe_reporter_send(this, md, evt) >= 0;
+    }
+};
+
+
+class Config {
+public:
+    /**
+     * Check if the Oboe library is compatible with a given version.revision.
+     *
+     * This will succeed if the library is at least as recent as specified and if no
+     * definitions have been removed since that revision.
+     *
+     * @param version The library's version number which increments every time the API changes.
+     * @param revision The revision of the current version of the library.
+     * @return Non-zero if the Oboe library is considered compatible with the specified revision.
+     */
+    static bool checkVersion(int version, int revision) {
+        return (oboe_config_check_version(version, revision) != 0);
+    }
+
+    /**
+     * Get the Oboe library version number.
+     *
+     * This number increments whenever an incompatible change to the API/ABI is made.
+     *
+     * @return The library's version number or -1 if the version is not known.
+     */
+    static int getVersion() {
+        return oboe_config_get_version();
+    }
+
+    /**
+     * Get the Oboe library revision number.
+     *
+     * This number increments whenever a compatible change is made to the
+     * API/ABI (ie. an addition).
+     *
+     * @return The library's revision number or -1 if not known.
+     */
+    static int getRevision() {
+        return oboe_config_get_revision();
+    }
+};
+
+#endif