stack_trace 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac9e909692657f9e1b0cd9fc6475faf494458954513aa2e659e9faeacfb3d51b
-  data.tar.gz: d4819f5e40ef2d81cc5cc539247916ed16416eed9400f63007fe85edc8c9c4cf
+  metadata.gz: a44fbab04e5a7a787dd995fbee5ea3e503080172df937a91e122728eb4884744
+  data.tar.gz: c004c70f42efc53e0776520d9e39a902346015eca012614913dd9a04e9822344
 SHA512:
-  metadata.gz: 072443043f5910dfd02ded927653a23abacefede4f17fd87155521275818b0b90aa769544c30e9f06b5c46c24193e9bac12f711ae39c4f887340d435402f40c2
-  data.tar.gz: d3a5c0ae3803776ea0ad504c825c75ca0d9a70d5153a22133f809633631f824a7540fe7dd72c76c9e4eece214bb578d04765445f39089adadc6076abbe7af10a
+  metadata.gz: aab482726e6436266555c91fbd51a0b44d8b5d0b6b0f3e72cd11448eaac96ea0d49582df77ab828cbbd38be93d177214cddb50a606ad8e899bb541179c43ed0f
+  data.tar.gz: 4e57a54efcb00a4a2701a5169130642be00fcd1aff13c4d508b0ac663f933fa5443eceffc78d74199d0fcf2ced21054559eabe85675ec2190b2f8ec768a02dc3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stack_trace (0.4.0)
+    stack_trace (0.6.0)
 
 GEM
   remote: https://rubygems.org/

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++) {
+    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/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,18 +6,56 @@
 #include "current_trace.h"
 #include "utils.h"
 #include "configuration.h"
+#include "st_name.h"
 
-VALUE extract_arguments(VALUE tp_val) {
+struct MemoS {
+  int i;
+  Argument *arguments;
+};
+
+static void copy_str(char **target, VALUE string) {
+  *target = malloc(sizeof(char) * RSTRING_LEN(string) + 1);
+
+  memcpy(*target, RSTRING_PTR(string), RSTRING_LEN(string));
+}
+
+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);
+
+  memo->i++;
+
+  return ST_CONTINUE;
+}
+
+static void extract_arguments(Event *event, VALUE tp_val) {
   VALUE main_module = rb_const_get(rb_cObject, rb_intern("StackTrace"));
   VALUE extractor_class = rb_const_get(main_module, rb_intern("ArgumentExtractor"));
 
-  VALUE arguments = rb_funcall(extractor_class, rb_intern("extract"), 1, tp_val);
-  rb_gc_register_address(&arguments);
+  VALUE arguments_hash = rb_funcall(extractor_class, rb_intern("extract"), 1, tp_val);
+  VALUE hash_size = rb_funcall(arguments_hash, rb_intern("size"), 0);
+
+  int arguments_count = FIX2INT(hash_size);
+
+  if(arguments_count == 0) return;
+
+  event->arguments_count = arguments_count;
+  event->arguments = malloc(sizeof(Argument) * arguments_count);
 
-  return arguments;
+  struct MemoS memo = { 0, event->arguments };
+
+  rb_hash_foreach(arguments_hash, extract_kv, (VALUE)&memo);
 }
 
 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;
 
@@ -29,37 +67,50 @@ void create_event(VALUE tp_val, void *_data) {
   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.receiver = rb_funcall(self, rb_intern("st_name"), 0);
   event.method = method;
   event.for_singleton = for_singleton;
-  event.return_value = Qundef;
-  event.arguments = Qundef;
+  event.return_value = NULL;
+  event.arguments = NULL;
   event.at = get_monotonic_m_secs();
 
-  if(event.event == RUBY_EVENT_RAISE)
-    event.raised_exception = rb_tracearg_raised_exception(trace_arg);
+  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);
+
+    copy_str(&event.raised_exception, exception_to_s);
+  }
 
   if(RTEST(get_inspect_arguments()) &&
      (event.event == RUBY_EVENT_CALL || event.event == RUBY_EVENT_C_CALL || event.event == RUBY_EVENT_B_CALL))
-    event.arguments = extract_arguments(tp_val);
+    extract_arguments(&event, tp_val);
 
   if(RTEST(get_inspect_return_values()) &&
-     (event.event == RUBY_EVENT_RETURN || event.event == RUBY_EVENT_C_RETURN || event.event == RUBY_EVENT_B_RETURN))
-    event.return_value = rb_tracearg_return_value(trace_arg);
+     (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);
+
+    copy_str(&event.return_value, return_value_st_name);
+  }
 
   produce_event(event);
 }

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
 
@@ -11,9 +12,10 @@ Span *create_span(Event *event) {
   span->klass = event->klass;
   span->self_klass = event->self_klass;
   span->method = event->method;
-  span->return_value = Qundef;
+  span->return_value = NULL;
   span->arguments = event->arguments;
-  span->exception = Qundef;
+  span->arguments_count = event->arguments_count;
+  span->exception = NULL;
   span->children_count = 0;
   span->singleton = event->for_singleton ? Qtrue : Qfalse;
 
@@ -48,7 +50,6 @@ Span *close_span(Span *span, Event *event) {
   return span->caller;
 }
 
-
 // Deallocate the memory occupied by span
 // and its children.
 void free_span(Span *span) {
@@ -61,6 +62,24 @@ void free_span(Span *span) {
     free(span->children);
   }
 
+  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->arguments, span->arguments_count);
+
+  if(span->exception != NULL)
+    free(span->exception);
+
   free(span);
 }
 
