object_tracker 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a7d0b65299e8afcbd85241099ca20179d143b74
-  data.tar.gz: 03425ae584ea22e6a94d928c9c566d42b3f2984d
+  metadata.gz: 3fc6c464b675df1affa9690508114fb9ac137606
+  data.tar.gz: f8a2e38b99381cab9cd899670bad36d3d14fab7f
 SHA512:
-  metadata.gz: d6919b9db7a8442104f7b9caa0d388536d3ef368c876c65717ffaa9bd277152397e89ffaf0f86d609f24a54cb861453e8539b7d68cb60c1984ef6fb8d80ead79
-  data.tar.gz: 6209b7936adf4326b0d0c61d24e018fc6bab9e8b1ce6cbd4445533cde6325c718dfc448dde3d687b1646666d24789e5b17878a767620a43469f72f2805c43b4c
+  metadata.gz: 1518da9f3f6c230a8caf600a6b6cc7403625a57bb0b2ad58d64d39cfc0d51d1ca48909ba957ab083bcb2e33b8be16130e06e75283b9e4bd05fd2f45c5d3f7c5b
+  data.tar.gz: 2dd55ed1e2aa7d4e96f4a5d86e0fa7dc37a21de24ed4c5c0e1931ff130dfb766bda5d784f345d740256294d9003cd133d1cd97b370ee4b063d19cafad9903ad0

data/lib/object_tracker.rb

@@ -1,19 +1,29 @@
+require 'logger'
 require 'benchmark'
 require 'object_tracker/version'
 
 module ObjectTracker
   autoload :TrackerMethod, 'object_tracker/tracker_method'
+  autoload :LogFormatter, 'object_tracker/log_formatter'
 
   # @param method_names [Array<Symbol>] method names to track
   # @option :except [Array<Symbol>] method names to NOT track
-  # @option :before [Proc] proc to call before method execution (e.g. ->(_name, _context, *_args) {})
-  # @option :after [Proc] proc to call after method execution (e.g. ->(_name, _context, *_args) {})
+  # @option :before [Proc] proc to call before method execution (e.g. ->(name, context, args) {})
+  # @option :after [Proc] proc to call after method execution (e.g. ->(name, context, args, duration) {})
   def track_all!(method_names = [], **options)
     ObjectTracker.(self, method_names, **options)
     self
   end
 
   class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new(STDOUT).tap do |config|
+        config.formatter = LogFormatter.new
+      end
+    end
+
     def reserved_tracker_methods
       @__reserved_methods ||= begin
         names = [:__send__]
@@ -32,94 +42,124 @@ module ObjectTracker
   # @param obj [Object] class or instance to track
   # @param method_names [Array<Symbol>] method names to track
   # @option :except [Array<Symbol>] method names to NOT track
-  # @option :before [Proc] proc to call before method execution (e.g. ->(_name, _context, *_args) {})
-  # @option :after [Proc] proc to call after method execution (e.g. ->(_name, _context, *_args) {})
+  # @option :before [Proc] proc to call before method execution (e.g. ->(name, context, args) {})
+  # @option :after [Proc] proc to call after method execution (e.g. ->(name, context, args, duration) {})
   def self.call(obj, method_names = [], except: [], **options)
-    class_methods = []
-    inst_methods = []
-    reserved = obj.respond_to?(:reserved_tracker_methods) ? obj.reserved_tracker_methods : ObjectTracker.reserved_tracker_methods
-    obj_instance = obj.respond_to?(:allocate) ? obj.allocate : obj
-    if Array(method_names).any?
-      Array(method_names).each do |method_name|
-        if obj.methods.include?(method_name)
-          class_methods << TrackerMethod.new(obj, method_name)
-        elsif obj.respond_to?(:instance_method)
-          inst_methods << TrackerMethod.new(obj_instance, method_name)
-        end
-      end
-    else
-      if obj.respond_to?(:instance_methods)
-        (obj.instance_methods - reserved - Array(except)).each do |method_name|
-          inst_methods << TrackerMethod.new(obj_instance, method_name)
-        end
-      end
-      (obj.methods - reserved - Array(except)).each do |method_name|
-        class_methods << TrackerMethod.new(obj, method_name)
-      end
-    end
+    class_methods, inst_methods = ObjectTracker.build_tracker_methods(obj, method_names, except: except)
+    name = obj.to_s
     obj.send :extend, ObjectTracker.define_tracker_mod(obj, :TrackerExt, ObjectTracker.build_tracker_mod(class_methods, options))
     if inst_methods.any?
-      obj.send :prepend, ObjectTracker.define_tracker_mod(obj, :InstanceTrackerExt, ObjectTracker.build_tracker_mod(inst_methods, options))
+      # Silence all the noise about comparing class name and checking object behavior
+      ObjectTracker.with_error_logging do
+        obj.send :prepend, ObjectTracker.define_tracker_mod(obj, :InstanceTrackerExt, ObjectTracker.build_tracker_mod(inst_methods, options))
+      end
     end
+    logger.info { "following #{name}" }
     obj
   end
 
   def self.define_tracker_mod(context, name, mod)
     context = context.class unless context.respond_to?(:const_set)
