log_sanity 0.2.5

data/lib/log_sanity/extensions/action_controller_helper.rb

@@ -0,0 +1,12 @@
+module LogSanity
+  module Extensions
+    module ActionControllerHelper
+      extend ActiveSupport::Concern
+
+      def log_field(key, val)
+        LogSanity.log key, val
+      end
+
+    end
+  end
+end

data/lib/log_sanity/extensions/active_support_subscriber.rb

@@ -0,0 +1,25 @@
+module LogSanity
+  module Extensions
+    module ActiveSupportSubscriber
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def detach_from(namespace, notifier=ActiveSupport::Notifications)
+          subscribers.select{|s| s.is_a? self}.each do |subscriber|
+            subscriber.public_methods(false).each do |event|
+              pattern = "#{event}.#{namespace}"
+              notifier.notifier.listeners_for(pattern).each do |listener|
+                if listener.instance_variable_get(:@delegate) == subscriber
+                  notifier.unsubscribe listener
+                  subscriber.patterns.delete pattern
+                end
+              end
+            end
+            subscribers.delete subscriber if subscriber.patterns.empty?
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/log_sanity/formatter.rb

@@ -0,0 +1,45 @@
+# Receives a variety of objects for logging.
+# LogSanity itself sends Hashes which are formatted with #to_json.
+# Other than Strings, will embed any other object into a jsonified hash.
+# Strings are a bit of a special case and by default continue to be formatted
+# with whatever Rails' formatter originally was. As such, it can be configured
+# using `config.log_formatter`. This keeps exception backtraces and other
+# various logs still as Strings. If you prefer Strings to also be turned into
+# jsonified messages, set `config.logsanity.json_strings = true`.
+
+module LogSanity
+  class Formatter < Logger::Formatter
+
+    def call(severity, timestamp, progname, msg)
+      if msg.is_a? Hash
+        msg['at'] = timestamp unless msg.key?('at')
+      elsif msg.is_a? String
+        if string_formatter
+          return string_formatter.call(severity, timestamp, progname, msg)
+        else
+          msg = {'at' => timestamp, 'message' => msg}
+        end
+      else
+        msg = {'at' => timestamp, 'object' => msg.inspect}
+      end
+      if msg['at'].is_a? Float
+        monot = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        msg['at'] = Time.now - (monot - msg['at'])
+      end
+      msg['at'] = msg['at'].utc
+      "#{msg.to_json}\n"
+    end
+
+    # noop; for TaggedLogging compatibility
+    def clear_tags! ; end
+    def tagged(*_) ; yield self ; end
+    def current_tags ; [] ; end
+
+    attr_writer :string_formatter
+
+    def string_formatter
+      @string_formatter ||= ActiveSupport::Logger::SimpleFormatter.new
+    end
+
+  end
+end

data/lib/log_sanity/log_subscribers/action_controller.rb

@@ -0,0 +1,56 @@
+module LogSanity
+  module LogSubscriber
+    class ActionController < Base
+      INTERNAL_PARAMS = %w(controller action format _method only_path)
+
+      def process_action(event)
+        payload = event.payload
+        params  = payload[:params].except(*INTERNAL_PARAMS)
+        format  = payload[:format]
+
+        # log 'method', payload[:method]
+        # log 'path', payload[:path]
+        # log 'controller', payload[:controller]
+        # log 'action', payload[:action]
+        log 'route', "#{payload[:controller]}##{payload[:action]}"
+        log 'format', format
+        log 'params', params if params.present?
+
+        status = payload[:status]
+        if status.nil? && payload[:exception].present?
+          exception_class_name = payload[:exception].first
+          status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+        end
+
+        durations = {'total' => event.duration.round}
+        additions = ::ActionController::Base.log_process_action(payload)
+        additions.each do |add|
+          if add =~ /^([^:]+):?\s*([0-9.]+)(ms)?/
+            ms = $2.to_f.round
+            durations[$1.downcase] = ms if ms > 0
+          end
+        end
+
+        log 'duration', durations
+        log 'status', status
+      end
+
+      def halted_callback(event)
+        log 'filter_chain_halt', event.payload[:filter].inspect
+      end
+
+      def send_file(event)
+        log 'send_file', event.payload[:path]
+      end
+
+      def redirect_to(event)
+        log 'redirect', event.payload[:location]
+      end
+
+      def send_data(event)
+        log 'send_data', event.payload[:filename] || 'binary'
+      end
+
+    end
+  end
+end

