stack_trace 0.2.1 → 0.4.0

data/ext/stack_trace/event_store.c

@@ -0,0 +1,109 @@
+/*
+* Implements a ring buffer which blocks the producer if
+* there is no space left and blocks the consumer if
+* there is no event available in the queue.
+*/
+
+#include <stdlib.h>
+#include <pthread.h>
+#include <ruby/digest.h>
+#include <time.h>
+
+#include "types/event.h"
+#include "debug.h"
+
+#define SIZE 1000
+#define TEN_MILLISECONDS 10000000
+
+pthread_cond_t has_space = PTHREAD_COND_INITIALIZER;
+pthread_cond_t has_event = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+
+static Event **store;
+int producer_cursor = 0, consumer_cursor = 0, free_space = SIZE;
+
+void Init_event_store() {
+  store = malloc(sizeof(Event *) * SIZE);
+
+  int i;
+
+  for(i = 0; i < SIZE; i++) {
+    store[i] = malloc(sizeof(Event));
+  }
+}
+
+static void wait_free_space() {
+  if(free_space == 0) pthread_cond_wait(&has_space, &lock);
+}
+
+static int wait_event() {
+  if(free_space == SIZE) {
+    rb_thread_check_ints(); // Otherwise the GC stucks!
+
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    ts.tv_nsec += TEN_MILLISECONDS;
+
+    return pthread_cond_timedwait(&has_event, &lock, &ts); // returns 0 if the thread gets signal from another one
+  }
+
+  return 0;
+}
+
+static Event *claim_event() {
+  producer_cursor = producer_cursor % SIZE;
+
+  wait_free_space();
+
+  return store[producer_cursor++];
+}
+
+static Event *pull_event() {
+  consumer_cursor = consumer_cursor % SIZE;
+
+  if(wait_event() != 0) return NULL; // either timeout or an error
+
+  return store[consumer_cursor++];
+}
+
+static void event_produced() {
+  DEBUG_TEXT("Event produced. Free space: %d", free_space - 1);
+
+  free_space--;
+
+  pthread_cond_signal(&has_event);
+}
+
+static void event_consumed() {
+  free_space++;
+
+  pthread_cond_signal(&has_space);
+}
+
+// Takes a callback function which populates the event information.
+void produce_event(Event event) {
+  pthread_mutex_lock(&lock);
+
+  Event *slot = claim_event();
+
+  memcpy(slot, &event, sizeof(Event));
+
+  event_produced();
+
+  pthread_mutex_unlock(&lock);
+}
+
+// Takes a callback function which consumes the event.
+void consume_event(void(*processor_func)(Event *event)) {
+  pthread_mutex_lock(&lock);
+
+  Event *event = pull_event();
+
+  if(event != NULL) {
+    processor_func(event);
+
+    event_consumed();
+  }
+
+  pthread_mutex_unlock(&lock);
+}

data/ext/stack_trace/event_store.h

@@ -0,0 +1,5 @@
+#include "types/event.h"
+
+void Init_event_store();
+void produce_event(Event event);
+void consume_event(void(*func)(Event *event));

data/ext/stack_trace/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+
+if ENV['ST_DEBUG']
+  $defs << "-DST_DEBUG"
+end
+
+create_makefile("stack_trace/ext/stack_trace")

data/ext/stack_trace/sidecar.c

