appoptics_apm 4.11.2 → 4.13.0

data/ext/oboe_metal/src/oboe_api.hpp

@@ -0,0 +1,431 @@
+/**
+ * @file oboe_api.hpp - C++ liboboe wrapper primarily for generating SWIG interfaces
+ * and used by Ruby c++ extension for profiling
+ *
+ * TODO:  This doc is outdated
+ * This API should follow https://github.com/tracelytics/tracelons/wiki/Instrumentation-API
+ */
+
+#ifndef OBOE_API_HPP
+#define OBOE_API_HPP
+
+#include <unistd.h>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "oboe.h"
+
+class Event;
+class Reporter;
+class Context;
+
+// exclude some stuff that unnecessarily bloats the swig interface
+#ifndef SWIG
+// FrameData is for profiling and only used via Ruby directly compiled c++ code
+typedef struct frame_data {
+    std::string klass;
+    std::string method;
+    std::string file;
+    int lineno = 0;
+} FrameData;
+#endif  // SWIG exclusion
+
+/**
+ * Metadata is the X-Trace identifier and the information needed to work with it.
+ */
+class Metadata : private oboe_metadata_t {
+    friend class Reporter;
+    friend class Context;
+
+   public:
+    Metadata(const oboe_metadata_t *md);
+    ~Metadata();
+
+    // these new objects are managed by SWIG %newobject
+    /**
+     * Create a new event object using this Metadata's context.
+     *
+     * NOTE: The returned object must be "delete"d.
+     */
+    Event *createEvent();
+
+    Metadata *copy();
+    bool isValid();
+    bool isSampled();
+
+    static Metadata *makeRandom(bool sampled = true);
+    static Metadata *fromString(std::string s);
+
+    oboe_metadata_t *metadata();
+
+#ifdef SWIGJAVA
+    std::string toStr();
+#else
+    std::string toString();
+#endif
+};
+
+/**
+ * The Context class manages the metadata and the settings configuration.
+ *
+ * The metadata includes the X-Trace identifier fields and the information work working with it.
+ * The metadata is needed before any trace messages can be sent and must either be generated for
+ * new traces or derived from the X-Trace header of an existing trace.
+ *
+ * The settings information is used primarily to determine when a new request should be traced.
+ * The information begins with configuration values for tracing_mode and sample_rate and then
+ * updates are received periodically from the collector to adjust the rate at which traces
+ * are generated.
+ */
+class Context {
+   public:
+    /**
+     * Set the tracing mode.
+     *
+     * @param newMode One of
+     * - OBOE_TRACE_DISABLED(0) to disable tracing,
+     * - OBOE_TRACE_ENABLED(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);
+
+    /**
+     * Set the default sample rate.
+     *
+     * This rate is used until overridden by the AppOptics servers.  If not set then the
+     * value comes from settings records downloaded from AppOptics.
+     *
+     * 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);
+
+    /**
+     * Ask the collector for the final tracing decisions
+     *
+     * call once per request
+     *
+     * when compiled via SWIG this function takes 0-8 input argss and returns 9 output args
+     *
+     * inputs (0-8, all optional):
+     * @param in_xtrace, a valid xtrace string
+     * @param custom_sample_rate, 0-1000000
+     * @param custom_tracing_mode, 0(disabled) or 1(enabled)
+     * @param request_type, 0 normal sampling, 1 trigger trace
+     * @param custom_custom_trigger_mode, 0(disabled) or 1(enabled)
+     * @param header_options, the string from the X-Trace-Options header
+     * @param header_signature, the string from the X-Trace-Options-Signature header
+     * @param header_timestamp, the timestamp inside the X-Trace-Options header
+     *
+     * returns:
+     * @param do_metrics, ignore when using SWIG, it will be mapped to the first return value
+     * @param do_sample, ignore when using SWIG, it will be mapped to the second return value
+     * @param sample_rate, ignore when using SWIG, it will be mapped to the third return value
+     * @param sample_source, ignore when using SWIG, it will be mapped to the forth return value
+     * @param type, 0 normal sampling, 1 - trigger trace
+     * @param auth, 0 success, 1 failure, -1 not requested
+     * @param status_msg, message describing the trigger tracing decision
+     * @param auth_msg, message describing the success/failure of the authorization
+     *
+     * @status one of the OBOE_TRACING_DECISION_* codes
+     */
+
+    static void getDecisions(
+        // output
+        int *do_metrics,
+        int *do_sample,
+        int *sample_rate,
+        int *sample_source,
+        double *bucket_rate,
+        double *bucket_cap,
+        int *type,
+        int *auth,
+        std::string *status_msg,
+        std::string *auth_msg,
+        int *status,
+        // input
+        const char *in_xtrace = NULL,
+        int custom_tracing_mode = OBOE_SETTINGS_UNSET,
+        int custom_sample_rate = OBOE_SETTINGS_UNSET,
+        int request_type = 0,
+        int custom_trigger_mode = 0,
+        const char *header_options = NULL,
+        const char *header_signature = NULL,
+        long header_timestamp = 0);
+
+    /**
+     * Get a pointer to the current context (from thread-local storage)
+     */
+    static oboe_metadata_t *get();
+
+    /**
+     * Get the current context as a printable string.
+     */
+#ifdef SWIGJAVA
+    static std::string toStr();
+#else
+    static std::string toString();
+#endif
+
+    /**
+     * Set the current context (this updates thread-local storage).
+     */
+    static void set(oboe_metadata_t *md);
+
+    /**
+     * Set the current context from a string.
+     */
+    static void fromString(std::string s);
+
+    // this new object is managed by SWIG %newobject
+    static Metadata *copy();
+
+    static void setSampledFlag();
+
+    static void clear();
+
+    static bool isValid();
+
+    static bool isSampled();
+
+    /**
+     * Perform validation and replacement of invalid characters on the given service key.
+     */
+    static std::string validateTransformServiceName(std::string service_key);
+
+    /**
+     * Shut down the Oboe library.
+     *
+     * This releases any resources held by the library which may include terminating
+     * child threads.
+     */
+    static void shutdown();
+
+    /**
+     * check if oboe is ready for tracing
+     *
+     * @param timeout an optional timeout (in milli seconds) to block this function until ready
+     * @return one of the return codes (see oboe.h):
+     * - OBOE_SERVER_RESPONSE_UNKNOWN
+     * - OBOE_SERVER_RESPONSE_OK
+     * - OBOE_SERVER_RESPONSE_TRY_LATER
+     * - OBOE_SERVER_RESPONSE_LIMIT_EXCEEDED
+     * - OBOE_SERVER_RESPONSE_INVALID_API_KEY
+     * - OBOE_SERVER_RESPONSE_CONNECT_ERROR
+     */
+    static int isReady(unsigned int timeout);
+
+    /**
+     * check if oboe is running in a AWS Lambda environment
+     */
+    static bool isLambda();
+
+    // these new objects are managed by SWIG %newobject
+    /**
+     * Create a new event object using the thread's context.
+     *
+     * NOTE: The returned object must be "delete"d.
+     */
+    static Event *createEvent();
+    static Event *startTrace();
+};
+
+class Event : private oboe_event_t {
+    friend class Reporter;
+    friend class Context;
+    friend class Metadata;
+
+   private:
+    Event();
+    Event(const oboe_metadata_t *md, bool addEdge = true);
+
+   public:
+    ~Event();
+
+    // called e.g. from Python e.addInfo("Key", None) & Ruby e.addInfo("Key", nil)
+    bool addInfo(char *key, void *val);
+    bool addInfo(char *key, const std::string &val);
+    bool addInfo(char *key, long val);
+    bool addInfo(char *key, double val);
+    bool addInfo(char *key, bool val);
+    bool addInfo(char *key, const long *vals, int num);
+
+#ifndef SWIG  // for profiling only used by Ruby gem cpp-code
+    bool addInfo(char *key, const std::vector<FrameData> &vals);
+#endif
+
+    bool addEdge(oboe_metadata_t *md);
+    bool addEdgeStr(const std::string &val);
+    bool addContextOpId(const oboe_metadata_t *md);
+
+    bool addHostname();
+
+    /**
+     * Get a new copy of this metadata.
+     *
+     * NOTE: The returned object must be "delete"d.
+     */
+    Metadata *getMetadata();
+    std::string metadataString();
+    std::string opIdString();
+
+    /**
+     * Report this event.
+     *
+     * This sends the event using the default reporter.
+     *
+     * @return True on success; otherwise an error message is logged.
+     */
+    bool send();
+
+    /**
+     * Report a profiling event
+     *
+     * This sends the event using the dafault reporter
+     * It doesn't add a timestamp
+     * The timestamp needs to be precise for profiling and therefor
+     * needs to be added by the agent when the snapshot is taken
+     */
+    bool sendProfiling();
+
+    bool addSpanRef(const oboe_metadata_t *md);
+    bool addProfileEdge(std::string id);
+
+    /**
+      * Create a new event object using the given metadata context.
+      *
+      * NOTE: The metadata context must be unique to the new trace.
+      *
+      * NOTE: The returned object must be "delete"d.
+      *
+      * @param md The metadata object to use when creating the new event.
+      */
+    static Event *startTrace(const oboe_metadata_t *md);
+};
+
+class Span {
+   public:
+   /**
+    * these functions return the final transaction name
+    * to be used in the exit event of the trace
+    */
+    static std::string createSpan(const char *transaction, const char *domain, const int64_t duration, const int has_error, const char *service_name = NULL);
+
+    static std::string createHttpSpan(const char *transaction, const char *url, const char *domain, const int64_t duration,
+                                      const int status, const char *method, const int has_error, const char *service_name = NULL);
+};
+
+class MetricTags {
+    friend class CustomMetrics;
+
+   public:
+    MetricTags(size_t count);
+    ~MetricTags();
+    bool add(size_t index, const char *k, const char *v);
+    /**
+     * Get oboe_metric_tag_t function
+     * Please note that SWIG doesn't have the definition of
+     * oboe_metric_tag_t.
+     * Ruby and Python should not call this method
+     * @return oboe_metric_tag_t*
+     */
+    oboe_metric_tag_t *get() const;
+   private:
+    oboe_metric_tag_t *tags;
+    size_t size;
+};
+
+class CustomMetrics {
+   public:
+    static int summary(const char *name, const double value, const int count, const int host_tag,
+                       const char *service_name, const MetricTags *tags, size_t tags_count);
+
+    static int increment(const char *name, const int count, const int host_tag,
+                         const char *service_name, const MetricTags *tags, size_t tags_count);
+};
+
+#ifndef SWIG  // for profiling only used by Ruby gem c++-code
+class OboeProfiling {
+    public:
+     static int get_interval();
+};
+#endif
+
+class Reporter : private oboe_reporter_t {
+    friend class Context;  // Access to the private oboe_reporter_t base structure.
+   public:
+    int init_status;
+
+    /**
+      * Initialize a reporter structure.
+      *
+      * See the wrapped Context::init for more details.
+      *
+      * @params  these correspond to the keys of the oboe_init_options struct
+      */
+    Reporter(
+        std::string hostname_alias,  // optional hostname alias
+        int log_level,               // level at which log messages will be written to log file (0-6)
+        std::string log_file_path,   // file name including path for log file
+
+        int max_transactions,        // maximum number of transaction names to track
+        int max_flush_wait_time,     // maximum wait time for flushing data before terminating in milli seconds
+        int events_flush_interval,   // events flush timeout in seconds (threshold for batching messages before sending off)
+        int max_request_size_bytes,  // events flush batch size in KB (threshold for batching messages before sending off)
+
+        std::string reporter,      // the reporter to be used ("ssl", "upd", "file", "null")
+        std::string host,          // collector endpoint (reporter=ssl), udp address (reporter=udp), or file path (reporter=file)
+        std::string service_key,   // the service key (also known as access_key)
+        std::string trusted_path,  // path to the SSL certificate (only for ssl)
+
+        int buffer_size,                // size of the message buffer
+        int trace_metrics,              // flag indicating if trace metrics reporting should be enabled (default) or disabled
+        int histogram_precision,        // the histogram precision (only for ssl)
+        double token_bucket_capacity,   // custom token bucket capacity
+        double token_bucket_rate,       // custom token bucket rate
+        int file_single,                // use single files in file reporter for each event
+
+        int ec2_metadata_timeout,       // the timeout (milli seconds) for retrieving EC2 metadata
+        std::string grpc_proxy,         // HTTP proxy address and port to be used for the gRPC connection
+        int stdout_clear_nonblocking,   // flag indicating if the O_NONBLOCK flag on stdout should be cleared,
+                                        // only used in lambda reporter (off=0, on=1, default off)
+        int is_grpc_clean_hack_enabled  // flag indicating if custom grpc clean hack enabled (default 0)
+    );
+
+    ~Reporter();
+
+    bool sendReport(Event *evt);
+    bool sendReport(Event *evt, oboe_metadata_t *md);
+    bool sendStatus(Event *evt);
+    bool sendStatus(Event *evt, oboe_metadata_t *md);
+    void flush();
+    std::string getType();
+};
+
+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);
+
+    /**
+     * Get the complete Oboe library version number as a string, e.g. '10.0.3'
+     *
+     * @return The library's version string
+     */
+    static std::string getVersionString();
+};
+
+#endif  // OBOE_API_HPP

