markdown_logging_proxy 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ede32c7a00afa640bd44e6ec610034cc8a968e369a214d80bc3071c5b902516
-  data.tar.gz: c2032172bb4e05c3ebf6ac0ba30984c08623d4948b371f1afb77199ed4effae3
+  metadata.gz: aff578739daa97caef0a7014bf062fe113a495cc124da496f6a08d8c31790e49
+  data.tar.gz: 560c9efb88be9083d5d91b46a174c8b5c26c5c0b30289776c80f937b9ee81b1b
 SHA512:
-  metadata.gz: a60b3241307b03bd0ef86b4cec3ca1fc149e3cb552dfea7eecffadf9e831f014f367cd714b4e3a3897d3f08b6258ece8e22111500989707e216f909726e45ab1
-  data.tar.gz: 2dadcbef2a63e99aa6187751ee8cbf2c1318add028e0d6443f6f2331895dbadc27c4a20cdf740468df83937183a94f88bd28e6a8d46dee6fe21b5a3572f18bbe
+  metadata.gz: aa0ff0ff2637a3bd8eb9141cd6200e763478d071859958a07ca6585a2405fcce83160a9b03c49a88afa7f11428d3ed50bc4b3cde944bf96060c820b253406d20
+  data.tar.gz: 45f2d7f82f0e7d366857b8da7ab7a6397e582190969155013facd87a5ae66c7c441f006486fee4cfe9b388538d614eaa60c533f478ec4a7165f9038031e31dcb

data/CHANGELOG.md

@@ -3,3 +3,29 @@
 ## [0.1.0] - 2022-08-22
 
 - Initial release