@@ -0,0 +1,77 @@
+#include <ruby.h>
+#include <stdbool.h>
+#include <ruby/debug.h>
+
+#include "event_store.h"
+#include "trace.h"
+
+static bool running = false;
+static VALUE ractor;
+
+static VALUE listen_events(VALUE data, VALUE m, int _argc, const VALUE *_argv, VALUE _) {
+  running = true;
+
+  while(running) {
+    consume_event(&process_event);
+  }
+
+  return Qtrue;
+}
+
+static VALUE exit_sidecar(VALUE data, VALUE m, int _argc, const VALUE *_argv, VALUE _) {
+  VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
+  VALUE sidecar_class = rb_const_get(main_module, rb_intern("Sidecar"));
+
+  rb_funcall(sidecar_class, rb_intern("stop"), 0);
+
+  return Qtrue;
+}
+
+static VALUE rb_run(VALUE self) {
+  if(running) return Qnil;
+
+  VALUE kernel_module = rb_const_get(rb_cObject, rb_intern("Kernel"));
+  rb_block_call(kernel_module, rb_intern("at_exit"), 0, NULL, &exit_sidecar, (VALUE)NULL);
+
+  VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
+  VALUE configuration = rb_funcall(main_module, rb_intern("configuration"), 0);
+  VALUE check_proc = rb_funcall(configuration, rb_intern("check_proc"), 0);
+  set_check_proc(check_proc);  // hack to share an object between main thread and ractor
+
+  VALUE ractor_module = rb_const_get(rb_cObject, rb_intern("Ractor"));
+  ractor = rb_block_call(ractor_module, rb_intern("new"), 0, NULL, &listen_events, (VALUE)NULL);
+
+  rb_gc_register_address(&ractor); // So the GC does not try to free this object.
+
+  return Qtrue;
+}
+
+static VALUE rb_stop(VALUE self) {
+  if(!running) return Qnil;
+
+  running = false;
+
+  // The sidecar might be waiting for an event to arrive
+  // so here we are sending a no-op event to break the loop.
+  // Same could be done by using `pthread_cond_timedwait` but
+  // then I have to do more changes.
+  Event event = {};
+  event.event = NOOP_EVENT;
+
+  produce_event(event);
+
+  return Qtrue;
+}
+
+static VALUE rb_is_running(VALUE self) {
+  return running ? Qtrue : Qfalse;
+}
+
+void Init_sidecar() {
+  VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
+  VALUE sidecar_class = rb_define_class_under(main_module, "Sidecar", rb_cObject);
+
+  rb_define_singleton_method(sidecar_class, "run", rb_run, 0);
+  rb_define_singleton_method(sidecar_class, "stop", rb_stop, 0);
+  rb_define_singleton_method(sidecar_class, "running?", rb_is_running, 0);
+}

data/ext/stack_trace/sidecar.h

@@ -0,0 +1 @@
+void Init_sidecar();

data/ext/stack_trace/span.c

@@ -0,0 +1,106 @@
+#include "span.h"
+#include "utils.h"
+
+#define CHILDREN_BUF_INC_SIZE 10
+
+Span *create_span(Event *event) {
+  Span *span = malloc(sizeof(Span));
+
+  span->started_at = event->at;
+  span->receiver = event->receiver;
+  span->klass = event->klass;
+  span->self_klass = event->self_klass;
+  span->method = event->method;
+  span->return_value = Qundef;
+  span->arguments = event->arguments;
+  span->exception = Qundef;
+  span->children_count = 0;
+  span->singleton = event->for_singleton ? Qtrue : Qfalse;
+
+  return span;
+}
+
+static void allocate_children_buf(Span *parent) {
+  parent->children = malloc(CHILDREN_BUF_INC_SIZE * sizeof(Span *));
+}
+
+static void reallocate_children_buf(Span *parent) {
+  size_t new_size = ((parent->children_count / CHILDREN_BUF_INC_SIZE) + 1) * CHILDREN_BUF_INC_SIZE * sizeof(Span *);
+
+  parent->children = realloc(parent->children, new_size);
+}
+
+Span *add_child(Span *parent, Span *child) {
+  if(parent->children_count == 0) allocate_children_buf(parent);
+  if(parent->children_count % CHILDREN_BUF_INC_SIZE == 0) reallocate_children_buf(parent);
+
+  parent->children[parent->children_count] = child;
+  parent->children_count++;
+  child->caller = parent;
+
+  return child;
+}
+
+Span *close_span(Span *span, Event *event) {
+  span->finished_at = event->at;
+  span->return_value = event->return_value;
+
+  return span->caller;
+}
+
+
+// Deallocate the memory occupied by span
+// and its children.
+void free_span(Span *span) {
+  int i;
+
+  if(span->children_count > 0) {
+    for(i = 0; i < span->children_count; i++)
+      free_span(span->children[i]);
+
+    free(span->children);
+  }
+
+  free(span);
+}
+
+int duration_of(Span *span) {
+  return (int)(span->finished_at - span->started_at);
+}
+
+VALUE span_to_ruby_hash(Span *span) {
+  VALUE hash = rb_hash_new();
+
+  rb_hash_aset(hash, rb_str_new2("receiver"), span->receiver);
+  rb_hash_aset(hash, rb_str_new2("defined_class"), span->klass);
+  rb_hash_aset(hash, rb_str_new2("self_class"), span->self_klass);
+  rb_hash_aset(hash, rb_str_new2("method_name"), span->method);
+  rb_hash_aset(hash, rb_str_new2("singleton"), span->singleton);
+  rb_hash_aset(hash, rb_str_new2("duration"), INT2FIX(duration_of(span)));
+  rb_hash_aset(hash, rb_str_new2("spans"), to_ruby_array(span->children_count, span->children));
+
+  if(span->exception != Qundef)
+    rb_hash_aset(hash, rb_str_new2("exception"), span->exception);
+
+  if(span->return_value != Qundef)
+    rb_hash_aset(hash, rb_str_new2("return_value"), rb_funcall(span->return_value, rb_intern("st_name"), 0));
+
+  if(span->arguments != Qundef) {
+    rb_gc_unregister_address(&span->arguments);
+
+    rb_hash_aset(hash, rb_str_new2("arguments"), span->arguments);
+  }
+
+  return hash;
+}
+
+VALUE to_ruby_array(int count, Span **spans) {
+  int i;
+  VALUE children = rb_ary_new();
+
+  for(i = 0; i < count; i++) {
+    rb_ary_push(children, span_to_ruby_hash(spans[i]));
+  }
+
+  return children;
+}