data/lib/log_sanity/log_subscribers/action_dispatch.rb

@@ -0,0 +1,63 @@
+module LogSanity
+  module LogSubscriber
+    class ActionDispatch < Base
+
+      def request(event)
+        payload = event.payload
+        return if payload[:silence]
+
+        info do
+          request = payload[:request]
+          response = payload[:response]
+          method = payload[:method] || (request.request_method rescue nil) || 'UNKNOWN'
+          f2 = {
+            'at' => event.time,
+            'event' => "#{request.scheme}_#{method.downcase}",
+            'ip' => request.remote_ip,
+            'rq' => request.uuid,
+            # 'params' => request.filtered_params,
+            # 'path' => request.filtered_path,
+          }
+
+          # unless fields['route']
+          #   # most errors repopulate path, so look for the original one first.
+          #   # original_path is, however, unfiltered.
+          #   fields['path'] = payload[:env]['action_dispatch.original_path']
+          #   fields['path'] ||= request.filtered_path
+          # end
+
+          fields['duration'] ||= {}
+          fields['duration']['total'] = event.duration.round
+            # rewrites 'total', which includes more of time spent in middleware
+          fields['status'] ||= response[0].to_i if response
+          compute_tags(request)
+          f2.merge fields
+        end
+      end
+
+
+      private
+
+      def compute_tags(request)
+        Rails.application.config.log_tags.each_with_index do |tag, idx|
+          res = case tag
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+          if res.is_a?(Hash)
+            fields.deep_merge!(res)
+          elsif tag.is_a? Symbol
+            log tag.to_s, res
+          else
+            log "tag#{idx}", res
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/log_sanity/log_subscribers/action_mailer.rb

