appoptics_apm 4.12.2 → 4.13.0

data/ext/oboe_metal/src/logging.cc

@@ -0,0 +1,95 @@
+// Copyright (c) 2021 SolarWinds, LLC.
+// All rights reserved.
+
+#include "logging.h"
+
+using namespace std;
+
+const string Logging::profiling = "profiling";
+const string Logging::ruby = "ruby";
+const string Logging::entry = "entry";
+const string Logging::info = "info";
+const string Logging::exit = "exit";
+
+Event *Logging::createEvent(Metadata &md, string &prof_op_id, bool entry_event) {
+    // startTrace does not add "Edge", for profiling we need to keep track of edges
+    // separately from the main trace metadata
+
+    oboe_metadata_t *md_t = md.metadata();
+    Event *event = Event::startTrace(md_t);
+
+    if (entry_event) {
+        event->addSpanRef(md_t);
+    } else {
+        event->addProfileEdge(prof_op_id);
+        event->addContextOpId(md_t);
+    }
+    prof_op_id.assign(event->opIdString());
+
+    return event;
+}
+
+bool Logging::log_profile_entry(Metadata &md, string &prof_op_id, pid_t tid, long interval) {
+    Event *event = Logging::createEvent(md, prof_op_id, true);
+    event->addInfo((char *)"Label", Logging::entry);
+    event->addInfo((char *)"Language", Logging::ruby);
+    event->addInfo((char *)"TID", (long)tid);
+    event->addInfo((char *)"Interval", interval);
+
+    struct timeval tv;
+    oboe_gettimeofday(&tv);
+    event->addInfo((char *)"Timestamp_u", (long)tv.tv_sec * 1000000 + (long)tv.tv_usec);
+
+    return Logging::log_profile_event(event);
+}
+
+bool Logging::log_profile_exit(Metadata &md, string &prof_op_id, pid_t tid,
+                               long *omitted, int num_omitted) {
+    Event *event = Logging::createEvent(md, prof_op_id);
+    event->addInfo((char *)"Label", Logging::exit);
+    event->addInfo((char *)"TID", (long)tid);
+    event->addInfo((char *)"SnapshotsOmitted", omitted, num_omitted);
+
+    struct timeval tv;
+    oboe_gettimeofday(&tv);
+    event->addInfo((char *)"Timestamp_u", (long)tv.tv_sec * 1000000 + (long)tv.tv_usec);
+
+    return Logging::log_profile_event(event);
+}
+
+bool Logging::log_profile_snapshot(Metadata &md,
+                                   string &prof_op_id,
+                                   long timestamp,
+                                   std::vector<FrameData> const &new_frames,
+                                   long exited_frames,
+                                   long total_frames,
+                                   long *omitted,
+                                   int num_omitted,
+                                   pid_t tid) {
+
+    Event *event = Logging::createEvent(md, prof_op_id);
+    event->addInfo((char *)"Timestamp_u", timestamp);
+    event->addInfo((char *)"Label", Logging::info);
+
+    event->addInfo((char *)"SnapshotsOmitted", omitted, num_omitted);
+    event->addInfo((char *)"NewFrames", new_frames);
+    event->addInfo((char *)"FramesExited", exited_frames);
+    event->addInfo((char *)"FramesCount", total_frames);
+    event->addInfo((char *)"TID", (long)tid);
+
+    return Logging::log_profile_event(event);
+}
+
+bool Logging::log_profile_event(Event *event) {
+        event->addInfo((char *)"Spec", Logging::profiling);
+        event->addHostname();
+        event->addInfo((char *)"PID", (long)AO_GETPID());
+        event->addInfo((char *)"X-Trace", event->metadataString());
+        event->sendProfiling();
+
+        // see comment in oboe_api.cpp:
+        // "event needs to be deleted, it is managed by swig %newobject"
+        // !!! It needs to be deleted, I tested it !!!
+        delete event;
+        return true;
+}

data/ext/oboe_metal/src/logging.h

