stack_trace 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac9e909692657f9e1b0cd9fc6475faf494458954513aa2e659e9faeacfb3d51b
-  data.tar.gz: d4819f5e40ef2d81cc5cc539247916ed16416eed9400f63007fe85edc8c9c4cf
+  metadata.gz: 3e528eba64406556bc7638531e10cd80b0aa0027649d1dfcd223f3e0171e0c47
+  data.tar.gz: c1a935f65476ba84ef18bed8873f82f54d39f3ae6fc384ce13571039c6b3571a
 SHA512:
-  metadata.gz: 072443043f5910dfd02ded927653a23abacefede4f17fd87155521275818b0b90aa769544c30e9f06b5c46c24193e9bac12f711ae39c4f887340d435402f40c2
-  data.tar.gz: d3a5c0ae3803776ea0ad504c825c75ca0d9a70d5153a22133f809633631f824a7540fe7dd72c76c9e4eece214bb578d04765445f39089adadc6076abbe7af10a
+  metadata.gz: d3adb5c1b7a759a18e0baad12bbefa11f27703396ae833ac887cf40bac0710268b9cda7e3e157c3df9ae313a1388e6222d7c7b50f02ac476b34d6f7d1941e022
+  data.tar.gz: b5cc60e857c0c28c9f0ee2b0d2cd6b64641eb97ad1d62e100f694e1ce0bbcb13f438ebb576ccba6f42536d024fd5d38b8da7305f18a273f126b2516165366756

data/Gemfile.lock

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

data/ext/stack_trace/event_producer.c

@@ -7,14 +7,45 @@
 #include "utils.h"
 #include "configuration.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);
 
-  return arguments;
+  int arguments_count = FIX2INT(hash_size);
+
+  if(arguments_count == 0) return;
+
+  event->arguments_count = arguments_count;
+  event->arguments = malloc(sizeof(Argument) * arguments_count);
+
+  struct MemoS memo = { 0, event->arguments };
+
+  rb_hash_foreach(arguments_hash, extract_kv, (VALUE)&memo);
 }
 
 void create_event(VALUE tp_val, void *_data) {
@@ -25,6 +56,7 @@ 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;
 
@@ -43,23 +75,32 @@ void create_event(VALUE tp_val, void *_data) {
   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);
+  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);
+
+    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

@@ -11,9 +11,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,6 +49,16 @@ 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.
@@ -61,6 +72,18 @@ void free_span(Span *span) {
     free(span->children);
   }
 
+  if(span->receiver != NULL)
+    free(span->receiver);
+
+  if(span->return_value != NULL)
+    free(span->return_value);
+
+  if(span->arguments != NULL)
+    free_arguments(span);
+
+  if(span->exception != NULL)
+    free(span->exception);
+
   free(span);
 }
 
@@ -68,10 +91,21 @@ 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("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("method_name"), span->method);
@@ -79,16 +113,14 @@ VALUE span_to_ruby_hash(Span *span) {
   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/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
 
@@ -18,13 +20,14 @@
     VALUE tp_val;
     rb_event_flag_t event;
     rb_trace_arg_t *trace_arg;
+    char *receiver;
     VALUE klass;
     VALUE self_klass;
-    VALUE receiver;
     VALUE method;
-    VALUE raised_exception;
-    VALUE return_value;
-    VALUE arguments;
+    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;
 
+    char *receiver;
     VALUE klass;
     VALUE self_klass;
-    VALUE receiver;
     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.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stack_trace
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Mehmet Emin INAC
@@ -44,6 +44,7 @@ files:
 - 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