solarwinds_apm 5.0.0

data/ext/oboe_metal/test/frames_test.cc

@@ -0,0 +1,164 @@
+
+
+#include <string.h>
+
+#include <algorithm>
+
+#include "../src/profiling.h"
+#include "../src/frames.h"
+#include "gtest/gtest.h"
+#include "ruby/debug.h"
+#include "ruby/ruby.h"
+#include "test.h"
+
+extern unordered_map<VALUE, FrameData> cached_frames;
+
+static VALUE test_frames[BUF_SIZE];
+static int test_lines[BUF_SIZE];
+int test_num;
+
+static int ruby_version;
+
+VALUE RubyCallsFrames::c_get_frames() {
+    test_num = rb_profile_frames(1, sizeof(test_frames) / sizeof(VALUE), test_frames, test_lines);
+    return Qnil;
+}
+
+void Init_RubyCallsFrames() {
+    static VALUE cTest = rb_define_module("RubyCalls");
+    rb_define_singleton_method(cTest, "get_frames", reinterpret_cast<VALUE (*)(...)>(RubyCallsFrames::c_get_frames), 0);
+
+    VALUE result;
+    result = rb_eval_string("RUBY_VERSION[0].to_i");
+    ruby_version = NUM2INT(result);
+};
+
+TEST(Frames, reserve_cached_frames) {
+    // it should only reserve once used during init
+    // unordered_map grows automatically
+    cached_frames.clear();
+
+    Frames::reserve_cached_frames();
+    int bucket_count = cached_frames.bucket_count();
+
+    Frames::reserve_cached_frames();
+    EXPECT_EQ(bucket_count, cached_frames.bucket_count());
+}
+
+TEST(Frames, collect_frame_data) {
+    rb_eval_string("TestMe::Snapshot::all_kinds");
+
+    int num = Frames::remove_garbage(test_frames, test_num);
+
+    vector<FrameData> data;
+    // Ruby 3 reports a <cfunc>, before the "take_snapshot" method
+    // we have to adjust the index of the trace we are checking
+    int i = ruby_version == 2 ? 0 : 1;
+    Frames::collect_frame_data(test_frames, i + 1, data);
+
+    EXPECT_EQ("take_snapshot", data[i].method) << "method name incorrect";
+    EXPECT_EQ("TestMe::Snapshot", data[i].klass) << "klass name incorrect";
+    std::size_t found = data[i].file.find("ext/oboe_metal/test/ruby_test_helper.rb");
+    EXPECT_EQ(data[i].file.length() - 39, found)
+        << "filename incorrect " << found << " " << data[i].file.length();
+    EXPECT_EQ(7, data[i].lineno) << "line number incorrect";
+}
+
+TEST(Frames, remove_garbage) {
+    // run some Ruby code and get a snapshot
+    rb_eval_string("TestMe::Snapshot::all_kinds");
+
+    int num = Frames::remove_garbage(test_frames, test_num);
+
+    int expected = (ruby_version == 2) ? 7 : 9;
+    EXPECT_EQ(expected, num)
+        << "wrong number of expected frames after remove_garbage";
+    // check no lineno 0 frame at top
+    VALUE val;
+    int i = (ruby_version == 2) ? 0 : 1;
+    val = rb_profile_frame_first_lineno(test_frames[i]);  // returns line number
+    if (RB_TYPE_P(val, T_FIXNUM)) {
+        EXPECT_NE(0, NUM2INT(val))
+            << "the frame with linenumber 0 was not removed";
+    } else {
+        EXPECT_TRUE(false) << " ************ line number not an int **********";
+    }
+    // check no repeated frames
+    for (i = 0; i < num; i++)
+        for (int j = i + 1; j < num; j++)
+            EXPECT_NE(test_frames[i], test_frames[j])
+                << "not all repeated frames were removed";
+}
+
+TEST(Frames, num_matching) {
+    VALUE a[BUF_SIZE];
+    VALUE b[BUF_SIZE];
+
+    int a_num = 0;
+    int b_num = 0;
+    EXPECT_EQ(0, Frames::num_matching(a, a_num, b, b_num))
+        << "* empty frames array should have 0 matches";
+
+    a[0] = (VALUE)11;
+    a[1] = (VALUE)12;
+    a[2] = (VALUE)13;
+    b[0] = (VALUE)11;
+    b[1] = (VALUE)12;
+    b[2] = (VALUE)13;
+    a_num = 3;
+    b_num = 3;
+    EXPECT_EQ(3, Frames::num_matching(a, a_num, b, b_num))
+        << "* equal frames array should have matched";
+
+    b[1] = (VALUE)222;
+    EXPECT_EQ(1, Frames::num_matching(a, a_num, b, b_num))
+        << "* only one should match for same length but different content";
+
+    b[1] = (VALUE)12;
+    a[3] = 14;
+    a_num = 4;
+    EXPECT_EQ(0, Frames::num_matching(a, a_num, b, b_num))
+        << "* different length, frames NOT matching from the end";
+
+    a[0] = 10;
+    a[1] = 11;
+    a[2] = 12;
+    a[3] = 13;
+    EXPECT_EQ(3, Frames::num_matching(a, a_num, b, b_num))
+        << "* different length, frames matching from the end";
+
+    b[0] = (VALUE)18;
+    b[1] = (VALUE)19;
+    b[2] = (VALUE)11;
+    b[3] = (VALUE)12;
+    b[4] = (VALUE)13;
+    b_num = 5;
+
+    EXPECT_EQ(3, Frames::num_matching(a, a_num, b, b_num))
+        << "* different length, frames matching from the end";
+}
+
+TEST(Frames, cached_frames) {
+    cached_frames.clear();
+    // run some Ruby code and get a snapshot
+    rb_eval_string("TestMe::Snapshot::all_kinds");
+
+    Frames::remove_garbage(test_frames, test_num);
+
+    // Check the expected size
+    int expected = (ruby_version == 2) ? 8 : 10;
+    EXPECT_EQ(expected, cached_frames.size());
+
+    // check that each frame is cached
+    for (int i = 0; i < test_num; i++)
+        EXPECT_EQ(1, cached_frames.count(test_frames[i]));
+
+    // repeat
+    rb_eval_string("TestMe::Snapshot::all_kinds");
+    Frames::remove_garbage(test_frames, test_num);
+
+    expected = (ruby_version == 2) ? 9 : 11;
+    EXPECT_EQ(expected, cached_frames.size());  // +1 for an extra main frame
+    for (int i = 0; i < test_num; i++)
+        EXPECT_EQ(1, cached_frames.count(test_frames[i]));
+}

