scout_apm 2.1.32 → 2.2.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13a92807ec823e335d8c008de7b2ee934f2b2a5a
-  data.tar.gz: 0914f1345038c081b84dd22ee1b98f009cbd8bb5
+  metadata.gz: a1a02cb2156a16b3ddaa054eb34065653ed2abb7
+  data.tar.gz: 8023afd5daf499a2441ee54b9d7c5914ec00ac73
 SHA512:
-  metadata.gz: 917cd00759988d396425711cc5471641edbf8c02a5434e2cea567a6d4bb1aea8fdb06b429950289631b7338432a528a9bd82033a154c6ccdf58a5ca835deed4d
-  data.tar.gz: 958687024b4bc80bf5c7364196b0a06c8cfc61e3afce63777c0fa31a5203c6ba892a7089a58e0539d2a6976c53fae2f4557f47a279eea89718d0d9cdc2cb0dc1
+  metadata.gz: 2483b8a46a365e9568f36f7d2c46b8271b295b9c12c950694318d4dd09668d91d30a39cd3c0b7c03396ce07e9a5bd9f1f77710d9cc3175cfb09d57e41aea8d28
+  data.tar.gz: 979cae85d0a830fe3c4ff4be8640f7bc503e1bceb72bb096ae731d7679bf93b2d17de266dd300a57b23029014ccabc61d20863fcd6d8b104b3c82e4b632c91d5

data/.gitignore

@@ -17,4 +17,4 @@ test/tmp/*coverage/*
 coverage/*
 lib/*.bundle
 lib/*.so
-log/scout_apm.log
+**/.RUBYARCHDIR.time

data/CHANGELOG.markdown

@@ -1,165 +1,6 @@
-# 2.1.32
+# 2.2.0
 
-* Better naming when using Resque + ActiveJob
-* Better naming when using Sidekiq + DelayedExtension
-
-# 2.1.31
-
-* Better detection of Resque queue names
-* Fix passing arguments through Active Record instrumentation. (Thanks to Nick Quaranto for providing the fix)
-* Stricter checks to prevent agent from starting in Rails console
-
-# 2.1.30
-
-* Add Resque support.
-
-# 2.1.29
-
-* Add `scm_subdirectory` option. Useful for when your app code does not live in your SCM root directory.
-
-# 2.1.28
-
-* Changes to app server load data
-
-# 2.1.27
-
-* Don't attempt to call `current_layer.type` on nil
-
-# 2.1.26
-
-* Bug fix [4b188d6](https://github.com/scoutapp/scout_apm_ruby/commit/4b188d698852c86b86d8768ea5b37d706ce544fe)
-
-# 2.1.25
-
-* Automatically instrument API and Metal controllers.
-
-# 2.1.24
-
-* Capture additional layers of application backtrace frames. (From 3 -> 8)
-
-# 2.1.23
-
-* Extend Mongoid instrumentation to 6.x
-
-# 2.1.22
-
-* Add DevTrace support for newest 4.2.x and 5.x versions of Rails
-
-# 2.1.21
-
-* Fix edge case, causing DevTrace to fail
-* Add debug tooling, allowing custom functions to be inserted into the agent at
-  key points.
-
-# 2.1.20
-
-* Add a `detailed_middleware` boolean configuration option to capture
-  per-middleware data, as opposed to the default of aggregating all middleware
-  together.  This has a small amount of additional overhead, approximately
-  10-15ms per request.
-
-# 2.1.19
-
-* Log all configuration settings at start when log level is debug
-* Tune DelayedJob class name detection
-
-# 2.1.18
-
-* Max layaway file threshold limit
-
-# 2.1.17
-
-* Additional logging around file system usage
-
-# 2.1.16
-
-* Extract the name correctly for DelayedJob workers run via ActiveJob
-
-# 2.1.15
-
-* Limit memory usage for very long running requests.
-
-# 2.1.14
-
-* Add TrackedRequest#ignore_request! to entirely ignore and stop capturing a
-  certain request. Use in your code by calling:
-    ScoutApm::RequestManager.lookup.ignore_request!
-
-# 2.1.13
-
-* Rework Delayed Job instrumentation to not interfere with other instruments.
-
-# 2.1.12
-
-* Revert 2.1.11's Delayed Job change - caused issues in a handful of environments
-
-# 2.1.11
-
-* Support alternate methods of launching Delayed Job
-
-# 2.1.10
-
-* Fix issue getting a default Application Name when it wasn't explicitly set
-
-# 2.1.9
-
-* Send raw histograms of response time, enabling more accurate 95th %iles
-* Raw histograms are used in Apdex calculations
-* Gzip payloads
-* Fix Mongoid (5.0) + Mongo (2.1) support
-* Initial Delayed Job support
-* Limit max metric size of a trace to 500.
-
-
-# 2.1.8
-
-* Adds Git revision detection, which is reported on app load and associated with transaction traces
-
-# 2.1.7
-
-* Fix allocations extension compilation on Ruby 1.8.7
-
-# 2.1.6
-
-* Support older versions of Grape (0.10 onward)
-* Vendor rusage library
-* Fix double-exit that caused error messages when running under Passenger
-
-# 2.1.5
-
-* Be less strict loading Rails environments that don't have a matching
-  scout_apm.yml section. Previously we raised, now we log and continue
-  to load with the ENV settings
-* Fix a memory leak in error recovery code
-* Fix a minor race condition in data coordination between processes.
-  * There was a tiny sliver of a window where a lock wasn't held, and it caused
-    an exception to be raised.
-
-# 2.1.4
-
-* Enhance regular expression that determines if a backtrace line is "inside"
-  the application
-    * Avoids labeling vendor/ as part of the monitored app
-
-# 2.1.3
-
-* Less noisy output on errors with Context
-  * Not logging errors w/nil keys or values
-  * Bumping log level down from WARN => INFO on errors
-* Fix error with complicated AR queries
-  * Caused high log noise
-* Sidekiq instrumentation changes to handle a variety of edge cases
-
-# 2.1.2
-
-* Applies `Rails.application.config.filter_parameters` settings to reported transaction trace uris
-* Fix incompatibility with ResqueWeb and middleware instrumentation
-
-# 2.1.1
-
-* Fix an issue with AR instrumentation and complex queries
-* Fix use of configuration option `data_file`
-* Update unit tests
+* ScoutProf BETA
 
 # 2.1.0
 

data/Rakefile

@@ -3,7 +3,7 @@ require "bundler/gem_tasks"
 task :default => :test
 
 desc "Run Unit Tests"
-task :test => [:compile] do
+task :test do
   $: << File.expand_path(File.dirname(__FILE__) + "/test")
   Dir.glob('./test/**/*_test.rb').each { |file| require file }
 end
@@ -21,5 +21,5 @@ end
 # Rake Compiler
 require 'rake/extensiontask'
 Rake::ExtensionTask.new('allocations')
-Rake::ExtensionTask.new('rusage')
+Rake::ExtensionTask.new('stacks')
 

data/ext/allocations/allocations.c

@@ -1,8 +1,4 @@
-#ifdef HAVE_RUBY_RUBY_H
 #include <ruby/ruby.h>
-#else // Ruby <= 1.8.7
-#include <ruby.h>
-#endif
 
 VALUE mScoutApm;
 VALUE mInstruments;
@@ -56,7 +52,6 @@ void Init_allocations()
     mInstruments = rb_define_module_under(mScoutApm, "Instruments");
     cAllocations = rb_define_class_under(mInstruments, "Allocations", rb_cObject);
     rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
-    rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
     rb_define_const(cAllocations, "ENABLED", Qtrue);
     Init_hooks(mScoutApm);
 }
