roda-enhanced_logger 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 10033e09d39197a7f03ad6701bdb91cce5ed31888b160a2e46ac5c16917549eb
+  data.tar.gz: dc48be6ce4b9b65eab182baf4faeebc108a25e7037fc25146648b1583a8c9e7c
+SHA512:
+  metadata.gz: 6e1bd2ea35322e882b794b740393f1377242fe7fd3fe9d2d2aff733ac3f36e910d11930a54639b3f50c73633013b1869c7592a7ca3556b14e88dd7a861b4bdc1
+  data.tar.gz: 2d1cf39e8cf2ce2b7c009edb32ad2f852869585f705045b8fb47c0018d0cbe846c68694e042db0c825e57fb81d15ec534c8881d62384dfc861c68f878f2be8cd

data/README.md

@@ -0,0 +1,86 @@
+# Roda Enhanced Logger
+
+A powerful logger for Roda with a few tricks up it's sleeve.
+
+- Coloured output per level
+- Structured output of query params
+- Tracking of database query time and count
+- Tracking of blocks which handle path segment
+- Tracing missed requests
+- Tracing all requests
+
+![Enhanced Logger Output](roda-enhanced_logger.png)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "roda-enhanced_logger"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install roda-enhanced_logger
+
+## Usage
+
+For basic usage, simply enable through the `plugin` mechanism.
+
+
+```ruby
+class App < Roda
+  plugin :enhanced_logger
+end
+```
+
+If you serve assets through Roda, your logs might be fairly noisy, so you can
+filter them.
+
+```ruby
+plugin :enhanced_logger, filter: ->(path) { path.start_with?("/assets") }
+```
+
+By default, EnhancedLogger will attempt to filter passwords and CSRF tokens,
+but you can filter other fields too.
+
+```ruby
+plugin :enhanced_logger, filtered_params: %w[api_key]
+```
+
+If there's a `DB` constant defined for Sequel, EnhancedLogger will automatically
+use it, but you can pass in a custom value if necessary.
+
+```ruby
+plugin :enhanced_logger, db: Container[:db]
+```
+
+During development, a 404 might catch you off guard for a path that you feel should
+exist, so it's handy to trace missed routes to aide in debugging.
+
+```ruby
+plugin :enhanced_logger, trace_missed: true
+```
+
+Or always trace every request.
+
+```ruby
+plugin :enhanced_logger, trace_all: true
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/adam12/roda-enhanced_logger.
+
+I love pull requests! If you fork this project and modify it, please ping me to see
+if your changes can be incorporated back into this project.
+
+That said, if your feature idea is nontrivial, you should probably open an issue to
+[discuss it](http://www.igvita.com/2011/12/19/dont-push-your-pull-requests/)
+before attempting a pull request.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/roda/enhanced_logger/current.rb

@@ -0,0 +1,58 @@
+# frozen-string-literal: true
+
+require "roda"
+
+class Roda
+  module EnhancedLogger
+    ##
+    # Data collection for request in current thread
+    module Current
+      extend self
+
+      # Increment the accrued database time
+      # @param value [Numeric]
+      #   the value to increment
+      # @return [Numeric]
+      #   the updated value
+      def increment_accrued_database_time(value)
+        Thread.current[:accrued_database_time] ||= 0
+        Thread.current[:accrued_database_time] += value
+      end
+
+      # The accrued database time
+      # @return [Numeric]
+      def accrued_database_time
+        Thread.current[:accrued_database_time]
+      end
+
+      # Set accrued database time
+      # @param value [Numeric]
+      #   the value to set
+      # @return [Numeric]
+      #   the new value
+      def accrued_database_time=(value)
+        Thread.current[:accrued_database_time] = value
+      end
+
+      def increment_database_query_count(value = 1)
+        Thread.current[:database_query_count] ||= 0
+        Thread.current[:database_query_count] += value
+      end
+
+      def database_query_count
+        Thread.current[:database_query_count]
+      end
+
+      def database_query_count=(value)
+        Thread.current[:database_query_count] = value
+      end
+
+      # Reset the counters
+      def reset
+        self.accrued_database_time = nil
+        self.database_query_count = nil
+        true
+      end
+    end
+  end
+end

data/lib/roda/enhanced_logger/instance.rb

@@ -0,0 +1,135 @@
+# frozen-string-literal: true
+
+require "roda"
+
+class Roda
+  module EnhancedLogger
+    ##
+    # Logger instance for this application
+    class Instance
+      # Application root
+      attr_reader :root
+
+      # Log entries generated during request
+      attr_reader :log_entries
+
+      # Logger instance
+      attr_reader :logger
+
+      # Route matches during request
+      attr_reader :matches
+
+      attr_reader :timer
+      private :timer
+
+      # Callable object to filter log entries
+      attr_reader :filter
+
+      def initialize(logger, env, instance_id, root, filter)
+        @logger = logger
+        @root = root
+        @log_entries = []
+        @matches = []
+        @timer = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @filter = filter || proc { false }
+        if env["enhanced_logger_id"].nil?
+          @primary = true
+          env["enhanced_logger_id"] = instance_id
+        else
+          @primary = false
+        end
+      end
+
+      # Add a matched route handler
+      def add_match(caller)
+        @matches << caller
+      end
+
+      # Add log entry for request
+      # @param status [Integer]
+      #   status code for the response
+      # @param request [Roda::RodaRequest]
+      #   request object
+      # @param trace [Boolean]
+      #   tracing was enabled
+      def add(status, request, trace = false)
+        if (last_matched_caller = matches.last)
+          handler = format("%s:%d",
+            Pathname(last_matched_caller.path).relative_path_from(root),
+            last_matched_caller.lineno)
+        end
+
+        meth =
+          case status
+          when 400..499
+            :warn
+          when 500..599
+            :error
+          else
+            :info
+          end
+
+        data = {
+          duration: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - timer).round(4),
+          status: status,
+          verb: request.request_method,
+          path: request.path,
+          remaining_path: request.remaining_path,
+          handler: handler,
+          params: request.params
+        }
+
+        if (db = Roda::EnhancedLogger::Current.accrued_database_time)
+          data[:db] = db.round(6)
+        end
+
+        if (query_count = Roda::EnhancedLogger::Current.database_query_count)
+          data[:db_queries] = query_count
+        end
+
+        if trace
+          matches.each do |match|
+            add_log_entry([meth, format("  %s (%s:%s)",
+              File.readlines(match.path)[match.lineno - 1].strip.sub(" do", ""),
+              Pathname(match.path).relative_path_from(root),
+              match.lineno)])
+          end
+        end
+
+        return if filter.call(request.path)
+
+        add_log_entry([meth, "#{request.request_method} #{request.path}", data])
+      end
+
+      # This instance is the primary logger
+      # @return [Boolean]
+      def primary?
+        @primary
+      end
+
+      # Drain the log entry queue, writing each to the logger at their respective level
+      # @return [Boolean]
+      def drain
+        return unless primary?
+
+        log_entries.each do |args|
+          logger.public_send(*args)
+        end
+
+        true
+      end
+
+      # Reset the counters for this thread
+      # @return [Boolean]
+      def reset
+        Roda::EnhancedLogger::Current.reset
+      end
+
+      private
+
+      def add_log_entry(record)
+        @log_entries << record
+      end
+    end
+  end
+end

data/lib/roda/plugins/enhanced_logger.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+
+require "tty-logger"
+require "roda/enhanced_logger/current"
+require "roda/enhanced_logger/instance"
+
+class Roda
+  module RodaPlugins
+    # The +enhanced_logger+ plugin provides a coloured, single line log
+    # entry for requests in a Roda application.
+    #
+    # Some interesting pieces of the log entry include which line matched the request,
+    # any time incurred by Sequel DB queries, and the remaining path that might have
+    # not been matched.
+    #
+    # It's mostly suitable in development but would likely be fine in production.
+    #
+    # @example Basic configuration
+    #   plugin :enhanced_logger
+    #
+    # @example Filter requests to assets
+    #   plugin :enahanced_logger, filter: ->(path) { path.start_with?("/assets") }
+    #
+    # @example Filter parameters
+    #   plugin :enhanced_logger, filtered_params: %i[api_key]
+    #
+    module EnhancedLogger
+      DEFAULTS = {
+        db: nil,
+        log_time: false,
+        trace_missed: true,
+        trace_all: false,
+        filtered_params: %w[password password_confirmation _csrf],
+        handlers: [:console]
+      }.freeze
+
+      def self.load_dependencies(app, _opts = {})
+        app.plugin :hooks
+        app.plugin :match_hook
+      end
+
+      def self.configure(app, opts = {})
+        options = DEFAULTS.merge(opts)
+
+        logger = TTY::Logger.new { |config|
+          config.handlers = options[:handlers]
+          config.output = options.fetch(:output) { $stdout }
+          config.metadata = [:data, :time] if options[:log_time]
+          config.filters.data = options[:filtered_params].map(&:to_s)
+          config.filters.mask = "<FILTERED>"
+        }
+
+        root = Pathname(app.opts[:root] || Dir.pwd)
+
+        db = options[:db] || (defined?(DB) && DB)
+        db&.extension :enhanced_logger
+
+        app.match_hook do
+          callee = caller_locations.find { |location|
+            location.path.start_with?(root.to_s)
+          }
+
+          @_enhanced_logger_instance.add_match(callee)
+        end
+
+        app.before do
+          @_enhanced_logger_instance = Roda::EnhancedLogger::Instance.new(logger, env, object_id, root, options[:filter])
+        end
+
+        app.after do |status, _|
+          @_enhanced_logger_instance.add(
+            status,
+            request,
+            (options[:trace_missed] && status == 404) || options[:trace_all]
+          )
+
+          @_enhanced_logger_instance.drain
+          @_enhanced_logger_instance.reset
+        end
+      end
+    end
+
+    register_plugin :enhanced_logger, EnhancedLogger
+  end
+end

data/lib/sequel/extensions/enhanced_logger.rb

@@ -0,0 +1,29 @@
+# frozen-string-literal: true
+
+require "sequel"
+
+module EnhancedLogger
+  module Sequel
+    if ::Sequel::VERSION_NUMBER >= 50240
+      def skip_logging?
+        false
+      end
+    else
+      def self.extended(base)
+        return if base.loggers.any?
+
+        require "logger"
+        base.loggers = [Logger.new("/dev/null")]
+      end
+    end
+
+    def log_duration(duration, _message)
+      Roda::EnhancedLogger::Current.increment_accrued_database_time(duration)
+      Roda::EnhancedLogger::Current.increment_database_query_count
+
+      super
+    end
+  end
+
+  ::Sequel::Database.register_extension :enhanced_logger, EnhancedLogger::Sequel
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: roda-enhanced_logger
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Adam Daniels
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: roda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.19.0
+- !ruby/object:Gem::Dependency
+  name: tty-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email: adam@mediadrive.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/roda/enhanced_logger/current.rb
+- lib/roda/enhanced_logger/instance.rb
+- lib/roda/plugins/enhanced_logger.rb
+- lib/sequel/extensions/enhanced_logger.rb
+homepage: https://github.com/adam12/roda-enhanced_logger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: An enhanced logger for Roda applications
+test_files: []