appoptics_apm-zearn 4.13.1

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

@@ -0,0 +1,220 @@
+/* bson.h */
+
+/*    Copyright 2009, 2010 10gen Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#ifndef _BSON_H_
+#define _BSON_H_
+
+#define MONGO_HAVE_STDINT
+#include "platform_hacks.h"
+#include <time.h>
+
+MONGO_EXTERN_C_START
+
+typedef enum {
+    oboe_bson_error=-1,
+    oboe_bson_eoo=0,
+    oboe_bson_double=1,
+    oboe_bson_string=2,
+    oboe_bson_object=3,
+    oboe_bson_array=4,
+    oboe_bson_bindata=5,
+    oboe_bson_undefined=6,
+    oboe_bson_oid=7,
+    oboe_bson_bool=8,
+    oboe_bson_date=9,
+    oboe_bson_null=10,
+    oboe_bson_regex=11,
+    oboe_bson_dbref=12, /* deprecated */
+    oboe_bson_code=13,
+    oboe_bson_symbol=14,
+    oboe_bson_codewscope=15,
+    oboe_bson_int = 16,
+    oboe_bson_timestamp = 17,
+    oboe_bson_long = 18
+} oboe_bson_type;
+
+typedef int oboe_bson_bool_t;
+
+typedef struct {
+    char * data;
+    oboe_bson_bool_t owned;
+} oboe_bson;
+
+typedef struct {
+    const char * cur;
+    oboe_bson_bool_t first;
+} oboe_bson_iterator;
+
+typedef struct {
+    char * buf;
+    char * cur;
+    int bufSize;
+    oboe_bson_bool_t finished;
+    int stack[32];
+    int stackPos;
+} oboe_bson_buffer;
+
+#pragma pack(1)
+typedef union{
+    char bytes[12];  // Flawfinder: ignore
+    int ints[3];
+} oboe_bson_oid_t;
+#pragma pack()
+
+typedef int64_t oboe_bson_date_t; /* milliseconds since epoch UTC */
+
+/* ----------------------------
+   READING
+   ------------------------------ */
+
+
+oboe_bson * oboe_bson_empty(oboe_bson * obj); /* returns pointer to static empty bson object */
+int oboe_bson_copy(oboe_bson* out, const oboe_bson* in); /* puts data in new buffer. NOOP if out==NULL */
+oboe_bson * oboe_bson_from_buffer(oboe_bson * b, oboe_bson_buffer * buf);
+oboe_bson * oboe_bson_init( oboe_bson * b , char * data , oboe_bson_bool_t mine );
+oboe_bson * oboe_bson_init_safe( oboe_bson * b , char * data , oboe_bson_bool_t mine , size_t buflen);
+int oboe_bson_size(const oboe_bson * b );
+void oboe_bson_destroy( oboe_bson * b );
+
+void oboe_bson_print( oboe_bson * b );
+void oboe_bson_print_raw( const char * bson , int depth );
+
+/* advances iterator to named field */
+/* returns bson_eoo (which is false) if field not found */
+oboe_bson_type oboe_bson_find(oboe_bson_iterator* it, const oboe_bson* obj, const char* name);
+
+void oboe_bson_iterator_init( oboe_bson_iterator * i , const char * bson );
+
+/* more returns true for eoo. best to loop with bson_iterator_next(&it) */
+oboe_bson_bool_t oboe_bson_iterator_more( const oboe_bson_iterator * i );
+oboe_bson_type oboe_bson_iterator_next( oboe_bson_iterator * i );
+
+oboe_bson_type oboe_bson_iterator_type( const oboe_bson_iterator * i );
+const char * oboe_bson_iterator_key( const oboe_bson_iterator * i );
+const char * oboe_bson_iterator_value( const oboe_bson_iterator * i );
+
+/* these convert to the right type (return 0 if non-numeric) */
+double oboe_bson_iterator_double( const oboe_bson_iterator * i );
+int oboe_bson_iterator_int( const oboe_bson_iterator * i );
+int64_t oboe_bson_iterator_long( const oboe_bson_iterator * i );
+
+/* false: boolean false, 0 in any type, or null */
+/* true: anything else (even empty strings and objects) */
+oboe_bson_bool_t oboe_bson_iterator_bool( const oboe_bson_iterator * i );
+
+/* these assume you are using the right type */
+double oboe_bson_iterator_double_raw( const oboe_bson_iterator * i );
+int oboe_bson_iterator_int_raw( const oboe_bson_iterator * i );
+int64_t oboe_bson_iterator_long_raw( const oboe_bson_iterator * i );
+oboe_bson_bool_t oboe_bson_iterator_bool_raw( const oboe_bson_iterator * i );
+oboe_bson_oid_t* oboe_bson_iterator_oid( const oboe_bson_iterator * i );
+
+/* these can also be used with bson_code and bson_symbol*/
+const char * oboe_bson_iterator_string( const oboe_bson_iterator * i );
+int oboe_bson_iterator_string_len( const oboe_bson_iterator * i );
+
+/* works with bson_code, bson_codewscope, and bson_string */
+/* returns NULL for everything else */
+const char * oboe_bson_iterator_code(const oboe_bson_iterator * i);
+
+/* calls bson_empty on scope if not a bson_codewscope */
+void oboe_bson_iterator_code_scope(const oboe_bson_iterator * i, oboe_bson * scope);
+
+/* both of these only work with bson_date */
+oboe_bson_date_t oboe_bson_iterator_date(const oboe_bson_iterator * i);
+time_t oboe_bson_iterator_time_t(const oboe_bson_iterator * i);
+
+int oboe_bson_iterator_bin_len( const oboe_bson_iterator * i );
+char oboe_bson_iterator_bin_type( const oboe_bson_iterator * i );
+const char * oboe_bson_iterator_bin_data( const oboe_bson_iterator * i );
+
+const char * oboe_bson_iterator_regex( const oboe_bson_iterator * i );
+const char * oboe_bson_iterator_regex_opts( const oboe_bson_iterator * i );
+
+/* these work with bson_object and bson_array */
+void oboe_bson_iterator_subobject(const oboe_bson_iterator * i, oboe_bson * sub);
+void oboe_bson_iterator_subiterator(const oboe_bson_iterator * i, oboe_bson_iterator * sub);
+
+/* str must be at least 24 hex chars + null byte */
+void oboe_bson_oid_from_string(oboe_bson_oid_t* oid, const char* str);
+void oboe_bson_oid_to_string(const oboe_bson_oid_t* oid, char* str);
+void oboe_bson_oid_gen(oboe_bson_oid_t* oid);
+
+time_t oboe_bson_oid_generated_time(oboe_bson_oid_t* oid); /* Gives the time the OID was created */
+
+/* ----------------------------
+   BUILDING
+   ------------------------------ */
+
+oboe_bson_buffer * oboe_bson_buffer_init( oboe_bson_buffer * b );
+oboe_bson_buffer * oboe_bson_ensure_space( oboe_bson_buffer * b , const int bytesNeeded );
+
+/**
+ * @return the raw data.  you either should free this OR call bson_destroy not both
+ */
+char * oboe_bson_buffer_finish( oboe_bson_buffer * b );
+void oboe_bson_buffer_destroy( oboe_bson_buffer * b );
+
+oboe_bson_buffer * oboe_bson_append_oid( oboe_bson_buffer * b , const char * name , const oboe_bson_oid_t* oid );
+oboe_bson_buffer * oboe_bson_append_int( oboe_bson_buffer * b , const char * name , const int i );
+oboe_bson_buffer * oboe_bson_append_long( oboe_bson_buffer * b , const char * name , const int64_t i );
+oboe_bson_buffer * oboe_bson_append_double( oboe_bson_buffer * b , const char * name , const double d );
+oboe_bson_buffer * oboe_bson_append_string( oboe_bson_buffer * b , const char * name , const char * str );
+oboe_bson_buffer * oboe_bson_append_symbol( oboe_bson_buffer * b , const char * name , const char * str );
+oboe_bson_buffer * oboe_bson_append_code( oboe_bson_buffer * b , const char * name , const char * str );
+oboe_bson_buffer * oboe_bson_append_code_w_scope( oboe_bson_buffer * b , const char * name , const char * code , const oboe_bson * scope);
+oboe_bson_buffer * oboe_bson_append_binary( oboe_bson_buffer * b, const char * name, char type, const char * str, int len );
+oboe_bson_buffer * oboe_bson_append_bool( oboe_bson_buffer * b , const char * name , const oboe_bson_bool_t v );
+oboe_bson_buffer * oboe_bson_append_null( oboe_bson_buffer * b , const char * name );
+oboe_bson_buffer * oboe_bson_append_undefined( oboe_bson_buffer * b , const char * name );
+oboe_bson_buffer * oboe_bson_append_regex( oboe_bson_buffer * b , const char * name , const char * pattern, const char * opts );
+oboe_bson_buffer * oboe_bson_append_bson( oboe_bson_buffer * b , const char * name , const oboe_bson* bson);
+oboe_bson_buffer * oboe_bson_append_element( oboe_bson_buffer * b, const char * name_or_null, const oboe_bson_iterator* elem);
+
+/* these both append a bson_date */
+oboe_bson_buffer * oboe_bson_append_date(oboe_bson_buffer * b, const char * name, oboe_bson_date_t millis);
+oboe_bson_buffer * oboe_bson_append_time_t(oboe_bson_buffer * b, const char * name, time_t secs);
+
+oboe_bson_buffer * oboe_bson_append_start_object( oboe_bson_buffer * b , const char * name );
+oboe_bson_buffer * oboe_bson_append_start_array( oboe_bson_buffer * b , const char * name );
+oboe_bson_buffer * oboe_bson_append_finish_object( oboe_bson_buffer * b );
+
+void oboe_bson_numstr(char* str, int i);
+void oboe_bson_incnumstr(char* str);
+
+
+/* ------------------------------
+   ERROR HANDLING - also used in mongo code
+   ------------------------------ */
+
+void * oboe_bson_malloc(int size); /* checks return value */
+
+/* bson_err_handlers shouldn't return!!! */
+typedef void(*ob_bson_err_handler)(const char* errmsg);
+
+/* returns old handler or NULL */
+/* default handler prints error then exits with failure*/
+ob_bson_err_handler oboe_set_bson_err_handler(ob_bson_err_handler func);
+
+
+
+/* does nothing is ok != 0 */
+void oboe_bson_fatal( int ok );
+int oboe_bson_fatal_msg( int ok, const char* msg );
+
+MONGO_EXTERN_C_END
+#endif

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