@@ -79,7 +74,6 @@ void Init_allocations()
     mInstruments = rb_define_module_under(mScoutApm, "Instruments");
     cAllocations = rb_define_class_under(mInstruments, "Allocations", rb_cObject);
     rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
-    rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
     rb_define_const(cAllocations, "ENABLED", Qfalse);
     Init_hooks(mScoutApm);
 }

data/ext/allocations/extconf.rb

@@ -1,4 +1,3 @@
 require 'mkmf'
 
-have_header("ruby/ruby.h") # Needed to check for Ruby <= 1.8.7
 create_makefile('allocations')

data/ext/stacks/extconf.rb

@@ -0,0 +1,33 @@
+begin
+  require 'mkmf'
+  can_compile = true
+rescue Exception
+  # This will appear only in verbose mode.
+  $stderr.puts "Could not require 'mkmf'. Not fatal, the Stacks extension is optional."
+end
+
+can_compile &&= have_func('rb_postponed_job_register_one')
+can_compile &&= have_func('rb_profile_frames')
+can_compile &&= have_func('rb_profile_frame_absolute_path')
+can_compile &&= have_func('rb_profile_frame_label')
+can_compile &&= have_func('rb_profile_frame_classpath')
+can_compile &&= have_library('rt') # for timer_create, timer_settime
+
+# Pick the atomics implementation
+has_atomics_header = have_header("stdatomic.h")
+if has_atomics_header
+  $defs.push "-DSCOUT_USE_NEW_ATOMICS"
+else
+  $defs.push "-DSCOUT_USE_OLD_ATOMICS"
+end
+
+if can_compile
+  create_makefile('stacks')
+else
+  # Create a dummy Makefile, to satisfy Gem::Installer#install
+  mfile = open("Makefile", "wb")
+  mfile.puts '.PHONY: install'
+  mfile.puts 'install:'
+  mfile.puts "\t" + '@echo "Stack extension not installed, skipping."'
+  mfile.close
+end

data/ext/stacks/scout_atomics.h

