itrace 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aaee13c8ccc9bafa35ce956930204faa2b7cf854e873fa4d3115a7163882870b
+  data.tar.gz: e0af7f995dca9a058d56a86bbf9e6141e88e76ddad72200a2d92b058f6075397
+SHA512:
+  metadata.gz: 7927e6da51baedecc9b1a1cb671a1f67f4088f70374352fb8bceef75e525d24e35ca18f26c059d14181082278ea60cda8d63dccc9bdcc004311bea19a5842304
+  data.tar.gz: cf535894e672ef424eaa43b2f0806071257bcafe2811833b1920c32eca409bfb267ca5cbf5decef72770cd7e1e49c033e427c97ea11b66c98c494d68e633a44f

data/lib/itrace.rb

@@ -0,0 +1,39 @@
+require 'itrace/tracer'
+require 'logger'
+
+module ITrace
+  def logger
+    @logger ||= default_logger
+  end
+
+  def tracer
+    @tracer ||= default_tracer
+  end
+
+  def trace(*modules, **opts, &blk)
+    tracer.trace(*modules, **opts, &blk)
+  end
+
+  def enable_logging
+    tracer.enable_logging
+  end
+
+  def disable_logging
+    tracer.disable_logging
+  end
+
+private
+  def default_logger
+    @default_logger ||= begin
+      logger = ::Logger.new($stderr)
+      logger.level = ::Logger::DEBUG
+      logger
+    end
+  end
+
+  def default_tracer
+    @default_tracer ||= Tracer.new(logger)
+  end
+
+  extend self
+end

data/lib/itrace/defaults.rb

@@ -0,0 +1,5 @@
+module ITrace
+  module Defaults
+    METHODS_TO_EXCLUDE = ::Kernel.instance_methods + ::Module.instance_methods
+  end
+end

data/lib/itrace/interceptor.rb

@@ -0,0 +1,67 @@
+module ITrace
+  class Interceptor < ::Module
+    def initialize(log_switch, mod, methods_to_exclude, opts)
+      @log_switch = log_switch
+      intercepted_first_method = false
+      interceptor = self
+
+      mod.public_instance_methods.each do |method_sym|
+        next if methods_to_exclude[method_sym]
+        @module_name ||= produce_module_name(mod)
+
+        unless intercepted_first_method
+          log_module_interception if opts[:log_interception_of_modules]
+          intercepted_first_method = true
+        end
+
+        method_name = method_sym.to_s
+        log_method_interception(method_name) if opts[:log_interception_of_methods]
+
+        define_method(method_sym) do |*args, &blk|
+          interceptor.log_call(self, method_name, args)
+          super(*args, &blk)
+        end
+      end
+
+      mod.prepend(self)
+    end
+
+    def log_call(instance, method_name, args)
+      @log_switch.debug('itrace') do
+        args = args.map do |a|
+          a = a.inspect
+          a.size > 20 ? a[0, 17] + '...' : a
+        end.join(', ')
+
+        if @module_name == instance.class.name
+          "#{get_instance_name(instance)}.#{method_name}(#{args})"
+        else
+          "#{get_instance_name(instance)}[#{@module_name}].#{method_name}(#{args})"
+        end
+      end
+    end
+
+  private
+    def log_module_interception
+      @log_switch.debug('itrace'){ "Intercepting #{@module_name}." }
+    end
+
+    def log_method_interception(module_name, method_name)
+      @log_switch.debug('itrace'){ "Intercepting #{@module_name}\##{method_name}." }
+    end
+
+    def produce_module_name(mod)
+      mod.singleton_class? ? 'singleton' : (mod.name || mod.object_id.to_s)
+    end
+
+    def get_instance_name(instance)
+      @instance_names ||= {}
+      @instance_names[instance.object_id] ||= produce_instance_name(instance)
+    end
+
+    def produce_instance_name(instance)
+      instance_name = instance.is_a?(::Module) && instance.name
+      instance_name ? "#{instance.class}:(#{instance.name})" : "#{instance.class}:#{instance.object_id}"
+    end
+  end
+end

