stack_trace 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e528eba64406556bc7638531e10cd80b0aa0027649d1dfcd223f3e0171e0c47
-  data.tar.gz: c1a935f65476ba84ef18bed8873f82f54d39f3ae6fc384ce13571039c6b3571a
+  metadata.gz: 569140beba085e365500fa422fbb4c17fdadd9cc9bb6c8c9d8ec961762d6d75f
+  data.tar.gz: 82b6503c9d3ef301e0c25a362917badd2c10de725b3e3d553e597d7d85662aaf
 SHA512:
-  metadata.gz: d3adb5c1b7a759a18e0baad12bbefa11f27703396ae833ac887cf40bac0710268b9cda7e3e157c3df9ae313a1388e6222d7c7b50f02ac476b34d6f7d1941e022
-  data.tar.gz: b5cc60e857c0c28c9f0ee2b0d2cd6b64641eb97ad1d62e100f694e1ce0bbcb13f438ebb576ccba6f42536d024fd5d38b8da7305f18a273f126b2516165366756
+  metadata.gz: be5151cc46d1450d064ec7fed0093b3e8d1be8c84f65edff47dc2410fdfa86eb64029548f46ec56c3be5a1b016f918001691df93e4b252823af54f3b2ae53390
+  data.tar.gz: aada681ea172314b8b0657e13be065fe52a0fce05bda5d7b283a78b7a184f68b03d35881942db9c64d834621cc28a4a3b27a5ad83a2a8168c30f955d7b490eba

data/Dockerfile

@@ -0,0 +1,17 @@
+FROM ruby:3.0.6-alpine
+
+RUN apk update
+RUN apk add build-base git --virtual build-dependencies
+
+RUN mkdir /stack_trace
+WORKDIR /stack_trace
+
+ENV BUNDLE_PATH=/bundle \
+    BUNDLE_BIN=/bundle/bin \
+    GEM_HOME=/bundle
+ENV PATH="${BUNDLE_BIN}:${PATH}"
+
+COPY . ./
+
+RUN gem install bundler
+RUN bundle install --jobs 20 --retry 5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stack_trace (0.5.0)
+    stack_trace (0.7.0)
 
 GEM
   remote: https://rubygems.org/
@@ -25,6 +25,7 @@ GEM
     rspec-support (3.12.0)
 
 PLATFORMS
+  aarch64-linux-musl
   arm64-darwin-21
 
 DEPENDENCIES

data/Makefile

@@ -0,0 +1,12 @@
+usage:
+	@echo "Available targets:"
+	@echo "  * build - Builds image"
+	@echo "  * dev   - Opens an ash session in the container"
+
+.PHONY: build
+build:
+	docker build . -t stack_trace
+
+.PHONY: dev
+dev:
+	docker run -it --rm -v $(PWD):/stack_trace stack_trace sh

data/README.md

@@ -33,6 +33,11 @@ StackTrace.configure do |config|
 
   config.check_proc = -> (klass_name, method_name) do # If you want to limit the tracing for a set of classes
     klass_name == "Bar"