@@ -0,0 +1,91 @@
+/* platform_hacks.h */
+/*    Copyright 2009, 2010 10gen Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+
+/* all platform-specific ifdefs should go here */
+
+#ifndef _PLATFORM_HACKS_H_
+#define _PLATFORM_HACKS_H_
+
+#ifdef __GNUC__
+#define MONGO_INLINE static __inline__
+#else
+#define MONGO_INLINE static
+#endif
+
+#ifdef __cplusplus
+#define MONGO_EXTERN_C_START extern "C" {
+#define MONGO_EXTERN_C_END }
+#else
+#define MONGO_EXTERN_C_START
+#define MONGO_EXTERN_C_END
+#endif
+
+
+#if defined(MONGO_HAVE_STDINT) || __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+#elif defined(MONGO_HAVE_UNISTD)
+#include <unistd.h>
+#elif defined(MONGO_USE__INT64)
+typedef __int64 int64_t;
+#elif defined(MONGO_USE_LONG_LONG_INT)
+typedef long long int int64_t;
+#else
+#error must have a 64bit int type
+#endif
+
+/* big endian is only used for OID generation. little is used everywhere else */
+#ifdef MONGO_BIG_ENDIAN
+#define oboe_bson_little_endian64(out, in) ( oboe_bson_swap_endian64(out, in) )
+#define oboe_bson_little_endian32(out, in) ( oboe_bson_swap_endian32(out, in) )
+#define oboe_bson_big_endian64(out, in) ( memmove(out, in, 8) )
+#define oboe_bson_big_endian32(out, in) ( memmove(out, in, 4) )
+#else
+#define oboe_bson_little_endian64(out, in) ( memmove(out, in, 8) )
+#define oboe_bson_little_endian32(out, in) ( memmove(out, in, 4) )
+#define oboe_bson_big_endian64(out, in) ( oboe_bson_swap_endian64(out, in) )
+#define oboe_bson_big_endian32(out, in) ( oboe_bson_swap_endian32(out, in) )
+#endif
+
+MONGO_EXTERN_C_START
+
+MONGO_INLINE void oboe_bson_swap_endian64(void* outp, const void* inp){
+    const char *in = (const char*)inp;
+    char *out = (char*)outp;
+
+    out[0] = in[7];
+    out[1] = in[6];
+    out[2] = in[5];
+    out[3] = in[4];
+    out[4] = in[3];
+    out[5] = in[2];
+    out[6] = in[1];
+    out[7] = in[0];
+
+}
+MONGO_INLINE void oboe_bson_swap_endian32(void* outp, const void* inp){
+    const char *in = (const char*)inp;
+    char *out = (char*)outp;
+
+    out[0] = in[3];
+    out[1] = in[2];
+    out[2] = in[1];
+    out[3] = in[0];
+}
+
+MONGO_EXTERN_C_END
+
+#endif