+    if context.const_defined?(name, false)
+      context.send :remove_const, name
+    end
     context.const_set name, mod
   end
 
   # @param trackers [Array<TrackerMethod>]
   # @option :mod [Module] module to add tracking to, will be mixed into self
-  # @option :before [Proc] proc to call before method execution (e.g. ->(_name, _context, *_args) {})
-  # @option :after [Proc] proc to call after method execution (e.g. ->(_name, _context, *_args) {})
+  # @option :before [Proc] proc to call before method execution (e.g. ->(name, context, args) {})
+  # @option :after [Proc] proc to call after method execution (e.g. ->(name, context, args, duration) {})
   def self.build_tracker_mod(trackers, mod: Module.new, before: nil, after: nil)
     ObjectTracker.tracker_hooks[:before] << before if before
     ObjectTracker.tracker_hooks[:after] << after if after
     Array(trackers).each do |tracker|
       mod.module_eval <<-RUBY, __FILE__, __LINE__
         def #{tracker.name}(*args)
-          ObjectTracker.call_tracker_hooks(:before, "#{tracker.display_name}", self, *args)
-          result, message = ObjectTracker.call_with_tracking("#{tracker.display_name}", args, "#{tracker.source}") { super }
-          puts message
+          ObjectTracker.call_tracker_hooks(:before, "#{tracker.display_name}", self, args)
+          result, message, duration = ObjectTracker.call_with_tracking("#{tracker.display_name}", args, "#{tracker.source}") { super }
+          ObjectTracker.logger.debug { message  + " (%.5f)" % duration }
           result
         ensure
-          ObjectTracker.call_tracker_hooks(:after, "#{tracker.display_name}", self, *args)
+          ObjectTracker.call_tracker_hooks(:after, "#{tracker.display_name}", self, args, duration)
         end
       RUBY
     end
     mod
   end
 
+  #
+  # Private
+  #
+
+  def self.build_tracker_methods(obj, method_names, except: [])
+    class_methods, inst_methods = [], []
+    reserved = obj.respond_to?(:reserved_tracker_methods) ? obj.reserved_tracker_methods : ObjectTracker.reserved_tracker_methods
+    obj_instance = obj.respond_to?(:allocate) ? obj.allocate : obj
+    if Array(method_names).any?
+      Array(method_names).each do |method_name|
+        if obj.methods.include?(method_name)
+          class_methods << TrackerMethod.new(obj, method_name)
+        elsif obj.respond_to?(:instance_method)
+          inst_methods << TrackerMethod.new(obj_instance, method_name)
+        end
+      end
+    else
+      if obj.respond_to?(:instance_methods)
+        (obj.instance_methods - reserved - Array(except)).each do |method_name|
+          inst_methods << TrackerMethod.new(obj_instance, method_name)
+        end
+      end
+      (obj.methods - reserved - Array(except)).each do |method_name|
+        class_methods << TrackerMethod.new(obj, method_name)
+      end
+    end
+    return class_methods, inst_methods
+  end
+
   # @note If we don't rescue, watch out for segfaults o.0
-  def self.call_tracker_hooks(key, method_name, context, *args)
+  def self.call_tracker_hooks(key, method_name, context, args, duration = nil)
     tracker_hooks[key].each do |hook|
-      hook.call(context, method_name, *args) rescue nil
+      begin
+        if duration
+          hook.call(context, method_name, args, duration)
+        else
+          hook.call(context, method_name, args)
+        end
+      rescue Exception
+        next
+      end
     end
   end
 
-  def self.call_with_tracking(method_name, args, source)
+  def self.call_with_tracking(msg, args, source)
     result = nil
-    msg = %Q(   * called "#{method_name}" )
-    msg << "with " << ObjectTracker.format_args(args) unless args.empty?
-    msg << "[#{source}]"
+    msg += ObjectTracker.format_args(args) unless args.empty?
+    msg += " [#{source}]"
     bm = Benchmark.measure do
       result = yield rescue nil
     end
-    [result, msg << " (%.5f)" % bm.real]
+    [result, msg, bm.real]
   end
 
   def self.format_args(args)
-    result = "["
+    result = " with ["
     args.each do |arg|
       result << (arg ? arg.to_s : "nil")
       result << ", "
     end
     result.sub! /,\s\z/, ""
-    result << "] "
+    result << "]"
   end
 
   def self.tracker_hooks
     @__tracker_hooks ||= Hash.new { |me, key| me[key] = [] }
   end
+
+  def self.with_error_logging
+    old_log_level, logger.level = logger.level, Logger::ERROR
+    yield
+  ensure
+    logger.level = old_log_level if old_log_level
+  end
 end

data/lib/object_tracker/log_formatter.rb

@@ -0,0 +1,9 @@
+module ObjectTracker
+  class LogFormatter < Logger::Formatter
+    FORMAT = "[%s] %5s -- ObjectTracker: %s\n".freeze
+
+    def call(severity, time, _progname, msg)
+      FORMAT % [format_datetime(time), severity, msg2str(msg)]
+    end
+  end
+end

data/lib/object_tracker/version.rb

@@ -1,3 +1,3 @@
 module ObjectTracker
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.1.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_tracker
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,6 +47,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/object_tracker.rb
+- lib/object_tracker/log_formatter.rb
 - lib/object_tracker/tracker_method.rb
 - lib/object_tracker/version.rb
 - object_tracker.gemspec