+
+    # If you use autoload and resolve the constant with `klass_name`
+    # it's really likelly that you get a segfault: https://bugs.ruby-lang.org/issues/18120.
+    # Preload all the constants before running the `StackTrace.trace` if you want to
+    # constantize klass_name.
   end
 end
 ```

data/ext/stack_trace/argument.c

@@ -0,0 +1,11 @@
+#include "argument.h"
+
+void free_arguments(Argument *arguments, int count) {
+  int i;
+
+  for(i = 0; i < count; i++) {
+    if(arguments[i].value != NULL) free(arguments[i].value);
+  }
+
+  free(arguments);
+}

data/ext/stack_trace/argument.h

@@ -0,0 +1,3 @@
+#include "types/argument.h"
+
+void free_arguments(Argument *arguments, int count);

data/ext/stack_trace/current_trace.c

@@ -22,6 +22,14 @@ VALUE rb_create_trace(VALUE _self) {
   Span *span = malloc(sizeof(Span));
   span->children_count = 0;
   span->caller = NULL;
+  span->receiver = NULL;
+  span->klass = NULL;
+  span->self_klass = NULL;
+  span->return_value = NULL;
+  span->arguments = NULL;
+  span->arguments_count = 0;
+  span->exception = NULL;
+  span->children_count = 0;
 
   current_trace = malloc(sizeof(Trace));
   current_trace->finished = false;

data/ext/stack_trace/debug.c

@@ -15,12 +15,7 @@ void serialize_event(char *buffer, Event *event) {
       return;
   }
 
-  VALUE klass_name = rb_funcall(event->klass, rb_intern("name"), 0);
-  VALUE self_name = rb_funcall(event->self_klass, rb_intern("name"), 0);
   VALUE method_name = rb_funcall(event->method, rb_intern("name"), 0);
-
-  char *klass_name_str = RSTRING_PTR(klass_name);
-  char *self_name_str = RSTRING_PTR(self_name);
   char *method_name_str = RSTRING_PTR(method_name);
 
   sprintf(
@@ -30,8 +25,8 @@ void serialize_event(char *buffer, Event *event) {
     "method: %s, "
     "event: %d, "
     "for_singleton: %d",
-    klass_name_str,
-    self_name_str,
+    event->klass,
+    event->self_klass,
     method_name_str,
     event->event,
     event->for_singleton

data/ext/stack_trace/event_producer.c

@@ -6,6 +6,7 @@
 #include "current_trace.h"
 #include "utils.h"
 #include "configuration.h"
+#include "st_name.h"
 
 struct MemoS {
   int i;
@@ -13,16 +14,23 @@ struct MemoS {
 };
 
 static void copy_str(char **target, VALUE string) {
-  *target = malloc(sizeof(char) * RSTRING_LEN(string) + 1);
+  const char *cstr = StringValueCStr(string);
+  size_t len = strlen(cstr);
 
-  memcpy(*target, RSTRING_PTR(string), RSTRING_LEN(string));
+  *target = malloc(sizeof(char) * (len + 1));
+
+  memcpy(*target, cstr, (len + 1));
 }
 
 static int extract_kv(VALUE key, VALUE value, VALUE data) {
   struct MemoS *memo = (struct MemoS *)data;
 
   memo->arguments[memo->i].key = key;
-  copy_str(&memo->arguments[memo->i].value, value);
+
+  VALUE value_klass = rb_obj_class(value);
+  VALUE value_st_name = st_name(value, value_klass);
+
+  if(value_st_name != Qundef) copy_str(&memo->arguments[memo->i].value, value_st_name);
 
   memo->i++;
 
@@ -49,6 +57,12 @@ static void extract_arguments(Event *event, VALUE tp_val) {
 }
 
 void create_event(VALUE tp_val, void *_data) {
+  Trace *current_trace = get_current_trace();
+
+  // This can happen if a new thread spawns in trace scope.
+  // TODO: Save them with their thread identifier.
+  if(current_trace == NULL) return;
+
   Event event = {};
   int for_singleton = false;
 
@@ -56,33 +70,36 @@ void create_event(VALUE tp_val, void *_data) {
 
   VALUE klass = rb_tracearg_defined_class(trace_arg);
   VALUE self = rb_tracearg_self(trace_arg);
-  VALUE receiver = rb_funcall(self, rb_intern("st_name"), 0);
   VALUE method = rb_tracearg_method_id(trace_arg);
   VALUE self_klass;
 
   if(FL_TEST(klass, FL_SINGLETON)) {
-    klass = rb_ivar_get(klass, rb_intern("__attached__"));
     for_singleton = true;
-    self_klass = rb_funcall(self, rb_intern("name"), 0);
+    klass = rb_ivar_get(klass, rb_intern("__attached__"));
+    self_klass = self;
   } else {
-    VALUE class = rb_funcall(self, rb_intern("class"), 0);
-    self_klass = rb_funcall(class, rb_intern("name"), 0);
+    self_klass = CLASS_OF(self);
   }
 
-  event.trace = get_current_trace();
-  event.tp_val = tp_val;
-  event.trace_arg = trace_arg;
+  VALUE receiver = st_name(self, klass);
+  VALUE klass_name = get_cname(klass);
+  VALUE self_klass_name = get_cname(self_klass);
+
+  if(receiver == Qundef || klass_name == Qundef || self_klass_name == Qundef) return;
+  if(!rb_obj_is_kind_of(klass_name, rb_cString) || !rb_obj_is_kind_of(self_klass_name, rb_cString)) return; // These values can be Qnil
+
+  copy_str(&event.receiver, receiver);
+  copy_str(&event.klass, klass_name);
+  copy_str(&event.self_klass, self_klass_name);
+
+  event.trace = current_trace;
   event.event = rb_tracearg_event_flag(trace_arg);
-  event.klass = klass;
-  event.self_klass = self_klass;
   event.method = method;
   event.for_singleton = for_singleton;
   event.return_value = NULL;
   event.arguments = NULL;
   event.at = get_monotonic_m_secs();
 
-  copy_str(&event.receiver, receiver);
-
   if(event.event == RUBY_EVENT_RAISE) {
     VALUE exception = rb_tracearg_raised_exception(trace_arg);
     VALUE exception_to_s = rb_funcall(exception, rb_intern("to_s"), 0);
@@ -97,9 +114,10 @@ void create_event(VALUE tp_val, void *_data) {
   if(RTEST(get_inspect_return_values()) &&
      (event.event == RUBY_EVENT_RETURN || event.event == RUBY_EVENT_C_RETURN || event.event == RUBY_EVENT_B_RETURN)) {
     VALUE return_value = rb_tracearg_return_value(trace_arg);
-    VALUE return_value_st_name = rb_funcall(return_value, rb_intern("st_name"), 0);
+    VALUE return_value_class = rb_obj_class(return_value);
+    VALUE return_value_st_name = st_name(return_value, return_value_class);
 
-    copy_str(&event.return_value, return_value_st_name);
+    if(return_value_st_name != Qundef) copy_str(&event.return_value, return_value_st_name);
   }
 
   produce_event(event);

data/ext/stack_trace/event_store.c

@@ -38,8 +38,6 @@ static void wait_free_space() {
 
 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;
@@ -80,7 +78,6 @@ static void event_consumed() {
   pthread_cond_signal(&has_space);
 }
 
-// Takes a callback function which populates the event information.
 void produce_event(Event event) {
   pthread_mutex_lock(&lock);
 
@@ -93,14 +90,15 @@ void produce_event(Event event) {
   pthread_mutex_unlock(&lock);
 }
 
-// Takes a callback function which consumes the event.
-void consume_event(void(*processor_func)(Event *event)) {
+void get_event(Event *target, int *status) {
   pthread_mutex_lock(&lock);
+  *status = 1;
 
   Event *event = pull_event();
 
   if(event != NULL) {
-    processor_func(event);
+    *status = 0;
+    memcpy(target, event, sizeof(Event));
 
     event_consumed();
   }

data/ext/stack_trace/event_store.h

@@ -2,4 +2,4 @@
 
 void Init_event_store();
 void produce_event(Event event);
-void consume_event(void(*func)(Event *event));
+void get_event(Event *target, int *status);

data/ext/stack_trace/sidecar.c

@@ -4,15 +4,22 @@
 
 #include "event_store.h"
 #include "trace.h"
+#include "types/event.h"
 
 static bool running = false;
 static VALUE ractor;
 
 static VALUE listen_events(VALUE data, VALUE m, int _argc, const VALUE *_argv, VALUE _) {
   running = true;
+  Event event;
+  int status;
 
   while(running) {
-    consume_event(&process_event);
+    get_event(&event, &status);
+
+    if(status == 0) process_event(&event);
+
+    rb_thread_check_ints();
   }
 
   return Qtrue;

data/ext/stack_trace/span.c

@@ -1,5 +1,6 @@
 #include "span.h"
 #include "utils.h"
+#include "argument.h"
 
 #define CHILDREN_BUF_INC_SIZE 10
 
@@ -49,17 +50,6 @@ Span *close_span(Span *span, Event *event) {
   return span->caller;
 }
 
-static void free_arguments(Span *span) {
-  int i;
-
-  for(i = 0; i < span->arguments_count; i++) {
-    free(span->arguments[i].value);
-  }
-
-  free(span->arguments);
-}
-
-
 // Deallocate the memory occupied by span
 // and its children.
 void free_span(Span *span) {
@@ -75,11 +65,17 @@ void free_span(Span *span) {
   if(span->receiver != NULL)
     free(span->receiver);
 
+  if(span->klass != NULL)
+    free(span->klass);
+
+  if(span->self_klass != NULL)
+    free(span->self_klass);
+
   if(span->return_value != NULL)
     free(span->return_value);
 
   if(span->arguments != NULL)
-    free_arguments(span);
+    free_arguments(span->arguments, span->arguments_count);
 
   if(span->exception != NULL)
     free(span->exception);
@@ -96,7 +92,8 @@ VALUE serialize_arguments(Argument *arguments, int count) {
   int i;
 
   for(i = 0; i < count; i++) {
-    rb_hash_aset(hash, arguments[i].key, rb_str_new_cstr(arguments[i].value));
+    if(arguments[i].value != NULL)
+      rb_hash_aset(hash, arguments[i].key, rb_str_new_cstr(arguments[i].value));
   }
 
   return hash;
@@ -106,8 +103,8 @@ VALUE span_to_ruby_hash(Span *span) {
   VALUE hash = rb_hash_new();
 
   rb_hash_aset(hash, rb_str_new2("receiver"), rb_str_new_cstr(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("defined_class"), rb_str_new_cstr(span->klass));
+  rb_hash_aset(hash, rb_str_new2("self_class"), rb_str_new_cstr(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)));

data/ext/stack_trace/st_name.c

@@ -0,0 +1,47 @@
+#include "st_name.h"
+
+static VALUE extract_st_name(VALUE object) {
+  return rb_funcall(object, rb_intern("st_name"), 0);
+}
+
+VALUE get_cname(VALUE constant) {
+  if(rb_obj_is_kind_of(constant, rb_cClass)) {
+    return rb_class_name(constant);
+  } else if(rb_obj_is_kind_of(constant, rb_cModule)) {
+    return rb_mod_name(constant);
+  } else {
+    return Qundef; // This is still possible!
+  }
+}
+
+static VALUE object_name_for_cBasicObject(VALUE object, VALUE klass) {
+  VALUE cname = get_cname(klass);
+
+  if(cname == Qundef) return Qundef;
+
+  return rb_sprintf("#<%"PRIsVALUE":%p>", cname, (void*)object);
+}
+
+static VALUE object_name_for_cObject(VALUE object, VALUE klass) {
+  int status;
+
+  VALUE st_name = rb_protect(extract_st_name, object, &status);
+
+  if(status != 0) {
+    rb_set_errinfo(Qnil);
+
+    return object_name_for_cBasicObject(object, klass);
+  } else {
+    return st_name;
+  }
+}
+
+VALUE st_name(VALUE object, VALUE klass) {
+  if(rb_obj_is_kind_of(object, rb_cObject)) {
+    return object_name_for_cObject(object, klass);
+  } else if(rb_obj_is_kind_of(object, rb_cBasicObject)) {
+    return object_name_for_cBasicObject(object, klass);
+  } else {
+    return Qundef;
+  }
+}

data/ext/stack_trace/st_name.h

@@ -0,0 +1,4 @@
+#include <ruby.h>
+
+VALUE st_name(VALUE object, VALUE klass);
+VALUE get_cname(VALUE constant);

data/ext/stack_trace/trace.c

@@ -8,18 +8,19 @@
 #include "span.h"
 #include "debug.h"
 #include "current_trace.h"
+#include "argument.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) {
+static void free_trace(Trace *trace) {
   free_span(trace->top_span);
   free(trace);
 }
 
-void process_obsolote_event(Event *event) {
+static void process_obsolote_event(Event *event) {
   // Free this trace as there is no reference to it anymore!
   free_trace(event->trace);
 }
@@ -28,16 +29,51 @@ void set_check_proc(VALUE proc) {
   check_proc = proc;
 }
 
-bool is_tracked_event(Event *event) {
+static VALUE call_proc(VALUE val) {
+  Event *event = (Event *)val;
+
+  return rb_funcall(check_proc, rb_intern("call"), 2, rb_str_new_cstr(event->self_klass), event->method);
+}
+
+static 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);
+  int state;
+  VALUE result = rb_protect(call_proc, (VALUE)event, &state); // I don't really like allocating a new array for each call so that's why I use this hack!
+
+  if(state != 0) {
+    rb_p(rb_errinfo());
+
+    rb_set_errinfo(Qnil);
+
+    return false;
+  }
 
   return RTEST(result);
 }
 
+static void free_event_members(Event *event) {
+  if(event->receiver != NULL)
+    free(event->receiver);
+
+  if(event->klass != NULL)
+    free(event->klass);
+
+  if(event->self_klass != NULL)
+    free(event->self_klass);
+
+  if(event->return_value != NULL)
+    free(event->return_value);
+
+  if(event->raised_exception != NULL)
+    free(event->raised_exception);
+
+  if(event->arguments != NULL)
+    free_arguments(event->arguments, event->arguments_count);
+}
+
 void create_new_span(Event *event) {
-  if(!is_tracked_event(event)) return;
+  if(!is_tracked_event(event)) return free_event_members(event);
 
   Span *new_span = create_span(event);
 
@@ -47,7 +83,7 @@ void create_new_span(Event *event) {
 }
 
 void close_current_span(Event *event) {
-  if(!is_tracked_event(event)) return;
+  if(!is_tracked_event(event)) return free_event_members(event);
 
   Trace *trace = event->trace;
 

data/ext/stack_trace/types/event.h

@@ -17,13 +17,11 @@
 
   struct EventS {
     Trace *trace;
-    VALUE tp_val;
     rb_event_flag_t event;
-    rb_trace_arg_t *trace_arg;
     char *receiver;
-    VALUE klass;
-    VALUE self_klass;
-    VALUE method;
+    char *klass;
+    char *self_klass;
+    VALUE method; // This is a symbol anyway
     char *return_value;
     Argument *arguments;
     int arguments_count;

data/ext/stack_trace/types/span.h

@@ -10,8 +10,8 @@
     long int finished_at;
 
     char *receiver;
-    VALUE klass;
-    VALUE self_klass;
+    char *klass;
+    char *self_klass;
     VALUE method;
     VALUE singleton;
     char *return_value;

data/ext/stack_trace/utils.c

@@ -1,4 +1,7 @@
+#define _POSIX_C_SOURCE 199309L
+
 #include <sys/time.h>
+#include <time.h>
 
 long int get_monotonic_m_secs() {
   struct timespec at;

data/lib/stack_trace/argument_extractor.rb

@@ -7,7 +7,7 @@ module StackTrace
         trace_point.parameters
                   .map(&:last)
                   .each_with_object({}) do |parameter, memo|
-                    memo[parameter] = extract_argument(trace_point, parameter).st_name
+                    memo[parameter] = extract_argument(trace_point, parameter)
                   end
       end
 

data/lib/stack_trace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StackTrace
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stack_trace
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Mehmet Emin INAC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-06 00:00:00.000000000 Z
+date: 2023-04-11 00:00:00.000000000 Z
 dependencies: []
 description: StackTrace
 email:
@@ -21,11 +21,15 @@ files:
 - ".rspec"
 - ".tool-versions"
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
+- Makefile
 - README.md
 - Rakefile
+- ext/stack_trace/argument.c
+- ext/stack_trace/argument.h
 - ext/stack_trace/configuration.c
 - ext/stack_trace/configuration.h
 - ext/stack_trace/current_trace.c
@@ -41,6 +45,8 @@ files:
 - ext/stack_trace/sidecar.h
 - ext/stack_trace/span.c
 - ext/stack_trace/span.h
+- ext/stack_trace/st_name.c
+- ext/stack_trace/st_name.h
 - ext/stack_trace/stack_trace.c
 - ext/stack_trace/trace.c
 - ext/stack_trace/trace.h