stack_trace 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62cea37e30a1a5cddfef34c91b25a5411b4a5edc017743179f4097a2a9682c43
-  data.tar.gz: c06b33ab71d5c66dd4593952201eddbdfc85fec53fde5f321fc1d9a563d3f54e
+  metadata.gz: 3e528eba64406556bc7638531e10cd80b0aa0027649d1dfcd223f3e0171e0c47
+  data.tar.gz: c1a935f65476ba84ef18bed8873f82f54d39f3ae6fc384ce13571039c6b3571a
 SHA512:
-  metadata.gz: e1f0daca22d85120157d4252b7a63d0035a882bad2f3f4b14312734ca65af30d9c8b2c0f6057d573bb27d4ab3494b19e333c090230ec2d39da4b0743b7bd6d4a
-  data.tar.gz: 33500c08305ce31b29049e3bab8fbcefbbc5a1a60ce4dd08ba0bd65efd23a7da9bbbf169993908e6b7e67d970db99fd2bd8aad9c67cbab6a2eaf84df6ae0ee99
+  metadata.gz: d3adb5c1b7a759a18e0baad12bbefa11f27703396ae833ac887cf40bac0710268b9cda7e3e157c3df9ae313a1388e6222d7c7b50f02ac476b34d6f7d1941e022
+  data.tar.gz: b5cc60e857c0c28c9f0ee2b0d2cd6b64641eb97ad1d62e100f694e1ce0bbcb13f438ebb576ccba6f42536d024fd5d38b8da7305f18a273f126b2516165366756

data/Gemfile.lock

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

data/Rakefile

@@ -6,7 +6,7 @@ require "rake/extensiontask"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+task default: [:compile, :spec]
 
 Rake::ExtensionTask.new "stack_trace" do |ext|
   ext.lib_dir = "lib/stack_trace/ext"

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/trace.c

@@ -20,7 +20,8 @@ void free_trace(Trace *trace) {
 }
 
 void process_obsolote_event(Event *event) {
-  // free_trace(event->trace);
+  // Free this trace as there is no reference to it anymore!
+  free_trace(event->trace);
 }
 
 void set_check_proc(VALUE proc) {
@@ -118,10 +119,14 @@ VALUE to_ruby_hash(Trace *trace) {
 }
 
 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);
 
-  free_trace(trace);
-
   return ruby_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.3.0"
+  VERSION = "0.5.0"
 end

data/lib/stack_trace.rb

@@ -24,6 +24,8 @@ module StackTrace
     end
 
     def trace(&block)
+      return block.call if trace_point.enabled?
+
       start_trace # This creates the wrapper span
 
       trace_point.enable do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stack_trace
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Mehmet Emin INAC
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-05 00:00:00.000000000 Z
+date: 2023-04-06 00:00:00.000000000 Z
 dependencies: []
 description: StackTrace
 email:
@@ -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