data/ext/stack_trace/span.h

@@ -0,0 +1,9 @@
+#include <ruby.h>
+#include <types/event.h>
+#include <types/span.h>
+
+Span *create_span(Event *event);
+Span *add_child(Span *parent, Span *child);
+Span *close_span(Span *span, Event *event);
+void free_span(Span *span);
+VALUE to_ruby_array(int count, Span **span);

data/ext/stack_trace/stack_trace.c

@@ -0,0 +1,54 @@
+#include <ruby.h>
+#include <ruby/debug.h>
+
+#include "sidecar.h"
+#include "event_producer.h"
+#include "event_store.h"
+#include "current_trace.h"
+#include "trace.h"
+#include "configuration.h"
+
+static rb_event_flag_t traced_events() {
+  VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
+
+  rb_event_flag_t events = 0;
+
+  VALUE configuration = rb_funcall(main_module, rb_intern("configuration"), 0);
+  VALUE trace_ruby = rb_funcall(configuration, rb_intern("trace_ruby"), 0);
+  VALUE trace_c = rb_funcall(configuration, rb_intern("trace_c"), 0);
+
+  if(RTEST(trace_ruby)) events |= RUBY_EVENT_CALL | RUBY_EVENT_RETURN;
+  if(RTEST(trace_c)) events |= RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN;
+  if(events != 0) events |= RUBY_EVENT_RAISE;
+
+  return events;
+}
+
+VALUE rb_trace_point(VALUE self) {
+  VALUE tracePoint = rb_iv_get(self, "@trace_point");
+
+  if(NIL_P(tracePoint)) {
+    tracePoint = rb_tracepoint_new(Qnil, traced_events(), create_event, NULL);
+    rb_iv_set(self, "@trace_point", tracePoint);
+  }
+
+  return tracePoint;
+}
+
+void Init_stack_trace() {
+  rb_ext_ractor_safe(true);
+
+  VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
+  VALUE configuration_class = rb_const_get(main_module, rb_intern("Configuration"));
+
+  rb_define_singleton_method(main_module, "trace_point", rb_trace_point, 0);
+  rb_define_singleton_method(main_module, "start_trace", rb_create_trace, 0);
+  rb_define_singleton_method(main_module, "complete_trace", rb_send_eot, 0);
+  rb_define_singleton_method(main_module, "current", rb_get_current_trace, 0);
+
+  rb_define_method(configuration_class, "inspect_return_values=", rb_set_inspect_return_values, 1);
+  rb_define_method(configuration_class, "inspect_arguments=", rb_set_inspect_arguments, 1);
+
+  Init_event_store();
+  Init_sidecar();
+}

data/ext/stack_trace/trace.c