data/ext/oboe_metal/test/profiling_test.cc

@@ -0,0 +1,93 @@
+
+#include "../src/frames.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <thread>
+#include <array>
+
+#include "../src/profiling.h"
+#include "gtest/gtest.h"
+#include "ruby/debug.h"
+#include "ruby/ruby.h"
+#include "test.h"
+
+extern atomic_bool profiling_shut_down;
+// extern oboe_reporter_t *cur_reporter;
+
+// FIXME how can I access profiling_shut_down ?
+TEST(Profiling, try_catch_shutdown) {
+    EXPECT_FALSE(profiling_shut_down);
+
+    int result;
+    result = Profiling::try_catch_shutdown([] {
+        // provoke exception
+        std::string ().replace (100, 1, 1, 'c');
+        return 0;
+    }, "Profiling::try_catch()");
+
+    EXPECT_NE(0, result);
+    EXPECT_TRUE(profiling_shut_down); 
+
+    // reset global var
+    profiling_shut_down = false;
+}
+
+TEST(Profiling, oboe_0_profiling) {
+    atomic_bool atomic_a1{true};
+    atomic_bool atomic_a2{false};
+
+    atomic_bool running;
+
+    cout << running << endl;
+    cout << running.exchange(true) << endl;
+    cout << running.exchange(true) << endl;
+
+    // cout << "prev val " << atomic_a2.exchange(false) << endl;
+    // cout << atomic_a2 << endl;
+    // cout << "prev val " <<  atomic_a2.exchange(true) << endl;
+    // cout << atomic_a2 << endl;
+    // cout << "prev val " <<  atomic_a2.exchange(true) << endl;
+    // cout << atomic_a2 << endl;
+    // cout << "prev val " <<  atomic_a2.exchange(false) << endl;
+    // cout << atomic_a2 << endl;
+
+
+
+    // static bool b1{true};
+    // static bool b2{false};
+
+    // array<thread, 4> threads;
+
+    // for (auto& t : threads) {
+    //     t = thread([] { Profiling::profiler_signal_handler(0, NULL, NULL); });
+    // }
+
+    // cout << "waiting..." << endl;
+
+    // for (auto& t : threads) {
+    //     t.join();
+    // }
+
+    // cout << "Done." << endl;
+
+
+    // cout << atomic_a1 << ", " << b1 << endl;
+    // cout << atomic_a1 << ", " << b1 << ", " << atomic_a1.compare_exchange_weak(b1, false) << endl;
+    // cout << atomic_a1 << ", " << b1 << endl;
+    // cout << atomic_a2 << ", " << b2 << endl;
+    // cout << atomic_a2 << ", " << b2 << ", " << atomic_a2.compare_exchange_weak(b2, true) << endl;
+    // cout << atomic_a2 << ", " << b2 << endl;
+    // cout << endl;
+
+    // cout << atomic_a1 << ", " << b1 << endl;
+    // cout << atomic_a1 << ", " << b1 << ", " << atomic_a1.compare_exchange_weak(b1, false) << endl;
+    // cout << atomic_a1 << ", " << b1 << endl;
+    // cout << atomic_a2 << ", " << b2 << endl;
+    // cout << atomic_a2 << ", " << b2 << ", " << atomic_a2.compare_exchange_weak(b2, true) << endl;
+    // cout << atomic_a2 << ", " << b2 << endl;
+    // cout << endl;
+    
+     
+}

