stack_trace 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e528eba64406556bc7638531e10cd80b0aa0027649d1dfcd223f3e0171e0c47
-  data.tar.gz: c1a935f65476ba84ef18bed8873f82f54d39f3ae6fc384ce13571039c6b3571a
+  metadata.gz: a44fbab04e5a7a787dd995fbee5ea3e503080172df937a91e122728eb4884744
+  data.tar.gz: c004c70f42efc53e0776520d9e39a902346015eca012614913dd9a04e9822344
 SHA512:
-  metadata.gz: d3adb5c1b7a759a18e0baad12bbefa11f27703396ae833ac887cf40bac0710268b9cda7e3e157c3df9ae313a1388e6222d7c7b50f02ac476b34d6f7d1941e022
-  data.tar.gz: b5cc60e857c0c28c9f0ee2b0d2cd6b64641eb97ad1d62e100f694e1ce0bbcb13f438ebb576ccba6f42536d024fd5d38b8da7305f18a273f126b2516165366756
+  metadata.gz: aab482726e6436266555c91fbd51a0b44d8b5d0b6b0f3e72cd11448eaac96ea0d49582df77ab828cbbd38be93d177214cddb50a606ad8e899bb541179c43ed0f
+  data.tar.gz: 4e57a54efcb00a4a2701a5169130642be00fcd1aff13c4d508b0ac663f933fa5443eceffc78d74199d0fcf2ced21054559eabe85675ec2190b2f8ec768a02dc3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stack_trace (0.5.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,6 +6,7 @@
 #include "current_trace.h"
 #include "utils.h"
 #include "configuration.h"
+#include "st_name.h"
 
 struct MemoS {
   int i;
@@ -49,6 +50,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 +63,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);

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);
@@ -106,8 +102,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/lib/stack_trace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StackTrace
-  VERSION = "0.5.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.5.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,6 +43,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