solarwinds_apm 5.1.9 → 6.0.0.preV1

data/ext/oboe_metal/src/logging.cc

@@ -1,97 +0,0 @@
-// 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;
-    struct timezone *tz = NULL;
-    gettimeofday(&tv, tz);
-    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;
-    struct timezone *tz = NULL;
-    gettimeofday(&tv, tz);
-    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

@@ -1,34 +0,0 @@
-// Copyright (c) 2021 SolarWinds, LLC.
-// All rights reserved.
-
-#ifndef LOGGING_H
-#define LOGGING_H
-
-#include "oboe_api.h"
-
-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/profiling.cc

@@ -1,435 +0,0 @@
-// Copyright (c) 2021 SolarWinds, LLC.
-// All rights reserved.
-
-#include "profiling.h"
-
-#include <ruby/debug.h>
-#include <signal.h>
-#include <time.h>
-
-#include <atomic>
-#include <unordered_map>
-#include <vector>
-
-#include "frames.h"
-#include "logging.h"
-#include "oboe_api.h"
-
-
-#define TIMER_SIG SIGRTMAX        // the timer notification signal
-
-using namespace std;
-
-static atomic_bool running;
-atomic_bool profiling_shut_down;  // !! can't be static because of tests
-
-// need to initialize here, hangs if it is done inside the signal handler
-// these are reused for every snapshot
-static VALUE frames_buffer[BUF_SIZE];
-static int lines_buffer[BUF_SIZE];
-
-
-static long configured_interval = 10;  // in milliseconds, initializing in case Ruby forgets to
-static long current_interval = 10;
-timer_t timerid;
-
-typedef struct prof_data {
-    bool running_p = false;
-    Metadata md = Metadata(Context::get());
-    string prof_op_id;
-
-    VALUE prev_frames_buffer[BUF_SIZE];
-    int prev_num = 0;
-    long omitted[BUF_SIZE];
-    int omitted_num = 0;
-} prof_data_t;
-
-unordered_map<pid_t, prof_data_t> prof_data_map;
-
-const string Profiling::string_job_handler = "Profiling::profiler_job_handler()";
-const string Profiling::string_gc_handler = "Profiling::profiler_gc_handler()";
-const string Profiling::string_signal_handler = "Profiling::profiler_signal_handler()";
-const string Profiling::string_stop = "Profiling::profiling_stop()";
-
-// for debugging only
-void print_prof_data_map() {
-    pid_t tid = AO_GETTID;
-    Metadata md_str(prof_data_map[tid].md);
-    cout << tid << ", " << prof_data_map[tid].running_p << ", " << prof_data_map[tid].prof_op_id << ", ";
-    cout << md_str.toString() << ", " << prof_data_map[tid].prev_num << ", " << prof_data_map[tid].omitted_num << endl;
-}
-
-long ts_now() {
-    struct timeval tv;
-    struct timezone *tz = NULL;
-    gettimeofday(&tv, tz);
-    return (long)tv.tv_sec * 1000000 + (long)tv.tv_usec;
-}
-
-// try catch block to be used inside functions that return an int
-// shuts down profiling and returns -1 on error
-int Profiling::try_catch_shutdown(std::function<int()> f, const string& fun_name) {
-    try {
-        return f();
-    } catch (const std::exception &e) {
-        string msg = "Exception in " + fun_name + ", can't recover, profiling shutting down";
-        OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, e.what());
-        OBOE_DEBUG_LOG_HIGH(OBOE_MODULE_RUBY, msg.c_str());
-        Profiling::shut_down();
-        return -1;
-    } catch (...) {
-        string msg = "Exception in " + fun_name + ", can't recover, profiling shutting down";
-        OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, msg.c_str());
-        Profiling::shut_down();
-        return -1;
-    }
-}
-
-void Profiling::profiler_record_frames() {
-    pid_t tid = AO_GETTID;
-    long ts = ts_now();
-
-    // check if this thread is being profiled
-    if (prof_data_map[tid].running_p) {
-        // executes in the same thread as rb_postponed_job was called from
-
-        // get the frames
-        // won't overrun frames buffer, because size is set in arg 2
-        int num = rb_profile_frames(0, sizeof(frames_buffer) / sizeof(VALUE), frames_buffer, lines_buffer);
-
-        Profiling::process_snapshot(frames_buffer, num, tid, ts);
-    }
-
-    // add this timestamp as omitted to other running threads that are profiled
-    for (pair<const pid_t, prof_data_t> &ele : prof_data_map) {
-        if (ele.second.running_p && ele.first != tid) {
-            frames_buffer[0] = PR_OTHER_THREAD;
-            Profiling::process_snapshot(frames_buffer, 1, ele.first, ts);
-        }
-    }
-}
-
-void Profiling::profiler_record_gc() {
-   pid_t tid = AO_GETTID;
-   long ts = ts_now();
-
-    // check if this thread is being profiled
-    if (prof_data_map[tid].running_p) {
-        frames_buffer[0] = PR_IN_GC;
-        Profiling::process_snapshot(frames_buffer, 1, tid, ts);
-    }
-
-    // add this timestamp as omitted to other running threads that are profiled
-    for (pair<const pid_t, prof_data_t> &ele : prof_data_map) {
-        if (ele.second.running_p && ele.first != tid) {
-            frames_buffer[0] = PR_OTHER_THREAD;
-            Profiling::process_snapshot(frames_buffer, 1, ele.first, ts);
-        }
-    }
-}
-
-void Profiling::send_omitted(pid_t tid, long ts) {
-    static vector<FrameData> empty;
-    Logging::log_profile_snapshot(prof_data_map[tid].md,
-                                  prof_data_map[tid].prof_op_id,
-                                  ts,                              // timestamp
-                                  empty,                           // <vector> new frames
-                                  0,                               // number of exited frames
-                                  prof_data_map[tid].prev_num,     // total number of frames
-                                  prof_data_map[tid].omitted,      // array of timestamps of omitted snapshots
-                                  prof_data_map[tid].omitted_num,  // number of omitted snapshots
-                                  tid);                            // thread id
-
-    prof_data_map[tid].omitted_num = 0;
-}
-
-void Profiling::process_snapshot(VALUE *frames_buffer, int num, pid_t tid, long ts) {
-    int num_new = 0;
-    int num_exited = 0;
-    vector<FrameData> new_frames;
-
-    num = Frames::remove_garbage(frames_buffer, num);
-
-    // find the number of matching frames from the top
-    int num_match = Frames::num_matching(frames_buffer,
-                                         num,
-                                         prof_data_map[tid].prev_frames_buffer,
-                                         prof_data_map[tid].prev_num);
-    num_new = num - num_match;
-    num_exited = prof_data_map[tid].prev_num - num_match;
-
-    if (num_new == 0 && num_exited == 0) {
-        prof_data_map[tid].omitted[prof_data_map[tid].omitted_num] = ts;
-        prof_data_map[tid].omitted_num++;
-
-        // the omitted buffer can fill up if the interval is small
-        // and the stack doesn't change
-        // We need to send a profiling event with the timestamps when it is full
-        if (prof_data_map[tid].omitted_num >= BUF_SIZE) {
-            Profiling::send_omitted(tid, ts);
-        }
-        return;
-    }
-
-    Frames::collect_frame_data(frames_buffer, num_new, new_frames);
-
-    Logging::log_profile_snapshot(prof_data_map[tid].md,
-                                  prof_data_map[tid].prof_op_id,
-                                  ts,                              // timestamp
-                                  new_frames,                      // <vector> new frames
-                                  num_exited,                      // number of exited frames
-                                  num,                             // total number of frames
-                                  prof_data_map[tid].omitted,      // array of timestamps of omitted snapshots
-                                  prof_data_map[tid].omitted_num,  // number of omitted snapshots
-                                  tid);                            // thread id
-
-    prof_data_map[tid].omitted_num = 0;
-    prof_data_map[tid].prev_num = num;
-    for (int i = 0; i < num; ++i)
-        prof_data_map[tid].prev_frames_buffer[i] = frames_buffer[i];
-}
-
-void Profiling::profiler_job_handler(void *data) {
-    static atomic_bool in_job_handler{false};
-
-    // atomically replaces the value of the object, returns the value held previously
-    if (in_job_handler.exchange(true)) return;
-
-    try_catch_shutdown([&]() {
-        Profiling::profiler_record_frames();
-        return 0;  // block needs an int returned
-    }, Profiling::string_job_handler);
-
-    in_job_handler = false;
-}
-
-void Profiling::profiler_gc_handler(void *data) {
-    static atomic_bool in_gc_handler{false};
-
-    // atomically replaces the value of the object, returns the value held previously
-    if (in_gc_handler.exchange(true)) return;
-
-    try_catch_shutdown([]() {
-        Profiling::profiler_record_gc();
-        return 0;  // block needs an int returned
-    }, Profiling::string_gc_handler);
-
-    in_gc_handler = false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// THIS IS THE SIGNAL HANDLER FUNCTION
-// ONLY ASYNC-SAFE FUNCTIONS ALLOWED IN HERE (no exception handling !!!)
-////////////////////////////////////////////////////////////////////////////////
-extern "C" void profiler_signal_handler(int sigint, siginfo_t *siginfo, void *ucontext) {
-    if (!ruby_native_thread_p()) return;
-    static std::atomic_bool in_signal_handler{false};
-
-    // atomically replaces the value of the object, returns the value held previously
-    // also keeps in_signal_handler lock_free -> async-safe
-    if (in_signal_handler.exchange(true)) return;
-
-    // the following two ruby c-functions are async safe
-    if (rb_during_gc())
-    {
-        rb_postponed_job_register(0, Profiling::profiler_gc_handler, (void *)0);
-    } else {
-        rb_postponed_job_register(0, Profiling::profiler_job_handler, (void *)0);
-    }
-
-    in_signal_handler = false;
-}
-
-void Profiling::profiling_start(pid_t tid) {
-    prof_data_map[tid].md = Metadata(Context::get());
-    prof_data_map[tid].prev_num = 0;
-    prof_data_map[tid].omitted_num = 0;
-    prof_data_map[tid].running_p = true;
-
-    Logging::log_profile_entry(prof_data_map[tid].md,
-                               prof_data_map[tid].prof_op_id,
-                               tid,
-                               current_interval);
-
-    if (!running.exchange(true)) {
-        // start timer with interval timer spec
-        struct itimerspec ts;
-        ts.it_interval.tv_sec = 0;
-        ts.it_interval.tv_nsec = current_interval * 1000000;
-        ts.it_value.tv_sec = 0;
-        ts.it_value.tv_nsec = ts.it_interval.tv_nsec;
-
-        // global timer_t timerid points to timer created in Init_profiling
-        if (timer_settime(timerid, 0, &ts, NULL) == -1) {
-            OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, "timer_settime() failed");
-            shut_down();
-        }
-    }
-}
-
-VALUE Profiling::profiling_stop(pid_t tid) {
-    if (!running.exchange(false)) return Qfalse;
-
-    int result = try_catch_shutdown([&]() {
-        // stop the timer, needs both (value and interval) set to 0
-        struct itimerspec ts;
-        ts.it_value.tv_sec = 0;
-        ts.it_value.tv_nsec = 0;
-        ts.it_interval.tv_sec = 0;
-        ts.it_interval.tv_nsec = 0;
-
-        if (timer_settime(timerid, 0, &ts, NULL) == -1) {
-            OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, "timer_settime() failed");
-            shut_down();
-        }
-
-        Logging::log_profile_exit(prof_data_map[tid].md,
-                                  prof_data_map[tid].prof_op_id,
-                                  tid,
-                                  prof_data_map[tid].omitted,
-                                  prof_data_map[tid].omitted_num);
-
-        prof_data_map[tid].running_p = false;
-        return 0; // block needs an int returned
-    }, Profiling::string_stop);
-
-    return (result == 0) ? Qtrue : Qfalse;
-}
-
-VALUE Profiling::set_interval(VALUE self, VALUE val) {
-    if (!FIXNUM_P(val)) return Qfalse;
-
-    configured_interval = FIX2INT(val);
-
-    return INT2FIX(configured_interval);
-}
-
-VALUE Profiling::get_interval() {
-    return INT2FIX(current_interval);
-}
-
-VALUE Profiling::profiling_run(VALUE self, VALUE rb_thread_val, VALUE interval) {
-    rb_need_block();  // checks if function is called with a block in Ruby
-    if (profiling_shut_down || OboeProfiling::get_interval() == 0) {
-        return rb_yield(Qundef);
-    }
-
-    if (FIXNUM_P(interval)) configured_interval = FIX2INT(interval);
-    current_interval = max(configured_interval, (long)OboeProfiling::get_interval());
-
-    // !!!!! Can't use try_catch_shutdown() here, MAKES rb_ensure cause a memory leak !!!!!
-    try {
-        pid_t tid = AO_GETTID;
-        profiling_start(tid);
-        rb_ensure(reinterpret_cast<VALUE (*)(...)>(rb_yield), Qundef,
-                  reinterpret_cast<VALUE (*)(...)>(profiling_stop), tid);
-        return Qtrue;
-    } catch (const std::exception &e) {
-        string msg = "Exception in Profiling::profiling_run(), can't recover, profiling shutting down";
-        OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, e.what());
-        OBOE_DEBUG_LOG_HIGH(OBOE_MODULE_RUBY, msg.c_str());
-        shut_down();
-        return Qfalse;
-    } catch (...) {
-        string msg = "Exception in Profiling::profiling_run(), can't recover, profiling shutting down";
-        OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, msg.c_str());
-        shut_down();
-        return Qfalse;
-    }
-
-    return Qfalse;
-}
-
-// in case C++ misbehaves we will stop profiling
-// to be used when catching exceptions
-void Profiling::shut_down() {
-    static atomic_bool ending{false};
-
-    if (ending.exchange(true)) return;
-
-    // avoid running any more profiling
-    profiling_shut_down = true;
-
-    // stop all profiling, the last one also stops the timer/signals
-    for (pair<const pid_t, prof_data_t> &ele : prof_data_map) {
-        profiling_stop(ele.first);
-    }
-}
-
-VALUE Profiling::getTid() {
-    pid_t tid = AO_GETTID;
-
-    return INT2NUM(tid);
-}
-
-static void
-prof_atfork_prepare(void) {
-    // cout << "Parent getting ready" << endl;
-}
-
-static void
-prof_atfork_parent(void) {
-    // cout << "Parent let child loose" << endl;
-}
-
-// make sure new processes have a clean slate for profiling
-static void
-prof_atfork_child(void) {
-    // cout << "A child is born" << endl;
-    Frames::clear_cached_frames();
-    prof_data_map.clear();
-    running = false;
-
-    // make sure it has a timer ready, it is a per-process-timer
-    Profiling::create_timer();
-}
-
-void Profiling::create_sigaction() {
-    struct sigaction sa;
-    // what happens if there is another action for the same signal?
-    // => last one defined wins!
-    sa.sa_sigaction = profiler_signal_handler;
-    sa.sa_flags = SA_RESTART | SA_SIGINFO;
-    sigemptyset(&sa.sa_mask);
-    if (sigaction(TIMER_SIG, &sa, NULL) == -1) {
-        OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, "sigaction() failed");
-        profiling_shut_down = true;  // no profiling without sigaction
-    }
-}
-
-void Profiling::create_timer() {
-    struct sigevent sev;
-
-    sev.sigev_value.sival_ptr = &timerid;
-    sev.sigev_notify = SIGEV_SIGNAL; /* Notify via signal */
-    sev.sigev_signo = TIMER_SIG;     /* Notify using this signal */
-
-    if (timer_create(CLOCK_REALTIME, &sev, &timerid) == -1) {
-        OBOE_DEBUG_LOG_ERROR(OBOE_MODULE_RUBY, "timer_create() failed");
-        profiling_shut_down = true;  // no profiling without clock
-    }
-}
-
-extern "C" void Init_profiling(void) {
-    // assign values to global atomic vars that know about state of profiling
-    running = false;
-    profiling_shut_down = false;
-
-    // prep data structures
-    Profiling::create_sigaction();
-    Profiling::create_timer();
-    Frames::reserve_cached_frames();
-
-    // create Ruby Module: SolarWindsAPM::CProfiler
-    static VALUE rb_mSolarWindsAPM = rb_define_module("SolarWindsAPM");
-    static VALUE rb_mCProfiler = rb_define_module_under(rb_mSolarWindsAPM, "CProfiler");
-
-    rb_define_singleton_method(rb_mCProfiler, "get_interval", reinterpret_cast<VALUE (*)(...)>(Profiling::get_interval), 0);
-    rb_define_singleton_method(rb_mCProfiler, "set_interval", reinterpret_cast<VALUE (*)(...)>(Profiling::set_interval), 1);
-    rb_define_singleton_method(rb_mCProfiler, "run", reinterpret_cast<VALUE (*)(...)>(Profiling::profiling_run), 2);
-    rb_define_singleton_method(rb_mCProfiler, "get_tid", reinterpret_cast<VALUE (*)(...)>(Profiling::getTid), 0);
-
-    pthread_atfork(prof_atfork_prepare,
-                   prof_atfork_parent,
-                   prof_atfork_child);
-}