@@ -0,0 +1,132 @@
+#include <ruby.h>
+#include <pthread.h>
+#include <ruby/debug.h>
+#include <ruby/thread.h>
+#include <stdbool.h>
+
+#include "types/trace.h"
+#include "span.h"
+#include "debug.h"
+#include "current_trace.h"
+
+static VALUE check_proc;
+
+pthread_cond_t trace_finished = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t trace_access_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void free_trace(Trace *trace) {
+  free_span(trace->top_span);
+  free(trace);
+}
+
+void process_obsolote_event(Event *event) {
+  // Free this trace as there is no reference to it anymore!
+  free_trace(event->trace);
+}
+
+void set_check_proc(VALUE proc) {
+  check_proc = proc;
+}
+
+bool is_tracked_event(Event *event) {
+  if(!RTEST(check_proc)) return true; // Check proc is not configured, all the events will be tracked.
+
+  VALUE result = rb_funcall(check_proc, rb_intern("call"), 2, event->self_klass, event->method);
+
+  return RTEST(result);
+}
+
+void create_new_span(Event *event) {
+  if(!is_tracked_event(event)) return;
+
+  Span *new_span = create_span(event);
+
+  add_child(event->trace->current_span, new_span);
+
+  event->trace->current_span = new_span;
+}
+
+void close_current_span(Event *event) {
+  if(!is_tracked_event(event)) return;
+
+  Trace *trace = event->trace;
+
+  trace->current_span = close_span(trace->current_span, event);
+}
+
+void attach_exception(Event *event) {
+  Trace *trace = event->trace;
+
+  trace->current_span->exception = event->raised_exception;
+}
+
+void close_current_trace(Event *event) {
+  pthread_mutex_lock(&trace_access_mutex);
+  event->trace->finished = true;
+  pthread_cond_broadcast(&trace_finished);
+  pthread_mutex_unlock(&trace_access_mutex);
+}
+
+void process_event(Event *event) {
+  DEBUG("Event received: ", event);
+
+  switch (event->event) {
+    case RUBY_EVENT_CALL:
+    case RUBY_EVENT_C_CALL:
+    case RUBY_EVENT_B_CALL:
+      return create_new_span(event);
+    case RUBY_EVENT_RETURN:
+    case RUBY_EVENT_C_RETURN:
+    case RUBY_EVENT_B_RETURN:
+      return close_current_span(event);
+    case RUBY_EVENT_RAISE:
+      return attach_exception(event);
+    case END_OF_TRACE:
+      return close_current_trace(event);
+    case END_OF_OBSOLOTE_TRACE_EVENT:
+      return process_obsolote_event(event);
+  }
+}
+
+// Ruby threads are preemptive(from the kernel and Ruby programmer POV) but forced to be
+// cooperative by the VM, therefore, if we don't yield back, other threads won't have chance to run.
+// For this reason, we need to call this function with `rb_thread_call_without_gvl` to release the GVL
+// while waiting for the trace to be ready without blocking other Ruby programmer-level threads.
+void ensure_trace_is_finished() {
+  pthread_mutex_lock(&trace_access_mutex);
+
+  while(!get_current_trace()->finished) { // This is the easiest way to wait for the related trace, not the most efficient one though!
+    DEBUG_TEXT("Waiting for the trace to be ready...");
+
+    pthread_cond_wait(&trace_finished, &trace_access_mutex);
+  }
+
+  pthread_mutex_unlock(&trace_access_mutex);
+}
+
+Trace *get_current_trace_without_gvl() {
+  rb_thread_call_without_gvl((void *)ensure_trace_is_finished, NULL, NULL, NULL);
+
+  return get_current_trace();
+}
+
+VALUE to_ruby_hash(Trace *trace) {
+  VALUE hash = rb_hash_new();
+
+  rb_hash_aset(hash, rb_str_new2("spans"), to_ruby_array(trace->top_span->children_count, trace->top_span->children));
+
+  return hash;
+}
+
+VALUE rb_get_current_trace(VALUE _self) {
+  VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
+  VALUE tracePoint = rb_iv_get(main_module, "@trace_point");
+  VALUE is_tracepoint_enabled = rb_funcall(tracePoint, rb_intern("enabled?"), 0);
+
+  if(RTEST(is_tracepoint_enabled)) rb_raise(rb_eRuntimeError, "Trace is active!");
+
+  Trace *trace = get_current_trace_without_gvl();
+  VALUE ruby_hash = to_ruby_hash(trace);
+
+  return ruby_hash;
+}

data/ext/stack_trace/trace.h

@@ -0,0 +1,8 @@
+#include <ruby.h>
+
+#include "types/event.h"
+
+void process_event(Event *event);
+VALUE rb_get_current_trace(VALUE _self);
+Trace *get_current_trace();
+void set_check_proc(VALUE proc);

data/ext/stack_trace/types/event.h

@@ -0,0 +1,31 @@
+#include <ruby.h>
+#include <ruby/debug.h>
+#include <types/trace.h>
+#include <stdbool.h>
+#include <sys/time.h>
+
+#ifndef EVENT_H
+  #define EVENT_H
+
+  #define END_OF_TRACE 0xfffffff0
+  #define END_OF_OBSOLOTE_TRACE_EVENT 0xffffffff
+  #define NOOP_EVENT 0xfffffff1
+
+  typedef struct EventS Event;
+
+  struct EventS {
+    Trace *trace;
+    VALUE tp_val;
+    rb_event_flag_t event;
+    rb_trace_arg_t *trace_arg;
+    VALUE klass;
+    VALUE self_klass;
+    VALUE receiver;
+    VALUE method;
+    VALUE raised_exception;
+    VALUE return_value;
+    VALUE arguments;
+    bool for_singleton;
+    long int at;
+  };
+#endif