data/ext/oboe_metal/src/frames.cc

@@ -0,0 +1,246 @@
+// Copyright (c) 2021 SolarWinds, LLC.
+// All rights reserved.
+
+#include "frames.h"
+
+using namespace std;
+
+unordered_map<VALUE, FrameData> cached_frames;
+
+// in theory the mutex is not needed, because Ruby does not context switch
+// while executing a foreign function, but will this always hold true?
+mutex cached_frames_mutex;
+
+void Frames::reserve_cached_frames() {
+    lock_guard<mutex> guard(cached_frames_mutex);
+    // unordered_maps grow automatically, but it starts at 1 and then
+    // doubles when it is full, so lets avoid the warmup
+    cached_frames.reserve(500);  // it will round to a prime number: 503
+}
+
+void Frames::clear_cached_frames() {
+    lock_guard<mutex> guard(cached_frames_mutex);
+        // unordered_maps grow automatically, but it starts at 1 and then
+        // doubles when it is full, so lets avoid the warmup
+    cached_frames.clear();
+}
+
+// this is a private function
+int Frames::cache_frame(VALUE frame) {
+    VALUE val;
+    FrameData data;
+
+    // only cache it if it does not exist
+    if (cached_frames.count(frame) == 0) {
+        val = rb_profile_frame_label(frame);  // returns method or block
+        if (RB_TYPE_P(val, T_STRING))
+            data.method = RSTRING_PTR(val);
+
+        if (data.method.rfind("block ", 0) == 0) {
+            // we don't need more info if it is a block
+            // we ignore block level info because they make things messy
+            lock_guard<mutex> guard(cached_frames_mutex);
+            cached_frames.insert({frame, data});
+            return 0;
+        }
+
+        val = rb_profile_frame_classpath(frame);  // returns class or nil
+        if (RB_TYPE_P(val, T_STRING)) data.klass = RSTRING_PTR(val);
+
+        val = rb_profile_frame_absolute_path(frame);  // returns file, use rb_profile_frame_path() if nil
+        if (!RB_TYPE_P(val, T_STRING)) val = rb_profile_frame_path(frame);
+        if (RB_TYPE_P(val, T_STRING)) data.file = RSTRING_PTR(val);
+
+        // Ruby 3 reports <cfunc>, but the linenumbers are bogus
+        // the default line number is 0
+        if (!data.file.compare("<cfunc>") == 0) {
+            val = rb_profile_frame_first_lineno(frame);  // returns line number
+            if (RB_TYPE_P(val, T_FIXNUM)) {
+                data.lineno = NUM2INT(val);
+            }
+        }
+        lock_guard<mutex> guard(cached_frames_mutex);
+        cached_frames.insert({frame, data});
+    }
+    return 0;
+}
+
+// all frames in frames_buffer must be in cached_frames
+// before calling this function
+// we are saving the check for better performance
+int Frames::collect_frame_data(VALUE *frames_buffer, int num, vector<FrameData> &frame_data) {
+    if (num == 1) {
+        if (frames_buffer[0] == PR_IN_GC) {
+            FrameData data;
+            data.method = "GARBAGE COLLECTION";
+            frame_data.push_back(data);
+            return 0;
+        } else if (frames_buffer[0] == PR_OTHER_THREAD) {
+            FrameData data;
+            data.method = "OTHER THREADS";
+            frame_data.push_back(data);
+            return 0;
+        }
+    }
+
+    for (int i = 0; i < num; i++) {
+        VALUE frame = frames_buffer[i];
+        frame_data.push_back(cached_frames[frame]);
+    }
+    return 0;
+}
+
+/////
+// For the sake of efficiency this function filters uninteresting frames and
+// does the caching of frames at the same time
+//
+// in-place removal of
+// - frames with line number == 0
+// - all but last of repeated frames
+// - "block" frames (they are confusing) <- revisit
+// and cache uncached frames
+int Frames::remove_garbage(VALUE *frames_buffer, int num) {
+    if (num == 1 && (frames_buffer[0] == PR_OTHER_THREAD || frames_buffer[0] == PR_IN_GC))
+        return 1;
+
+    // TODO decide what to do with <cfunc> frames in Ruby 3
+
+    // 1) ignore top frames where the line number is 0
+    // does that mean there is no line number???
+    bool found = true;
+
+    while (found && num > 0) {
+        if (cached_frames.count(frames_buffer[num - 1]) == 1) {
+            found = (cached_frames[frames_buffer[num - 1]].lineno == 0);
+            if (found) num--;
+        } else {
+            VALUE val = rb_profile_frame_first_lineno(frames_buffer[num - 1]);
+            found = (!RB_TYPE_P(val, T_FIXNUM) || !NUM2INT(val));
+            if (found) {
+                lock_guard<mutex> guard(cached_frames_mutex);
+                cached_frames[frames_buffer[num - 1]].lineno = 0;
+                num--;
+            }
+        }
+    }
+
+    // 2) remove all repeated frames, keep the last one
+    int count = 0;
+    int k = 0;
+    found = false;
+    while (count < num - k) {
+        // is this frame repeated ahead?
+        // if so we will replace it with the next one in line
+        for (int j = count + k + 1; j < num; j++) {
+            if (frames_buffer[count] == frames_buffer[j]) {
+                found = true;
+                break;
+            }
+        }
+
+        if (found) {
+            // if we found this frame again later in the snapshot
+            // we are going to override this one
+            // but not if this is going beyond the boundary
+            k++;
+            if (count + k < num - 1) frames_buffer[count] = frames_buffer[count + k];
+        } else {
+            count++;
+            frames_buffer[count] = frames_buffer[count + k];
+        }
+        found = false;
+    }
+
+    // 3) remove "block" frames, they are reported inconsistently and mess up
+    //    the profile in the dashboard
+    // 4)  while we are at it we also cache all the frames
+    // these 2 are combined so we don't have to run this loop twice
+    num = count;
+    count = 0, k = 0;
+    string method;
+
+    while (count < num - k) {
+        frames_buffer[count] = frames_buffer[count + k];
+        cache_frame(frames_buffer[count]);
+        method = cached_frames[frames_buffer[count]].method;
+
+        // TODO revisit need to remove block frames, they only appear when the Ruby
+        // ____ script is not started with a method and has blocks outside of the
+        // ____ methods called and sometimes inside of rack
+        if (method.rfind("block ", 0) == 0) {
+            k++;
+        } else {
+            count++;
+        }
+    }
+    return count;
+}
+
+// returns the number of the matching frames
+int Frames::num_matching(VALUE *frames_buffer, int num,
+                         VALUE *prev_frames_buffer, int prev_num) {
+    int i;
+    int min = std::min(num, prev_num);
+
+    for (i = 0; i < min; i++) {
+        // we have to start from the "top"
+        if (frames_buffer[num - 1 - i] != prev_frames_buffer[prev_num - 1 - i]) {
+            return i;
+        }
+    }
+    return i;
+}
+
+/////////////////////// DEBUGGING HELPER FUNCTIONS /////////////////////////////
+// helper function to print frame from ruby pointers to frame
+void Frames::print_raw_frame_info(VALUE frame) {
+    if (frame == PR_IN_GC || frame == PR_OTHER_THREAD) {
+        return;
+    }
+
+    VALUE val;
+    int lineno;
+    string file, klass, method;
+
+    val = rb_profile_frame_first_lineno(frame);  // returns line number
+    if (RB_TYPE_P(val, T_FIXNUM)) lineno = NUM2INT(val);
+
+    val = rb_profile_frame_classpath(frame);  // returns class or nil
+    if (RB_TYPE_P(val, T_STRING)) klass = RSTRING_PTR(val);
+
+    val = rb_profile_frame_absolute_path(frame);  // returns file, use rb_profile_frame_path() if nil
+    if (!RB_TYPE_P(val, T_STRING)) val = rb_profile_frame_path(frame);
+    if (RB_TYPE_P(val, T_STRING)) file = RSTRING_PTR(val);
+
+    val = rb_profile_frame_label(frame);  // returns method or block
+    if (RB_TYPE_P(val, T_STRING)) method = RSTRING_PTR(val);
+
+    cout << "    " << frame << "   "
+         << "L: " << lineno << " "
+         << "F: " << file << " "
+         << "C: " << klass << " "
+         << "M: " << method << endl;
+}
+
+void Frames::print_all_raw_frames(VALUE *frames_buffer, int num) {
+    for (int i = 0; i < num; i++) {
+        print_raw_frame_info(frames_buffer[i]);
+    }
+}
+
+// helper function to print frame info
+void Frames::print_frame_info(VALUE frame) {
+    if (cached_frames.find(frame) != cached_frames.end())
+        std::cout << cached_frames[frame].lineno << " "
+                  << cached_frames[frame].file << " "
+                  << cached_frames[frame].klass << " "
+                  << cached_frames[frame].method << std::endl;
+}
+
+// helper function for printing the cached frames
+void Frames::print_cached_frames() {
+    std::cout << "cached_frames contains:" << endl;
+    for (auto it = cached_frames.cbegin(); it != cached_frames.cend(); ++it)
+        std::cout << "           " << it->first << " - " << it->second.method << ":" << it->second.lineno << endl;  // cannot modify *it
+    std::cout << std::endl;
+}