data/lib/itrace/log_switch.rb

@@ -0,0 +1,52 @@
+module ITrace
+  class LogSwitch
+    attr_reader :logger
+
+    def initialize(logger, enable_logging = true)
+      @logger = logger
+      @logger_methods = {}
+      @enable_logging = enable_logging
+    end
+
+    def enable_logging
+      @enable_logging = true
+      self
+    end
+
+    def disable_logging
+      @enable_logging = false
+      self
+    end
+
+    def call_logger(m_id, *args, &blk)
+      get_logger_method(m_id).call(*args, &blk) if @enable_logging
+    end
+
+    def change_logger(logger)
+      raise NotYetImplementedError
+    end
+
+  private
+    class NotYetImplementedError < ::StandardError
+      def initialize; super("Not yet implemented"); end
+    end
+
+    def get_logger_method(m_id)
+      @logger_methods[m_id] ||= @logger.method(m_id)
+    end
+
+    def create_wrapper_method(m_id)
+      logger_method = get_logger_method(m_id)
+
+      define_singleton_method(m_id) do |*args, &blk|
+        logger_method.call(*args, &blk) if @enable_logging
+      end
+
+      singleton_method(m_id)
+    end
+
+    def method_missing(m_id, *args, &blk)
+      create_wrapper_method(m_id).call(*args, &blk)
+    end
+  end
+end

data/lib/itrace/not_a_module_error.rb

@@ -0,0 +1,7 @@
+module ITrace
+  class NotAModuleError < ::RuntimeError
+    def initialize(not_a_module)
+      super("Not a module: #{not_a_module.inspect}")
+    end
+  end
+end

data/lib/itrace/tracer.rb

@@ -0,0 +1,129 @@
+require 'itrace/defaults'
+require 'itrace/interceptor'
+require 'itrace/log_switch'
+require 'itrace/not_a_module_error'
+
+module ITrace
+  class Tracer
+    def initialize(logger, enable_logging = true)
+      @logger = logger
+      @log_switch = ::ITrace::LogSwitch.new(@logger, enable_logging = true)
+      @intercepted = {}
+    end
+
+    def trace(*modules, **opts)
+      rause "Not an array: #{opts[:include_methods]}" unless opts[:include_methods].nil? || \
+          opts[:include_methods].is_a?(Array)
+      rause "Not an array: #{opts[:exclude_methods]}" unless opts[:exclude_methods].nil? || \
+          opts[:exclude_methods].is_a?(Array)
+
+      modules_to_exclude = (opts[:exclude_modules] || [])
+          .map{ |e| [get_object_id(e, opts[:use_orig_object_id]), true] }.to_h
+      methods_to_include = (opts[:include_methods] || []).map(&:to_sym)
+      methods_to_exclude = (opts[:exclude_methods] || [])
+          .concat(::ITrace::Defaults::METHODS_TO_EXCLUDE).map(&:to_sym)
+          .reject{ |e| methods_to_include.include?(e) }.map{ |e| [e, true] }.to_h
+
+      modules.flatten.each do |mod|
+        unless mod.is_a?(::Module)
+          if opts[:ignore_non_modules]
+            @log_switch.warn("Ignoring non-module: #{get_object_id(mod, true)}")
+          else
+            raise ::ITrace::NotAModuleError.new(mod)
+          end
+        end
+
+        intercept(mod, modules_to_exclude, methods_to_exclude, opts)
+      end
+
+      if block_given?
+        begin
+          yield
+        ensure
+          @log_switch.disable_logging
+        end
+      end
+
+      self
+    end
+
+    def enable_logging
+      @log_switch.enable_logging
+      self
+    end
+
+    def disable_logging
+      @log_switch.disable_logging
+      self
+    end
+
+  private
+    def intercept(mod, modules_to_exclude, methods_to_exclude, opts, done = {})
+      return if mod.is_a?(::ITrace) || mod.is_a?(::ITrace::Interceptor)
+      object_id = get_object_id(mod, opts[:use_orig_object_id])
+      return if modules_to_exclude[object_id]
+      return if done[object_id]
+      done[object_id] = true
+
+      unless @intercepted[mod.object_id]
+        ::ITrace::Interceptor.new(@log_switch, mod, methods_to_exclude, opts)
+        @intercepted[mod.object_id] = true
+      end
+
+      if opts[:include_singleton_classes]
+        singleton_class = mod.singleton_class
+        object_id = get_object_id(singleton_class, opts[:use_orig_object_id])
+
+        unless @intercepted[object_id]
+          ::ITrace::Interceptor.new(@log_switch, singleton_class, methods_to_exclude, opts)
+          @intercepted[object_id] = true
+        end
+      end
+
+      if opts[:recursive]
+        mod.constants.each do |const|
+          begin
+            submod = get_const_get_method(mod, opts[:use_orig_const_get]).call(const)
+          rescue Exception => e
+            if opts[:ignore_exceptions] && opts[:ignore_exceptions].any?{ |k| e.class == k }
+              @log_switch.warn('itrace'){ "Ignoring caught exceptoin: #{e.class.name}" }
+              next
+            end
+
+            raise e
+          end
+
+          if submod.is_a?(::Module)
+            intercept(mod, modules_to_exclude, methods_to_exclude, opts, done)
+          end
+        end
+      end
+    end
+
+    def get_const_get_method(mod, get_original)
+      method = mod.method(:const_get)
+
+      if get_original
+        until method.owner == ::Module
+          super_method = method.super_method or return method
+          method = super_method
+        end
+      end
+
+      return method
+    end
+
+    def get_object_id(obj, get_original)
+      method = obj.method(:object_id)
+
+      if get_original
+        until method.owner == ::Kernel
+          super_method = method.super_method or return method.call
+          method = super_method
+        end
+      end
+
+      return method.call
+    end
+  end
+end