data/ext/oboe_metal/test/ruby_inc_dir.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2021 SolarWinds, LLC.
+# All rights reserved.
+
+require 'mkmf'
+puts $topdir
+

data/ext/oboe_metal/test/ruby_prefix.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2021 SolarWinds, LLC.
+# All rights reserved.
+
+require 'mkmf'
+puts CONFIG["prefix"]
+

data/ext/oboe_metal/test/ruby_test_helper.rb

@@ -0,0 +1,67 @@
+class TestMe
+  class Snapshot
+
+    class << self
+      # !!! do not shift the definition of take_snapshot from line 7 !!!
+      # the line number is used to verify a test in frames_test.cc
+      def take_snapshot
+        # puts "getting frames ...."
+        begin
+          ::RubyCalls::get_frames
+        rescue => e
+          puts "oops, getting frames didn't work"
+          puts e
+        end
+      end
+
+      def all_kinds
+        begin
+          Teddy.new.sing do
+            take_snapshot
+          end
+        rescue => e
+          puts "Ruby call did not work"
+          puts e
+        end
+      end
+    end
+  end
+
+  class Teddy
+
+    attr_accessor :name
+
+    def sing
+      3.times do
+        yodel do
+          html_wrap("title", "Hello") { |_html| yield }
+        end
+      end
+    end
+
+    private
+
+    def yodel
+      a_proc = -> (x) { x * x;  yield }
+      in_block(&a_proc)
+    end
+
+    def in_block(&block)
+      begin
+        yield 7
+        # puts "block called!"
+      rescue => e
+        puts "no, this should never happen"
+        puts e
+      end
+    end
+
+    def html_wrap(tag, text)
+      html = "<#{tag}>#{text}</#{tag}>"
+      yield html
+    end
+
+  end
+end
+
+

data/ext/oboe_metal/test/test.h

@@ -0,0 +1,11 @@
+#ifndef TEST_H
+#define TEST_H
+
+class RubyCallsFrames {
+    public:
+    static VALUE c_get_frames();
+};
+
+void Init_RubyCallsFrames();
+
+#endif //TEST_H

data/ext/oboe_metal/test/test_main.cc