data/ext/oboe_metal/src/oboe_debug.h

@@ -38,10 +38,12 @@ enum OBOE_DEBUG_MODULE {
     OBOE_MODULE_REPORTER_FILE,      /*!< File reporter */
     OBOE_MODULE_REPORTER_UDP,       /*!< UDP (Tracelyzer) reporter */
     OBOE_MODULE_REPORTER_SSL,       /*!< SSL reporter */
+    OBOE_MODULE_REPORTER_LAMBDA,    /*!< lambda wrapper */
     OBOE_MODULE_APACHE,             /*!< Apache webserver */
     OBOE_MODULE_NGINX,              /*!< Nginx webserver */
     OBOE_MODULE_PHP,                /*!< PHP interpreter */
     OBOE_MODULE_DOTNET,             /*!< dotnet wrapper */
+    OBOE_MODULE_RUBY,               /*!< ruby c++ extension */
 };
 
 /**

data/ext/oboe_metal/src/{oboe_wrap.cxx → oboe_swig_wrap.cc}

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 4.0.0
+ * Version 4.0.2
  *
  * 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
@@ -977,38 +977,46 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 
 
 /*
- * Need to be very careful about how these macros are defined, especially
- * when compiling C++ code or C code with an ANSI C compiler.
+ * The following macros are used for providing the correct type of a
+ * function pointer to the Ruby C API.
+ * Starting with Ruby 2.7 (corresponding to RB_METHOD_DEFINITION_DECL being
+ * defined) these macros act transparently due to Ruby's moving away from
+ * ANYARGS and instead employing strict function signatures.
  *
- * VALUEFUNC(f) is a macro used to typecast a C function that implements
- * a Ruby method so that it can be passed as an argument to API functions
- * like rb_define_method() and rb_define_singleton_method().
+ * Note: In case of C (not C++) the macros are transparent even before
+ * Ruby 2.7 due to the fact that the Ruby C API used function declarators
+ * with empty parentheses, which allows for an unspecified number of
+ * arguments.
  *
- * VOIDFUNC(f) is a macro used to typecast a C function that implements
- * either the "mark" or "free" stuff for a Ruby Data object, so that it
- * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * PROTECTFUNC(f) is used for the function pointer argument of the Ruby
+ * C API function rb_protect().
+ *
+ * VALUEFUNC(f) is used for the function pointer argument(s) of Ruby C API
+ * functions like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is used to typecast a C function that implements either
+ * the "mark" or "free" stuff for a Ruby Data object, so that it can be
+ * passed as an argument to Ruby C API functions like Data_Wrap_Struct()
  * and Data_Make_Struct().
+ *
+ * SWIG_RUBY_VOID_ANYARGS_FUNC(f) is used for the function pointer
+ * argument(s) of Ruby C API functions like rb_define_virtual_variable().
+ *
+ * SWIG_RUBY_INT_ANYARGS_FUNC(f) is used for the function pointer
+ * argument(s) of Ruby C API functions like st_foreach().
  */
- 
-#ifdef __cplusplus
-#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
-#    define PROTECTFUNC(f) ((VALUE (*)()) f)
-#    define VALUEFUNC(f) ((VALUE (*)()) f)
-#    define VOIDFUNC(f)  ((void (*)()) f)
-#  else
-#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
-#      define PROTECTFUNC(f) ((VALUE (*)()) f)
-#      define VALUEFUNC(f) ((VALUE (*)()) f)
-#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
-#    else /* These definitions should work for Ruby 1.7+ */
-#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
-#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
-#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
-#    endif
-#  endif
+#if defined(__cplusplus) && !defined(RB_METHOD_DEFINITION_DECL)
+#  define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#  define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#  define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
+#  define SWIG_RUBY_VOID_ANYARGS_FUNC(f) ((void (*)(ANYARGS))(f))
+#  define SWIG_RUBY_INT_ANYARGS_FUNC(f) ((int (*)(ANYARGS))(f))
 #else
+#  define PROTECTFUNC(f) (f)
 #  define VALUEFUNC(f) (f)
 #  define VOIDFUNC(f) (f)
+#  define SWIG_RUBY_VOID_ANYARGS_FUNC(f) (f)
+#  define SWIG_RUBY_INT_ANYARGS_FUNC(f) (f)
 #endif
 
 /* Don't use for expressions have side effect */
@@ -1227,7 +1235,7 @@ extern "C" {
 */
 static st_table* swig_ruby_trackings = NULL;
 
-static VALUE swig_ruby_trackings_count(ANYARGS) {
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
   return SWIG2NUM(swig_ruby_trackings->num_entries);
 }
 
@@ -1264,7 +1272,9 @@ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
     swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
   }
 
-  rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
+  rb_define_virtual_variable("SWIG_TRACKINGS_COUNT",
+                             VALUEFUNC(swig_ruby_trackings_count),
+                             SWIG_RUBY_VOID_ANYARGS_FUNC((rb_gvar_setter_t*)NULL));
 }
 
 /* Add a Tracking from a C/C++ struct to a Ruby object */
@@ -1313,13 +1323,15 @@ SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
    to the passed callback function. */
 
 /* Proxy method to abstract the internal trackings datatype */
-static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
-  (*meth)(ptr, obj);
+static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+  ((void (*) (void *, VALUE))meth)((void *)ptr, (VALUE)obj);
   return ST_CONTINUE;
 }
 
 SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
-  st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
+  st_foreach(swig_ruby_trackings,
+             SWIG_RUBY_INT_ANYARGS_FUNC(swig_ruby_internal_iterate_callback),
+             (st_data_t)meth);
 }
 
 #ifdef __cplusplus
@@ -1600,6 +1612,8 @@ SWIGRUNTIMEINLINE char *
 SWIG_Ruby_MangleStr(VALUE obj)
 {
   VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  if (NIL_P(stype))
+    return NULL;
   return StringValuePtr(stype);
 }
 
@@ -1833,18 +1847,18 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_Config swig_types[0]
 #define SWIGTYPE_p_Context swig_types[1]
 #define SWIGTYPE_p_CustomMetrics swig_types[2]
-#define SWIGTYPE_p_DebugLog swig_types[3]
-#define SWIGTYPE_p_DebugLogger swig_types[4]
-#define SWIGTYPE_p_Event swig_types[5]
-#define SWIGTYPE_p_FILE swig_types[6]
-#define SWIGTYPE_p_Metadata swig_types[7]
-#define SWIGTYPE_p_MetricTags swig_types[8]
-#define SWIGTYPE_p_Reporter swig_types[9]
-#define SWIGTYPE_p_Span swig_types[10]
-#define SWIGTYPE_p_char swig_types[11]
-#define SWIGTYPE_p_int swig_types[12]
-#define SWIGTYPE_p_long_long swig_types[13]
-#define SWIGTYPE_p_oboe_metadata_t swig_types[14]
+#define SWIGTYPE_p_Event swig_types[3]
+#define SWIGTYPE_p_Metadata swig_types[4]
+#define SWIGTYPE_p_MetricTags swig_types[5]
+#define SWIGTYPE_p_Reporter swig_types[6]
+#define SWIGTYPE_p_Span swig_types[7]
+#define SWIGTYPE_p_char swig_types[8]
+#define SWIGTYPE_p_double swig_types[9]
+#define SWIGTYPE_p_int swig_types[10]
+#define SWIGTYPE_p_long swig_types[11]
+#define SWIGTYPE_p_long_long swig_types[12]
+#define SWIGTYPE_p_oboe_metadata_t swig_types[13]
+#define SWIGTYPE_p_oboe_metric_tag_t swig_types[14]
 #define SWIGTYPE_p_short swig_types[15]
 #define SWIGTYPE_p_signed_char swig_types[16]
 #define SWIGTYPE_p_std__string swig_types[17]
@@ -1868,7 +1882,7 @@ static VALUE mOboe_metal;
 #define SWIG_RUBY_THREAD_END_BLOCK
 
 
-#define SWIGVERSION 0x040000 
+#define SWIGVERSION 0x040002 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -1879,7 +1893,7 @@ static VALUE mOboe_metal;
 #include <stdexcept>
 
 
-#include "oboe.hpp"
+#include "oboe_api.hpp"
 
 
 #include <limits.h>