@@ -0,0 +1,86 @@
+/////////////////////////////////////////////////////////////////////////////////
+// ATOMIC DEFS
+//
+// GCC added C11 atomics in 4.9, which is after ubuntu 14.04's version. Provide
+// typedefs around what we really use to allow compatibility
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////////
+// Build system MUST set either SCOUT_USE_OLD_ATOMICS or SCOUT_USE_NEW_ATOMICS,
+// but not both
+/////////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef SCOUT_USE_OLD_ATOMICS
+
+typedef bool atomic_bool_t;
+typedef uint16_t atomic_uint16_t;
+typedef uint32_t atomic_uint32_t;
+
+// Function which abuses compare&swap to set the value to what you want.
+void scout_macro_fn_atomic_store_bool(bool* p_ai, bool val)
+{
+  bool ai_was;
+  ai_was = *p_ai;
+
+  do {
+    ai_was = __sync_val_compare_and_swap (p_ai, ai_was, val);
+  } while (ai_was != *p_ai);
+}
+
+// Function which abuses compare&swap to set the value to what you want.
+void scout_macro_fn_atomic_store_int16(atomic_uint16_t* p_ai, atomic_uint16_t val)
+{
+  atomic_uint16_t ai_was;
+  ai_was = *p_ai;
+
+  do {
+    ai_was = __sync_val_compare_and_swap (p_ai, ai_was, val);
+  } while (ai_was != *p_ai);
+}
+
+// Function which abuses compare&swap to set the value to what you want.
+void scout_macro_fn_atomic_store_int32(atomic_uint32_t* p_ai, atomic_uint32_t val)
+{
+  atomic_uint32_t ai_was;
+  ai_was = *p_ai;
+
+  do {
+    ai_was = __sync_val_compare_and_swap (p_ai, ai_was, val);
+  } while (ai_was != *p_ai);
+}
+
+
+#define ATOMIC_STORE_BOOL(var, value) scout_macro_fn_atomic_store_bool(var, value)
+#define ATOMIC_STORE_INT16(var, value) scout_macro_fn_atomic_store_int16(var, value)
+#define ATOMIC_STORE_INT32(var, value) scout_macro_fn_atomic_store_int32(var, value)
+#define ATOMIC_LOAD(var) __sync_fetch_and_add((var),0)
+#define ATOMIC_ADD(var, value) __sync_fetch_and_add((var), value)
+#define ATOMIC_INIT(value) value
+
+#endif
+
+
+/////////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef SCOUT_USE_NEW_ATOMICS
+
+// We have c11 atomics
+#include <stdatomic.h>
+#define ATOMIC_STORE_BOOL(var, value) atomic_store(var, value)
+#define ATOMIC_STORE_INT16(var, value) atomic_store(var, value)
+#define ATOMIC_STORE_INT32(var, value) atomic_store(var, value)
+#define ATOMIC_LOAD(var) atomic_load(var)
+#define ATOMIC_ADD(var, value) atomic_fetch_add(var, value)
+#define ATOMIC_INIT(value) ATOMIC_VAR_INIT(value)
+
+typedef atomic_bool atomic_bool_t;
+typedef atomic_uint_fast16_t atomic_uint16_t;
+typedef atomic_uint_fast32_t atomic_uint32_t;
+
+#endif
+
+

data/ext/stacks/stacks.c