@@ -0,0 +1,35 @@
+// Copyright (c) 2021 SolarWinds, LLC.
+// All rights reserved.
+
+#ifndef LOGGING_H
+#define LOGGING_H
+
+#include "oboe_api.hpp"
+
+using namespace std;
+
+extern "C" int oboe_gettimeofday(struct timeval *tv);
+
+
+class Logging {
+   public:
+    static const string profiling, ruby, entry, info, exit;
+    static bool log_profile_entry(Metadata &md, string &prof_op_id, pid_t tid, long interval);
+    static bool log_profile_exit(Metadata &md, string &prof_op_id, pid_t tid,
+                                 long *omitted, int num_omitted);
+    static bool log_profile_snapshot(Metadata &md,
+                                     string &prof_op_id,
+                                     long timestamp,
+                                     std::vector<FrameData> const &new_frames,
+                                     long exited_frames,
+                                     long total_frames,
+                                     long *omitted,
+                                     int num_omitted,
+                                     pid_t tid);
+
+   private:
+    static Event *createEvent(Metadata &md, string &prof_op_id, bool entry_event = false);
+    static bool log_profile_event(Event *event);
+};
+
+#endif  //LOGGING_H

data/ext/oboe_metal/src/oboe.h

@@ -161,7 +161,7 @@ typedef struct oboe_metric_tag {
 } oboe_metric_tag_t;
 
 typedef struct oboe_init_options {
-    int version;                            // the version of this structure
+    int version;                            // the version of this structure (currently on version 12)
     const char *hostname_alias;             // optional hostname alias
     int log_level;                          // level at which log messages will be written to log file (0-6)
                                             // use LOGLEVEL_DEFAULT for default log level
@@ -184,6 +184,9 @@ typedef struct oboe_init_options {
 
     int ec2_metadata_timeout;               // EC2 metadata timeout in milliseconds
     const char *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)
 } oboe_init_options_t;
 
 typedef struct oboe_span_params {
@@ -265,9 +268,9 @@ int oboe_metadata_destroy   (oboe_metadata_t *);
 
 int oboe_metadata_is_valid   (const oboe_metadata_t *);
 
-void oboe_metadata_copy     (oboe_metadata_t *, const oboe_metadata_t *);
+int oboe_metadata_copy     (oboe_metadata_t *, const oboe_metadata_t *);
 
-void oboe_metadata_random   (oboe_metadata_t *);
+int oboe_metadata_random   (oboe_metadata_t *);
 
 int oboe_metadata_set_lengths   (oboe_metadata_t *, size_t, size_t);
 int oboe_metadata_create_event  (const oboe_metadata_t *, oboe_event_t *);
@@ -311,10 +314,10 @@ int oboe_event_send(int channel, oboe_event_t *evt, oboe_metadata_t *md);
 // oboe_context
 
 oboe_metadata_t *oboe_context_get();
-void oboe_context_set(oboe_metadata_t *);
+int oboe_context_set(oboe_metadata_t *);
 int oboe_context_set_fromstr(const char *, size_t);
 
-void oboe_context_clear();
+int oboe_context_clear();
 
 int oboe_context_is_valid();
 

data/ext/oboe_metal/src/oboe_api.cpp

@@ -10,7 +10,7 @@
 
 /////// Metatdata ///////
 
-Metadata::Metadata(oboe_metadata_t *md) {
+Metadata::Metadata(const oboe_metadata_t *md) {
     oboe_metadata_copy(this, md);
 }
 
@@ -80,9 +80,9 @@ void Context::setDefaultSampleRate(int newRate) {
 }
 
 void Context::getDecisions(
-    // this paramter list is too long, but other forms of sending info 
+    // this paramter list is too long, but other forms of sending info
     // between python/ruby and c++ would require extra roudn trips
-    // and may be less efficient. 
+    // and may be less efficient.
     // TODO: benchmark this assumption
 
     // output
@@ -214,6 +214,10 @@ int Context::isReady(unsigned int timeout) {
     return oboe_is_ready(timeout);
 }
 
+bool Context::isLambda() {
+    return (bool) oboe_is_lambda();
+}
+
 /**
  * Create a new event object that continues the trace context.
  *
@@ -289,7 +293,7 @@ bool Event::addInfo(char *key, bool val) {
 }
 
 /*
- * this function was added for profiling 
+ * this function was added for profiling
  * to report the timestamps of omitted snapshots
  */
 bool Event::addInfo(char *key, const long *vals, int num) {
@@ -324,7 +328,7 @@ bool Event::addInfo(char *key, const std::vector<FrameData> &vals) {
             oboe_bson_append_string(&(this->bbuf), "C", (val.klass).c_str());
         if (val.file != "")
             oboe_bson_append_string(&(this->bbuf), "F", (val.file).c_str());
-        if (val.lineno != 0)
+        if (val.lineno > 0)
             oboe_bson_append_long(&(this->bbuf), "L", (int64_t)val.lineno);
 
         oboe_bson_append_finish_object(&(this->bbuf));
@@ -357,7 +361,7 @@ bool Event::addHostname() {
     return oboe_event_add_info(this, "Hostname", oboe_hostname) == 0;
 }
 
-bool Event::addContextOpId(oboe_metadata_t *md) {
+bool Event::addContextOpId(const oboe_metadata_t *md) {
     char buf[OBOE_MAX_METADATA_PACK_LEN]; // Flawfinder: ignore
     oboe_metadata_tostr(md, buf, OBOE_MAX_METADATA_PACK_LEN);
     buf[58] = '\0';
@@ -365,7 +369,7 @@ bool Event::addContextOpId(oboe_metadata_t *md) {
     return oboe_event_add_info(this, "ContextOpId", &buf[42]);
 }
 
-bool Event::addSpanRef(oboe_metadata_t *md) {
+bool Event::addSpanRef(const oboe_metadata_t *md) {
     char buf[OBOE_MAX_METADATA_PACK_LEN]; // Flawfinder: ignore
     oboe_metadata_tostr(md, buf, OBOE_MAX_METADATA_PACK_LEN);
     buf[58] = '\0';
@@ -483,18 +487,26 @@ std::string Span::createHttpSpan(const char *transaction, const char *url, const
 
 MetricTags::MetricTags(size_t count) {
     tags = new oboe_metric_tag_t[count];
+    for (size_t i = 0; i < count; i++) {
+        tags[i].key = nullptr;
+        tags[i].value = nullptr;
+    }
     size = count;
 }
 
 MetricTags::~MetricTags() {
+    for (size_t i = 0; i < size; i++) {
+        delete tags[i].key; tags[i].key = nullptr;
+        delete tags[i].value; tags[i].value = nullptr;
+    }
     delete[] tags;
 }
 
-bool MetricTags::add(size_t index, char *k, char *v) {
+bool MetricTags::add(size_t index, const char *k, const char *v) {
     if (index < size) {
-        tags[index].key = k;
-        tags[index].value = v;
-        return true;
+        tags[index].key = strdup(k);
+        tags[index].value = strdup(v);
+        return (tags[index].key != nullptr && tags[index].value != nullptr);
     }
     return false;
 }
@@ -520,6 +532,15 @@ int CustomMetrics::increment(const char *name, const int count, const int host_t
     return oboe_custom_metric_increment(name, count, host_tag, service_name, tags->get(), tags_count);
 }
 
+/////// Profiling ///////
+
+// adding this to have a proper interface, even though it just
+// returns the return value of the oboe function
+// 0 indicates not to profile, returns -1 if the collector hasn't sent anything
+int OboeProfiling::get_interval() {
+    return oboe_get_profiling_interval();
+}
+
 /////// Reporter ///////
 
 Reporter::Reporter(
@@ -544,12 +565,15 @@ Reporter::Reporter(
     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 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)
 ) {
     oboe_init_options_t options;
     memset(&options, 0, sizeof(options));
-    options.version = 10;
+    options.version = 12;
     oboe_init_options_set_defaults(&options);
 
     if (hostname_alias != "") {
@@ -583,6 +607,8 @@ Reporter::Reporter(
     if (grpc_proxy != "") {
         options.proxy = grpc_proxy.c_str();
     }
+    options.stdout_clear_nonblocking = stdout_clear_nonblocking;
+    options.is_grpc_clean_hack_enabled = is_grpc_clean_hack_enabled;
     init_status = oboe_init(&options);
 }
 

data/ext/oboe_metal/src/oboe_api.hpp

@@ -41,7 +41,7 @@ class Metadata : private oboe_metadata_t {
     friend class Context;
 
    public:
-    Metadata(oboe_metadata_t *md);
+    Metadata(const oboe_metadata_t *md);
     ~Metadata();
 
     // these new objects are managed by SWIG %newobject
@@ -219,6 +219,11 @@ class Context {
      */
     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.
@@ -255,7 +260,7 @@ class Event : private oboe_event_t {
 
     bool addEdge(oboe_metadata_t *md);
     bool addEdgeStr(const std::string &val);
-    bool addContextOpId(oboe_metadata_t *md);
+    bool addContextOpId(const oboe_metadata_t *md);
 
     bool addHostname();
 
@@ -287,7 +292,7 @@ class Event : private oboe_event_t {
      */
     bool sendProfiling();
 
-    bool addSpanRef(oboe_metadata_t *md);
+    bool addSpanRef(const oboe_metadata_t *md);
     bool addProfileEdge(std::string id);
 
     /**
@@ -320,10 +325,16 @@ class MetricTags {
    public:
     MetricTags(size_t count);
     ~MetricTags();
-    bool add(size_t index, char *k, char *v);
-
-   private:
+    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;
 };
@@ -337,6 +348,13 @@ class CustomMetrics {
                          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:
@@ -371,8 +389,11 @@ class Reporter : private oboe_reporter_t {
         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 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();

data/ext/oboe_metal/src/oboe_debug.h

@@ -43,6 +43,7 @@ enum OBOE_DEBUG_MODULE {
     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_swig_wrap.cc

@@ -1858,15 +1858,16 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #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_short swig_types[14]
-#define SWIGTYPE_p_signed_char swig_types[15]
-#define SWIGTYPE_p_std__string swig_types[16]
-#define SWIGTYPE_p_unsigned_char swig_types[17]
-#define SWIGTYPE_p_unsigned_int swig_types[18]
-#define SWIGTYPE_p_unsigned_long_long swig_types[19]
-#define SWIGTYPE_p_unsigned_short swig_types[20]
-static swig_type_info *swig_types[22];
-static swig_module_info swig_module = {swig_types, 21, 0, 0, 0, 0};
+#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]
+#define SWIGTYPE_p_unsigned_char swig_types[18]
+#define SWIGTYPE_p_unsigned_int swig_types[19]
+#define SWIGTYPE_p_unsigned_long_long swig_types[20]
+#define SWIGTYPE_p_unsigned_short swig_types[21]
+static swig_type_info *swig_types[23];
+static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -2300,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:
@@ -4518,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 ;
@@ -5098,10 +5115,10 @@ _wrap_Event_addContextOpId(int argc, VALUE *argv, VALUE 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 *","addContextOpId", 2, argv[0] )); 
+    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(arg2);
+  result = (bool)(arg1)->addContextOpId((oboe_metadata_t const *)arg2);
   vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
@@ -5274,10 +5291,10 @@ _wrap_Event_addSpanRef(int argc, VALUE *argv, VALUE 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 *","addSpanRef", 2, argv[0] )); 
+    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(arg2);
+  result = (bool)(arg1)->addSpanRef((oboe_metadata_t const *)arg2);
   vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
@@ -5931,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;
@@ -5951,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
@@ -6228,6 +6269,8 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
   int arg17 ;
   int arg18 ;
   std::string arg19 ;
+  int arg20 ;
+  int arg21 ;
   int val2 ;
   int ecode2 = 0 ;
   int val4 ;
@@ -6252,10 +6295,14 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
   int ecode17 = 0 ;
   int val18 ;
   int ecode18 = 0 ;
+  int val20 ;
+  int ecode20 = 0 ;
+  int val21 ;
+  int ecode21 = 0 ;
   Reporter *result = 0 ;
   
-  if ((argc < 19) || (argc > 19)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 19)",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;
@@ -6380,7 +6427,17 @@ _wrap_new_Reporter(int argc, VALUE *argv, VALUE self) {
     arg19 = *ptr;
     if (SWIG_IsNewObj(res)) delete ptr;
   }
-  result = (Reporter *)new Reporter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
+  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:
@@ -6797,6 +6854,7 @@ static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t
 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};
@@ -6820,6 +6878,7 @@ static swig_type_info *swig_type_initial[] = {
   &_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,
@@ -6843,6 +6902,7 @@ 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}};
@@ -6866,6 +6926,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _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,
@@ -7147,6 +7208,7 @@ SWIGEXPORT void Init_oboe_metal(void) {
   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);
@@ -7183,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;
@@ -7224,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;