+
+## [1.0.0]
+
+- Release of gem to rubygems
+- Proxy now defines zero methods besides `method_missing`
+- Addition of `bin/example` script
+
+## [1.0.1]
+
+- Add missing CHANGELOG updates
+- Commit updates to compiled `dist/` version of library
+
+## [1.0.2]
+
+- Improved log formatting
+- Fix to proxy method overwrite behavior
+
+## [1.1.0]
+
+- Don't show object IDs for args arrays. It's confusing.
+- BREAKING: Proxies most `Object` methods by default now
+
+## [1.1.1]
+
+- Allow proxying of `nil`
+- Add require statements to copy+paste version

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    markdown_logging_proxy (0.1.0)
+    markdown_logging_proxy (1.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -18,7 +18,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ### Copy+Paste
 
-Look at `dist/` for compiled versions of the gem which can safely (relatively) be copied into irb/pry sessions.
+You can copy the contents of [`dist/markdown_logging_proxy.rb`](dist/markdown_logging_proxy.rb) into a live irb/pry session.
 
 ## Usage
 

data/dist/markdown_logging_proxy.rb

@@ -1,149 +1,247 @@
+require 'logger'
+require 'securerandom'
+require 'pp'
+require 'time'
 module MarkdownLoggingProxy
-  # frozen_string_literal: true
+  class MarkdownLogger
+    def self.inspect_object(object, show_id = true)
+      [
+        '```ruby',
+        ("# #{id_object(object)}" if show_id),
+        object.pretty_inspect.chomp,
+        '```'
+      ].compact.join("\n")
+    end
+
+    def self.id_object(object)
+      # #<Object:0x00007f5a0919e140>
+      "`#<#{object.class}:0x#{object.object_id.to_s(16)}>`"
+    end
+
+    def self.build(location, **options)
+      return location if location.is_a?(MarkdownLogger)
+      new(location, **options)
+    end
+
+    attr_reader :std_logger, :backtrace, :heading_level, :created_at
+
+    def initialize(location, backtrace: true)
+      @created_at = Time.now
+      @std_logger = create_logger(location)
+      @heading_level = 1
+      @backtrace = backtrace
+    end
+
+    def log(level, heading = 3, msg)
+      @heading_level = heading
+      std_logger.send(level, msg)
+    end
+
+    def inspect_backtrace(ignore = 4)
+      return unless backtrace
+      lines =
+        case backtrace
+        when true then caller(ignore)
+        when Regexp then caller(ignore).grep(backtrace)
+        else
+          []
+        end
+      <<~MSG.chomp
 
-  require 'logger'
-  require 'securerandom'
-  require 'pp'
-  require 'time'
+        Backtrace:
 
+        #{lines.map { |l| "* #{l.chop}`" }.join("\n")}
+      MSG
+    end
+
+    private
+
+    def logger_instance(location)
+      case location
+      when Logger then location
+      else
+        Logger.new(location)
+      end
+    end
+
+    def create_logger(location)
+      logger_instance(location).tap do |logger|
+        logger.formatter = markdown_formatter
+      end
+    end
+
+    def markdown_formatter
+      proc do |severity, time, __exec, msg|
+        elapsed = Time.now - created_at
+        "#{'#' * heading_level} #{severity} at +#{elapsed.round(5)} -- #{msg}\n\n"
+      end
+    end
+  end
+end
+module MarkdownLoggingProxy
+  # just a shortcut for Proxy.new
+  def self.new(*args, **options)
+    Proxy.new(*args, **options)
+  end
+end
+module MarkdownLoggingProxy
   class Proxy
+    # Object methods that should be proxied but won't hit method_missing
+    DEFAULT_OVERWRITES = %i[
+      ! != !~ <=> == === =~
+      clone display dup enum_for eql? equal? freeze frozen? hash inspect
+      is_a? itself kind_of? nil? taint tainted? tap then to_enum to_s
+      trust untaint unstrust untrusted? yield_self
+    ]
 
     def initialize(
-        target:,
-        logger: nil,
+        to_proxy = nil,
+        target: nil,
         location: STDOUT,
-        backtrace: /projects/, # regex/true/false backtrace control
-        ignore: [], # methods we shouldn't proxy
+        backtrace: true, # regex/true/false backtrace control
+        ignore: [], # methods we shouldn't log/proxy
         proxy_response: [], # methods we should return a proxy for
-        overwrite: [] # methods defined on Object we should overwrite
+        overwrite: DEFAULT_OVERWRITES
+      )
+      @target = to_proxy || target
+      @logger = MarkdownLogger.build(location, backtrace: backtrace)
+      @tracer = Tracer.new(
+        target: @target,
+        proxy: self,
+        logger: @logger,
+        ignore: ignore,
+        proxy_response: proxy_response,
+        proxy_options: {
+          overwrite: overwrite,
+          backtrace: backtrace,
+        }
       )
-      @ignore = (ignore + proxy_response).uniq
-      @proxy_response = proxy_response
-      @target = target
-      @logger =
-        if logger
-          Utils.format_logger(logger)
-        else
-          Utils.create_logger(location)
-        end
-      @backtrace = backtrace
       overwrite.each do |meth|
-        define_method(meth) do |*args, &blk|
-          __trace_method(meth, args, &blk)
+        self.class.define_method(meth) do |*args, &blk|
+          @tracer.trace(meth, args, &blk)
         end
       end
     end
 
     def method_missing(meth, *args, &blk)
-      __trace_method(meth, args, &blk)
+      @tracer.trace(meth, args, &blk)
     end
+  end
+end
+module MarkdownLoggingProxy
+  class Tracer
+    attr_reader :target, :logger, :ignore, :proxy
 
-    private
+    def initialize(
+        target:,
+        proxy:,
+        logger: nil,
+        ignore: [],
+        proxy_response: [],
+        proxy_options: {}
+      )
+      @target = target
+      @logger = logger
+      @ignore = ignore
+      @proxy_response = proxy_response
+      @proxy_options = proxy_options
+    end
 
-    def __trace_method(meth, args, &blk)
-      __log :info, meth, 2, <<~MSG
-        Calling `#{meth}`
+    def trace(meth, args, &blk)
+      log_call_signature(meth, args, &blk) unless ignore?(meth)
+      log_and_proxy_response(meth, args, &blk)
+    rescue StandardError => e
+      log_and_reraise_error(meth, e)
+    end
 
-        Arguments:
+    def proxy_response?(meth)
+      case @proxy_response
+      when true, false then @proxy_response
+      else
+        @proxy_response.member?(meth)
+      end
+    end
 
-        #{__inspect_object(args)}
+    def ignore?(meth)
+      @ignore.member?(meth)
+    end
 
-        Block? #{block_given? ? 'Yes' : 'No'}
-        #{__display_backtrace}
-      MSG
+    private
 
-      __proxy_response(meth, @target.public_send(meth, *args, &__proxy_block(meth, blk))).tap do |response|
-        __log :info, meth, <<~MSG
-          `#{meth}` Response
+    def log_call_signature(meth, args, &blk)
+      return if ignore.member?(meth)
+      logger.log :info, 1, <<~MSG.chomp
+        Calling `#{meth}` on #{MarkdownLogger.id_object(target)}
 
-          #{__inspect_object(response)}
-        MSG
-      end
-    rescue StandardError => e
-      __log :error, meth, <<~MSG
-        Error in `#{meth}`
+        Arguments:
 
-        Type: #{e.class}
+        #{MarkdownLogger.inspect_object(args, false)}
 
-        #{__inspect_object(e)}
+        Block given? #{block_given? ? 'Yes' : 'No'}
+        #{logger.inspect_backtrace}
       MSG
-      raise e
     end
 
-    def __display_backtrace(ignore = 3)
-      displayed_trace =
-        case @backtrace
-        when true then caller(ignore)
-        when Regexp then caller(ignore).grep(@backtrace)
-        end
-      displayed_trace.map { |l| "* #{l.chop}`" }.join("\n") if displayed_trace
-    end
+    def log_and_proxy_response(meth, args, &blk)
+      response = target.public_send(meth, *args, &log_and_proxy_block(meth, blk))
+      log_response(meth, response) unless ignore?(meth)
+      return response unless proxy_response?(meth)
+      logger.log :info, 3, <<~MSG.chomp
+        Returning proxied response to `#{meth}`
 
-    def __log(level, meth, heading = 3, msg)
-      return if @ignore.member?(meth)
-      @heading_level = heading
-      @logger.send(level, msg)
-    end
-
-    def __proxy_response(meth, response)
-      return response unless @proxy_response.member?(meth)
-      __log :info, nil, <<~MSG
-        Using proxied response for `#{meth}`
+        Proxy from `#{meth}` on #{MarkdownLogger.id_object(target)}
 
-        Object to proxy:
+        Proxy for:
 
-        #{__inspect_object(response)}
+        #{MarkdownLogger.inspect_object(response)}
       MSG
-      self.class.new(target: response, logger: @logger)
+      Proxy.new(**@proxy_options.merge(
+        target: response,
+        location: logger,
+        proxy_response: @proxy_response,
+        ignore: @ignore,
+      ))
     end
 
-    def __proxy_block(meth, block)
-      return if block.nil?
-      logger = @logger
+    def log_and_proxy_block(meth, blk)
+      return if blk.nil?
       proc do |*args|
-        logger.info <<~MSG
-          Yield to block in `#{meth}`
+        logger.log :info, 2, <<~MSG.chomp
+          Yield to block in `#{meth}` on #{MarkdownLogger.id_object(target)}
 
           Arguments:
 
-          #{__inspect_object(args)}
+          #{MarkdownLogger.inspect_object(args, false)}
         MSG
-        block.call(*args).tap do |response|
-          logger.info <<~MSG
+        blk.call(*args).tap do |response|
+          logger.log :info, 3, <<~MSG.chomp
             Response from block in `#{meth}`
 
-            #{__inspect_object(response)}
+            #{MarkdownLogger.inspect_object(response)}
           MSG
         end
       end
     end
 
-    def __inspect_object(obj)
-      ['```ruby', obj.pretty_inspect.chomp, '```'].join("\n")
-    end
-  end
+    def log_and_reraise_error(meth, error)
+      logger.log :error, 2, <<~MSG.chomp
+        Error in `#{meth}`
 
-end
-module MarkdownLoggingProxy
-  module Utils
-    def self.heading_level
-      @heading_level || 1
-    end
+        Type: #{error.class}
 
-    def self.heading_level=(level)
-      @heading_level = level
+        #{MarkdownLogger.inspect_object(error)}
+      MSG
+      raise error
     end
 
-    def self.create_logger(location)
-      logger = location.kind_of?(Logger) ? location : Logger.new(location)
-      format_logger logger
-    end
+    def log_response(meth, response)
+      return if ignore?(meth)
+      logger.log :info, 2, <<~MSG.chomp
+        `#{meth}` response
 
-    def self.format_logger(logger)
-      logger.formatter = proc do |severity, time, _, msg|
-        "#{'#' * heading_level} #{severity} in #{Process.pid} at #{time.iso8601} -- #{msg}\n\n"
-      end
-      logger
+        #{MarkdownLogger.inspect_object(response)}
+      MSG
     end
   end
-end
+end
+

data/lib/markdown_logging_proxy/markdown_logger.rb

@@ -1,12 +1,17 @@
 module MarkdownLoggingProxy
   class MarkdownLogger
-    def self.inspect_object(object)
-      ['```ruby', object.pretty_inspect.chomp, '```'].join("\n")
+    def self.inspect_object(object, show_id = true)
+      [
+        '```ruby',
+        ("# #{id_object(object)}" if show_id),
+        object.pretty_inspect.chomp,
+        '```'
+      ].compact.join("\n")
     end
 
     def self.id_object(object)
       # #<Object:0x00007f5a0919e140>
-      "##{object.class}:0x#{object.object_id.to_s(16)}>"
+      "`#<#{object.class}:0x#{object.object_id.to_s(16)}>`"
     end
 
     def self.build(location, **options)
@@ -14,9 +19,10 @@ module MarkdownLoggingProxy
       new(location, **options)
     end
 
-    attr_reader :std_logger, :backtrace, :heading_level
+    attr_reader :std_logger, :backtrace, :heading_level, :created_at
 
     def initialize(location, backtrace: true)
+      @created_at = Time.now
       @std_logger = create_logger(location)
       @heading_level = 1
       @backtrace = backtrace
@@ -62,7 +68,8 @@ module MarkdownLoggingProxy
 
     def markdown_formatter
       proc do |severity, time, __exec, msg|
-        "#{'#' * heading_level} #{severity} in #{Process.pid} at #{time.iso8601} -- #{msg}\n\n"
+        elapsed = Time.now - created_at
+        "#{'#' * heading_level} #{severity} at +#{elapsed.round(5)} -- #{msg}\n\n"
       end
     end
   end

data/lib/markdown_logging_proxy/proxy.rb

@@ -1,12 +1,12 @@
 module MarkdownLoggingProxy
-  # frozen_string_literal: true
-
-  require 'logger'
-  require 'securerandom'
-  require 'pp'
-  require 'time'
-
   class Proxy
+    # Object methods that should be proxied but won't hit method_missing
+    DEFAULT_OVERWRITES = %i[
+      ! != !~ <=> == === =~
+      clone display dup enum_for eql? equal? freeze frozen? hash inspect
+      is_a? itself kind_of? nil? taint tainted? tap then to_enum to_s
+      trust untaint unstrust untrusted? yield_self
+    ]
 
     def initialize(
         to_proxy = nil,
@@ -15,10 +15,9 @@ module MarkdownLoggingProxy
         backtrace: true, # regex/true/false backtrace control
         ignore: [], # methods we shouldn't log/proxy
         proxy_response: [], # methods we should return a proxy for
-        overwrite: [] # methods defined on Object we should overwrite
+        overwrite: DEFAULT_OVERWRITES
       )
       @target = to_proxy || target
-      raise ArgumentError, "Missing required proxy target" unless @target
       @logger = MarkdownLogger.build(location, backtrace: backtrace)
       @tracer = Tracer.new(
         target: @target,
@@ -32,8 +31,8 @@ module MarkdownLoggingProxy
         }
       )
       overwrite.each do |meth|
