stack_trace 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b44fd93d88276fa812cfa13f22d2cbee7ab4fa3007c32372ef0a2ba8bccee182
-  data.tar.gz: a9308ce4f7223a1bd72860c4a1db54d81328ec0992c4135f94c9055c0a7c6f3d
+  metadata.gz: 6c29060d98a3ca570339220779da0a26b5d5d8be19994b3ce6a3b808caf51d8c
+  data.tar.gz: ecc897ccf6ea4257cc950a2f349450f14e3026a6f32fb2bb45342d3367af63d5
 SHA512:
-  metadata.gz: 7e655afe6d165fe287322d42ad5d1244d59f05151656dfbae99efdc3ac8c78030fec755eca1a3264daeff2435e564cec7ffd0a780e9b12ad9d5289135ea342c9
-  data.tar.gz: 01d0bee421dc2e2c021d3bcb8c38bef1bda022384a711d9d04eaa323043d3af9bbdb7b84dbc5efd30fa82b0fe275bf7bf0e2c4132e8fe0649f636d521988d52a
+  metadata.gz: 93084a9322b703052f22124360a76bec238ab218dcd38004167db5d5d71b6b2f191323bd1f233aff153ddfed2944ad204be1471f5ac477efe51e869203950d57
+  data.tar.gz: fc08282fc1f32aa5983ebe68213f22a87d5f9a1f34388b1b80ef7e04629237a71570141b005d93291506020e93aa775a56f4edf91573e38fb3b255924d961d69

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    stack_trace (0.2.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.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  pry
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  stack_trace!
+
+BUNDLED WITH
+   2.0.1

data/README.md

@@ -1,8 +1,6 @@
 # StackTrace
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/stack_trace`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+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.
 
 ## Installation
 
@@ -20,9 +18,186 @@ Or install it yourself as:
 
     $ 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
 
-TODO: Write usage instructions here
+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;
+
+```ruby
+  StackTrace.trace do
+    # Do something usefull
+    StackTrace::Trace.as_json
+  end
+```
+
+#### 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;
+
+```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
+```
+
+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
+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
 
@@ -32,7 +207,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/stack_trace.
+Bug reports and pull requests are welcome on GitHub at https://github.com/meinac/stack_trace.
 
 ## License
 

data/lib/stack_trace.rb

@@ -1,43 +1,48 @@
 # frozen-string-literal: true
 
-require "stack_trace/version"
+require "stack_trace/configuration"
+require "stack_trace/module_extensions"
+require "stack_trace/setup"
 require "stack_trace/span"
 require "stack_trace/trace"
+require "stack_trace/version"
 
 module StackTrace
-  def trace(*method_names)
-    self.traced_methods = method_names
-  end
-
-  def method_added(method_name)
-    return unless should_override?(method_name)
+  TRACED_EVENTS = %i(call c_call return c_return raise).freeze
 
-    overridden_methods << method_name
-    define_trace_method(method_name)
-  end
+  class << self
+    def configure
+      yield configuration
+      trace_point.enable
+    end
 
-  private
+    def configuration
+      @configuration ||= Configuration.new
+    end
 
-  attr_accessor :traced_methods
+    def trace
+      return unless block_given?
 
-  def should_override?(method_name)
-    traced_methods.include?(method_name) && !overridden_methods.include?(method_name)
-  end
-
-  def overridden_methods
-    @overridden_methods ||= []
-  end
+      Trace.start
+      yield
+    end
 
-  def define_trace_method(method_name)
-    traced_method_name = traced_method_name(method_name)
-    alias_method(traced_method_name, method_name)
+    def current
+      Trace.current
+    end
 
-    define_method(method_name) do |*args|
-      Trace.track(method_name, *args) { send(traced_method_name, *args) }
+    def as_json
+      Trace.as_json
     end
-  end
 
-  def traced_method_name(original_method_name)
-    "_traced_#{original_method_name}"
+    def trace_point
+      @trace_point ||= TracePoint.new(*TRACED_EVENTS) { |tp| Trace.track(tp) }
+    end
   end
 end
+
+TracePoint.new(:class) do |tp|
+  tp.binding.eval <<~RUBY
+    self.stack_trace_source_location = __FILE__
+  RUBY
+end.enable

data/lib/stack_trace/configuration.rb

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+require "objspace"
+
+module StackTrace
+  class Configuration
+    CONFIG_ATTRIBUTES = {
+      enabled: false,
+      modules: {},
+    }
+
+    attr_writer *CONFIG_ATTRIBUTES.keys
+
+    CONFIG_ATTRIBUTES.each do |attr_name, default_value|
+      define_method(attr_name) do
+        instance_variable_get("@#{attr_name}") || default_value
+      end
+    end
+
+    def for(klass)
+      config_holder = config_holder_for(klass)
+      modules.find { |module_name_conf, _| config_for_class?(module_name_conf, config_holder) }
+    end
+
+    private
+
+    # Configuration for StackTrace is done by specifying the class/module itself
+    # so if the klass we receive here is a singleton_class, we should get the
+    # class/module of that singleton_class first.
+    def config_holder_for(klass)
+      klass.singleton_class? ? ObjectSpace.each_object(klass).first : klass
+    end
+
+    def config_for_class?(config, klass)
+      case config
+      when Regexp
+        klass.name =~ config
+      when Hash
+        match_hash_config(config, klass)
+      else
+        [config].flatten.include?(klass)
+      end
+    end
+
+    def match_hash_config(config, klass)
+      inherits_config?(klass, config) || path_config?(klass, config)
+    end
+
+    def inherits_config?(klass, inherits: nil, **)
+      inherits &&
+        klass.ancestors.include?(inherits) &&
+        klass != inherits
+    end
+
+    def path_config?(klass, path: nil, **)
+      path &&
+        klass.respond_to?(:stack_trace_source_location) &&
+        klass.stack_trace_source_location &&
+        klass.stack_trace_source_location.match(path)
+    end
+  end
+end

data/lib/stack_trace/integration/rspec.rb

@@ -0,0 +1,79 @@
+# frozen-string-literal: true
+
+require "json"
+
+RSpec.configuration.before(:suite) do
+  StackTrace::Integration::Rspec.create_tracing_directory
+end
+
+RSpec.configuration.after(:suite) do
+  StackTrace::Integration::Rspec.finish_tracing
+end
+
+RSpec.configuration.around(:each) do |example|
+  StackTrace.trace do
+    example.run
+    StackTrace::Integration::Rspec.save_trace_for(example)
+  end
+end
+
+module StackTrace
+  module Integration
+    class Rspec
+      EXAMPLE_META_KEYS = %i(file_path line_number scoped_id description full_description)
+      FINAL_MESSAGE = <<~TEXT
+        \e[1m
+        StackTrace:
+
+        Trace information is saved into \e[32m%{file_path}\e[0m
+        \e[22m
+      TEXT
+
+      class << self
+        def create_tracing_directory
+          Dir.mkdir(tracing_dir_path) unless Dir.exist?(tracing_dir_path)
+        end
+
+        def finish_tracing
+          save_examples
+          print_message
+        end
+
+        def save_trace_for(example)
+          examples << example_data(example)
+        end
+
+        private
+
+        def examples
+          @examples ||= []
+        end
+
+        def save_examples
+          File.write(tracing_file_path, examples.to_json)
+        end
+
+        def tracing_file_path
+          File.join(tracing_dir_path, trace_file_name)
+        end
+
+        def tracing_dir_path
+          File.expand_path("stack_trace")
+        end
+
+        def trace_file_name
+          @trace_file_name ||= Time.now.strftime('%d_%m_%Y %H_%M_%S.json')
+        end
+
+        def example_data(example)
+          example.metadata.slice(*EXAMPLE_META_KEYS)
+                          .merge!(trace: Trace.current.as_json)
+        end
+
+        def print_message
+          puts format(FINAL_MESSAGE, file_path: tracing_file_path)
+        end
+      end
+    end
+  end
+end

data/lib/stack_trace/module_extensions.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module StackTrace
+  module ModuleExtensions
+    attr_accessor :stack_trace_source_location
+
+    def trace_method?(method_id)
+      Setup.trackable?(self, method_id)
+    end
+  end
+end
+
+Module.include(StackTrace::ModuleExtensions)

data/lib/stack_trace/setup.rb

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+module StackTrace
+  class Setup
+    class << self
+      def trackable?(mod, method_id)
+        store[mod].trace?(method_id)
+      end
+
+      def store
+        @store ||= Hash.new do |h, k|
+          h[k.singleton_class] = new(k, :class_methods)
+          h[k] = new(k, :instance_methods)
+        end
+      end
+    end
+
+    def initialize(klass, context)
+      self.klass = klass
+      self.context = context
+    end
+
+    def trace?(method_id)
+      enabled? && traced_method?(method_id)
+    end
+
+    private
+
+    attr_accessor :klass, :context
+
+    def enabled?
+      defined?(@enabled) ? @enabled : (@enabled = !config.nil?)
+    end
+
+    def config
+      @config ||= StackTrace.configuration.for(klass)
+    end
+
+    def traced_method?(method_id)
+      method_lookup[method_id]
+    end
+
+    def method_lookup
+      @method_lookup ||= Hash.new { |lookup, method_id| lookup[method_id] = method_enabled?(method_id) }
+    end
+
+    def method_enabled?(method_id)
+      case method_config
+      when Array
+        method_config.include?(method_id)
+      when Symbol
+        method_config != :skip_inherited || instance_methods(false).include?(method_id)
+      when Regexp
+        method_id =~ method_config
+      end
+    end
+
+    def method_config
+      @method_config ||= config[1].fetch(context, [])
+    end
+  end
+end

data/lib/stack_trace/span.rb

@@ -2,29 +2,69 @@
 
 module StackTrace
   class Span
-    attr_accessor :value, :exception
-    attr_reader :method_name, :args, :spans
+    class << self
+      def start_from(trace_point, parent)
+        new(
+          receiver(trace_point),
+          trace_point.method_id,
+          extract_arguments(trace_point),
+          parent
+        )
+      end
 
-    def initialize(method_name, *args)
-      self.started_at = Time.now.to_f
+      private
+
+      def receiver(trace_point)
+        trace_point.binding.eval("self").to_s
+      end
+
+      def extract_arguments(trace_point)
+        trace_point.parameters
+                   .map(&:last)
+                   .each_with_object({}) do |parameter, memo|
+                      memo[parameter] = trace_point.binding.eval(parameter.to_s).inspect
+                   end
+      end
+    end
+
+    attr_writer :exception
+
+    def initialize(receiver, method_name, args, parent)
+      self.receiver = receiver
       self.method_name = method_name
       self.args = args
+      self.parent = parent
+      self.started_at = Time.now.to_f
       self.spans = []
     end
 
-    def add(method_name, *args)
-      (spans << span = Span.new(method_name, *args)) && span
+    def <<(span)
+      (spans << span) && span
     end
 
-    def close
-      @finished_at = Time.now.to_f
-      @closed = true
+    def close(trace_point)
+      self.value = trace_point.return_value.inspect
+      self.finished_at = Time.now.to_f
+      parent
     end
 
-    def open?
-      !@closed
+    def as_json
+      {
+        receiver: receiver,
+        method_name: method_name,
+        arguments: args,
+        value: value,
+        exception: exception_as_json,
+        time: time,
+        spans: spans.map(&:as_json)
+      }
     end
 
+    private
+
+    attr_accessor :receiver, :method_name, :args, :value, :parent, :spans, :started_at, :finished_at
+    attr_reader :exception
+
     def time
       case time_ns
       when 0..1_000
@@ -38,22 +78,15 @@ module StackTrace
       end
     end
 
-    def as_json
+    def exception_as_json
+      return unless exception
+
       {
-        method_name: method_name,
-        arguments: args,
-        value: value,
-        exception: exception,
-        time: time,
-        spans: spans.map(&:as_json)
+        message: exception.message,
+        backtrace: exception.backtrace
       }
     end
 
-    private
-
-    attr_accessor :started_at, :finished_at
-    attr_writer :method_name, :args, :spans
-
     def time_ns
       (finished_at - started_at) * 1_000_000_000
     end

data/lib/stack_trace/trace.rb

@@ -1,16 +1,16 @@
 # frozen-string-literal: true
 
+require "securerandom"
+
 module StackTrace
   class Trace
+    TRACE_START_EVENTS = %i(call c_call).freeze
+    TRACE_END_EVENTS = %i(return c_return).freeze
+    TRACE_RAISE_EVENT = :raise
+
     class << self
-      def track(method_name, *args)
-        span = current.add(method_name, *args)
-        span.value = yield
-      rescue StandardError => e
-        span.exception = e
-        raise e
-      ensure
-        span.close
+      def track(trace_point)
+        current.add(trace_point) if trackable?(trace_point)
       end
 
       def start
@@ -24,32 +24,60 @@ module StackTrace
       def as_json
         current.as_json
       end
+
+      private
+
+      def trackable?(trace_point)
+        trace_point.defined_class&.trace_method?(trace_point.method_id)
+      end
     end
 
-    attr_reader :spans
+    attr_reader :uuid, :spans
 
     def initialize
+      @uuid = SecureRandom.uuid
       @spans = []
     end
 
-    def add(method_name, *args)
-      add_to_active_span(method_name, *args) || create_new_span(method_name, *args)
+    def add(trace_point)
+      case trace_point.event
+      when *TRACE_START_EVENTS
+        create_new_span(trace_point)
+      when *TRACE_END_EVENTS
+        close_current_span(trace_point)
+      else
+        apply_exception_to_current_span(trace_point)
+      end
     end
 
     def as_json
-      { spans: spans.map(&:as_json) }
+      {
+        uuid: uuid,
+        spans: spans.map(&:as_json)
+      }
+    end
+
+    def <<(span)
+      spans << span
     end
 
     private
 
-    def add_to_active_span(method_name, *args)
-      return unless @current_span&.open?
+    def create_new_span(trace_point)
+      span = Span.start_from(trace_point, container)
+      container << (@active_span = span)
+    end
+
+    def close_current_span(trace_point)
+      @active_span = @active_span&.close(trace_point)
+    end
 
-      @current_span.add(method_name, *args)
+    def apply_exception_to_current_span(trace_point)
+      @active_span.exception = trace_point.raised_exception
     end
 
-    def create_new_span(method_name, *args)
-      (spans << @current_span = Span.new(method_name, *args)) && @current_span
+    def container
+      @active_span || self
     end
   end
 end

data/lib/stack_trace/version.rb

@@ -1,3 +1,3 @@
 module StackTrace
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/stack_trace.gemspec

@@ -23,7 +23,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 1.9.2'
+
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stack_trace
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mehmet Emin INAC
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-27 00:00:00.000000000 Z
+date: 2020-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This library tracks the execution of methods, their arguments, return
   values etc.
 email:
@@ -64,12 +78,17 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/stack_trace.rb
+- lib/stack_trace/configuration.rb
+- lib/stack_trace/integration/rspec.rb
+- lib/stack_trace/module_extensions.rb
+- lib/stack_trace/setup.rb
 - lib/stack_trace/span.rb
 - lib/stack_trace/trace.rb
 - lib/stack_trace/version.rb
@@ -86,14 +105,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Tracks the execution of methods configured