@@ -0,0 +1,27 @@
+module LogSanity
+  module LogSubscriber
+    class ActionMailer < Base
+
+      def deliver(event)
+        info do
+          { 'at' => Time.now,
+            'event' => 'mail_send',
+            'from' => Array(event.payload[:from]),
+            'to' => Array(event.payload[:to])
+          }
+        end
+      end
+
+      def receive(event)
+        info do
+          { 'at' => Time.now,
+            'event' => 'mail_receive',
+            'from' => Array(event.payload[:from]),
+            'to' => Array(event.payload[:to])
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/log_sanity/log_subscribers/active_job.rb

@@ -0,0 +1,69 @@
+module LogSanity
+  module LogSubscriber
+    class ActiveJob < Base
+
+      def enqueue(event)
+        info do
+          job = event.payload[:job]
+          e = {
+            'at' => Time.now,
+            'event' => 'job_enqueue',
+            'job' => job.class.name,
+            'id' => job.job_id,
+            'queue' => job.queue_name
+          }
+          e['params'] = job.arguments if job.arguments.any?
+          e
+        end
+      end
+
+      def enqueue_at(event)
+        info do
+          job = event.payload[:job]
+          e = {
+            'at' => Time.now,
+            'event' => 'job_enqueue',
+            'job' => job.class.name,
+            'id' => job.job_id,
+            'queue' => job.queue_name,
+            'start_at' => job.scheduled_at
+          }
+          e['params'] = job.arguments if job.arguments.any?
+          e
+        end
+      end
+
+      # def perform_start(event)
+      #   info do
+      #     job = event.payload[:job]
+      #     e = {
+      #       'at' => Time.now,
+      #       'event' => 'job_start',
+      #       'job' => job.class.name,
+      #       'id' => job.job_id,
+      #       'queue' => job.queue_name,
+      #     }
+      #     e['params'] = job.arguments if job.arguments.any?
+      #     e
+      #   end
+      # end
+
+      def perform(event)
+        info do
+          job = event.payload[:job]
+          e = {
+            'at' => Time.now,
+            'event' => 'job_perform',
+            'job' => job.class.name,
+            'id' => job.job_id,
+            'queue' => job.queue_name,
+            'duration' => {'total' => event.duration.round}
+          }
+          e['params'] = job.arguments if job.arguments.any?
+          e
+        end
+      end
+
+    end
+  end
+end

data/lib/log_sanity/log_subscribers/base.rb

@@ -0,0 +1,10 @@
+module LogSanity
+  module LogSubscriber
+    class Base < ::ActiveSupport::LogSubscriber
+
+      private
+      delegate :fields, :log, to: LogSanity
+
+    end
+  end
+end

data/lib/log_sanity/middleware/request_logger.rb

@@ -0,0 +1,69 @@
+module LogSanity
+  class RequestLogger
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+
+      conditionally_silence(request) do |silence|
+        begin
+          start(request: request)
+          resp = @app.call(env)
+          resp[2] = Rack::BodyProxy.new(resp[2]) do
+            finish(env: env, request: request, response: resp, silence: silence)
+          end
+          resp
+        rescue Exception => e
+          finish(env: env, request: request, exception: e, silence: silence)
+          raise e
+        end
+      end
+    ensure
+      ActiveSupport::LogSubscriber.flush_all!
+    end
+
+    def conditionally_silence(request)
+      if silence = silence_path?(request)
+        logger.silence do
+          yield silence
+        end
+      else
+        yield silence
+      end
+    end
+
+
+
+    private
+
+    def start(params)
+      LogSanity.reset_fields
+      instrumenter = ActiveSupport::Notifications.instrumenter
+      instrumenter.start 'request.action_dispatch', params
+    end
+
+    def finish(params)
+      instrumenter = ActiveSupport::Notifications.instrumenter
+      instrumenter.finish 'request.action_dispatch', params
+    end
+
+    def silence_path?(request)
+      Rails.application.config.logsanity.silence_paths.any? do |s|
+        case s
+        when Regexp
+          s =~ request.path
+        when String
+          s == request.path
+        end
+      end
+    end
+
+    def logger
+      Rails.logger
+    end
+
+  end
+end

data/lib/log_sanity/middleware/routing_error_catcher.rb

@@ -0,0 +1,30 @@
+# middleware to catch and sanely handle routing errors without treating them
+# like all other exceptions (that is, without verbose backtraces and other
+# such).
+# intended to be added to the end of the middleware stack (nearest the app).
+# while built on top of ShowExceptions to reuse its error rendering logic,
+# does not replace it.
+
+module LogSanity
+  class RoutingErrorCatcher < ActionDispatch::ShowExceptions
+
+    def call(env)
+      request = ActionDispatch::Request.new env
+      _, headers, body = response = @app.call(env)
+
+      if headers['X-Cascade'] == 'pass'
+        body.close if body.respond_to?(:close)
+        raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
+      end
+
+      response
+    rescue ActionController::RoutingError => exception
+      if request.show_exceptions?
+        render_exception(request, exception)
+      else
+        raise exception
+      end
+    end
+
+  end
+end

data/lib/log_sanity/railtie.rb

@@ -0,0 +1,50 @@
+module LogSanity
+  class Railtie < Rails::Railtie
+    config.logsanity               = ActiveSupport::OrderedOptions.new
+    config.logsanity.enabled       = false
+    config.logsanity.json_strings  = false
+    config.logsanity.silence_paths = []
+
+    initializer "log_sanity.configure" do |app|
+      app.config.log_tags ||= []
+      if app.config.logsanity.enabled
+        orig_formatter = Rails.logger.formatter
+        Rails.logger.formatter = LogSanity::Formatter.new
+        Rails.logger.formatter.string_formatter = orig_formatter unless app.config.logsanity.json_strings
+
+        if defined?(ActionController)
+          require 'action_controller/log_subscriber'
+          ActionController::LogSubscriber.detach_from :action_controller
+        end
+        if defined?(ActionMailer)
+          require 'action_mailer/log_subscriber'
+          ActionMailer::LogSubscriber.detach_from :action_mailer
+        end
+        if defined?(ActionView)
+          require 'action_view/log_subscriber'
+          ActionView::LogSubscriber.detach_from :action_view
+        end
+        if defined?(ActiveJob)
+          require 'active_job/logging'
+          ActiveJob::Logging::LogSubscriber.detach_from :active_job
+        end
+        if defined?(ActiveRecord)
+          if ActiveRecord::Base.logger.debug?
+            Rails.logger.info '[LogSanity] ActiveRecord::Base.logger in debug mode and will still log queries'
+          end
+        end
+
+        LogSanity::LogSubscriber::ActionController.attach_to :action_controller
+        LogSanity::LogSubscriber::ActionDispatch.attach_to :action_dispatch
+        LogSanity::LogSubscriber::ActionMailer.attach_to :action_mailer
+        LogSanity::LogSubscriber::ActiveJob.attach_to :active_job
+
+        app.middleware.swap Rails::Rack::Logger, LogSanity::RequestLogger
+
+        show_exceptions_app = app.config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
+        app.middleware.use LogSanity::RoutingErrorCatcher, show_exceptions_app
+      end
+    end
+
+  end
+end