@@ -68,27 +87,36 @@ int duration_of(Span *span) {
   return (int)(span->finished_at - span->started_at);
 }
 
+VALUE serialize_arguments(Argument *arguments, int count) {
+  VALUE hash = rb_hash_new();
+  int i;
+
+  for(i = 0; i < count; i++) {
+    rb_hash_aset(hash, arguments[i].key, rb_str_new_cstr(arguments[i].value));
+  }
+
+  return hash;
+}
+
 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("receiver"), rb_str_new_cstr(span->receiver));
+  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)));
   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->exception != NULL)
+    rb_hash_aset(hash, rb_str_new2("exception"), rb_str_new_cstr(span->exception));
 
-  if(span->arguments != Qundef) {
-    rb_gc_unregister_address(&span->arguments);
+  if(span->return_value != NULL)
+    rb_hash_aset(hash, rb_str_new2("return_value"), rb_str_new_cstr(span->return_value));
 
-    rb_hash_aset(hash, rb_str_new2("arguments"), span->arguments);
+  if(span->arguments != NULL) {
+    rb_hash_aset(hash, rb_str_new2("arguments"), serialize_arguments(span->arguments, span->arguments_count));
   }
 
   return hash;

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/argument.h

@@ -0,0 +1,12 @@
+#include <ruby.h>
+
+#ifndef ARGUMENT_H
+  #define ARGUMENT_H
+
+  typedef struct ArgumentS Argument;
+
+  struct ArgumentS {
+    VALUE key;
+    char *value;
+  };
+#endif

data/ext/stack_trace/types/event.h

@@ -4,6 +4,8 @@
 #include <stdbool.h>
 #include <sys/time.h>
 
+#include "types/argument.h"
+
 #ifndef EVENT_H
   #define EVENT_H
 
@@ -15,16 +17,15 @@
 
   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;
+    char *receiver;
+    char *klass;
+    char *self_klass;
+    VALUE method; // This is a symbol anyway
+    char *return_value;
+    Argument *arguments;
+    int arguments_count;
+    char *raised_exception;
     bool for_singleton;
     long int at;
   };

data/ext/stack_trace/types/span.h

@@ -1,3 +1,5 @@
+#include "types/argument.h"
+
 #ifndef SPAN_H
   #define SPAN_H
 
@@ -7,14 +9,15 @@
     long int started_at;
     long int finished_at;
 
-    VALUE klass;
-    VALUE self_klass;
-    VALUE receiver;
+    char *receiver;
+    char *klass;
+    char *self_klass;
     VALUE method;
     VALUE singleton;
-    VALUE exception;
-    VALUE return_value;
-    VALUE arguments;
+    char *return_value;
+    Argument *arguments;
+    int arguments_count;
+    char *exception;
     Span *caller;
     int children_count;
     Span **children;

data/lib/stack_trace/argument_extractor.rb

@@ -7,14 +7,14 @@ module StackTrace
         trace_point.parameters
                   .map(&:last)
                   .each_with_object({}) do |parameter, memo|
-                    memo[parameter] = extract_argument(trace_point, parameter)
+                    memo[parameter] = extract_argument(trace_point, parameter).st_name
                   end
       end
 
       private
 
       def extract_argument(trace_point, parameter)
-        trace_point.binding.eval(parameter.to_s).st_name
+        trace_point.binding.eval(parameter.to_s)
       rescue Exception # SyntaxError can happen as we are calling `eval` here!
       end
     end

data/lib/stack_trace/patch/false_class.rb

@@ -2,6 +2,6 @@
 
 class FalseClass
   def st_name
-    self
+    inspect
   end
 end

data/lib/stack_trace/patch/nil_class.rb

@@ -2,6 +2,6 @@
 
 class NilClass
   def st_name
-    self
+    inspect
   end
 end

data/lib/stack_trace/patch/numeric.rb

@@ -2,6 +2,6 @@
 
 class Numeric
   def st_name
-    self
+    inspect
   end
 end

data/lib/stack_trace/patch/true_class.rb

@@ -2,6 +2,6 @@
 
 class TrueClass
   def st_name
-    self
+    inspect
   end
 end

data/lib/stack_trace/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stack_trace
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Mehmet Emin INAC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-06 00:00:00.000000000 Z
+date: 2023-04-09 00:00:00.000000000 Z
 dependencies: []
 description: StackTrace
 email:
@@ -26,6 +26,8 @@ files:
 - LICENSE.txt
 - 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,9 +43,12 @@ 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
+- ext/stack_trace/types/argument.h
 - ext/stack_trace/types/event.h
 - ext/stack_trace/types/span.h
 - ext/stack_trace/types/trace.h