stack_trace 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 625635fd7b7003444962cd51a8baa282a8ce298db85ac3cecf46446008ea1da6
-  data.tar.gz: 660c040d48c94523ffe0e91c689a444cf6c4ea1bc04f7a86f5fe0e899427b947
+  metadata.gz: ac9e909692657f9e1b0cd9fc6475faf494458954513aa2e659e9faeacfb3d51b
+  data.tar.gz: d4819f5e40ef2d81cc5cc539247916ed16416eed9400f63007fe85edc8c9c4cf
 SHA512:
-  metadata.gz: 75d732bff4f5ee026501386afae896884f3a4939e91270aae06a45429b18550168a1d42c4088f51da64a2079dfca8f18c622d8d9db5c8e3b35e1493dcc649f39
-  data.tar.gz: 0f8a7d96cdeba0a942439553ee3e71c2864f25abd0fa95353be6726e7697344990d339ffff506a1dc0f8dad7f617a707f5e216642225a0a4d4f41e05c7984a5b
+  metadata.gz: 072443043f5910dfd02ded927653a23abacefede4f17fd87155521275818b0b90aa769544c30e9f06b5c46c24193e9bac12f711ae39c4f887340d435402f40c2
+  data.tar.gz: d3a5c0ae3803776ea0ad504c825c75ca0d9a70d5153a22133f809633631f824a7540fe7dd72c76c9e4eece214bb578d04765445f39089adadc6076abbe7af10a

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.0.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at mehmetemininac@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in stack_trace.gemspec
 gemspec
+
+gem "rake", "~> 13.0"
+gem "rake-compiler"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -1,41 +1,37 @@
 PATH
   remote: .
   specs:
-    stack_trace (0.2.1)
+    stack_trace (0.4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coderay (1.1.2)
-    diff-lcs (1.3)
-    method_source (0.9.2)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (13.0.1)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    diff-lcs (1.5.0)
+    rake (13.0.6)
+    rake-compiler (1.2.1)
+      rake
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
 
 PLATFORMS
-  ruby
+  arm64-darwin-21
 
 DEPENDENCIES
-  bundler (~> 2.0)
-  pry
   rake (~> 13.0)
+  rake-compiler
   rspec (~> 3.0)
   stack_trace!
 
 BUNDLED WITH
-   2.1.4
+   2.2.33

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Mehmet Emin INAC
+Copyright (c) 2023 Mehmet Emin INAC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,214 +1,38 @@
 # StackTrace
 
-StackTrace traces method calls in your application which can give you an overview about how your application works, which objects depends on which ones and what are the bottlenecks.
+Creates call stack trace for given block of Ruby code.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install the gem and add to the application's Gemfile by executing:
 
-```ruby
-gem 'stack_trace'
-```
-
-And then execute:
-
-    $ bundle
+    $ bundle add stack_trace
 
-Or install it yourself as:
+If bundler is not being used to manage dependencies, install the gem by executing:
 
     $ gem install stack_trace
 
-## Terminology
-
-Before we jump into details we should talk about the two important terms that you should grasp first to understand the tracing output, which are `trace` and `span`.
-
-#### Trace
-
-Trace is an object which encapsulates the whole process. Whenever you start tracing, there will be a `trace` object associated which has a unique identifier(uuid v4) and holds all the `spans`.
-
-#### Span
-
-Span holds the information about the actual **unit of work**. StackTrace will create a new span for each method call if it's been told to do so by the configuration. Spans hold all the information that you need about the method calls like the time taken, arguments etc. as well as the child spans if the method calls othre methods.
-You will see detailed information about the spans in the `Getting tracing information` chapter.
-
 ## Usage
 
-Using StackTrace gem is pretty straight forward. First you should configure it to set which modules/classes and which methods should be traced and then you can start tracing the execution of your code with `StackTrace::trace` method.
-
-#### Configuration
-
-With the belove configuration, StackTrace will trace all the methods of **Foo** `module/class` and only the `zoo` method of **Bar** `module/class`.
-
-```ruby
-StackTrace.configure do |config|
-  config.enabled = true
-  config.modules = {
-      Foo => {
-        instance_methods: :all,
-        class_methods: :all
-      },
-      Bar => { instance_methods: [:zoo] }
-  }
-end
-```
-
-`instance_methods` and `class_methods` can be configured with the following values;
-
-- `:all` to trace all methods
-- `:skip_inherited` to trace only the methods defined in module/class
-- `:path` to trace all the classes/modules defined in a specific path regex(Make sure that StackTrace gem is loaded into memory before any files to use this configuration)
-- Array of symbols to specify method names one by one
-- Regular expression to trace all methods with matching method names
-
-Also the keys for `modules` hash can have the following values;
-
-- `Class/Module` to trace methods of given value
-- An array of `Class/Module` to trace methods of all given values
-- Regular expression to trace methods of all matching modules or classes.
-- { inherits: Class } to trace methods of all classes inherited from base class.
-
-Here are the example usages;
-
-```ruby
-StackTrace.configure do |config|
-  config.enabled = true
-  config.modules = {
-      Foo => { instance_methods: :skip_inherited },
-      [Too, Joo] => { class_methods: :all }
-      /Ba.*/ => { instance_methods: :all },
-      { inherits: Zoo } => { instance_methods: [:foo, :bar, :zoo] }
-  }
-end
-```
-
-#### Tracing
-
-After configuring the StackTrace, you can call `StackTrace::trace` method to create a tracing information of the code execution as shown below;
-
 ```ruby
 StackTrace.trace do
-  foo = Foo.new
-  foo.do_something
- end
-```
-
-#### Getting tracing information
-
-Currently StackTrace gem provides tracing information as a Ruby `Hash` object. You can use `StackTrace::Trace::as_json` method to receive the `Hash` for the current trace like so;
+  Foo.bar
+end
 
-```ruby
-  StackTrace.trace do
-    # Do something usefull
-    StackTrace::Trace.as_json
-  end
+StackTrace.current # => Returns a Hash that contains all the method calls and exception information.
 ```
 
-#### What does StackTrace collect?
-
-The `Hash` object returned by `StackTrace::Trace::as_json` method has the following structure;
-
-* **uuid**: This is a UUID V4 value to identify the trace.
-* **spans**: This is an array of spans which has the following structure;
-  * **receiver**: The identifier for the receiver object.
-  * **method_name**: The name of the method which this span is created for.
-  * **arguments**: Arguments received by the method.
-  * **value**: The return value of the method.
-  * **exception**: The exception information if an exception is raised in this method. This attribute has the following child attributes:
-    * **message**: The error message(`error.message`).
-    * **backtrace**: The backtrace information of the excption as an array of strings.
-  * **time**: How long the execution of this unit of work took.
-  * **spans**: Child spans of the span.
-
-Imagine you have the following configuration and class;
+## Configuration
 
 ```ruby
-class Greeting
-  def hello(first_name, last_name)
-    "Hello, #{capitalize(first_name)} #{capitalize(last_name)}"
-  end
-
-  def capitalize(string)
-    string.capitalize
-  end
-end
-
 StackTrace.configure do |config|
-  config.enabled = true
-  config.modules = {
-    Greeting => { instance_methods: :all }
-  }
-end
-```
+  config.trace_ruby = true
+  config.trace_c = true
+  config.inspect_return_values = true # Default `false` for performance reasons
+  config.inspect_arguments = true # Default `false` for performance reasons
 
-The the execution of the following code leads to below return object from `StackTrace::Trace.as_json` method;
-
-```ruby
-StackTrace.trace do
-  Greeting.new.hello("john", "doe")
-  result = StackTrace::Trace.as_json
+  config.check_proc = -> (klass_name, method_name) do # If you want to limit the tracing for a set of classes
+    klass_name == "Bar"
+  end
 end
-
-result == {
-    uuid: "12e2a347-8d5a-4d1d-a5ad-efe012ffcdf9",
-    spans: [
-        {
-            receiver: "Greeting#123124312",
-            method_name: "initialize",
-            arguments: {},
-            value: nil,
-            exception: nil,
-            time: "10.927719116210938 µs",
-            spans: []
-        },
-        {
-            receiver: "Greeting#123124312",
-            method_name: "hello",
-            arguments: {
-                first_name: "john",
-                last_name: "doe"
-            },
-            value: "Hello, John Doe",
-            exception: nil,
-            time: "20.831909134113330 µs",
-            spans: [
-                {
-                    receiver: "Greeting#123124312",
-                    method_name: "capitalize",
-                    arguments: {
-                        string: "john"
-                    },
-                    value: "John",
-                    exception: nil,
-                    time: "6.198883056640625 µs",
-                    spans: []
-                },
-                {
-                    receiver: "Greeting#123124312",
-                    method_name: "capitalize",
-                    arguments: {
-                        string: "doe"
-                    },
-                    value: "Doe",
-                    exception: nil,
-                    time: "4.291534423828125 µs",
-                    spans: []
-                }
-            ]
-        }
-    ]
-}
 ```
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/meinac/stack_trace.
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+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"
+end

data/ext/stack_trace/configuration.c

@@ -0,0 +1,23 @@
+#include <ruby.h>
+
+static VALUE inspect_return_values = Qfalse;
+static VALUE inspect_arguments = Qfalse;
+
+// We are setting this static variable to gain some performance.
+// Otherwise each time we need this, we would need to get the constant
+// and make method calls.
+VALUE rb_set_inspect_return_values(VALUE self, VALUE val) {
+  return inspect_return_values = val;
+}
+
+VALUE get_inspect_return_values() {
+  return inspect_return_values;
+}
+
+VALUE rb_set_inspect_arguments(VALUE self, VALUE val) {
+  return inspect_arguments = val;
+}
+
+VALUE get_inspect_arguments() {
+  return inspect_arguments;
+}

data/ext/stack_trace/configuration.h

@@ -0,0 +1,6 @@
+#include <ruby.h>
+
+VALUE rb_set_inspect_return_values(VALUE self, VALUE val);
+VALUE get_inspect_return_values();
+VALUE rb_set_inspect_arguments(VALUE self, VALUE val);
+VALUE get_inspect_arguments();

data/ext/stack_trace/current_trace.c

@@ -0,0 +1,43 @@
+#include "current_trace.h"
+#include "event_store.h"
+#include "types/event.h"
+
+static __thread Trace *current_trace = NULL;
+
+Trace *get_current_trace() {
+  return current_trace;
+}
+
+VALUE rb_create_trace(VALUE _self) {
+  if(current_trace != NULL) {
+    current_trace->active = false;
+
+    Event event = {};
+    event.trace = current_trace;
+    event.event = END_OF_OBSOLOTE_TRACE_EVENT;
+
+    produce_event(event); // This will tell sidecar to free the memory
+  }
+
+  Span *span = malloc(sizeof(Span));
+  span->children_count = 0;
+  span->caller = NULL;
+
+  current_trace = malloc(sizeof(Trace));
+  current_trace->finished = false;
+  current_trace->top_span = span;
+  current_trace->current_span = span;
+  current_trace->active = true;
+
+  return Qtrue;
+}
+
+VALUE rb_send_eot(VALUE _self) {
+  Event event = {};
+  event.trace = current_trace;
+  event.event = END_OF_TRACE;
+
+  produce_event(event);
+
+  return Qtrue;
+}

data/ext/stack_trace/current_trace.h

@@ -0,0 +1,7 @@
+#include <ruby.h>
+
+#include "types/trace.h"
+
+Trace *get_current_trace(void);
+VALUE rb_create_trace(VALUE _self);
+VALUE rb_send_eot(VALUE _self);

data/ext/stack_trace/debug.c

@@ -0,0 +1,43 @@
+#include <ruby.h>
+
+#include "debug.h"
+
+void serialize_event(char *buffer, Event *event) {
+  switch(event->event) {
+    case END_OF_TRACE:
+      sprintf(buffer, "End of trace");
+      return;
+    case END_OF_OBSOLOTE_TRACE_EVENT:
+      sprintf(buffer, "End of obsolote trace");
+      return;
+    case NOOP_EVENT:
+      sprintf(buffer, "NO-OP 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(
+    buffer,
+    "klass: %s, "
+    "self: %s, "
+    "method: %s, "
+    "event: %d, "
+    "for_singleton: %d",
+    klass_name_str,
+    self_name_str,
+    method_name_str,
+    event->event,
+    event->for_singleton
+  );
+}
+
+void serialize_unknown(char *buffer, void *var) {
+  sprintf(buffer, "Address: %p", var);
+}

data/ext/stack_trace/debug.h

@@ -0,0 +1,37 @@
+#include "types/event.h"
+
+#ifdef ST_DEBUG
+  void serialize_event(char *buffer, Event *event);
+  void serialize_unknown(char *buffer, void *var);
+
+  static FILE *debug_fp = NULL;
+
+  #define OPEN_DEBUG_FILE() if(!debug_fp) debug_fp = fopen("debug.log", "a")
+
+  #define SERIALIZE_STRUCT(s, buffer) \
+    _Generic((s),                     \
+      Event*: serialize_event,        \
+      default: serialize_unknown      \
+    )(buffer, s)
+
+  #define DEBUG(msg, s)                                         \
+    do {                                                        \
+        OPEN_DEBUG_FILE();                                      \
+        char buffer[512];                                       \
+        SERIALIZE_STRUCT(s, buffer);                            \
+        fprintf(debug_fp, "DEBUG: %s:%d:%s(): " msg "{ %s }\n", \
+                __FILE__, __LINE__, __func__, buffer);          \
+        fflush(debug_fp);                                       \
+    } while(0)
+
+  #define DEBUG_TEXT(msg, ...)                                \
+    do {                                                      \
+      OPEN_DEBUG_FILE();                                      \
+      fprintf(debug_fp, "DEBUG: %s:%d:%s(): " msg "\n",       \
+                __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+      fflush(debug_fp);                                       \
+    } while(0)
+#else
+  #define DEBUG(msg, ...)
+  #define DEBUG_TEXT(msg, ...)
+#endif

data/ext/stack_trace/event_producer.c

@@ -0,0 +1,65 @@
+#include <ruby.h>
+#include <ruby/debug.h>
+
+#include "types/event.h"
+#include "event_store.h"
+#include "current_trace.h"
+#include "utils.h"
+#include "configuration.h"
+
+VALUE extract_arguments(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);
+
+  return arguments;
+}
+
+void create_event(VALUE tp_val, void *_data) {
+  Event event = {};
+  int for_singleton = false;
+
+  rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tp_val);
+
+  VALUE klass = rb_tracearg_defined_class(trace_arg);
+  VALUE self = rb_tracearg_self(trace_arg);
+  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);
+  } else {
+    VALUE class = rb_funcall(self, rb_intern("class"), 0);
+    self_klass = rb_funcall(class, rb_intern("name"), 0);
+  }
+
+  event.trace = get_current_trace();
+  event.tp_val = tp_val;
+  event.trace_arg = trace_arg;
+  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.at = get_monotonic_m_secs();
+
+  if(event.event == RUBY_EVENT_RAISE)
+    event.raised_exception = rb_tracearg_raised_exception(trace_arg);
+
+  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);
+
+  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);
+
+  produce_event(event);
+}

data/ext/stack_trace/event_producer.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+void create_event(VALUE tp_val, void *_data);