@@ -0,0 +1,32 @@
+#include "gtest/gtest.h"
+// #include "gmock/gmock.h"
+#include <ruby/ruby.h>
+#include "../src/profiling.h"
+#include "../src/frames.h"
+#include "test.h"
+
+#ifndef FRAMES_BUFFER
+#define FRAMES_BUFFER
+
+using namespace std;
+
+int main(int argc, char **argv) {
+    int state = -1;
+
+    // order important! init ruby before adding functions!
+    ruby_init();
+    Init_RubyCallsFrames();
+
+    // !!! if the require path is wrong, cmake will segfault !!!
+    string path(std::getenv("TEST_DIR"));
+    string cmd("require '" + path + "/" + "ruby_test_helper.rb" + "'");
+    rb_eval_string(cmd.c_str());
+
+    ::testing::InitGoogleTest(&argc, argv);
+
+    state = RUN_ALL_TESTS();
+
+    ruby_cleanup(0);
+    return state;
+}
+#endif //FRAMES_BUFFER

data/init.rb

@@ -0,0 +1,4 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'solarwinds_apm'

data/lib/oboe.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+# This module is provided for backward compatibility.
+# It simply redirects to the solarwinds_apm module which will
+# also load backward compatibility support.
+require 'solarwinds_apm'

data/lib/oboe_metal.rb

@@ -0,0 +1,172 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'thread'
+
+# Disable docs and Camelcase warns since we're implementing
+# an interface here.  See OboeBase for details.
+# rubocop:disable Style/Documentation, Naming/MethodName
+module SolarWindsAPM
+  extend SolarWindsAPMBase
+  include Oboe_metal
+
+  class Reporter
+    class << self
+      ##
+      # start
+      #
+      # Start the SolarWindsAPM Reporter
+      #
+      def start
+        SolarWindsAPM.loaded = false unless SolarWindsAPM::OboeInitOptions.instance.service_key_ok?
+        return unless SolarWindsAPM.loaded
+
+        begin
+          options = SolarWindsAPM::OboeInitOptions.instance.array_for_oboe # creates an array with the options in the right order
+
+          SolarWindsAPM.reporter = Oboe_metal::Reporter.new(*options)
+
+          # Only report __Init from here if we are not instrumenting a framework.
+          # Otherwise, frameworks will handle reporting __Init after full initialization
+          unless defined?(::Rails) || defined?(::Sinatra) || defined?(::Padrino) || defined?(::Grape)
+            SolarWindsAPM::API.report_init
+          end
+
+        rescue => e
+          $stderr.puts e.message
+          raise
+        end
+      end
+      alias :restart :start
+
+      ##
+      # sendReport
+      #
+      # Send the report for the given event
+      #
+      def sendReport(evt)
+        SolarWindsAPM.reporter.sendReport(evt)
+      end
+
+      ##
+      # sendStatus
+      #
+      # Send the report for the given event
+      #
+      def sendStatus(evt, context = nil)
+        SolarWindsAPM.reporter.sendStatus(evt, context)
+      end
+
+      ##
+      # clear_all_traces
+      #
+      # Truncates the trace output file to zero
+      #
+      def clear_all_traces
+        File.truncate(SolarWindsAPM::OboeInitOptions.instance.host, 0)
+      end
+
+      ##
+      # get_all_traces
+      #
+      # Retrieves all traces written to the trace file
+      #
+      def get_all_traces
+        io = File.open(SolarWindsAPM::OboeInitOptions.instance.host, 'r')
+        contents = io.readlines(nil)
+        io.close
+
+        return contents if contents.empty?
+
+        traces = []
+
+        # We use Gem.loaded_spec because older versions of the bson
+        # gem didn't even have a version embedded in the gem.  If the
+        # gem isn't in the bundle, it should rightfully error out
+        # anyways.
+        #
+        if Gem.loaded_specs['bson'] && Gem.loaded_specs['bson'].version.to_s < '4.0'
+          s = StringIO.new(contents[0])
+
+          until s.eof?
+            traces << if ::BSON.respond_to? :read_bson_document
+                        BSON.read_bson_document(s)
+                      else
+                        BSON::Document.from_bson(s)
+                      end
+          end
+        else
+          bbb = ::BSON::ByteBuffer.new(contents[0])
+          until bbb.length == 0
+            traces << Hash.from_bson(bbb)
+          end
+        end
+
+        traces
+      end
+    end
+  end
+
+  module EventUtil
+    def self.metadataString(evt)
+      evt.metadataString
+    end
+  end
+
+  class << self
+    # def sample?(opts = {})
+    #   # Return false if no-op mode
+    #   return false unless SolarWindsAPM.loaded
+    #
+    #   # Assure defaults since SWIG enforces Strings
+    #   xtrace  = opts[:xtrace]     ? opts[:xtrace].to_s.strip       : SW_APM_STR_BLANK
+    #
+    #   # the first arg has changed to be the service name, blank means to use the default (from the service key)
+    #   rv = SolarWindsAPM::Context.sampleRequest(SW_APM_STR_BLANK, xtrace)
+    #
+    #   if rv == 0
+    #     SolarWindsAPM.sample_rate = -1
+    #     SolarWindsAPM.sample_source = -1
+    #     false
+    #   else
+    #     # liboboe version > 1.3.1 returning a bit masked integer with SampleRate and
+    #     # source embedded
+    #     SolarWindsAPM.sample_rate = (rv & SAMPLE_RATE_MASK)
+    #     SolarWindsAPM.sample_source = (rv & SAMPLE_SOURCE_MASK) >> 24
+    #     true
+    #   end
+    # rescue StandardError => e
+    #   SolarWindsAPM.logger.debug "[oboe/error] sample? error: #{e.inspect}"
+    #   false
+    # end
+
+    # def set_tracing_mode(mode)
+    #   return unless SolarWindsAPM.loaded
+    #
+    #   value = mode.to_sym
+    #
+    #   case value
+    #   when :disabled, :never
+    #     SolarWindsAPM::Context.setTracingMode(SW_APM_TRACE_DISABLED)
+    #
+    #   when :enabled, :always
+    #     SolarWindsAPM::Context.setTracingMode(SW_APM_TRACE_ENABLED)
+    #
+    #   else
+    #     SolarWindsAPM.logger.fatal "[oboe/error] Invalid tracing mode set: #{mode}"
+    #     SolarWindsAPM::Context.setTracingMode(SW_APM_TRACE_DISABLED)
+    #   end
+    # end
+
+    def set_sample_rate(rate)
+      return unless SolarWindsAPM.loaded
+
+      # Update liboboe with the new SampleRate value
+      SolarWindsAPM::Context.setDefaultSampleRate(rate.to_i)
+    end
+  end
+end
+# rubocop:enable Style/Documentation
+
+SolarWindsAPM.loaded = true
+SolarWindsAPM.config_lock = Mutex.new