data/ext/stack_trace/types/span.h

@@ -0,0 +1,22 @@
+#ifndef SPAN_H
+  #define SPAN_H
+
+  typedef struct SpanS Span;
+
+  struct SpanS {
+    long int started_at;
+    long int finished_at;
+
+    VALUE klass;
+    VALUE self_klass;
+    VALUE receiver;
+    VALUE method;
+    VALUE singleton;
+    VALUE exception;
+    VALUE return_value;
+    VALUE arguments;
+    Span *caller;
+    int children_count;
+    Span **children;
+  };
+#endif

data/ext/stack_trace/types/trace.h

@@ -0,0 +1,15 @@
+#include <types/span.h>
+#include <stdbool.h>
+
+#ifndef TRACE_H
+  #define TRACE_H
+
+  typedef struct TraceS Trace;
+
+  struct TraceS {
+    Span *top_span;
+    Span *current_span;
+    bool finished;
+    bool active;
+  };
+#endif

data/ext/stack_trace/utils.c

@@ -0,0 +1,8 @@
+#include <sys/time.h>
+
+long int get_monotonic_m_secs() {
+  struct timespec at;
+  clock_gettime(CLOCK_MONOTONIC_RAW, &at);
+
+  return at.tv_sec * 1000000 + at.tv_nsec / 1000;
+}

data/ext/stack_trace/utils.h

@@ -0,0 +1 @@
+long int get_monotonic_m_secs(void);

data/lib/stack_trace/argument_extractor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StackTrace
+  class ArgumentExtractor
+    class << self
+      def extract(trace_point)
+        trace_point.parameters
+                  .map(&:last)
+                  .each_with_object({}) do |parameter, memo|
+                    memo[parameter] = extract_argument(trace_point, parameter)
+                  end
+      end
+
+      private
+
+      def extract_argument(trace_point, parameter)
+        trace_point.binding.eval(parameter.to_s).st_name
+      rescue Exception # SyntaxError can happen as we are calling `eval` here!
+      end
+    end
+  end
+end

data/lib/stack_trace/configuration.rb

@@ -1,62 +1,7 @@
-# frozen-string-literal: true
-
-require "objspace"
+# frozen_string_literal: true
 
 module StackTrace
   class Configuration
-    CONFIG_ATTRIBUTES = {
-      enabled: false,
-      modules: {},
-    }
-
-    attr_writer *CONFIG_ATTRIBUTES.keys
-
-    CONFIG_ATTRIBUTES.each do |attr_name, default_value|
-      define_method(attr_name) do
-        instance_variable_get("@#{attr_name}") || default_value
-      end
-    end
-
-    def for(klass)
-      config_holder = config_holder_for(klass)
-      modules.find { |module_name_conf, _| config_for_class?(module_name_conf, config_holder) }
-    end
-
-    private
-
-    # Configuration for StackTrace is done by specifying the class/module itself
-    # so if the klass we receive here is a singleton_class, we should get the
-    # class/module of that singleton_class first.
-    def config_holder_for(klass)
-      klass.singleton_class? ? ObjectSpace.each_object(klass).first : klass
-    end
-
-    def config_for_class?(config, klass)
-      case config
-      when Regexp
-        klass.respond_to?(:name) && klass.name =~ config
-      when Hash
-        match_hash_config(config, klass)
-      else
-        [config].flatten.include?(klass)
-      end
-    end
-
-    def match_hash_config(config, klass)
-      inherits_config?(klass, config) || path_config?(klass, config)
-    end
-
-    def inherits_config?(klass, inherits: nil, **)
-      inherits &&
-        klass.ancestors.include?(inherits) &&
-        klass != inherits
-    end
-
-    def path_config?(klass, path: nil, **)
-      path &&
-        klass.respond_to?(:stack_trace_source_location) &&
-        klass.stack_trace_source_location &&
-        klass.stack_trace_source_location.match(path)
-    end
+    attr_accessor :trace_ruby, :trace_c, :check_proc
   end
 end

data/lib/stack_trace/patch/class.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Class
+  def st_name
+    name || "Anonymous"
+  end
+end