@@ -1908,6 +1922,86 @@ SWIG_From_int  (int value)
 #include <string>
 
 
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE SWIGUNUSEDPARM(arg1), VALUE SWIGUNUSEDPARM(arg2))
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/local/share/swig/4.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE arg)
+{
+  VALUE *args = (VALUE *)arg;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2LONG), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+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;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_bool (VALUE obj, bool *val)
+{
+  if (obj == Qtrue) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == Qfalse) {
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    int res = 0;
+    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
+      if (val) *val = res ? true : false;
+      return SWIG_OK;
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
 SWIGINTERN swig_type_info*
 SWIG_pchar_descriptor(void)
 {
@@ -1986,85 +2080,6 @@ SWIG_AsPtr_std_string (VALUE obj, std::string **val)
 }
 
 
-SWIGINTERN VALUE
-SWIG_ruby_failed(void)
-{
-  return Qnil;
-} 
-
-
-/*@SWIG:/usr/local/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
-{
-  VALUE obj = args[0];
-  VALUE type = TYPE(obj);
-  long *res = (long *)(args[1]);
-  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
-  return obj;
-}
-/*@SWIG@*/
-
-SWIGINTERN int
-SWIG_AsVal_long (VALUE obj, long* val)
-{
-  VALUE type = TYPE(obj);
-  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
-    long v;
-    VALUE a[2];
-    a[0] = obj;
-    a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
-      if (val) *val = v;
-      return SWIG_OK;
-    }
-  }
-  return SWIG_TypeError;
-}
-
-
-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;
-}
-
-
-SWIGINTERN int
-SWIG_AsVal_bool (VALUE obj, bool *val)
-{
-  if (obj == Qtrue) {
-    if (val) *val = true;
-    return SWIG_OK;
-  } else if (obj == Qfalse) {
-    if (val) *val = false;
-    return SWIG_OK;
-  } else {
-    int res = 0;
-    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
-      if (val) *val = res ? true : false;
-      return SWIG_OK;
-    }
-  }  
-  return SWIG_TypeError;
-}
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_bool  (bool value)
-{
-  return value ? Qtrue : Qfalse;
-}
-
-
 SWIGINTERNINLINE VALUE 
 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
 {
@@ -2092,9 +2107,10 @@ SWIG_From_std_string  (const std::string& s)
 
 
 
-/*@SWIG:/usr/local/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
+/*@SWIG:/usr/local/share/swig/4.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE arg)
 {
+  VALUE *args = (VALUE *)arg;
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   unsigned long *res = (unsigned long *)(args[1]);
@@ -2112,7 +2128,7 @@ SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
     VALUE a[2];
     a[0] = obj;
     a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -2137,9 +2153,10 @@ SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
 }
 
 
-/*@SWIG:/usr/local/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
+/*@SWIG:/usr/local/share/swig/4.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE arg)
 {
+  VALUE *args = (VALUE *)arg;
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   double *res = (double *)(args[1]);
@@ -2157,7 +2174,7 @@ SWIG_AsVal_double (VALUE obj, double *val)
     VALUE a[2];
     a[0] = obj;
     a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2DBL), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -2172,9 +2189,10 @@ SWIG_AsVal_double (VALUE obj, double *val)
 
 
 #ifdef SWIG_LONG_LONG_AVAILABLE
-/*@SWIG:/usr/local/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2LL(VALUE *args)
+/*@SWIG:/usr/local/share/swig/4.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LL(VALUE arg)
 {
+  VALUE *args = (VALUE *)arg;
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   long long *res = (long long *)(args[1]);
@@ -2192,7 +2210,7 @@ SWIG_AsVal_long_SS_long (VALUE obj, long long *val)
     VALUE a[2];
     a[0] = obj;
     a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2LL), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -2203,9 +2221,10 @@ SWIG_AsVal_long_SS_long (VALUE obj, long long *val)
 
 
 #ifdef SWIG_LONG_LONG_AVAILABLE
-/*@SWIG:/usr/local/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
-SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
+/*@SWIG:/usr/local/share/swig/4.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE arg)
 {
+  VALUE *args = (VALUE *)arg;
   VALUE obj = args[0];
   VALUE type = TYPE(obj);
   long long *res = (long long *)(args[1]);
@@ -2223,7 +2242,7 @@ SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
     VALUE a[2];
     a[0] = obj;
     a[1] = (VALUE)(&v);
-    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+    if (rb_rescue(VALUEFUNC(SWIG_AUX_NUM2ULL), (VALUE)a, VALUEFUNC(SWIG_ruby_failed), 0) != Qnil) {
       if (val) *val = v;
       return SWIG_OK;
     }
@@ -2282,10 +2301,10 @@ _wrap_new_Metadata(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "oboe_metadata_t *","Metadata", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "oboe_metadata_t const *","Metadata", 1, argv[0] )); 
   }
   arg1 = reinterpret_cast< oboe_metadata_t * >(argp1);
-  result = (Metadata *)new Metadata(arg1);
+  result = (Metadata *)new Metadata((oboe_metadata_t const *)arg1);
   DATA_PTR(self) = result;
   return self;
 fail:
@@ -2300,24 +2319,46 @@ free_Metadata(void *self) {
 }
 
 SWIGINTERN VALUE
-_wrap_Metadata_fromString(int argc, VALUE *argv, VALUE self) {
-  std::string arg1 ;
+_wrap_Metadata_createEvent(int argc, VALUE *argv, VALUE self) {
+  Metadata *arg1 = (Metadata *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Event *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","createEvent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Metadata * >(argp1);
+  result = (Event *)(arg1)->createEvent();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Metadata_copy(int argc, VALUE *argv, VALUE self) {
+  Metadata *arg1 = (Metadata *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   Metadata *result = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",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","Metadata::fromString", 1, argv[0] )); 
-    }
-    arg1 = *ptr;
-    if (SWIG_IsNewObj(res)) delete ptr;
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","copy", 1, self )); 
   }
-  result = (Metadata *)Metadata::fromString(arg1);
+  arg1 = reinterpret_cast< Metadata * >(argp1);
+  result = (Metadata *)(arg1)->copy();
   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Metadata, SWIG_POINTER_OWN |  0 );
   return vresult;
 fail:
@@ -2326,11 +2367,11 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Metadata_createEvent(int argc, VALUE *argv, VALUE self) {
+_wrap_Metadata_isValid(int argc, VALUE *argv, VALUE self) {
   Metadata *arg1 = (Metadata *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  Event *result = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -2338,11 +2379,35 @@ _wrap_Metadata_createEvent(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","createEvent", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","isValid", 1, self )); 
   }
   arg1 = reinterpret_cast< Metadata * >(argp1);
-  result = (Event *)(arg1)->createEvent();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Event, SWIG_POINTER_OWN |  0 );
+  result = (bool)(arg1)->isValid();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Metadata_isSampled(int argc, VALUE *argv, VALUE self) {
+  Metadata *arg1 = (Metadata *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","isSampled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Metadata * >(argp1);
+  result = (bool)(arg1)->isSampled();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -2423,47 +2488,25 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Metadata_copy(int argc, VALUE *argv, VALUE self) {
-  Metadata *arg1 = (Metadata *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+_wrap_Metadata_fromString(int argc, VALUE *argv, VALUE self) {
+  std::string arg1 ;
   Metadata *result = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","copy", 1, self )); 
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  arg1 = reinterpret_cast< Metadata * >(argp1);
-  result = (Metadata *)(arg1)->copy();
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Metadata, SWIG_POINTER_OWN |  0 );
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Metadata_isValid(int argc, VALUE *argv, VALUE self) {
-  Metadata *arg1 = (Metadata *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  bool result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","isValid", 1, self )); 
+  {
+    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","Metadata::fromString", 1, argv[0] )); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
   }
-  arg1 = reinterpret_cast< Metadata * >(argp1);
-  result = (bool)(arg1)->isValid();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  result = (Metadata *)Metadata::fromString(arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Metadata, SWIG_POINTER_OWN |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -2471,11 +2514,11 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Metadata_isSampled(int argc, VALUE *argv, VALUE self) {
+_wrap_Metadata_metadata(int argc, VALUE *argv, VALUE self) {
   Metadata *arg1 = (Metadata *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  bool result;
+  oboe_metadata_t *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -2483,11 +2526,11 @@ _wrap_Metadata_isSampled(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Metadata, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","isSampled", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Metadata *","metadata", 1, self )); 
   }
   arg1 = reinterpret_cast< Metadata * >(argp1);
-  result = (bool)(arg1)->isSampled();
-  vresult = SWIG_From_bool(static_cast< bool >(result));
+  result = (oboe_metadata_t *)(arg1)->metadata();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
   return vresult;
 fail:
   return Qnil;
@@ -2568,19 +2611,21 @@ _wrap_Context_getDecisions__SWIG_0(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
-  int arg12 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
   int arg13 ;
   int arg14 ;
-  char *arg15 = (char *) 0 ;
-  char *arg16 = (char *) 0 ;
-  long arg17 ;
+  int arg15 ;
+  int arg16 ;
+  char *arg17 = (char *) 0 ;
+  char *arg18 = (char *) 0 ;
+  long arg19 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -2589,35 +2634,39 @@ _wrap_Context_getDecisions__SWIG_0(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
-  int val12 ;
-  int ecode12 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
   int val13 ;
   int ecode13 = 0 ;
   int val14 ;
   int ecode14 = 0 ;
-  int res15 ;
-  char *buf15 = 0 ;
-  int alloc15 = 0 ;
-  int res16 ;
-  char *buf16 = 0 ;
-  int alloc16 = 0 ;
-  long val17 ;
-  int ecode17 = 0 ;
+  int val15 ;
+  int ecode15 = 0 ;
+  int val16 ;
+  int ecode16 = 0 ;
+  int res17 ;
+  char *buf17 = 0 ;
+  int alloc17 = 0 ;
+  int res18 ;
+  char *buf18 = 0 ;
+  int alloc18 = 0 ;
+  long val19 ;
+  int ecode19 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -2629,50 +2678,52 @@ _wrap_Context_getDecisions__SWIG_0(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 8) || (argc > 8)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
-  } 
-  arg11 = static_cast< int >(val11);
-  ecode12 = SWIG_AsVal_int(argv[2], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "int","Context::getDecisions", 12, argv[2] ));
-  } 
-  arg12 = static_cast< int >(val12);
-  ecode13 = SWIG_AsVal_int(argv[3], &val13);
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
   if (!SWIG_IsOK(ecode13)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
   arg13 = static_cast< int >(val13);
-  ecode14 = SWIG_AsVal_int(argv[4], &val14);
+  ecode14 = SWIG_AsVal_int(argv[2], &val14);
   if (!SWIG_IsOK(ecode14)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[2] ));
   } 
   arg14 = static_cast< int >(val14);
-  res15 = SWIG_AsCharPtrAndSize(argv[5], &buf15, NULL, &alloc15);
-  if (!SWIG_IsOK(res15)) {
-    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 15, argv[5] ));
-  }
-  arg15 = reinterpret_cast< char * >(buf15);
-  res16 = SWIG_AsCharPtrAndSize(argv[6], &buf16, NULL, &alloc16);
-  if (!SWIG_IsOK(res16)) {
-    SWIG_exception_fail(SWIG_ArgError(res16), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 16, argv[6] ));
-  }
-  arg16 = reinterpret_cast< char * >(buf16);
-  ecode17 = SWIG_AsVal_long(argv[7], &val17);
-  if (!SWIG_IsOK(ecode17)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "long","Context::getDecisions", 17, argv[7] ));
+  ecode15 = SWIG_AsVal_int(argv[3], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "int","Context::getDecisions", 15, argv[3] ));
+  } 
+  arg15 = static_cast< int >(val15);
+  ecode16 = SWIG_AsVal_int(argv[4], &val16);
+  if (!SWIG_IsOK(ecode16)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "int","Context::getDecisions", 16, argv[4] ));
+  } 
+  arg16 = static_cast< int >(val16);
+  res17 = SWIG_AsCharPtrAndSize(argv[5], &buf17, NULL, &alloc17);
+  if (!SWIG_IsOK(res17)) {
+    SWIG_exception_fail(SWIG_ArgError(res17), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 17, argv[5] ));
+  }
+  arg17 = reinterpret_cast< char * >(buf17);
+  res18 = SWIG_AsCharPtrAndSize(argv[6], &buf18, NULL, &alloc18);
+  if (!SWIG_IsOK(res18)) {
+    SWIG_exception_fail(SWIG_ArgError(res18), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 18, argv[6] ));
+  }
+  arg18 = reinterpret_cast< char * >(buf18);
+  ecode19 = SWIG_AsVal_long(argv[7], &val19);
+  if (!SWIG_IsOK(ecode19)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode19), Ruby_Format_TypeError( "", "long","Context::getDecisions", 19, argv[7] ));
   } 
-  arg17 = static_cast< long >(val17);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12,arg13,arg14,(char const *)arg15,(char const *)arg16,arg17);
+  arg19 = static_cast< long >(val19);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14,arg15,arg16,(char const *)arg17,(char const *)arg18,arg19);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -2702,40 +2753,52 @@ _wrap_Context_getDecisions__SWIG_0(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
-  if (alloc15 == SWIG_NEWOBJ) delete[] buf15;
-  if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
+  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
+  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
-  if (alloc15 == SWIG_NEWOBJ) delete[] buf15;
-  if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
+  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
+  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
   return Qnil;
 }
 
@@ -2746,18 +2809,20 @@ _wrap_Context_getDecisions__SWIG_1(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
-  int arg12 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
   int arg13 ;
   int arg14 ;
-  char *arg15 = (char *) 0 ;
-  char *arg16 = (char *) 0 ;
+  int arg15 ;
+  int arg16 ;
+  char *arg17 = (char *) 0 ;
+  char *arg18 = (char *) 0 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -2766,33 +2831,37 @@ _wrap_Context_getDecisions__SWIG_1(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
-  int val12 ;
-  int ecode12 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
   int val13 ;
   int ecode13 = 0 ;
   int val14 ;
   int ecode14 = 0 ;
-  int res15 ;
-  char *buf15 = 0 ;
-  int alloc15 = 0 ;
-  int res16 ;
-  char *buf16 = 0 ;
-  int alloc16 = 0 ;
+  int val15 ;
+  int ecode15 = 0 ;
+  int val16 ;
+  int ecode16 = 0 ;
+  int res17 ;
+  char *buf17 = 0 ;
+  int alloc17 = 0 ;
+  int res18 ;
+  char *buf18 = 0 ;
+  int alloc18 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -2804,45 +2873,47 @@ _wrap_Context_getDecisions__SWIG_1(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 7) || (argc > 7)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
-  } 
-  arg11 = static_cast< int >(val11);
-  ecode12 = SWIG_AsVal_int(argv[2], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "int","Context::getDecisions", 12, argv[2] ));
-  } 
-  arg12 = static_cast< int >(val12);
-  ecode13 = SWIG_AsVal_int(argv[3], &val13);
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
   if (!SWIG_IsOK(ecode13)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
   arg13 = static_cast< int >(val13);
-  ecode14 = SWIG_AsVal_int(argv[4], &val14);
+  ecode14 = SWIG_AsVal_int(argv[2], &val14);
   if (!SWIG_IsOK(ecode14)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[2] ));
   } 
   arg14 = static_cast< int >(val14);
-  res15 = SWIG_AsCharPtrAndSize(argv[5], &buf15, NULL, &alloc15);
-  if (!SWIG_IsOK(res15)) {
-    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 15, argv[5] ));
+  ecode15 = SWIG_AsVal_int(argv[3], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "int","Context::getDecisions", 15, argv[3] ));
+  } 
+  arg15 = static_cast< int >(val15);
+  ecode16 = SWIG_AsVal_int(argv[4], &val16);
+  if (!SWIG_IsOK(ecode16)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "int","Context::getDecisions", 16, argv[4] ));
+  } 
+  arg16 = static_cast< int >(val16);
+  res17 = SWIG_AsCharPtrAndSize(argv[5], &buf17, NULL, &alloc17);
+  if (!SWIG_IsOK(res17)) {
+    SWIG_exception_fail(SWIG_ArgError(res17), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 17, argv[5] ));
   }
-  arg15 = reinterpret_cast< char * >(buf15);
-  res16 = SWIG_AsCharPtrAndSize(argv[6], &buf16, NULL, &alloc16);
-  if (!SWIG_IsOK(res16)) {
-    SWIG_exception_fail(SWIG_ArgError(res16), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 16, argv[6] ));
+  arg17 = reinterpret_cast< char * >(buf17);
+  res18 = SWIG_AsCharPtrAndSize(argv[6], &buf18, NULL, &alloc18);
+  if (!SWIG_IsOK(res18)) {
+    SWIG_exception_fail(SWIG_ArgError(res18), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 18, argv[6] ));
   }
-  arg16 = reinterpret_cast< char * >(buf16);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12,arg13,arg14,(char const *)arg15,(char const *)arg16);
+  arg18 = reinterpret_cast< char * >(buf18);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14,arg15,arg16,(char const *)arg17,(char const *)arg18);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -2872,40 +2943,52 @@ _wrap_Context_getDecisions__SWIG_1(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
-  if (alloc15 == SWIG_NEWOBJ) delete[] buf15;
-  if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
+  }
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
+  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
+  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
-  if (alloc15 == SWIG_NEWOBJ) delete[] buf15;
-  if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
+  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
+  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
   return Qnil;
 }
 
@@ -2916,17 +2999,19 @@ _wrap_Context_getDecisions__SWIG_2(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
-  int arg12 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
   int arg13 ;
   int arg14 ;
-  char *arg15 = (char *) 0 ;
+  int arg15 ;
+  int arg16 ;
+  char *arg17 = (char *) 0 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -2935,30 +3020,34 @@ _wrap_Context_getDecisions__SWIG_2(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
-  int val12 ;
-  int ecode12 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
   int val13 ;
   int ecode13 = 0 ;
   int val14 ;
   int ecode14 = 0 ;
-  int res15 ;
-  char *buf15 = 0 ;
-  int alloc15 = 0 ;
+  int val15 ;
+  int ecode15 = 0 ;
+  int val16 ;
+  int ecode16 = 0 ;
+  int res17 ;
+  char *buf17 = 0 ;
+  int alloc17 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -2970,40 +3059,42 @@ _wrap_Context_getDecisions__SWIG_2(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 6) || (argc > 6)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
-  } 
-  arg11 = static_cast< int >(val11);
-  ecode12 = SWIG_AsVal_int(argv[2], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "int","Context::getDecisions", 12, argv[2] ));
-  } 
-  arg12 = static_cast< int >(val12);
-  ecode13 = SWIG_AsVal_int(argv[3], &val13);
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
   if (!SWIG_IsOK(ecode13)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
   arg13 = static_cast< int >(val13);
-  ecode14 = SWIG_AsVal_int(argv[4], &val14);
+  ecode14 = SWIG_AsVal_int(argv[2], &val14);
   if (!SWIG_IsOK(ecode14)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[2] ));
   } 
   arg14 = static_cast< int >(val14);
-  res15 = SWIG_AsCharPtrAndSize(argv[5], &buf15, NULL, &alloc15);
-  if (!SWIG_IsOK(res15)) {
-    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 15, argv[5] ));
+  ecode15 = SWIG_AsVal_int(argv[3], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "int","Context::getDecisions", 15, argv[3] ));
+  } 
+  arg15 = static_cast< int >(val15);
+  ecode16 = SWIG_AsVal_int(argv[4], &val16);
+  if (!SWIG_IsOK(ecode16)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "int","Context::getDecisions", 16, argv[4] ));
+  } 
+  arg16 = static_cast< int >(val16);
+  res17 = SWIG_AsCharPtrAndSize(argv[5], &buf17, NULL, &alloc17);
+  if (!SWIG_IsOK(res17)) {
+    SWIG_exception_fail(SWIG_ArgError(res17), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 17, argv[5] ));
   }
-  arg15 = reinterpret_cast< char * >(buf15);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12,arg13,arg14,(char const *)arg15);
+  arg17 = reinterpret_cast< char * >(buf17);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14,arg15,arg16,(char const *)arg17);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3033,38 +3124,50 @@ _wrap_Context_getDecisions__SWIG_2(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
-  if (alloc15 == SWIG_NEWOBJ) delete[] buf15;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
+  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
-  if (alloc15 == SWIG_NEWOBJ) delete[] buf15;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
+  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
   return Qnil;
 }
 
@@ -3075,16 +3178,18 @@ _wrap_Context_getDecisions__SWIG_3(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
-  int arg12 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
   int arg13 ;
   int arg14 ;
+  int arg15 ;
+  int arg16 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -3093,27 +3198,31 @@ _wrap_Context_getDecisions__SWIG_3(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
-  int val12 ;
-  int ecode12 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
   int val13 ;
   int ecode13 = 0 ;
   int val14 ;
   int ecode14 = 0 ;
+  int val15 ;
+  int ecode15 = 0 ;
+  int val16 ;
+  int ecode16 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -3125,35 +3234,37 @@ _wrap_Context_getDecisions__SWIG_3(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 5) || (argc > 5)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
-  } 
-  arg11 = static_cast< int >(val11);
-  ecode12 = SWIG_AsVal_int(argv[2], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "int","Context::getDecisions", 12, argv[2] ));
-  } 
-  arg12 = static_cast< int >(val12);
-  ecode13 = SWIG_AsVal_int(argv[3], &val13);
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
   if (!SWIG_IsOK(ecode13)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
   arg13 = static_cast< int >(val13);
-  ecode14 = SWIG_AsVal_int(argv[4], &val14);
+  ecode14 = SWIG_AsVal_int(argv[2], &val14);
   if (!SWIG_IsOK(ecode14)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[2] ));
   } 
   arg14 = static_cast< int >(val14);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12,arg13,arg14);
+  ecode15 = SWIG_AsVal_int(argv[3], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "int","Context::getDecisions", 15, argv[3] ));
+  } 
+  arg15 = static_cast< int >(val15);
+  ecode16 = SWIG_AsVal_int(argv[4], &val16);
+  if (!SWIG_IsOK(ecode16)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "int","Context::getDecisions", 16, argv[4] ));
+  } 
+  arg16 = static_cast< int >(val16);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14,arg15,arg16);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3183,36 +3294,48 @@ _wrap_Context_getDecisions__SWIG_3(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return Qnil;
 }
 
@@ -3223,15 +3346,17 @@ _wrap_Context_getDecisions__SWIG_4(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
-  int arg12 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
   int arg13 ;
+  int arg14 ;
+  int arg15 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -3240,25 +3365,29 @@ _wrap_Context_getDecisions__SWIG_4(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
-  int val12 ;
-  int ecode12 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
   int val13 ;
   int ecode13 = 0 ;
+  int val14 ;
+  int ecode14 = 0 ;
+  int val15 ;
+  int ecode15 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -3270,30 +3399,32 @@ _wrap_Context_getDecisions__SWIG_4(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 4) || (argc > 4)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
-  } 
-  arg11 = static_cast< int >(val11);
-  ecode12 = SWIG_AsVal_int(argv[2], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "int","Context::getDecisions", 12, argv[2] ));
-  } 
-  arg12 = static_cast< int >(val12);
-  ecode13 = SWIG_AsVal_int(argv[3], &val13);
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
   if (!SWIG_IsOK(ecode13)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
   arg13 = static_cast< int >(val13);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12,arg13);
+  ecode14 = SWIG_AsVal_int(argv[2], &val14);
+  if (!SWIG_IsOK(ecode14)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[2] ));
+  } 
+  arg14 = static_cast< int >(val14);
+  ecode15 = SWIG_AsVal_int(argv[3], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "int","Context::getDecisions", 15, argv[3] ));
+  } 
+  arg15 = static_cast< int >(val15);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14,arg15);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3323,36 +3454,48 @@ _wrap_Context_getDecisions__SWIG_4(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return Qnil;
 }
 
@@ -3363,14 +3506,16 @@ _wrap_Context_getDecisions__SWIG_5(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
-  int arg12 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
+  int arg13 ;
+  int arg14 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -3379,23 +3524,27 @@ _wrap_Context_getDecisions__SWIG_5(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
-  int val12 ;
-  int ecode12 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
+  int val13 ;
+  int ecode13 = 0 ;
+  int val14 ;
+  int ecode14 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -3407,25 +3556,27 @@ _wrap_Context_getDecisions__SWIG_5(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 3) || (argc > 3)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
+  if (!SWIG_IsOK(ecode13)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
-  arg11 = static_cast< int >(val11);
-  ecode12 = SWIG_AsVal_int(argv[2], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "int","Context::getDecisions", 12, argv[2] ));
+  arg13 = static_cast< int >(val13);
+  ecode14 = SWIG_AsVal_int(argv[2], &val14);
+  if (!SWIG_IsOK(ecode14)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Context::getDecisions", 14, argv[2] ));
   } 
-  arg12 = static_cast< int >(val12);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11,arg12);
+  arg14 = static_cast< int >(val14);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3455,36 +3606,48 @@ _wrap_Context_getDecisions__SWIG_5(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
+  }
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return Qnil;
 }
 
@@ -3495,13 +3658,15 @@ _wrap_Context_getDecisions__SWIG_6(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
-  int arg11 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
+  int arg13 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -3510,21 +3675,25 @@ _wrap_Context_getDecisions__SWIG_6(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
-  int val11 ;
-  int ecode11 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
+  int val13 ;
+  int ecode13 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -3536,20 +3705,22 @@ _wrap_Context_getDecisions__SWIG_6(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  ecode11 = SWIG_AsVal_int(argv[1], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","Context::getDecisions", 11, argv[1] ));
+  arg12 = reinterpret_cast< char * >(buf12);
+  ecode13 = SWIG_AsVal_int(argv[1], &val13);
+  if (!SWIG_IsOK(ecode13)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "int","Context::getDecisions", 13, argv[1] ));
   } 
-  arg11 = static_cast< int >(val11);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10,arg11);
+  arg13 = static_cast< int >(val13);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3579,36 +3750,48 @@ _wrap_Context_getDecisions__SWIG_6(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return Qnil;
 }
 
@@ -3619,12 +3802,14 @@ _wrap_Context_getDecisions__SWIG_7(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
-  char *arg10 = (char *) 0 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
+  char *arg12 = (char *) 0 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -3633,19 +3818,23 @@ _wrap_Context_getDecisions__SWIG_7(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
-  int res10 ;
-  char *buf10 = 0 ;
-  int alloc10 = 0 ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
+  int res12 ;
+  char *buf12 = 0 ;
+  int alloc12 = 0 ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -3657,15 +3846,17 @@ _wrap_Context_getDecisions__SWIG_7(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res10 = SWIG_AsCharPtrAndSize(argv[0], &buf10, NULL, &alloc10);
-  if (!SWIG_IsOK(res10)) {
-    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 10, argv[0] ));
+  res12 = SWIG_AsCharPtrAndSize(argv[0], &buf12, NULL, &alloc12);
+  if (!SWIG_IsOK(res12)) {
+    SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "char const *","Context::getDecisions", 12, argv[0] ));
   }
-  arg10 = reinterpret_cast< char * >(buf10);
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
+  arg12 = reinterpret_cast< char * >(buf12);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3695,36 +3886,48 @@ _wrap_Context_getDecisions__SWIG_7(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return vresult;
 fail:
-  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
+  if (alloc12 == SWIG_NEWOBJ) delete[] buf12;
   return Qnil;
 }
 
@@ -3735,11 +3938,13 @@ _wrap_Context_getDecisions__SWIG_8(int argc, VALUE *argv, VALUE self) {
   int *arg2 = (int *) 0 ;
   int *arg3 = (int *) 0 ;
   int *arg4 = (int *) 0 ;
-  int *arg5 = (int *) 0 ;
-  int *arg6 = (int *) 0 ;
-  std::string *arg7 = (std::string *) 0 ;
-  std::string *arg8 = (std::string *) 0 ;
-  int *arg9 = (int *) 0 ;
+  double *arg5 = (double *) 0 ;
+  double *arg6 = (double *) 0 ;
+  int *arg7 = (int *) 0 ;
+  int *arg8 = (int *) 0 ;
+  std::string *arg9 = (std::string *) 0 ;
+  std::string *arg10 = (std::string *) 0 ;
+  int *arg11 = (int *) 0 ;
   int temp1 ;
   int res1 = SWIG_TMPOBJ ;
   int temp2 ;
@@ -3748,16 +3953,20 @@ _wrap_Context_getDecisions__SWIG_8(int argc, VALUE *argv, VALUE self) {
   int res3 = SWIG_TMPOBJ ;
   int temp4 ;
   int res4 = SWIG_TMPOBJ ;
-  int temp5 ;
+  double temp5 ;
   int res5 = SWIG_TMPOBJ ;
-  int temp6 ;
+  double temp6 ;
   int res6 = SWIG_TMPOBJ ;
-  std::string temp7 ;
+  int temp7 ;
   int res7 = SWIG_TMPOBJ ;
-  std::string temp8 ;
+  int temp8 ;
   int res8 = SWIG_TMPOBJ ;
-  int temp9 ;
+  std::string temp9 ;
   int res9 = SWIG_TMPOBJ ;
+  std::string temp10 ;
+  int res10 = SWIG_TMPOBJ ;
+  int temp11 ;
+  int res11 = SWIG_TMPOBJ ;
   VALUE vresult = Qnil;
   
   arg1 = &temp1;
@@ -3769,10 +3978,12 @@ _wrap_Context_getDecisions__SWIG_8(int argc, VALUE *argv, VALUE self) {
   arg7 = &temp7;
   arg8 = &temp8;
   arg9 = &temp9;
+  arg10 = &temp10;
+  arg11 = &temp11;
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+  Context::getDecisions(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
   vresult = rb_ary_new();
   if (SWIG_IsTmpObj(res1)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg1)));
@@ -3802,31 +4013,43 @@ _wrap_Context_getDecisions__SWIG_8(int argc, VALUE *argv, VALUE self) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
   } else {
     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res6)) {
     vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg6)));
   } else {
     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
   }
   if (SWIG_IsTmpObj(res7)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg7)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg7)));
   } else {
     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res8)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg8)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg8)));
   } else {
     int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_std__string, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
   }
   if (SWIG_IsTmpObj(res9)) {
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg9)));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg9)));
   } else {
     int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
-    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_int, new_flags));
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res10)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_std_string((*arg10)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_std__string, new_flags));
+  }
+  if (SWIG_IsTmpObj(res11)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg11)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
   }
   return vresult;
 fail:
@@ -4072,15 +4295,15 @@ SWIGINTERN VALUE _wrap_Context_getDecisions(int nargs, VALUE *args, VALUE self)
   
 fail:
   Ruby_Format_OverloadedError( argc, 8, "Context.getDecisions", 
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode, char const *header_options, char const *header_signature, long header_timestamp)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode, char const *header_options, char const *header_signature)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode, char const *header_options)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace)\n"
-    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status)\n");
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode, char const *header_options, char const *header_signature, long header_timestamp)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode, char const *header_options, char const *header_signature)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode, char const *header_options)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type, int custom_trigger_mode)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate, int request_type)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode, int custom_sample_rate)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace, int custom_tracing_mode)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status, char const *in_xtrace)\n"
+    "    void Context.getDecisions(int *do_metrics, int *do_sample, int *sample_rate, int *sample_source, double *bucket_rate, double *bucket_cap, int *type, int *auth, std::string *status_msg, std::string *auth_msg, int *status)\n");
   
   return Qnil;
 }
@@ -4296,6 +4519,22 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Context_isLambda(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)Context::isLambda();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Context_createEvent(int argc, VALUE *argv, VALUE self) {
   Event *result = 0 ;
@@ -4549,40 +4788,134 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_Event_addInfo(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[4];
-  int ii;
+SWIGINTERN VALUE
+_wrap_Event_addInfo__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  char *arg2 = (char *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 4) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        void *ptr = 0;
-        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_Event_addInfo__SWIG_0(nargs, args, self);
-        }
-      }
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Event, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Event *","addInfo", 1, self )); 
   }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
-    _v = SWIG_CheckState(res);
+  arg1 = reinterpret_cast< Event * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","addInfo", 2, argv[0] ));
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","addInfo", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  result = (bool)(arg1)->addInfo(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return vresult;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Event_addInfo__SWIG_5(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  char *arg2 = (char *) 0 ;
+  long *arg3 = (long *) 0 ;
+  int arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 *","addInfo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Event * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","addInfo", 2, argv[0] ));
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_long, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "long const *","addInfo", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< long * >(argp3);
+  ecode4 = SWIG_AsVal_int(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","addInfo", 4, argv[2] ));
+  } 
+  arg4 = static_cast< int >(val4);
+  result = (bool)(arg1)->addInfo(arg2,(long const *)arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return vresult;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_Event_addInfo(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *ptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Event_addInfo__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
+    _v = SWIG_CheckState(res);
     if (_v) {
       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
       _v = SWIG_CheckState(res);
@@ -4633,13 +4966,58 @@ SWIGINTERN VALUE _wrap_Event_addInfo(int nargs, VALUE *args, VALUE self) {
       }
     }
   }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Event_addInfo__SWIG_4(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Event, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Event_addInfo__SWIG_5(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 4, "Event.addInfo", 
+  Ruby_Format_OverloadedError( argc, 5, "Event.addInfo", 
     "    bool Event.addInfo(char *key, void *val)\n"
     "    bool Event.addInfo(char *key, std::string const &val)\n"
     "    bool Event.addInfo(char *key, long val)\n"
-    "    bool Event.addInfo(char *key, double val)\n");
+    "    bool Event.addInfo(char *key, double val)\n"
+    "    bool Event.addInfo(char *key, bool val)\n"
+    "    bool Event.addInfo(char *key, long const *vals, int num)\n");
   
   return Qnil;
 }
@@ -4716,6 +5094,62 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Event_addContextOpId(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  oboe_metadata_t *arg2 = (oboe_metadata_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  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 *","addContextOpId", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Event * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "oboe_metadata_t const *","addContextOpId", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< oboe_metadata_t * >(argp2);
+  result = (bool)(arg1)->addContextOpId((oboe_metadata_t const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Event_addHostname(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",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 *","addHostname", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Event * >(argp1);
+  result = (bool)(arg1)->addHostname();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Event_getMetadata(int argc, VALUE *argv, VALUE self) {
   Event *arg1 = (Event *) 0 ;
@@ -4764,6 +5198,30 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Event_opIdString(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  std::string result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",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 *","opIdString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Event * >(argp1);
+  result = (arg1)->opIdString();
+  vresult = SWIG_From_std_string(static_cast< std::string >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Event_send(int argc, VALUE *argv, VALUE self) {
   Event *arg1 = (Event *) 0 ;
@@ -4789,60 +5247,153 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Event_startTrace(int argc, VALUE *argv, VALUE self) {
-  oboe_metadata_t *arg1 = (oboe_metadata_t *) 0 ;
+_wrap_Event_sendProfiling(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  Event *result = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Event, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "oboe_metadata_t const *","Event::startTrace", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Event *","sendProfiling", 1, 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, SWIG_POINTER_OWN |  0 );
+  arg1 = reinterpret_cast< Event * >(argp1);
+  result = (bool)(arg1)->sendProfiling();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-static swig_class SwigClassSpan;
-
 SWIGINTERN VALUE
-_wrap_Span_createSpan__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  char *arg1 = (char *) 0 ;
-  char *arg2 = (char *) 0 ;
-  int64_t arg3 ;
-  char *arg4 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  int res2 ;
-  char *buf2 = 0 ;
-  int alloc2 = 0 ;
-  long long val3 ;
-  int ecode3 = 0 ;
-  int res4 ;
-  char *buf4 = 0 ;
-  int alloc4 = 0 ;
-  std::string result;
+_wrap_Event_addSpanRef(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  oboe_metadata_t *arg2 = (oboe_metadata_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 4) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Event, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","Span::createSpan", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Event *","addSpanRef", 1, self )); 
   }
-  arg1 = reinterpret_cast< char * >(buf1);
-  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+  arg1 = reinterpret_cast< Event * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "oboe_metadata_t const *","addSpanRef", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< oboe_metadata_t * >(argp2);
+  result = (bool)(arg1)->addSpanRef((oboe_metadata_t const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Event_addProfileEdge(int argc, VALUE *argv, VALUE self) {
+  Event *arg1 = (Event *) 0 ;
+  std::string arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  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 *","addProfileEdge", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Event * >(argp1);
+  {
+    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","addProfileEdge", 2, argv[0] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (bool)(arg1)->addProfileEdge(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Event_startTrace(int argc, VALUE *argv, VALUE self) {
+  oboe_metadata_t *arg1 = (oboe_metadata_t *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Event *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "oboe_metadata_t const *","Event::startTrace", 1, argv[0] )); 
+  }
+  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, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassSpan;
+
+SWIGINTERN VALUE
+_wrap_Span_createSpan__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int64_t arg3 ;
+  int arg4 ;
+  char *arg5 = (char *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  long long val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  int res5 ;
+  char *buf5 = 0 ;
+  int alloc5 = 0 ;
+  std::string result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","Span::createSpan", 1, argv[0] ));
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
   if (!SWIG_IsOK(res2)) {
     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Span::createSpan", 2, argv[1] ));
   }
@@ -4852,21 +5403,26 @@ _wrap_Span_createSpan__SWIG_0(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int64_t","Span::createSpan", 3, argv[2] ));
   } 
   arg3 = static_cast< int64_t >(val3);
-  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Span::createSpan", 4, argv[3] ));
+  ecode4 = SWIG_AsVal_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Span::createSpan", 4, argv[3] ));
+  } 
+  arg4 = static_cast< int >(val4);
+  res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","Span::createSpan", 5, argv[4] ));
   }
-  arg4 = reinterpret_cast< char * >(buf4);
-  result = Span::createSpan((char const *)arg1,(char const *)arg2,arg3,(char const *)arg4);
+  arg5 = reinterpret_cast< char * >(buf5);
+  result = Span::createSpan((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5);
   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
   return vresult;
 fail:
   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
   return Qnil;
 }
 
@@ -4876,6 +5432,7 @@ _wrap_Span_createSpan__SWIG_1(int argc, VALUE *argv, VALUE self) {
   char *arg1 = (char *) 0 ;
   char *arg2 = (char *) 0 ;
   int64_t arg3 ;
+  int arg4 ;
   int res1 ;
   char *buf1 = 0 ;
   int alloc1 = 0 ;
@@ -4884,11 +5441,13 @@ _wrap_Span_createSpan__SWIG_1(int argc, VALUE *argv, VALUE self) {
   int alloc2 = 0 ;
   long long val3 ;
   int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
   std::string result;
   VALUE vresult = Qnil;
   
-  if ((argc < 3) || (argc > 3)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
   res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
   if (!SWIG_IsOK(res1)) {
@@ -4905,7 +5464,12 @@ _wrap_Span_createSpan__SWIG_1(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int64_t","Span::createSpan", 3, argv[2] ));
   } 
   arg3 = static_cast< int64_t >(val3);
-  result = Span::createSpan((char const *)arg1,(char const *)arg2,arg3);
+  ecode4 = SWIG_AsVal_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Span::createSpan", 4, argv[3] ));
+  } 
+  arg4 = static_cast< int >(val4);
+  result = Span::createSpan((char const *)arg1,(char const *)arg2,arg3,arg4);
   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
@@ -4919,15 +5483,15 @@ fail:
 
 SWIGINTERN VALUE _wrap_Span_createSpan(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[4];
+  VALUE argv[5];
   int ii;
   
   argc = nargs;
-  if (argc > 4) SWIG_fail;
+  if (argc > 5) SWIG_fail;
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
-  if (argc == 3) {
+  if (argc == 4) {
     int _v;
     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
     _v = SWIG_CheckState(res);
@@ -4940,12 +5504,18 @@ SWIGINTERN VALUE _wrap_Span_createSpan(int nargs, VALUE *args, VALUE self) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_Span_createSpan__SWIG_1(nargs, args, self);
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Span_createSpan__SWIG_1(nargs, args, self);
+          }
         }
       }
     }
   }
-  if (argc == 4) {
+  if (argc == 5) {
     int _v;
     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
     _v = SWIG_CheckState(res);
@@ -4958,10 +5528,16 @@ SWIGINTERN VALUE _wrap_Span_createSpan(int nargs, VALUE *args, VALUE self) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
-          _v = SWIG_CheckState(res);
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
           if (_v) {
-            return _wrap_Span_createSpan__SWIG_0(nargs, args, self);
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_Span_createSpan__SWIG_0(nargs, args, self);
+            }
           }
         }
       }
@@ -4969,9 +5545,9 @@ SWIGINTERN VALUE _wrap_Span_createSpan(int nargs, VALUE *args, VALUE self) {
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 4, "Span.createSpan", 
-    "    std::string Span.createSpan(char const *transaction, char const *domain, int64_t const duration, char const *service_name)\n"
-    "    std::string Span.createSpan(char const *transaction, char const *domain, int64_t const duration)\n");
+  Ruby_Format_OverloadedError( argc, 5, "Span.createSpan", 
+    "    std::string Span.createSpan(char const *transaction, char const *domain, int64_t const duration, int const has_error, char const *service_name)\n"
+    "    std::string Span.createSpan(char const *transaction, char const *domain, int64_t const duration, int const has_error)\n");
   
   return Qnil;
 }
@@ -5372,15 +5948,15 @@ _wrap_MetricTags_add(int argc, VALUE *argv, VALUE self) {
   arg2 = static_cast< size_t >(val2);
   res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
   if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","add", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","add", 3, argv[1] ));
   }
   arg3 = reinterpret_cast< char * >(buf3);
   res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
   if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","add", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","add", 4, argv[2] ));
   }
   arg4 = reinterpret_cast< char * >(buf4);
-  result = (bool)(arg1)->add(arg2,arg3,arg4);
+  result = (bool)(arg1)->add(arg2,(char const *)arg3,(char const *)arg4);
   vresult = SWIG_From_bool(static_cast< bool >(result));
   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
   if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
@@ -5392,6 +5968,30 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_MetricTags_get(int argc, VALUE *argv, VALUE self) {
+  MetricTags *arg1 = (MetricTags *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  oboe_metric_tag_t *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MetricTags, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MetricTags const *","get", 1, self )); 
+  }
+  arg1 = reinterpret_cast< MetricTags * >(argp1);
+  result = (oboe_metric_tag_t *)((MetricTags const *)arg1)->get();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_oboe_metric_tag_t, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 static swig_class SwigClassCustomMetrics;
 
 SWIGINTERN VALUE
@@ -5664,10 +6264,13 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
   int arg12 ;
   int arg13 ;
   int arg14 ;
-  int arg15 ;
-  int arg16 ;
+  double arg15 ;
+  double arg16 ;
   int arg17 ;
   int arg18 ;
+  std::string arg19 ;
+  int arg20 ;
+  int arg21 ;
   int val2 ;
   int ecode2 = 0 ;
   int val4 ;
@@ -5684,18 +6287,22 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
   int ecode13 = 0 ;
   int val14 ;
   int ecode14 = 0 ;
-  int val15 ;
+  double val15 ;
   int ecode15 = 0 ;
-  int val16 ;
+  double val16 ;
   int ecode16 = 0 ;
   int val17 ;
   int ecode17 = 0 ;
   int val18 ;
   int ecode18 = 0 ;
+  int val20 ;
+  int ecode20 = 0 ;
+  int val21 ;
+  int ecode21 = 0 ;
   Reporter *result = 0 ;
   
-  if ((argc < 18) || (argc > 18)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 18)",argc); SWIG_fail;
+  if ((argc < 21) || (argc > 21)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 21)",argc); SWIG_fail;
   }
   {
     std::string *ptr = (std::string *)0;
@@ -5791,16 +6398,16 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "int","Reporter", 14, argv[13] ));
   } 
   arg14 = static_cast< int >(val14);
-  ecode15 = SWIG_AsVal_int(argv[14], &val15);
+  ecode15 = SWIG_AsVal_double(argv[14], &val15);
   if (!SWIG_IsOK(ecode15)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "int","Reporter", 15, argv[14] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "double","Reporter", 15, argv[14] ));
   } 
-  arg15 = static_cast< int >(val15);
-  ecode16 = SWIG_AsVal_int(argv[15], &val16);
+  arg15 = static_cast< double >(val15);
+  ecode16 = SWIG_AsVal_double(argv[15], &val16);
   if (!SWIG_IsOK(ecode16)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "int","Reporter", 16, argv[15] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "double","Reporter", 16, argv[15] ));
   } 
-  arg16 = static_cast< int >(val16);
+  arg16 = static_cast< double >(val16);
   ecode17 = SWIG_AsVal_int(argv[16], &val17);
   if (!SWIG_IsOK(ecode17)) {
     SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "int","Reporter", 17, argv[16] ));
@@ -5811,7 +6418,26 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode18), Ruby_Format_TypeError( "", "int","Reporter", 18, argv[17] ));
   } 
   arg18 = static_cast< int >(val18);
-  result = (Reporter *)new Reporter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[18], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","Reporter", 19, argv[18] )); 
+    }
+    arg19 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode20 = SWIG_AsVal_int(argv[19], &val20);
+  if (!SWIG_IsOK(ecode20)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode20), Ruby_Format_TypeError( "", "int","Reporter", 20, argv[19] ));
+  } 
+  arg20 = static_cast< int >(val20);
+  ecode21 = SWIG_AsVal_int(argv[20], &val21);
+  if (!SWIG_IsOK(ecode21)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode21), Ruby_Format_TypeError( "", "int","Reporter", 21, argv[20] ));
+  } 
+  arg21 = static_cast< int >(val21);
+  result = (Reporter *)new Reporter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
   DATA_PTR(self) = result;
   return self;
 fail:
@@ -5930,598 +6556,198 @@ SWIGINTERN VALUE _wrap_Reporter_sendReport(int nargs, VALUE *args, VALUE self) {
     if (_v) {
       void *vptr = 0;
       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Event, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_oboe_metadata_t, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_Reporter_sendReport__SWIG_1(nargs, args, self);
-        }
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 4, "Reporter.sendReport", 
-    "    bool Reporter.sendReport(Event *evt)\n"
-    "    bool Reporter.sendReport(Event *evt, oboe_metadata_t *md)\n");
-  
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Reporter_sendStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  Reporter *arg1 = (Reporter *) 0 ;
-  Event *arg2 = (Event *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  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_Reporter, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Reporter *","sendStatus", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Reporter * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Event, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Event *","sendStatus", 2, argv[0] )); 
-  }
-  arg2 = reinterpret_cast< Event * >(argp2);
-  result = (bool)(arg1)->sendStatus(arg2);
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Reporter_sendStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  Reporter *arg1 = (Reporter *) 0 ;
-  Event *arg2 = (Event *) 0 ;
-  oboe_metadata_t *arg3 = (oboe_metadata_t *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
-  void *argp3 = 0 ;
-  int res3 = 0 ;
-  bool result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Reporter, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Reporter *","sendStatus", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Reporter * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Event, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Event *","sendStatus", 2, argv[0] )); 
-  }
-  arg2 = reinterpret_cast< Event * >(argp2);
-  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "oboe_metadata_t *","sendStatus", 3, argv[1] )); 
-  }
-  arg3 = reinterpret_cast< oboe_metadata_t * >(argp3);
-  result = (bool)(arg1)->sendStatus(arg2,arg3);
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE _wrap_Reporter_sendStatus(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[4];
-  int ii;
-  
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 4) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reporter, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Event, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        return _wrap_Reporter_sendStatus__SWIG_0(nargs, args, self);
-      }
-    }
-  }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reporter, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      void *vptr = 0;
-      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Event, 0);
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_oboe_metadata_t, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_Reporter_sendStatus__SWIG_1(nargs, args, self);
-        }
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 4, "Reporter.sendStatus", 
-    "    bool Reporter.sendStatus(Event *evt)\n"
-    "    bool Reporter.sendStatus(Event *evt, oboe_metadata_t *md)\n");
-  
-  return Qnil;
-}
-
-
-static swig_class SwigClassDebugLogger;
-
-SWIGINTERN void
-free_DebugLogger(void *self) {
-    DebugLogger *arg1 = (DebugLogger *)self;
-    delete arg1;
-}
-
-SWIGINTERN VALUE
-_wrap_DebugLogger_log(int argc, VALUE *argv, VALUE self) {
-  DebugLogger *arg1 = (DebugLogger *) 0 ;
-  int arg2 ;
-  int arg3 ;
-  char *arg4 = (char *) 0 ;
-  int arg5 ;
-  char *arg6 = (char *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  int res4 ;
-  char *buf4 = 0 ;
-  int alloc4 = 0 ;
-  int val5 ;
-  int ecode5 = 0 ;
-  int res6 ;
-  char *buf6 = 0 ;
-  int alloc6 = 0 ;
-  
-  if ((argc < 5) || (argc > 5)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_DebugLogger, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "DebugLogger *","log", 1, self )); 
-  }
-  arg1 = reinterpret_cast< DebugLogger * >(argp1);
-  ecode2 = SWIG_AsVal_int(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","log", 2, argv[0] ));
-  } 
-  arg2 = static_cast< int >(val2);
-  ecode3 = SWIG_AsVal_int(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","log", 3, argv[1] ));
-  } 
-  arg3 = static_cast< int >(val3);
-  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","log", 4, argv[2] ));
-  }
-  arg4 = reinterpret_cast< char * >(buf4);
-  ecode5 = SWIG_AsVal_int(argv[3], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","log", 5, argv[3] ));
-  } 
-  arg5 = static_cast< int >(val5);
-  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","log", 6, argv[4] ));
-  }
-  arg6 = reinterpret_cast< char * >(buf6);
-  (arg1)->log(arg2,arg3,(char const *)arg4,arg5,(char const *)arg6);
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-  return Qnil;
-fail:
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_oboe_debug_log_handler(int argc, VALUE *argv, VALUE self) {
-  void *arg1 = (void *) 0 ;
-  int arg2 ;
-  int arg3 ;
-  char *arg4 = (char *) 0 ;
-  int arg5 ;
-  char *arg6 = (char *) 0 ;
-  int res1 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  int res4 ;
-  char *buf4 = 0 ;
-  int alloc4 = 0 ;
-  int val5 ;
-  int ecode5 = 0 ;
-  int res6 ;
-  char *buf6 = 0 ;
-  int alloc6 = 0 ;
-  
-  if ((argc < 6) || (argc > 6)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","oboe_debug_log_handler", 1, argv[0] )); 
-  }
-  ecode2 = SWIG_AsVal_int(argv[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","oboe_debug_log_handler", 2, argv[1] ));
-  } 
-  arg2 = static_cast< int >(val2);
-  ecode3 = SWIG_AsVal_int(argv[2], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","oboe_debug_log_handler", 3, argv[2] ));
-  } 
-  arg3 = static_cast< int >(val3);
-  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","oboe_debug_log_handler", 4, argv[3] ));
-  }
-  arg4 = reinterpret_cast< char * >(buf4);
-  ecode5 = SWIG_AsVal_int(argv[4], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","oboe_debug_log_handler", 5, argv[4] ));
-  } 
-  arg5 = static_cast< int >(val5);
-  res6 = SWIG_AsCharPtrAndSize(argv[5], &buf6, NULL, &alloc6);
-  if (!SWIG_IsOK(res6)) {
-    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","oboe_debug_log_handler", 6, argv[5] ));
-  }
-  arg6 = reinterpret_cast< char * >(buf6);
-  oboe_debug_log_handler(arg1,arg2,arg3,(char const *)arg4,arg5,(char const *)arg6);
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-  return Qnil;
-fail:
-  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
-  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
-  return Qnil;
-}
-
-
-static swig_class SwigClassDebugLog;
-
-SWIGINTERN VALUE
-_wrap_DebugLog_getLevelName(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  std::string result;
-  VALUE vresult = Qnil;
-  
-  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","DebugLog::getLevelName", 1, argv[0] ));
-  } 
-  arg1 = static_cast< int >(val1);
-  result = DebugLog::getLevelName(arg1);
-  vresult = SWIG_From_std_string(static_cast< std::string >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_DebugLog_getModuleName(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  std::string result;
-  VALUE vresult = Qnil;
-  
-  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","DebugLog::getModuleName", 1, argv[0] ));
-  } 
-  arg1 = static_cast< int >(val1);
-  result = DebugLog::getModuleName(arg1);
-  vresult = SWIG_From_std_string(static_cast< std::string >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_DebugLog_getLevel(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int result;
-  VALUE vresult = Qnil;
-  
-  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","DebugLog::getLevel", 1, argv[0] ));
-  } 
-  arg1 = static_cast< int >(val1);
-  result = (int)DebugLog::getLevel(arg1);
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_DebugLog_setLevel(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int arg2 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_oboe_metadata_t, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Reporter_sendReport__SWIG_1(nargs, args, self);
+        }
+      }
+    }
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","DebugLog::setLevel", 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","DebugLog::setLevel", 2, argv[1] ));
-  } 
-  arg2 = static_cast< int >(val2);
-  DebugLog::setLevel(arg1,arg2);
-  return Qnil;
+  
 fail:
+  Ruby_Format_OverloadedError( argc, 4, "Reporter.sendReport", 
+    "    bool Reporter.sendReport(Event *evt)\n"
+    "    bool Reporter.sendReport(Event *evt, oboe_metadata_t *md)\n");
+  
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_DebugLog_setOutputStream(int argc, VALUE *argv, VALUE self) {
-  FILE *arg1 = (FILE *) 0 ;
+_wrap_Reporter_sendStatus__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  Reporter *arg1 = (Reporter *) 0 ;
+  Event *arg2 = (Event *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int result;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  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(argv[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Reporter, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","DebugLog::setOutputStream", 1, argv[0] )); 
-  }
-  arg1 = reinterpret_cast< FILE * >(argp1);
-  result = (int)DebugLog::setOutputStream(arg1);
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_DebugLog_setOutputFile(int argc, VALUE *argv, VALUE self) {
-  char *arg1 = (char *) 0 ;
-  int res1 ;
-  char *buf1 = 0 ;
-  int alloc1 = 0 ;
-  int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Reporter *","sendStatus", 1, self )); 
   }
-  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","DebugLog::setOutputFile", 1, argv[0] ));
+  arg1 = reinterpret_cast< Reporter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Event, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Event *","sendStatus", 2, argv[0] )); 
   }
-  arg1 = reinterpret_cast< char * >(buf1);
-  result = (int)DebugLog::setOutputFile((char const *)arg1);
-  vresult = SWIG_From_int(static_cast< int >(result));
-  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  arg2 = reinterpret_cast< Event * >(argp2);
+  result = (bool)(arg1)->sendStatus(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
-  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_DebugLog_addDebugLogger(int argc, VALUE *argv, VALUE self) {
-  DebugLogger *arg1 = (DebugLogger *) 0 ;
-  int arg2 ;
+_wrap_Reporter_sendStatus__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  Reporter *arg1 = (Reporter *) 0 ;
+  Event *arg2 = (Event *) 0 ;
+  oboe_metadata_t *arg3 = (oboe_metadata_t *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int result;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_DebugLogger, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Reporter, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "DebugLogger *","DebugLog::addDebugLogger", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Reporter *","sendStatus", 1, self )); 
   }
-  arg1 = reinterpret_cast< DebugLogger * >(argp1);
-  ecode2 = SWIG_AsVal_int(argv[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","DebugLog::addDebugLogger", 2, argv[1] ));
-  } 
-  arg2 = static_cast< int >(val2);
-  result = (int)DebugLog::addDebugLogger(arg1,arg2);
-  vresult = SWIG_From_int(static_cast< int >(result));
+  arg1 = reinterpret_cast< Reporter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Event, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Event *","sendStatus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< Event * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_oboe_metadata_t, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "oboe_metadata_t *","sendStatus", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< oboe_metadata_t * >(argp3);
+  result = (bool)(arg1)->sendStatus(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN VALUE
-_wrap_DebugLog_removeDebugLogger(int argc, VALUE *argv, VALUE self) {
-  DebugLogger *arg1 = (DebugLogger *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int result;
-  VALUE vresult = Qnil;
+SWIGINTERN VALUE _wrap_Reporter_sendStatus(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_DebugLogger, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "DebugLogger *","DebugLog::removeDebugLogger", 1, argv[0] )); 
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reporter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Event, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Reporter_sendStatus__SWIG_0(nargs, args, self);
+      }
+    }
   }
-  arg1 = reinterpret_cast< DebugLogger * >(argp1);
-  result = (int)DebugLog::removeDebugLogger(arg1);
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Reporter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Event, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_oboe_metadata_t, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Reporter_sendStatus__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
 fail:
+  Ruby_Format_OverloadedError( argc, 4, "Reporter.sendStatus", 
+    "    bool Reporter.sendStatus(Event *evt)\n"
+    "    bool Reporter.sendStatus(Event *evt, oboe_metadata_t *md)\n");
+  
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_DebugLog_logMessage(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int arg2 ;
-  char *arg3 = (char *) 0 ;
-  int arg4 ;
-  char *arg5 = (char *) 0 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int res3 ;
-  char *buf3 = 0 ;
-  int alloc3 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
-  int res5 ;
-  char *buf5 = 0 ;
-  int alloc5 = 0 ;
+_wrap_Reporter_flush(int argc, VALUE *argv, VALUE self) {
+  Reporter *arg1 = (Reporter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
   
-  if ((argc < 5) || (argc > 5)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","DebugLog::logMessage", 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","DebugLog::logMessage", 2, argv[1] ));
-  } 
-  arg2 = static_cast< int >(val2);
-  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","DebugLog::logMessage", 3, argv[2] ));
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  arg3 = reinterpret_cast< char * >(buf3);
-  ecode4 = SWIG_AsVal_int(argv[3], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","DebugLog::logMessage", 4, argv[3] ));
-  } 
-  arg4 = static_cast< int >(val4);
-  res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
-  if (!SWIG_IsOK(res5)) {
-    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","DebugLog::logMessage", 5, argv[4] ));
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Reporter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Reporter *","flush", 1, self )); 
   }
-  arg5 = reinterpret_cast< char * >(buf5);
-  DebugLog::logMessage(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
+  arg1 = reinterpret_cast< Reporter * >(argp1);
+  (arg1)->flush();
   return Qnil;
 fail:
-  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
-  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_DebugLog_allocate(VALUE self)
-#else
-_wrap_DebugLog_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_DebugLog);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
-  return vresult;
-}
-
-
-SWIGINTERN VALUE
-_wrap_new_DebugLog(int argc, VALUE *argv, VALUE self) {
-  DebugLog *result = 0 ;
+_wrap_Reporter_getType(int argc, VALUE *argv, VALUE self) {
+  Reporter *arg1 = (Reporter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  std::string result;
+  VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  result = (DebugLog *)new DebugLog();
-  DATA_PTR(self) = result;
-  return self;
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Reporter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Reporter *","getType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Reporter * >(argp1);
+  result = (arg1)->getType();
+  vresult = SWIG_From_std_string(static_cast< std::string >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN void
-free_DebugLog(void *self) {
-    DebugLog *arg1 = (DebugLog *)self;
-    delete arg1;
-}
-
 static swig_class SwigClassConfig;
 
 SWIGINTERN VALUE
@@ -6557,31 +6783,15 @@ fail:
 
 
 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;
+_wrap_Config_getVersionString(int argc, VALUE *argv, VALUE self) {
+  std::string 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));
+  result = Config::getVersionString();
+  vresult = SWIG_From_std_string(static_cast< std::string >(result));
   return vresult;
 fail:
   return Qnil;
@@ -6633,18 +6843,18 @@ static void *_p_MetadataTo_p_oboe_metadata_t(void *x, int *SWIGUNUSEDPARM(newmem
 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_CustomMetrics = {"_p_CustomMetrics", "CustomMetrics *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_DebugLog = {"_p_DebugLog", "DebugLog *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_DebugLogger = {"_p_DebugLogger", "DebugLogger *", 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_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Metadata = {"_p_Metadata", "Metadata *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_MetricTags = {"_p_MetricTags", "MetricTags *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Reporter = {"_p_Reporter", "Reporter *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Span = {"_p_Span", "Span *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 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 _swigt__p_oboe_metric_tag_t = {"_p_oboe_metric_tag_t", "oboe_metric_tag_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
@@ -6657,18 +6867,18 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_Config,
   &_swigt__p_Context,
   &_swigt__p_CustomMetrics,
-  &_swigt__p_DebugLog,
-  &_swigt__p_DebugLogger,
   &_swigt__p_Event,
-  &_swigt__p_FILE,
   &_swigt__p_Metadata,
   &_swigt__p_MetricTags,
   &_swigt__p_Reporter,
   &_swigt__p_Span,
   &_swigt__p_char,
+  &_swigt__p_double,
   &_swigt__p_int,
+  &_swigt__p_long,
   &_swigt__p_long_long,
   &_swigt__p_oboe_metadata_t,
+  &_swigt__p_oboe_metric_tag_t,
   &_swigt__p_short,
   &_swigt__p_signed_char,
   &_swigt__p_std__string,
@@ -6681,18 +6891,18 @@ static swig_type_info *swig_type_initial[] = {
 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_CustomMetrics[] = {  {&_swigt__p_CustomMetrics, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_DebugLog[] = {  {&_swigt__p_DebugLog, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_DebugLogger[] = {  {&_swigt__p_DebugLogger, 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_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Metadata[] = {  {&_swigt__p_Metadata, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_MetricTags[] = {  {&_swigt__p_MetricTags, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Reporter[] = {  {&_swigt__p_Reporter, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Span[] = {  {&_swigt__p_Span, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 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 _swigc__p_oboe_metric_tag_t[] = {  {&_swigt__p_oboe_metric_tag_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
@@ -6705,18 +6915,18 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_Config,
   _swigc__p_Context,
   _swigc__p_CustomMetrics,
-  _swigc__p_DebugLog,
-  _swigc__p_DebugLogger,
   _swigc__p_Event,
-  _swigc__p_FILE,
   _swigc__p_Metadata,
   _swigc__p_MetricTags,
   _swigc__p_Reporter,
   _swigc__p_Span,
   _swigc__p_char,
+  _swigc__p_double,
   _swigc__p_int,
+  _swigc__p_long,
   _swigc__p_long_long,
   _swigc__p_oboe_metadata_t,
+  _swigc__p_oboe_metric_tag_t,
   _swigc__p_short,
   _swigc__p_signed_char,
   _swigc__p_std__string,
@@ -6993,21 +7203,24 @@ SWIGEXPORT void Init_oboe_metal(void) {
   rb_define_const(mOboe_metal, "OBOE_MODULE_REPORTER_FILE", SWIG_From_int(static_cast< int >(OBOE_MODULE_REPORTER_FILE)));
   rb_define_const(mOboe_metal, "OBOE_MODULE_REPORTER_UDP", SWIG_From_int(static_cast< int >(OBOE_MODULE_REPORTER_UDP)));
   rb_define_const(mOboe_metal, "OBOE_MODULE_REPORTER_SSL", SWIG_From_int(static_cast< int >(OBOE_MODULE_REPORTER_SSL)));
+  rb_define_const(mOboe_metal, "OBOE_MODULE_REPORTER_LAMBDA", SWIG_From_int(static_cast< int >(OBOE_MODULE_REPORTER_LAMBDA)));
   rb_define_const(mOboe_metal, "OBOE_MODULE_APACHE", SWIG_From_int(static_cast< int >(OBOE_MODULE_APACHE)));
   rb_define_const(mOboe_metal, "OBOE_MODULE_NGINX", SWIG_From_int(static_cast< int >(OBOE_MODULE_NGINX)));
   rb_define_const(mOboe_metal, "OBOE_MODULE_PHP", SWIG_From_int(static_cast< int >(OBOE_MODULE_PHP)));
   rb_define_const(mOboe_metal, "OBOE_MODULE_DOTNET", SWIG_From_int(static_cast< int >(OBOE_MODULE_DOTNET)));
+  rb_define_const(mOboe_metal, "OBOE_MODULE_RUBY", SWIG_From_int(static_cast< int >(OBOE_MODULE_RUBY)));
   
   SwigClassMetadata.klass = rb_define_class_under(mOboe_metal, "Metadata", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Metadata, (void *) &SwigClassMetadata);
   rb_define_alloc_func(SwigClassMetadata.klass, _wrap_Metadata_allocate);
   rb_define_method(SwigClassMetadata.klass, "initialize", VALUEFUNC(_wrap_new_Metadata), -1);
-  rb_define_singleton_method(SwigClassMetadata.klass, "fromString", VALUEFUNC(_wrap_Metadata_fromString), -1);
   rb_define_method(SwigClassMetadata.klass, "createEvent", VALUEFUNC(_wrap_Metadata_createEvent), -1);
-  rb_define_singleton_method(SwigClassMetadata.klass, "makeRandom", VALUEFUNC(_wrap_Metadata_makeRandom), -1);
   rb_define_method(SwigClassMetadata.klass, "copy", VALUEFUNC(_wrap_Metadata_copy), -1);
   rb_define_method(SwigClassMetadata.klass, "isValid", VALUEFUNC(_wrap_Metadata_isValid), -1);
   rb_define_method(SwigClassMetadata.klass, "isSampled", VALUEFUNC(_wrap_Metadata_isSampled), -1);
+  rb_define_singleton_method(SwigClassMetadata.klass, "makeRandom", VALUEFUNC(_wrap_Metadata_makeRandom), -1);
+  rb_define_singleton_method(SwigClassMetadata.klass, "fromString", VALUEFUNC(_wrap_Metadata_fromString), -1);
+  rb_define_method(SwigClassMetadata.klass, "metadata", VALUEFUNC(_wrap_Metadata_metadata), -1);
   rb_define_method(SwigClassMetadata.klass, "toString", VALUEFUNC(_wrap_Metadata_toString), -1);
   SwigClassMetadata.mark = 0;
   SwigClassMetadata.destroy = (void (*)(void *)) free_Metadata;
@@ -7032,6 +7245,7 @@ SWIGEXPORT void Init_oboe_metal(void) {
   rb_define_singleton_method(SwigClassContext.klass, "validateTransformServiceName", VALUEFUNC(_wrap_Context_validateTransformServiceName), -1);
   rb_define_singleton_method(SwigClassContext.klass, "shutdown", VALUEFUNC(_wrap_Context_shutdown), -1);
   rb_define_singleton_method(SwigClassContext.klass, "isReady", VALUEFUNC(_wrap_Context_isReady), -1);
+  rb_define_singleton_method(SwigClassContext.klass, "isLambda", VALUEFUNC(_wrap_Context_isLambda), -1);
   rb_define_singleton_method(SwigClassContext.klass, "createEvent", VALUEFUNC(_wrap_Context_createEvent), -1);
   rb_define_singleton_method(SwigClassContext.klass, "startTrace", VALUEFUNC(_wrap_Context_startTrace), -1);
   SwigClassContext.mark = 0;
@@ -7044,9 +7258,15 @@ SWIGEXPORT void Init_oboe_metal(void) {
   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, "addContextOpId", VALUEFUNC(_wrap_Event_addContextOpId), -1);
+  rb_define_method(SwigClassEvent.klass, "addHostname", VALUEFUNC(_wrap_Event_addHostname), -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_method(SwigClassEvent.klass, "opIdString", VALUEFUNC(_wrap_Event_opIdString), -1);
   rb_define_method(SwigClassEvent.klass, "send", VALUEFUNC(_wrap_Event_send), -1);
+  rb_define_method(SwigClassEvent.klass, "sendProfiling", VALUEFUNC(_wrap_Event_sendProfiling), -1);
+  rb_define_method(SwigClassEvent.klass, "addSpanRef", VALUEFUNC(_wrap_Event_addSpanRef), -1);
+  rb_define_method(SwigClassEvent.klass, "addProfileEdge", VALUEFUNC(_wrap_Event_addProfileEdge), -1);
   rb_define_singleton_method(SwigClassEvent.klass, "startTrace", VALUEFUNC(_wrap_Event_startTrace), -1);
   SwigClassEvent.mark = 0;
   SwigClassEvent.destroy = (void (*)(void *)) free_Event;
@@ -7067,6 +7287,7 @@ SWIGEXPORT void Init_oboe_metal(void) {
   rb_define_alloc_func(SwigClassMetricTags.klass, _wrap_MetricTags_allocate);
   rb_define_method(SwigClassMetricTags.klass, "initialize", VALUEFUNC(_wrap_new_MetricTags), -1);
   rb_define_method(SwigClassMetricTags.klass, "add", VALUEFUNC(_wrap_MetricTags_add), -1);
+  rb_define_method(SwigClassMetricTags.klass, "get", VALUEFUNC(_wrap_MetricTags_get), -1);
   SwigClassMetricTags.mark = 0;
   SwigClassMetricTags.destroy = (void (*)(void *)) free_MetricTags;
   SwigClassMetricTags.trackObjects = 0;
@@ -7089,43 +7310,18 @@ SWIGEXPORT void Init_oboe_metal(void) {
   rb_define_method(SwigClassReporter.klass, "init_status", VALUEFUNC(_wrap_Reporter_init_status_get), -1);
   rb_define_method(SwigClassReporter.klass, "sendReport", VALUEFUNC(_wrap_Reporter_sendReport), -1);
   rb_define_method(SwigClassReporter.klass, "sendStatus", VALUEFUNC(_wrap_Reporter_sendStatus), -1);
+  rb_define_method(SwigClassReporter.klass, "flush", VALUEFUNC(_wrap_Reporter_flush), -1);
+  rb_define_method(SwigClassReporter.klass, "getType", VALUEFUNC(_wrap_Reporter_getType), -1);
   SwigClassReporter.mark = 0;
   SwigClassReporter.destroy = (void (*)(void *)) free_Reporter;
   SwigClassReporter.trackObjects = 0;
   
-  SwigClassDebugLogger.klass = rb_define_class_under(mOboe_metal, "DebugLogger", rb_cObject);
-  SWIG_TypeClientData(SWIGTYPE_p_DebugLogger, (void *) &SwigClassDebugLogger);
-  rb_undef_alloc_func(SwigClassDebugLogger.klass);
-  rb_define_method(SwigClassDebugLogger.klass, "log", VALUEFUNC(_wrap_DebugLogger_log), -1);
-  SwigClassDebugLogger.mark = 0;
-  SwigClassDebugLogger.destroy = (void (*)(void *)) free_DebugLogger;
-  SwigClassDebugLogger.trackObjects = 0;
-  rb_define_module_function(mOboe_metal, "oboe_debug_log_handler", VALUEFUNC(_wrap_oboe_debug_log_handler), -1);
-  
-  SwigClassDebugLog.klass = rb_define_class_under(mOboe_metal, "DebugLog", rb_cObject);
-  SWIG_TypeClientData(SWIGTYPE_p_DebugLog, (void *) &SwigClassDebugLog);
-  rb_define_alloc_func(SwigClassDebugLog.klass, _wrap_DebugLog_allocate);
-  rb_define_method(SwigClassDebugLog.klass, "initialize", VALUEFUNC(_wrap_new_DebugLog), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "getLevelName", VALUEFUNC(_wrap_DebugLog_getLevelName), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "getModuleName", VALUEFUNC(_wrap_DebugLog_getModuleName), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "getLevel", VALUEFUNC(_wrap_DebugLog_getLevel), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "setLevel", VALUEFUNC(_wrap_DebugLog_setLevel), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "setOutputStream", VALUEFUNC(_wrap_DebugLog_setOutputStream), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "setOutputFile", VALUEFUNC(_wrap_DebugLog_setOutputFile), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "addDebugLogger", VALUEFUNC(_wrap_DebugLog_addDebugLogger), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "removeDebugLogger", VALUEFUNC(_wrap_DebugLog_removeDebugLogger), -1);
-  rb_define_singleton_method(SwigClassDebugLog.klass, "logMessage", VALUEFUNC(_wrap_DebugLog_logMessage), -1);
-  SwigClassDebugLog.mark = 0;
-  SwigClassDebugLog.destroy = (void (*)(void *)) free_DebugLog;
-  SwigClassDebugLog.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);
+  rb_define_singleton_method(SwigClassConfig.klass, "getVersionString", VALUEFUNC(_wrap_Config_getVersionString), -1);
   SwigClassConfig.mark = 0;
   SwigClassConfig.destroy = (void (*)(void *)) free_Config;
   SwigClassConfig.trackObjects = 0;