@@ -0,0 +1,744 @@
+/*
+ * General idioms:
+ *   - rb_* functions are attached to Ruby-accessible method calls (See Init_stacks)
+ * General approach:
+ *   - Because of how rb_profile_frames works, it must be called from within
+ *     each thread running, rather than from a 3rd party thread.
+ *   - We setup a global timer tick. The handler simply sends a thread signal
+ *     to each registered thread, which causes each thread to capture its own
+ *     trace
+ */
+
+/*
+ * Ruby lib
+ */
+#include <ruby/ruby.h>
+#include <ruby/debug.h>
+#include <ruby/st.h>
+#include <ruby/io.h>
+#include <ruby/intern.h>
+
+/*
+ * Std lib
+ */
+#include <errno.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdbool.h>
+
+/*
+ *  System
+ */
+#include <sys/syscall.h>
+#include <sys/time.h>
+
+#include "scout_atomics.h"
+
+
+int scout_profiling_installed = 0;
+int scout_profiling_running = 0;
+
+ID sym_ScoutApm;
+ID sym_Stacks;
+ID sym_collect;
+ID sym_scrub_bang;
+VALUE ScoutApm;
+VALUE Stacks;
+
+VALUE mScoutApm;
+VALUE mInstruments;
+VALUE cStacks;
+
+VALUE interval;
+
+#define BUF_SIZE 512
+#define MAX_TRACES 2000
+
+#define NANO_SECOND_MULTIPLIER  1000000  // 1 millisecond = 1,000,000 Nanoseconds
+const long INTERVAL = 1 * NANO_SECOND_MULTIPLIER; // milliseconds * NANO_SECOND_MULTIPLIER
+
+// For support of thread id in timer_create
+#define sigev_notify_thread_id _sigev_un._tid
+
+#ifdef RUBY_INTERNAL_EVENT_NEWOBJ
+
+// Forward Declarations
+static void init_thread_vars();
+static void scout_profile_broadcast_signal_handler(int sig);
+void scout_record_sample();
+static void scout_start_thread_timer();
+static void scout_stop_thread_timer();
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Per-Thread variables
+////////////////////////////////////////////////////////////////////////////////////////
+
+struct c_trace {
+  int num_tracelines;
+  int lines_buf[BUF_SIZE];
+  VALUE frames_buf[BUF_SIZE];
+};
+
+static __thread struct c_trace *_traces;
+
+static __thread atomic_bool_t _thread_registered = ATOMIC_INIT(false);
+static __thread atomic_bool_t _ok_to_sample = ATOMIC_INIT(false);
+static __thread atomic_bool_t _in_signal_handler = ATOMIC_INIT(false);
+
+static __thread atomic_uint16_t _start_frame_index = ATOMIC_INIT(0);
+static __thread atomic_uint16_t _start_trace_index = ATOMIC_INIT(0);
+static __thread atomic_uint16_t _cur_traces_num = ATOMIC_INIT(0);
+
+static __thread atomic_uint32_t _skipped_in_gc = ATOMIC_INIT(0);
+static __thread atomic_uint32_t _skipped_in_signal_handler = ATOMIC_INIT(0);
+static __thread atomic_uint32_t _skipped_in_job_registered = ATOMIC_INIT(0);
+
+static __thread VALUE _gc_hook;
+
+static __thread atomic_bool_t _job_registered = ATOMIC_INIT(false);
+
+static __thread timer_t _timerid;
+static __thread struct sigevent _sev;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Global variables
+////////////////////////////////////////////////////////////////////////////////////////
+
+static int
+scout_add_profiled_thread(pthread_t th)
+{
+  if (ATOMIC_LOAD(&_thread_registered) == true) return 1;
+
+  init_thread_vars();
+  ATOMIC_STORE_BOOL(&_thread_registered, true);
+
+  fprintf(stderr, "APM DEBUG: Added thread id: %li\n", (unsigned long int)pthread_self());
+  return 1;
+}
+
+/*
+ * rb_scout_add_profiled_thread: adds the currently running thread to the head of the linked list
+ *
+ * Initializes thread locals:
+ *   - ok_to_sample to false
+ *   - start_frame_index and start_trace_index to 0
+ *   - cur_traces_num to 0
+ */
+static VALUE
+rb_scout_add_profiled_thread(VALUE self)
+{
+  scout_add_profiled_thread(pthread_self());
+  return Qtrue;
+}
+
+/*
+ * remove_profiled_thread: removes a thread from the linked list.
+ * if the linked list is empty, this is a noop
+ */
+static int
+remove_profiled_thread(pthread_t th)
+{
+  if (ATOMIC_LOAD(&_thread_registered) == false) return 1;
+
+  ATOMIC_STORE_BOOL(&_ok_to_sample, false);
+
+  fprintf(stderr, "APM DEBUG: Would remove thread id: %li\n", (unsigned long int)th);
+
+  // Unregister the _gc_hook from Ruby ObjectSpace, then free it as well as the _traces struct it wrapped.
+  rb_gc_unregister_address(&_gc_hook);
+  xfree(&_gc_hook);
+  xfree(&_traces);
+
+  timer_delete(_timerid);
+
+  ATOMIC_STORE_BOOL(&_thread_registered, false);
+  return 0;
+}
+
+/* rb_scout_remove_profiled_thread: removes a thread from the linked list
+ *
+ */
+static VALUE rb_scout_remove_profiled_thread(VALUE self)
+{
+  remove_profiled_thread(pthread_self());
+  return Qtrue;
+}
+
+
+/* rb_scout_start_profiling: Installs the global timer
+ */
+static VALUE
+rb_scout_start_profiling(VALUE self)
+{
+  if (scout_profiling_running) {
+    return Qtrue;
+  }
+
+  scout_profiling_running = 1;
+
+  return Qtrue;
+}
+
+/*  rb_scout_uninstall_profiling: called when ruby is shutting down.
+ *  NOTE: If ever this method should be called where Ruby should continue to run, we need to free our
+ *        memory allocated in each profiled thread.
+ */
+static VALUE
+rb_scout_uninstall_profiling(VALUE self)
+{
+  return Qnil;
+}
+
+static VALUE
+rb_scout_install_profiling(VALUE self)
+{
+  struct sigaction new_vtaction, old_vtaction;
+
+  // We can only install once. If uninstall is called, we will NOT be able to call install again.
+  // Instead, stop/start should be used to temporarily disable all ScoutProf sampling.
+  if (scout_profiling_installed) {
+    return Qfalse;
+  }
+
+  // Also set up an interrupt handler for when we broadcast an alarm
+  new_vtaction.sa_handler = scout_profile_broadcast_signal_handler;
+  new_vtaction.sa_flags = SA_RESTART;
+  sigemptyset(&new_vtaction.sa_mask);
+  sigaction(SIGALRM, &new_vtaction, &old_vtaction);
+
+  rb_define_const(cStacks, "INSTALLED", Qtrue);
+  scout_profiling_installed = 1;
+
+  return Qtrue;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Per-Thread Handler
+////////////////////////////////////////////////////////////////////////////////////////
+
+static void
+scoutprof_gc_mark(void *data)
+{
+  uint_fast16_t i;
+  int n;
+  for (i = 0; i < ATOMIC_LOAD(&_cur_traces_num); i++) {
+    for (n = 0; n < _traces[i].num_tracelines; n++) {
+      rb_gc_mark(_traces[i].frames_buf[n]);
+    }
+  }
+}
+
+static void
+scout_parent_atfork_prepare()
+{
+  // TODO: Should we track how much time the fork took?
+  if (ATOMIC_LOAD(&_ok_to_sample) == true) {
+    scout_stop_thread_timer();
+  }
+}
+
+static void
+scout_parent_atfork_finish()
+{
+  if (ATOMIC_LOAD(&_ok_to_sample) == true) {
+    scout_start_thread_timer();
+  }
+}
+
+static void
+init_thread_vars()
+{
+  int res;
+
+  ATOMIC_STORE_BOOL(&_ok_to_sample, false);
+  ATOMIC_STORE_BOOL(&_in_signal_handler, false);
+  ATOMIC_STORE_INT16(&_start_frame_index, 0);
+  ATOMIC_STORE_INT16(&_start_trace_index, 0);
+  ATOMIC_STORE_INT16(&_cur_traces_num, 0);
+
+  _traces = ALLOC_N(struct c_trace, MAX_TRACES); // TODO Check return
+
+  _gc_hook = Data_Wrap_Struct(rb_cObject, &scoutprof_gc_mark, NULL, &_traces);
+  rb_gc_register_address(&_gc_hook);
+
+  res = pthread_atfork(scout_parent_atfork_prepare, scout_parent_atfork_finish, NULL);
+  if (res != 0) {
+    fprintf(stderr, "Pthread_atfork failed: %d\n", res);
+  }
+
+  // Create timer to target this thread
+  _sev.sigev_notify = SIGEV_THREAD_ID;
+  _sev.sigev_signo = SIGALRM;
+  _sev.sigev_notify_thread_id = syscall(SYS_gettid);
+  _sev.sigev_value.sival_ptr = &_timerid;
+  if (timer_create(CLOCK_MONOTONIC, &_sev, &_timerid) == -1) {
+    fprintf(stderr, "Time create failed: %d\n", errno);
+  }
+
+  return;
+}
+
+/*
+ *  Signal handler for each thread. Invoked from a signal when a job is run within Ruby's postponed_job queue
+ */
+static void
+scout_profile_broadcast_signal_handler(int sig)
+{
+  int register_result;
+
+  if (ATOMIC_LOAD(&_ok_to_sample) == false) return;
+
+  if (ATOMIC_LOAD(&_in_signal_handler) == true) {
+    ATOMIC_ADD(&_skipped_in_signal_handler, 1);
+    return;
+  }
+
+
+  ATOMIC_STORE_BOOL(&_in_signal_handler, true);
+
+  if (rb_during_gc()) {
+    ATOMIC_ADD(&_skipped_in_gc, 1);
+  } else {
+    if (ATOMIC_LOAD(&_job_registered) == false){
+      register_result = rb_postponed_job_register(0, scout_record_sample, 0);
+      if ((register_result == 1) || (register_result == 2)) {
+        ATOMIC_STORE_BOOL(&_job_registered, true);
+      } else {
+        ATOMIC_ADD(&_skipped_in_job_registered, 1);
+      }
+    } // !_job_registered
+  }
+
+  ATOMIC_STORE_BOOL(&_in_signal_handler, false);
+}
+
+/*
+ * scout_record_sample: Defered function run from the per-thread handler
+ *
+ * Note: that this is called from *EVERY PROFILED THREAD FOR EACH CLOCK TICK
+ *       INTERVAL*, so the performance of this method is crucial.
+ *
+ */
+void
+scout_record_sample()
+{
+  int num_frames;
+  uint_fast16_t cur_traces_num, start_frame_index;
+
+  if (ATOMIC_LOAD(&_ok_to_sample) == false) return;
+  if (rb_during_gc()) {
+    ATOMIC_ADD(&_skipped_in_gc, 1);
+    return;
+  }
+
+  cur_traces_num = ATOMIC_LOAD(&_cur_traces_num);
+  start_frame_index = ATOMIC_LOAD(&_start_frame_index);
+
+  if (cur_traces_num < MAX_TRACES) {
+    num_frames = rb_profile_frames(0, sizeof(_traces[cur_traces_num].frames_buf) / sizeof(VALUE), _traces[cur_traces_num].frames_buf, _traces[cur_traces_num].lines_buf);
+    if (num_frames - start_frame_index > 2) {
+      _traces[cur_traces_num].num_tracelines = num_frames - start_frame_index - 2; // The extra -2 is because there's a bug when reading the very first (bottom) 2 iseq objects for some reason
+      ATOMIC_ADD(&_cur_traces_num, 1);
+    } // TODO: add an else with a counter so we can track if we skipped profiling here
+  }
+  ATOMIC_STORE_BOOL(&_job_registered, false);
+}
+
+/* rb_scout_profile_frames: retreive the traces for the layer that is exiting
+ *
+ * Note: Calls to this must have already stopped sampling
+ */
+static VALUE rb_scout_profile_frames(VALUE self)
+{
+  int n;
+  uint_fast16_t i, cur_traces_num, start_trace_index;
+  VALUE traces, trace, trace_line;
+
+  if (ATOMIC_LOAD(&_thread_registered) == false) {
+    fprintf(stderr, "Error: trying to get profiled frames on a non-profiled thread!\n");
+    ATOMIC_STORE_INT16(&_cur_traces_num, 0);
+    return rb_ary_new();
+  }
+
+  cur_traces_num = ATOMIC_LOAD(&_cur_traces_num);
+  start_trace_index = ATOMIC_LOAD(&_start_trace_index);
+
+  if (cur_traces_num - start_trace_index > 0) {
+    traces = rb_ary_new2(cur_traces_num - start_trace_index);
+    for(i = start_trace_index; i < cur_traces_num; i++) {
+      if (_traces[i].num_tracelines > 0) {
+        trace = rb_ary_new2(_traces[i].num_tracelines);
+        for(n = 0; n < _traces[i].num_tracelines; n++) {
+          trace_line = rb_ary_new2(2);
+          rb_ary_store(trace_line, 0, _traces[i].frames_buf[n]);
+          rb_ary_store(trace_line, 1, INT2FIX(_traces[i].lines_buf[n]));
+          rb_ary_push(trace, trace_line);
+        }
+        rb_ary_push(traces, trace);
+      }
+    }
+  } else {
+    traces = rb_ary_new();
+  }
+  ATOMIC_STORE_INT16(&_cur_traces_num, start_trace_index);
+  return traces;
+}
+
+
+
+/*****************************************************/
+/* Control code */
+/*****************************************************/
+
+static void
+scout_start_thread_timer()
+{
+  struct itimerspec its;
+  sigset_t mask;
+
+  if (ATOMIC_LOAD(&_thread_registered) == false) return;
+
+  sigemptyset(&mask);
+  sigaddset(&mask, SIGALRM);
+  if (sigprocmask(SIG_SETMASK, &mask, NULL) == -1) {
+    fprintf(stderr, "Block mask failed: %d\n", errno);
+  }
+
+  its.it_value.tv_sec = 0;
+  its.it_value.tv_nsec = INTERVAL;
+  its.it_interval.tv_sec = its.it_value.tv_sec;
+  its.it_interval.tv_nsec = its.it_value.tv_nsec;
+
+  if (timer_settime(_timerid, 0, &its, NULL) == -1) {
+    fprintf(stderr, "Timer set failed in start sampling: %d\n", errno);
+  }
+
+  if (sigprocmask(SIG_UNBLOCK, &mask, NULL) == -1) {
+    fprintf(stderr, "UNBlock mask failed: %d\n", errno);
+  }
+}
+
+static void
+scout_stop_thread_timer()
+{
+  struct itimerspec its;
+
+  if (ATOMIC_LOAD(&_thread_registered) == false) return;
+
+  memset((void*)&its, 0, sizeof(its));
+  if (timer_settime(_timerid, 0, &its, NULL) == -1 ) {
+    fprintf(stderr, "Timer set failed: %d\n", errno);
+  }
+}
+
+/* Per thread start sampling */
+static VALUE
+rb_scout_start_sampling(VALUE self)
+{
+  scout_add_profiled_thread(pthread_self());
+  ATOMIC_STORE_BOOL(&_ok_to_sample, true);
+  scout_start_thread_timer();
+  return Qtrue;
+}
+
+/* Per thread stop sampling */
+static VALUE
+rb_scout_stop_sampling(VALUE self, VALUE reset)
+{
+  if(ATOMIC_LOAD(&_ok_to_sample) == true ) {
+    scout_stop_thread_timer();
+  }
+
+  ATOMIC_STORE_BOOL(&_ok_to_sample, false);
+
+  // TODO: I think this can be (reset == Qtrue)
+  if (TYPE(reset) == T_TRUE) {
+    ATOMIC_STORE_BOOL(&_job_registered, 0);
+    ATOMIC_STORE_BOOL(&_in_signal_handler, 0);
+    ATOMIC_STORE_INT16(&_start_trace_index, 0);
+    ATOMIC_STORE_INT16(&_start_frame_index, 0);
+    ATOMIC_STORE_INT16(&_cur_traces_num, 0);
+    ATOMIC_STORE_INT32(&_skipped_in_gc, 0);
+    ATOMIC_STORE_INT32(&_skipped_in_signal_handler, 0);
+    ATOMIC_STORE_INT32(&_skipped_in_job_registered, 0);
+  }
+  return Qtrue;
+}
+
+// rb_scout_update_indexes: Called when each layer starts or something
+static VALUE
+rb_scout_update_indexes(VALUE self, VALUE frame_index, VALUE trace_index)
+{
+  ATOMIC_STORE_INT16(&_start_trace_index, NUM2INT(trace_index));
+  ATOMIC_STORE_INT16(&_start_frame_index, NUM2INT(frame_index));
+  return Qtrue;
+}
+
+// rb_scout_current_trace_index: Get the current top of the trace stack
+static VALUE
+rb_scout_current_trace_index(VALUE self)
+{
+  return INT2NUM(ATOMIC_LOAD(&_cur_traces_num));
+}
+
+// rb_scout_current_trace_index: Get the current top of the trace stack
+static VALUE
+rb_scout_current_frame_index(VALUE self)
+{
+  int num_frames;
+  VALUE frames_buf[BUF_SIZE];
+  int lines_buf[BUF_SIZE];
+  num_frames = rb_profile_frames(0, sizeof(frames_buf) / sizeof(VALUE), frames_buf, lines_buf);
+  if (num_frames > 1) {
+    return INT2NUM(num_frames - 1);
+  } else {
+    return INT2NUM(0);
+  }
+}
+
+
+
+static VALUE
+rb_scout_skipped_in_gc(VALUE self)
+{
+  return INT2NUM(ATOMIC_LOAD(&_skipped_in_gc));
+}
+
+static VALUE
+rb_scout_skipped_in_handler(VALUE self)
+{
+  return INT2NUM(ATOMIC_LOAD(&_skipped_in_signal_handler));
+}
+
+static VALUE
+rb_scout_skipped_in_job_registered(VALUE self)
+{
+  return INT2NUM(ATOMIC_LOAD(&_skipped_in_job_registered));
+}
+
+////////////////////////////////////////////////////////////////
+// Fetch details from a frame
+////////////////////////////////////////////////////////////////
+
+static VALUE
+rb_scout_frame_klass(VALUE self, VALUE frame)
+{
+  return rb_profile_frame_classpath(frame);
+}
+
+static VALUE
+rb_scout_frame_method(VALUE self, VALUE frame)
+{
+  return rb_profile_frame_label(frame);
+}
+
+static VALUE
+rb_scout_frame_file(VALUE self, VALUE frame)
+{
+  return rb_profile_frame_absolute_path(frame);
+}
+
+static VALUE
+rb_scout_frame_lineno(VALUE self, VALUE frame)
+{
+  return rb_profile_frame_first_lineno(frame);
+}
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+
+// Gem Init. Set up constants, attach methods
+void Init_stacks()
+{
+    mScoutApm = rb_define_module("ScoutApm");
+    mInstruments = rb_define_module_under(mScoutApm, "Instruments");
+    cStacks = rb_define_class_under(mInstruments, "Stacks", rb_cObject);
+
+    rb_warning("Initializing ScoutProf Native Extension");
+
+    // Installs/uninstalls the signal handler.
+    rb_define_singleton_method(cStacks, "install", rb_scout_install_profiling, 0);
+    rb_define_singleton_method(cStacks, "uninstall", rb_scout_uninstall_profiling, 0);
+
+    rb_define_singleton_method(cStacks, "start", rb_scout_start_profiling, 0);
+
+    rb_define_singleton_method(cStacks, "add_profiled_thread", rb_scout_add_profiled_thread, 0);
+    rb_define_singleton_method(cStacks, "remove_profiled_thread", rb_scout_remove_profiled_thread, 0);
+
+    rb_define_singleton_method(cStacks, "profile_frames", rb_scout_profile_frames, 0);
+    rb_define_singleton_method(cStacks, "start_sampling", rb_scout_start_sampling, 0);
+    rb_define_singleton_method(cStacks, "stop_sampling", rb_scout_stop_sampling, 1);
+    rb_define_singleton_method(cStacks, "update_indexes", rb_scout_update_indexes, 2);
+    rb_define_singleton_method(cStacks, "current_trace_index", rb_scout_current_trace_index, 0);
+    rb_define_singleton_method(cStacks, "current_frame_index", rb_scout_current_frame_index, 0);
+
+    rb_define_singleton_method(cStacks, "frame_klass", rb_scout_frame_klass, 1);
+    rb_define_singleton_method(cStacks, "frame_method", rb_scout_frame_method, 1);
+    rb_define_singleton_method(cStacks, "frame_file", rb_scout_frame_file, 1);
+    rb_define_singleton_method(cStacks, "frame_lineno", rb_scout_frame_lineno, 1);
+
+    rb_define_singleton_method(cStacks, "skipped_in_gc", rb_scout_skipped_in_gc, 0);
+    rb_define_singleton_method(cStacks, "skipped_in_handler", rb_scout_skipped_in_handler, 0);
+    rb_define_singleton_method(cStacks, "skipped_in_job_registered", rb_scout_skipped_in_job_registered, 0);
+
+    rb_define_const(cStacks, "ENABLED", Qtrue);
+    rb_warning("Finished Initializing ScoutProf Native Extension");
+}
+
+#else
+
+static VALUE rb_scout_install_profiling(VALUE module)
+{
+  return Qnil;
+}
+
+static VALUE rb_scout_uninstall_profiling(VALUE module)
+{
+  return Qnil;
+}
+
+static VALUE rb_scout_start_profiling(VALUE module)
+{
+  return Qnil;
+}
+
+static VALUE rb_scout_stop_profiling(VALUE module)
+{
+  return Qnil;
+}
+
+static VALUE rb_scout_add_profiled_thread(VALUE module)
+{
+  return Qnil;
+}
+
+static VALUE rb_scout_remove_profiled_thread(VALUE module)
+{
+  return Qnil;
+}
+
+static VALUE rb_scout_profile_frames(VALUE self)
+{
+  return rb_ary_new();
+}
+
+static VALUE
+rb_scout_start_sampling(VALUE self)
+{
+  return Qtrue;
+}
+
+static VALUE
+rb_scout_stop_sampling(VALUE self)
+{
+  return Qtrue;
+}
+
+static VALUE
+rb_scout_update_indexes(VALUE self, VALUE frame_index, VALUE trace_index)
+{
+  return Qtrue;
+}
+
+// rb_scout_current_trace_index: Get the current top of the trace stack
+static VALUE
+rb_scout_current_trace_index(VALUE self)
+{
+  return INT2NUM(0);
+}
+
+// rb_scout_current_trace_index: Get the current top of the trace stack
+static VALUE
+rb_scout_current_frame_index(VALUE self)
+{
+  return INT2NUM(0);
+}
+
+static VALUE
+rb_scout_skipped_in_gc(VALUE self)
+{
+  return INT2NUM(0);
+}
+
+static VALUE
+rb_scout_skipped_in_handler(VALUE self)
+{
+  return INT2NUM(0);
+}
+
+static VALUE
+rb_scout_skipped_in_job_registered(VALUE self)
+{
+  return INT2NUM(0);
+}
+
+static VALUE
+rb_scout_frame_klass(VALUE self, VALUE frame)
+{
+  return Qnil;
+}
+
+static VALUE
+rb_scout_frame_method(VALUE self, VALUE frame)
+{
+  return Qnil;
+}
+
+static VALUE
+rb_scout_frame_file(VALUE self, VALUE frame)
+{
+  return Qnil;
+}
+
+static VALUE
+rb_scout_frame_lineno(VALUE self, VALUE frame)
+{
+  return Qnil;
+}
+
+void Init_stacks()
+{
+    mScoutApm = rb_define_module("ScoutApm");
+    mInstruments = rb_define_module_under(mScoutApm, "Instruments");
+    cStacks = rb_define_class_under(mInstruments, "Stacks", rb_cObject);
+
+    // Installs/uninstalls the signal handler.
+    rb_define_singleton_method(cStacks, "install", rb_scout_install_profiling, 0);
+    rb_define_singleton_method(cStacks, "uninstall", rb_scout_uninstall_profiling, 0);
+
+    // Starts/removes the timer tick, leaving the sighandler.
+    rb_define_singleton_method(cStacks, "start", rb_scout_start_profiling, 0);
+    rb_define_singleton_method(cStacks, "stop", rb_scout_stop_profiling, 0);
+
+    rb_define_singleton_method(cStacks, "add_profiled_thread", rb_scout_add_profiled_thread, 0);
+    rb_define_singleton_method(cStacks, "remove_profiled_thread", rb_scout_remove_profiled_thread, 0);
+
+    rb_define_singleton_method(cStacks, "profile_frames", rb_scout_profile_frames, 0);
+    rb_define_singleton_method(cStacks, "start_sampling", rb_scout_start_sampling, 0);
+    rb_define_singleton_method(cStacks, "stop_sampling", rb_scout_stop_sampling, 1);
+    rb_define_singleton_method(cStacks, "update_indexes", rb_scout_update_indexes, 2);
+    rb_define_singleton_method(cStacks, "current_trace_index", rb_scout_current_trace_index, 0);
+    rb_define_singleton_method(cStacks, "current_frame_index", rb_scout_current_frame_index, 0);
+
+    rb_define_singleton_method(cStacks, "frame_klass", rb_scout_frame_klass, 1);
+    rb_define_singleton_method(cStacks, "frame_method", rb_scout_frame_method, 1);
+    rb_define_singleton_method(cStacks, "frame_file", rb_scout_frame_file, 1);
+    rb_define_singleton_method(cStacks, "frame_lineno", rb_scout_frame_lineno, 1);
+
+    rb_define_singleton_method(cStacks, "skipped_in_gc", rb_scout_skipped_in_gc, 0);
+    rb_define_singleton_method(cStacks, "skipped_in_handler", rb_scout_skipped_in_handler, 0);
+    rb_define_singleton_method(cStacks, "skipped_in_job_registered", rb_scout_skipped_in_job_registered, 0);
+
+    rb_define_const(cStacks, "ENABLED", Qfalse);
+    rb_define_const(cStacks, "INSTALLED", Qfalse);
+}
+
+#endif //#ifdef RUBY_INTERNAL_EVENT_NEWOBJ
+