oboe 2.1.3 → 2.1.4

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

@@ -1,16 +1,9 @@
-// Copyright (c) 2012 by Tracelytics, Inc.
-// All rights reserved.
-
 #ifndef OBOE_HPP
 #define OBOE_HPP
 
 #include <string>
-#include <oboe/oboe.h>
+#include <oboe.h>
 
-// oboe prefix added in liboboe 1.0
-#ifndef MAX_METADATA_PACK_LEN
-#define MAX_METADATA_PACK_LEN OBOE_MAX_METADATA_PACK_LEN
-#endif
 
 class Event;
 
@@ -57,7 +50,7 @@ public:
 #else
     std::string toString() {
 #endif
-        char buf[MAX_METADATA_PACK_LEN];
+        char buf[OBOE_MAX_METADATA_PACK_LEN];
 
         int rc = oboe_metadata_tostr(this, buf, sizeof(buf) - 1);
         if (rc == 0) {
@@ -71,6 +64,55 @@ public:
 
 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 sampled based on settings.
+     *
+     *  If in_xtrace is empty, 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.
+     *
+     *  If a valid X-TV-Meta identifier is provided and AppView Web sample
+     *  always is enabled then return true independent of the other conditions.
+     *
+     *  @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 True if we should trace; otherwise false.
+     */
+    static bool sampleRequest(
+        std::string layer,
+        std::string in_xtrace,
+        std::string in_tv_meta)
+    {
+        return (oboe_sample_layer(layer.c_str(), in_xtrace.c_str(), in_tv_meta.c_str(), NULL, NULL));
+    }
+
     // returns pointer to current context (from thread-local storage)
     static oboe_metadata_t *get() {
         return oboe_context_get();
@@ -81,7 +123,7 @@ public:
 #else
     static std::string toString() {
 #endif
-        char buf[MAX_METADATA_PACK_LEN];
+        char buf[OBOE_MAX_METADATA_PACK_LEN];
 
         oboe_metadata_t *md = Context::get();
         int rc = oboe_metadata_tostr(md, buf, sizeof(buf) - 1);
@@ -152,6 +194,8 @@ public:
     // 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;
     }
 
@@ -176,12 +220,16 @@ public:
         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[MAX_METADATA_PACK_LEN];
+        char buf[OBOE_MAX_METADATA_PACK_LEN];
 
         int rc = oboe_metadata_tostr(&this->metadata, buf, sizeof(buf) - 1);
         if (rc == 0) {
@@ -253,4 +301,46 @@ public:
         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

data/ext/oboe_metal/src/oboe_wrap.cxx

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 2.0.8
+ * Version 2.0.4
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -1552,7 +1552,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
         downcast methods. */
       if (obj != Qnil) {
         VALUE value = rb_iv_get(obj, "@__swigtype__");
-        const char* type_name = RSTRING_PTR(value);
+        char* type_name = RSTRING_PTR(value);
 				
         if (strcmp(type->name, type_name) == 0) {
           return obj;
@@ -1813,15 +1813,16 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 
 /* -------- TYPES TABLE (BEGIN) -------- */
 
-#define SWIGTYPE_p_Context swig_types[0]
-#define SWIGTYPE_p_Event swig_types[1]
-#define SWIGTYPE_p_FileReporter swig_types[2]
-#define SWIGTYPE_p_Metadata swig_types[3]
-#define SWIGTYPE_p_UdpReporter swig_types[4]
-#define SWIGTYPE_p_char swig_types[5]
-#define SWIGTYPE_p_oboe_metadata_t swig_types[6]
-static swig_type_info *swig_types[8];
-static swig_module_info swig_module = {swig_types, 7, 0, 0, 0, 0};
+#define SWIGTYPE_p_Config swig_types[0]
+#define SWIGTYPE_p_Context swig_types[1]
+#define SWIGTYPE_p_Event swig_types[2]
+#define SWIGTYPE_p_FileReporter swig_types[3]
+#define SWIGTYPE_p_Metadata swig_types[4]
+#define SWIGTYPE_p_UdpReporter swig_types[5]
+#define SWIGTYPE_p_char swig_types[6]
+#define SWIGTYPE_p_oboe_metadata_t swig_types[7]
+static swig_type_info *swig_types[9];
+static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1836,7 +1837,7 @@ static VALUE mOboe_metal;
 #define SWIG_RUBY_THREAD_END_BLOCK
 
 
-#define SWIGVERSION 0x020008 
+#define SWIGVERSION 0x020004 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -1966,7 +1967,14 @@ SWIG_From_std_string  (const std::string& s)
 }
 
 
-
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
 
 
 SWIGINTERN VALUE
@@ -1976,7 +1984,7 @@ SWIG_ruby_failed(void)
 } 
 
 
-/*@SWIG:/usr/local/share/swig/2.0.8/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2005,7 +2013,26 @@ SWIG_AsVal_long (VALUE obj, long* val)
 }
 
 
-/*@SWIG:/usr/local/share/swig/2.0.8/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+
+
+
+/*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2033,7 +2060,17 @@ SWIG_AsVal_double (VALUE obj, double *val)
   return SWIG_TypeError;
 }
 
-static swig_class SwigClassMetadata;
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+swig_class SwigClassMetadata;
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
@@ -2099,7 +2136,7 @@ _wrap_Metadata_fromString(int argc, VALUE *argv, VALUE self) {
     if (SWIG_IsNewObj(res)) delete ptr;
   }
   result = (Metadata *)Metadata::fromString(arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Metadata, 0 |  0 );
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Metadata, SWIG_POINTER_OWN |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -2218,7 +2255,95 @@ fail:
 }
 
 
-static swig_class SwigClassContext;
+swig_class SwigClassContext;
+
+SWIGINTERN VALUE
+_wrap_Context_setTracingMode(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Context::setTracingMode", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  Context::setTracingMode(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Context_setDefaultSampleRate(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Context::setDefaultSampleRate", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  Context::setDefaultSampleRate(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Context_sampleRequest(int argc, VALUE *argv, VALUE self) {
+  std::string arg1 ;
+  std::string arg2 ;
+  std::string arg3 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","Context::sampleRequest", 1, argv[0] )); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","Context::sampleRequest", 2, argv[1] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[2], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","Context::sampleRequest", 3, argv[2] )); 
+    }
+    arg3 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (bool)Context::sampleRequest(arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
 
 SWIGINTERN VALUE
 _wrap_Context_get(int argc, VALUE *argv, VALUE self) {
@@ -2421,7 +2546,7 @@ free_Context(Context *arg1) {
     delete arg1;
 }
 
-static swig_class SwigClassEvent;
+swig_class SwigClassEvent;
 
 SWIGINTERN void
 free_Event(Event *arg1) {
@@ -2733,6 +2858,45 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Event_addEdgeStr(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  std::string *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Event, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Event *","addEdgeStr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Event * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","addEdgeStr", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","addEdgeStr", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  result = (bool)(arg1)->addEdgeStr((std::string const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return vresult;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Event_getMetadata(int argc, VALUE *argv, VALUE self) {
   Event *arg1 = (Event *) 0 ;
@@ -2798,14 +2962,14 @@ _wrap_Event_startTrace(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = reinterpret_cast< oboe_metadata_t * >(argp1);
   result = (Event *)Event::startTrace((oboe_metadata_t const *)arg1);
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, 0 |  0 );
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
   return vresult;
 fail:
   return Qnil;
 }
 
 
-static swig_class SwigClassUdpReporter;
+swig_class SwigClassUdpReporter;
 
 SWIGINTERN VALUE
 _wrap_new_UdpReporter__SWIG_0(int argc, VALUE *argv, VALUE self) {
@@ -3058,7 +3222,7 @@ fail:
 }
 
 
-static swig_class SwigClassFileReporter;
+swig_class SwigClassFileReporter;
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
@@ -3234,12 +3398,116 @@ fail:
 }
 
 
+swig_class SwigClassConfig;
+
+SWIGINTERN VALUE
+_wrap_Config_checkVersion(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int arg2 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Config::checkVersion", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Config::checkVersion", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  result = (bool)Config::checkVersion(arg1,arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Config_getVersion(int argc, VALUE *argv, VALUE self) {
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (int)Config::getVersion();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Config_getRevision(int argc, VALUE *argv, VALUE self) {
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (int)Config::getRevision();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_Config_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_Config_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Config);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_Config(int argc, VALUE *argv, VALUE self) {
+  Config *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (Config *)new Config();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_Config(Config *arg1) {
+    delete arg1;
+}
+
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
 static void *_p_MetadataTo_p_oboe_metadata_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((oboe_metadata_t *)  ((Metadata *) x));
 }
+static swig_type_info _swigt__p_Config = {"_p_Config", "Config *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Context = {"_p_Context", "Context *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Event = {"_p_Event", "Event *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_FileReporter = {"_p_FileReporter", "FileReporter *", 0, 0, (void*)0, 0};
@@ -3249,6 +3517,7 @@ static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_oboe_metadata_t = {"_p_oboe_metadata_t", "oboe_metadata_t *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_Config,
   &_swigt__p_Context,
   &_swigt__p_Event,
   &_swigt__p_FileReporter,
@@ -3258,6 +3527,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_oboe_metadata_t,
 };
 
+static swig_cast_info _swigc__p_Config[] = {  {&_swigt__p_Config, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Context[] = {  {&_swigt__p_Context, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Event[] = {  {&_swigt__p_Event, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_FileReporter[] = {  {&_swigt__p_FileReporter, 0, 0, 0},{0, 0, 0, 0}};
@@ -3267,6 +3537,7 @@ static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0,
 static swig_cast_info _swigc__p_oboe_metadata_t[] = {  {&_swigt__p_Metadata, _p_MetadataTo_p_oboe_metadata_t, 0, 0},  {&_swigt__p_oboe_metadata_t, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_Config,
   _swigc__p_Context,
   _swigc__p_Event,
   _swigc__p_FileReporter,
@@ -3337,7 +3608,8 @@ SWIG_InitializeModule(void *clientdata) {
   size_t i;
   swig_module_info *module_head, *iter;
   int found, init;
-  (void *)clientdata;
+
+  clientdata = clientdata;
 
   /* check to see if the circular list has been setup, if not, set it up */
   if (swig_module.next==0) {
@@ -3552,6 +3824,9 @@ SWIGEXPORT void Init_oboe_metal(void) {
   SWIG_TypeClientData(SWIGTYPE_p_Context, (void *) &SwigClassContext);
   rb_define_alloc_func(SwigClassContext.klass, _wrap_Context_allocate);
   rb_define_method(SwigClassContext.klass, "initialize", VALUEFUNC(_wrap_new_Context), -1);
+  rb_define_singleton_method(SwigClassContext.klass, "setTracingMode", VALUEFUNC(_wrap_Context_setTracingMode), -1);
+  rb_define_singleton_method(SwigClassContext.klass, "setDefaultSampleRate", VALUEFUNC(_wrap_Context_setDefaultSampleRate), -1);
+  rb_define_singleton_method(SwigClassContext.klass, "sampleRequest", VALUEFUNC(_wrap_Context_sampleRequest), -1);
   rb_define_singleton_method(SwigClassContext.klass, "get", VALUEFUNC(_wrap_Context_get), -1);
   rb_define_singleton_method(SwigClassContext.klass, "toString", VALUEFUNC(_wrap_Context_toString), -1);
   rb_define_singleton_method(SwigClassContext.klass, "set", VALUEFUNC(_wrap_Context_set), -1);
@@ -3571,6 +3846,7 @@ SWIGEXPORT void Init_oboe_metal(void) {
   rb_undef_alloc_func(SwigClassEvent.klass);
   rb_define_method(SwigClassEvent.klass, "addInfo", VALUEFUNC(_wrap_Event_addInfo), -1);
   rb_define_method(SwigClassEvent.klass, "addEdge", VALUEFUNC(_wrap_Event_addEdge), -1);
+  rb_define_method(SwigClassEvent.klass, "addEdgeStr", VALUEFUNC(_wrap_Event_addEdgeStr), -1);
   rb_define_method(SwigClassEvent.klass, "getMetadata", VALUEFUNC(_wrap_Event_getMetadata), -1);
   rb_define_method(SwigClassEvent.klass, "metadataString", VALUEFUNC(_wrap_Event_metadataString), -1);
   rb_define_singleton_method(SwigClassEvent.klass, "startTrace", VALUEFUNC(_wrap_Event_startTrace), -1);
@@ -3595,5 +3871,16 @@ SWIGEXPORT void Init_oboe_metal(void) {
   SwigClassFileReporter.mark = 0;
   SwigClassFileReporter.destroy = (void (*)(void *)) free_FileReporter;
   SwigClassFileReporter.trackObjects = 0;
+  
+  SwigClassConfig.klass = rb_define_class_under(mOboe_metal, "Config", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_Config, (void *) &SwigClassConfig);
+  rb_define_alloc_func(SwigClassConfig.klass, _wrap_Config_allocate);
+  rb_define_method(SwigClassConfig.klass, "initialize", VALUEFUNC(_wrap_new_Config), -1);
+  rb_define_singleton_method(SwigClassConfig.klass, "checkVersion", VALUEFUNC(_wrap_Config_checkVersion), -1);
+  rb_define_singleton_method(SwigClassConfig.klass, "getVersion", VALUEFUNC(_wrap_Config_getVersion), -1);
+  rb_define_singleton_method(SwigClassConfig.klass, "getRevision", VALUEFUNC(_wrap_Config_getRevision), -1);
+  SwigClassConfig.mark = 0;
+  SwigClassConfig.destroy = (void (*)(void *)) free_Config;
+  SwigClassConfig.trackObjects = 0;
 }