data/lib/itrace/version.rb

@@ -0,0 +1,3 @@
+module ITrace
+  VERSION = "0.0.0"
+end

data/lib/itrace_instance.rb

@@ -0,0 +1,9 @@
+require 'itrace'
+
+class ITraceInstance
+  include ITrace
+
+  def initialize(logger = nil)
+    @logger = logger
+  end
+end

data/test/test.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'itrace'
+require 'itrace_instance'
+
+class Sample
+  class Another
+    def sample(*args)
+      puts "Sample::Another#sample: #{args.join(' ')}"
+    end
+  end
+
+  def sample(*args)
+    puts "Sample#sample: #{args.join(' ')}"
+  end
+end
+
+describe ITrace do
+  it "logs method calls using default logger" do
+    ITrace.trace(Sample, recursive: true, include_singleton_classes: true) do
+      Sample.new.sample(1, 2, 3)
+      Sample::Another.new.sample(:a, :b, :c)
+    end
+  end
+end
+
+describe ITraceInstance do
+  it "instantiates and logs method calls using default logger" do
+    ITraceInstance.new.trace(Sample, recursive: true, include_singleton_classes: true) do
+      Sample.new.sample(1, 2, 3)
+      Sample::Another.new.sample(:a, :b, :c)
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: itrace
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- R.P. Pedraza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+description: Prepends anonymous modules that intercept and log method calls
+email: rp.pedraza@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/itrace.rb
+- lib/itrace/defaults.rb
+- lib/itrace/interceptor.rb
+- lib/itrace/log_switch.rb
+- lib/itrace/not_a_module_error.rb
+- lib/itrace/tracer.rb
+- lib/itrace/version.rb
+- lib/itrace_instance.rb
+- test/test.rb
+homepage: https://rubygems.org/gems/itrace
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/rp-pedraza/itrace
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: An intercepting tracer
+test_files: []