-        define_method(meth) do |*args, &blk|
-          @traceer.trace(meth, args, &blk)
+        self.class.define_method(meth) do |*args, &blk|
+          @tracer.trace(meth, args, &blk)
         end
       end
     end

data/lib/markdown_logging_proxy/tracer.rb

@@ -1,7 +1,7 @@
 module MarkdownLoggingProxy
   class Tracer
     attr_reader :target, :logger, :ignore, :proxy
-    
+
     def initialize(
         target:,
         proxy:,
@@ -12,7 +12,7 @@ module MarkdownLoggingProxy
       )
       @target = target
       @logger = logger
-      @ignore = (ignore + proxy_response)
+      @ignore = ignore
       @proxy_response = proxy_response
       @proxy_options = proxy_options
     end
@@ -45,9 +45,9 @@ module MarkdownLoggingProxy
 
         Arguments:
 
-        #{MarkdownLogger.inspect_object(args)}
+        #{MarkdownLogger.inspect_object(args, false)}
 
-        Block? #{block_given? ? 'Yes' : 'No'}
+        Block given? #{block_given? ? 'Yes' : 'No'}
         #{logger.inspect_backtrace}
       MSG
     end
@@ -56,12 +56,14 @@ module MarkdownLoggingProxy
       response = target.public_send(meth, *args, &log_and_proxy_block(meth, blk))
       log_response(meth, response) unless ignore?(meth)
       return response unless proxy_response?(meth)