data/ext/oboe_metal/src/profiling.h

@@ -1,78 +0,0 @@
-// Copyright (c) 2021 SolarWinds, LLC.
-// All rights reserved.
-
-#ifndef PROFILING_H
-#define PROFILING_H
-
-#include <ruby/ruby.h>
-#include <ruby/debug.h>
-#include <signal.h>
-#include <time.h>
-
-#include <atomic>
-#include <functional>
-#include <unordered_map>
-#include <vector>
-
-#include "frames.h"
-#include "logging.h"
-#include "oboe_api.h"
-
-#define BUF_SIZE 2048
-
-// these definitions are based on the assumption that there are no
-// frames with VALUE == 1 or VALUE == 2 in Ruby
-// profiling won't blow up if there are, because there is also a check to see
-// if the stack has size == 1 when assuming what these frames refer to
-#define PR_OTHER_THREAD 1
-#define PR_IN_GC 2
-
-#if !defined(AO_GETTID)
-     #if defined(_WIN32)
-        #define AO_GETTID GetCurrentThreadId
-     #else
-        #include <unistd.h>
-        #include <sys/syscall.h>
-        #ifdef SYS_gettid
-           #define AO_GETTID syscall(SYS_gettid);
-        #endif
-     #endif
-#endif
-
-class Profiling {
-   public:
-    static const string string_job_handler, string_gc_handler, string_signal_handler, string_stop;
-
-    static void create_sigaction();
-    static void create_timer();
-
-    static int try_catch_shutdown(std::function<int()>, const string& fun_name);
-    static void profiler_job_handler(void* data);
-    static void profiler_gc_handler(void* data);
-    // This is used when catching an exception
-    static void shut_down();
-
-    // The following are made available to Ruby and have to return VALUE
-    static VALUE profiling_run(VALUE self, VALUE rb_thread_val, VALUE interval);
-    static VALUE get_interval();
-    static VALUE set_interval(VALUE self, VALUE interval);
-    static VALUE getTid();
-
-   private:
-    static void profiling_start(pid_t tid);
-
-    // This is used via rb_ensure and therefore needs VALUE as a return type
-    static VALUE profiling_stop(pid_t tid);
-
-    static void process_snapshot(VALUE* frames_buffer,
-                                 int num,
-                                 pid_t tid,
-                                 long ts);
-    static void profiler_record_frames();
-    static void profiler_record_gc();
-    static void send_omitted(pid_t tid, long ts);
-};
-
-extern "C" void Init_profiling(void);
-
-#endif // PROFILING_H

data/ext/oboe_metal/test/CMakeLists.txt

@@ -1,53 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-project(test)
-
- # specify the C++ standard
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED True)
-# set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_LIST_DIR}/FindGMock.cmake)
-
-include(FetchContent)
-FetchContent_Declare(
-  googletest
-  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
-#  URL https://github.com/google/googletest/archive/refs/tags/release-1.11.0.zip
-)
-
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
-
-include_directories(
-  ${gtest_SOURCE_DIR}/include
-  ../src/
-  $ENV{RUBY_INC_DIR}
-  $ENV{RUBY_INC_DIR}/x86_64-linux/
-)
-
-link_directories(
-#  /usr/lib/
-  $ENV{RUBY_PREFIX}/lib/
-  ../../../lib/
-  ../lib
-)
-
-enable_testing()
-set (sources
-  test_main.cc
-  frames_test.cc
-  profiling_test.cc
-)
-
-## Link runTests with what we want to test and the GTest and pthread library
-add_executable(runTests ${sources})
-target_link_libraries(runTests
-#  ${GTEST_LIBRARIES}
-  gtest
-  solarwinds_apm.so
-  liboboe.so
-  libruby.so
-  pthread
-)
-
-include(GoogleTest)
-gtest_discover_tests(runTests)