data/lib/rails/generators/solarwinds_apm/install_generator.rb

@@ -0,0 +1,47 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  class InstallGenerator < ::Rails::Generators::Base
+    source_root File.join(File.dirname(__FILE__), 'templates')
+    desc "Copies a SolarWindsAPM gem initializer file to your application."
+
+    @namespace = "solarwinds_apm:install"
+
+    def copy_initializer
+      # Set defaults
+      @verbose = 'false'
+
+      print_header
+      print_footer
+
+      template "solarwinds_apm_initializer.rb", "config/initializers/solarwinds_apm.rb"
+    end
+
+    private
+
+    # rubocop:disable Metrics/MethodLength
+    def print_header
+      say ""
+      say shell.set_color "Welcome to the SolarWindsAPM Ruby instrumentation setup.", :green, :bold
+      say ""
+      say shell.set_color "Documentation Links", :magenta
+      say "-------------------"
+      say ""
+      say "SolarWindsAPM Installation Overview:"
+      say "https://documentation.solarwinds.com/en/success_center/swaas/"
+      say ""
+      say "More information on instrumenting Ruby applications can be found here:"
+      say "https://documentation.solarwinds.com/en/success_center/swaas/default.htm#cshid=app-add-ruby-agent"
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def print_footer
+      say ""
+      say "You can change configuration values in the future by modifying config/initializers/solarwinds_apm.rb"
+      say ""
+      say "Thanks! Creating the SolarWindsAPM initializer..."
+      say ""
+    end
+  end
+end