data/ext/oboe_metal/src/frames.h

@@ -0,0 +1,40 @@
+// Copyright (c) 2021 SolarWinds, LLC.
+// All rights reserved.
+
+#ifndef FRAMES_H
+#define FRAMES_H
+
+#include <vector>
+
+#include <mutex>
+#include <unordered_map>
+
+#include <ruby/ruby.h>
+#include <ruby/debug.h>
+
+#include "profiling.h"
+#include "oboe_api.hpp"
+
+using namespace std;
+
+class Frames {
+   public:
+    static void clear_cached_frames();
+    static void reserve_cached_frames();
+    static int collect_frame_data(VALUE *frames_buffer, int num, vector<FrameData> &frame_data);
+    static int remove_garbage(VALUE *frames_buffer, int num);
+    static int num_matching(VALUE *frames_buffer, int num,
+                            VALUE *prev_frames_buffer, int prev_num);
+
+   private:
+    static int cache_frame(VALUE frame);
+
+    // Debugging helper functions
+   public:
+    static void print_raw_frame_info(VALUE frame);
+    static void print_all_raw_frames(VALUE *frames_buffer, int num);
+    static void print_frame_info(VALUE frame);
+    static void print_cached_frames();
+};
+
+#endif //FRAMES_H

data/ext/oboe_metal/src/init_appoptics_apm.cc

@@ -0,0 +1,21 @@
+// Copyright (c) 2019 SolarWinds, LLC.
+// All rights reserved.
+
+#include <iostream>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Init_oboe_metal(void);
+
+void Init_profiling(void);
+
+void Init_libappoptics_apm() {
+    Init_oboe_metal();
+    Init_profiling();
+}
+
+#ifdef __cplusplus
+}
+#endif