-      logger.log :info, 3, <<~MSG
+      logger.log :info, 3, <<~MSG.chomp
         Returning proxied response to `#{meth}`
-        
+
         Proxy from `#{meth}` on #{MarkdownLogger.id_object(target)}
-        
-        Proxy for: #{MarkdownLogger.id_object(response)}
+
+        Proxy for:
+
+        #{MarkdownLogger.inspect_object(response)}
       MSG
       Proxy.new(**@proxy_options.merge(
         target: response,
@@ -74,15 +76,15 @@ module MarkdownLoggingProxy
     def log_and_proxy_block(meth, blk)
       return if blk.nil?
       proc do |*args|
-        logger.log :info, 3, <<~MSG
+        logger.log :info, 2, <<~MSG.chomp
           Yield to block in `#{meth}` on #{MarkdownLogger.id_object(target)}
 
           Arguments:
 
-          #{MarkdownLogger.inspect_object(args)}
+          #{MarkdownLogger.inspect_object(args, false)}
         MSG
         blk.call(*args).tap do |response|
-          logger.log :info, 4, <<~MSG
+          logger.log :info, 3, <<~MSG.chomp
             Response from block in `#{meth}`
 
             #{MarkdownLogger.inspect_object(response)}
@@ -92,7 +94,7 @@ module MarkdownLoggingProxy
     end
 
     def log_and_reraise_error(meth, error)
-      logger.log :error, 2, <<~MSG
+      logger.log :error, 2, <<~MSG.chomp
         Error in `#{meth}`
 
         Type: #{error.class}

data/markdown_logging_proxy.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |spec|
+  spec.name = "markdown_logging_proxy"
+  spec.version = "1.1.1"
+  spec.authors = ["Carl Zulauf"]
+  spec.email = ["carl@linkleaf.com"]
+
+  spec.summary = "Proxy object for debugging"
+  spec.description = "Wrap your ruby objects in a proxy to find out what happens to them"
+  spec.homepage = "https://github.com/carlzulauf/markdown_logging_proxy"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/carlzulauf/markdown_logging_proxy"
+  spec.metadata["changelog_uri"] = "https://github.com/carlzulauf/markdown_logging_proxy/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_logging_proxy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Carl Zulauf
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-28 00:00:00.000000000 Z
+date: 2022-08-29 00:00:00.000000000 Z
 dependencies: []
 description: Wrap your ruby objects in a proxy to find out what happens to them
 email:
@@ -31,6 +31,7 @@ files:
 - lib/markdown_logging_proxy/module_methods.rb
 - lib/markdown_logging_proxy/proxy.rb
 - lib/markdown_logging_proxy/tracer.rb
+- markdown_logging_proxy.gemspec
 homepage: https://github.com/carlzulauf/markdown_logging_proxy
 licenses:
 - MIT
@@ -53,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.20
 signing_key:
 specification_version: 4
 summary: Proxy object for debugging