paul_bunyan 1.0.0

data/lib/paul_bunyan/log_relayer.rb

@@ -0,0 +1,148 @@
+require 'forwardable'
+require 'set'
+
+module PaulBunyan
+  class LogRelayer
+    extend Forwardable
+
+    # delegate non-relayed methods to the primary logger
+    DELEGATED_METHODS = %i(
+      progname        progname=
+      level           level=
+      sev_threshold   sev_threshold=
+
+      formatter       formatter=
+      datetime_format datetime_format=
+
+      close
+
+      debug? info? warn? error? fatal?
+    )
+    delegate DELEGATED_METHODS => :primary_logger
+
+    include Logger::Severity
+
+    attr_reader :loggers
+
+    def primary_logger
+      loggers[0]
+    end
+
+    def secondary_loggers
+      loggers[1..-1] || []
+    end
+
+    def add_logger(logger)
+      loggers.push(logger)
+      logger
+    end
+
+    def remove_logger(logger)
+      loggers.delete(logger)
+    end
+
+    def initialize
+      @loggers = []
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      block = memoized_block(&block) if block
+      loggers.reduce(true) do |memo, logger|
+        logger.add(severity, message, progname, &block) && memo
+      end
+    end
+    alias_method :log, :add
+
+    def <<(msg)
+      loggers.reduce(nil) do |memo, logger|
+        n = logger << msg
+
+        # this would be simpler with an array, but would generate unnecessary garbage
+        if memo.nil? || n.nil?
+          memo || n
+        else
+          memo < n ? memo : n
+        end
+      end
+    end
+
+    def debug(progname = nil, &block)
+      add(DEBUG, nil, progname, &block)
+    end
+
+    def info(progname = nil, &block)
+      add(INFO, nil, progname, &block)
+    end
+
+    def warn(progname = nil, &block)
+      add(WARN, nil, progname, &block)
+    end
+
+    def error(progname = nil, &block)
+      add(ERROR, nil, progname, &block)
+    end
+
+    def fatal(progname = nil, &block)
+      add(FATAL, nil, progname, &block)
+    end
+
+    def unknown(progname = nil, &block)
+      add(UNKNOWN, nil, progname, &block)
+    end
+
+    def level
+      logger = loggers.min { |a, b| a.level <=> b.level }
+      logger.nil? ? DEBUG : logger.level
+    end
+
+    module TaggedRelayer
+      def current_tags
+        tags = loggers.each_with_object(Set.new) do |logger, set|
+          set.merge(logger.current_tags) if logger.respond_to?(:current_tags)
+        end
+        tags.to_a
+      end
+
+      def push_tags(*tags)
+        tags.flatten.reject(&:blank?).tap do |new_tags|
+          loggers.each { |logger| logger.push_tags(*new_tags) if logger.respond_to?(:push_tags) }
+        end
+      end
+
+      def pop_tags(size = 1)
+        loggers.each { |logger| logger.pop_tags(size) if logger.respond_to?(:pop_tags) }
+        nil
+      end
+
+      def clear_tags!
+        loggers.each { |logger| logger.clear_tags! if logger.respond_to?(:clear_tags!) }
+        nil
+      end
+
+      def flush
+        loggers.each { |logger| logger.flush if logger.respond_to?(:flush) }
+        nil
+      end
+
+      def tagged(*tags)
+        new_tags = push_tags(*tags)
+        yield self
+      ensure
+        pop_tags(new_tags.size)
+      end
+    end
+    include TaggedRelayer
+
+    private
+
+    def memoized_block(&block)
+      called = false
+      result = nil
+      proc do
+        next result if called
+        called = true
+        result = block.call
+      end
+    end
+  end
+end

data/lib/paul_bunyan/rails_ext.rb

@@ -0,0 +1,7 @@
+module PaulBunyan
+  module RailsExt
+  end
+end
+
+require 'paul_bunyan/rails_ext/rack_logger'
+require 'paul_bunyan/rails_ext/instrumentation'

data/lib/paul_bunyan/rails_ext/instrumentation.rb

@@ -0,0 +1,41 @@
+require 'action_controller/metal/instrumentation'
+
+module ActionController
+  module Instrumentation
+    def process_action(*args)
+      raw_payload = base_payload.merge(custom_payload)
+
+      ActiveSupport::Notifications.instrument('start_processing.action_controller', raw_payload.dup)
+
+      ActiveSupport::Notifications.instrument('process_action.action_controller', raw_payload) do |payload|
+        begin
+          result = super
+          payload[:status] = response.status
+          result
+        ensure
+          append_info_to_payload(payload)
+        end
+      end
+    end
+
+    private
+
+    def base_payload
+      {
+        controller: self.class.name,
+        action: self.action_name,
+        params: request.filtered_parameters,
+        format: request.format.try(:ref),
+        method: request.request_method,
+        path: (request.fullpath rescue 'unknown'),
+      }
+    end
+
+    def custom_payload
+      {
+        request_id: request.env['action_dispatch.request_id'],
+        ip: request.ip,
+      }
+    end
+  end
+end

data/lib/paul_bunyan/rails_ext/rack_logger.rb

@@ -0,0 +1,24 @@
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    class Logger
+
+      # This was copied directly from the rails source and had
+      # the logging lines removed. N.B. this may break in future
+      # versions of rails.
+      def call_app(request, env)
+        instrumenter = ActiveSupport::Notifications.instrumenter
+        instrumenter.start 'request.action_dispatch', request: request
+        resp = @app.call(env)
+        resp[2] = ::Rack::BodyProxy.new(resp[2]) { finish(request) }
+        resp
+      rescue
+        finish(request)
+        raise
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+    end
+  end
+end

data/lib/paul_bunyan/railtie.rb

@@ -0,0 +1,75 @@
+require 'paul_bunyan/rails_ext'
+require 'paul_bunyan/railtie/log_subscriber'
+require 'action_controller/log_subscriber'
+require 'action_view/log_subscriber'
+
+module PaulBunyan
+  class Railtie < ::Rails::Railtie
+    DEFAULT_LOGGERS = [ActionController::LogSubscriber, ActionView::LogSubscriber].freeze
+
+    def self.activesupport_formatter
+      ActiveSupport::Logger::SimpleFormatter.new.tap do |formatter|
+        formatter.extend ActiveSupport::TaggedLogging::Formatter
+      end
+    end
+
+    def self.development_or_test?
+      Rails.env.development? || Rails.env.test?
+    end
+
+    # Set up the config and some defaults
+    config.logging = ActiveSupport::OrderedOptions.new
+    config.logging.override_location = !Rails.env.test?
+    config.logging.formatter = (development_or_test? ? activesupport_formatter : JSONFormatter.new)
+    config.logging.handle_request_logging = !development_or_test?
+
+    # hook our initializer in before the rails logging initializer
+    initializer 'initalize_logger.logging', group: :all, before: :initialize_logger do |app|
+      logging_config = config.logging
+
+      new_logger = PaulBunyan.add_logger(ActiveSupport::Logger.new(log_target(app.config)))
+      new_logger.level = PaulBunyan::Level.coerce_level(ENV['LOG_LEVEL'] || ::Rails.application.config.log_level || 'INFO')
+      new_logger.formatter = logging_config.formatter
+
+      if logging_config.handle_request_logging
+        unsubscribe_default_log_subscribers
+        LogSubscriber.subscribe_to_events
+      end
+
+      Rails.logger = PaulBunyan.logger
+    end
+
+    def conditionally_unsubscribe(listener)
+      delegate = listener.instance_variable_get(:@delegate)
+      ActiveSupport::Notifications.unsubscribe(listener) if DEFAULT_LOGGERS.include?(delegate.class)
+    end
+
+    def file_target(app_config)
+      path = app_config.paths['log'].first
+      path_dir = File.dirname(path)
+      FileUtils.mkdir_p(path_dir) unless File.exist?(path_dir)
+
+      output = File.open(path, 'a')
+      output.binmode
+      output.sync = app_config.autoflush_log
+      output
+    end
+
+    def log_target(app_config)
+      config.logging.override_location ? stream_target : file_target(app_config)
+    end
+
+    def stream_target
+      STDOUT.sync = true
+      STDOUT
+    end
+
+    def unsubscribe_default_log_subscribers
+      LogSubscriber.event_patterns.each do |pattern|
+        ActiveSupport::Notifications.notifier.listeners_for(pattern).each do |listener|
+          conditionally_unsubscribe(listener)
+        end
+      end
+    end
+  end
+end

data/lib/paul_bunyan/railtie/log_subscriber.rb

@@ -0,0 +1,182 @@
+require 'set'
+require 'active_support/log_subscriber'
+require 'action_controller/log_subscriber'
+require 'action_view/log_subscriber'
+require 'request_store'
+
+module PaulBunyan
+  INTERNAL_PARAMS = ActionController::LogSubscriber::INTERNAL_PARAMS
+  VIEWS_PATTERN = ActionView::LogSubscriber::VIEWS_PATTERN
+
+  FileTransfer = Struct.new(:path, :transfer_time)
+  RenderedTemplate = Struct.new(:path, :runtime, :layout)
+  RequestAggregator = Struct.new(
+    :method,
+    :controller,
+    :action,
+    :format,
+    :path,
+    :request_id,
+    :ip,
+    :status,
+    :view_runtime,
+    :db_runtime,
+    :params,
+    :halting_filter,
+    :sent_file,
+    :redirect_location,
+    :sent_data,
+    :view,
+    :partials
+  )
+
+  class LogSubscriber < ActiveSupport::LogSubscriber
+
+    @action_controller_events = Set.new
+    @action_view_events = Set.new
+
+    class << self
+      attr_reader :action_controller_events, :action_view_events
+
+      # Register a new event for the the specified namespace this
+      # subscriber should subscribe to.
+      #
+      # @param event_name [Symbol] the name of the event we'll subscribe to
+      %w{controller view}.each do |namespace_part|
+        namespace = "action_#{namespace_part}"
+        define_method "#{namespace}_event" do |event_name|
+          send("#{namespace}_events") << event_name
+        end
+      end
+    end
+
+    # Build an array of event patterns from the action_controller_events
+    # set for use in finding subscriptions we should add and ones we should
+    # remove from the default subscribers
+    def self.event_patterns
+      action_controller_events.map{ |event| "#{event}.action_controller" } +
+        action_view_events.map { |event| "#{event}.action_view" }
+    end
+
+    # Subscribe to the events we've registered using action_controller_event
+    def self.subscribe_to_events(notifier = ActiveSupport::Notifications)
+      subscriber = new
+      notifier   = notifier
+
+      subscribers << subscriber
+
+      event_patterns.each do |pattern|
+        subscriber.patterns << pattern
+        notifier.subscribe(pattern, subscriber)
+      end
+    end
+
+    if Rails.version.start_with?('4.0')
+      attr_reader :patterns
+
+      def initialize
+        super
+        @patterns ||= []
+      end
+    end
+
+    # Handle the start_processing event in the action_controller namespace
+    #
+    # We're only registering for this event so the default
+    # log subscribe gets booted off of it :-)
+    action_controller_event def start_processing(event)
+      return
+    end
+
+    # Handle the process_action event in the action_controller namespace
+    #
+    # We're using this to capture the vast majority of our info that goes into
+    # the log line
+    #
+    # @param event [ActiveSupport::Notifications::Event]
+    ACTION_PAYLOAD_KEYS = [:method, :controller, :action, :format, :path, :request_id, :ip, :status, :view_runtime, :db_runtime]
+    action_controller_event def process_action(event)
+      payload = event.payload
+      ACTION_PAYLOAD_KEYS.each do |attr|
+        aggregator[attr] = payload[attr]
+      end
+      aggregator.params = payload[:params].except(*INTERNAL_PARAMS)
+
+      logger.info { aggregator_without_nils }
+    end
+
+    action_controller_event def halted_callback(event)
+      aggregator.halting_filter = event.payload[:filter].inspect
+    end
+
+    action_controller_event def send_file(event)
+      payload = event.payload
+      aggregator.sent_file = FileTransfer.new(payload[:path], event.duration)
+    end
+
+    action_controller_event def redirect_to(event)
+      aggregator.redirect_location = event.payload[:location]
+    end
+
+    action_controller_event def send_data(event)
+      payload = event.payload
+      aggregator.sent_data = FileTransfer.new(payload[:filename], event.duration)
+    end
+
+    action_view_event def render_template(event)
+      aggregator.view = extract_render_data_from(event)
+     end
+
+    action_view_event def render_partial(event)
+      aggregator.partials ||= []
+      aggregator.partials << extract_render_data_from(event)
+    end
+    alias :render_collection :render_partial
+    action_view_event :render_collection
+
+    def logger
+      PaulBunyan.logger
+    end
+
+    private
+
+    def aggregator
+      RequestStore[:logging_request_aggregator] ||= RequestAggregator.new
+    end
+
+    def aggregator_without_nils
+      struct_without_nils(aggregator).inject({}) { |data, (key, value)|
+        if Struct === value
+          new_data = {key => struct_without_nils(value)}
+        elsif Array === value
+          new_data = {key => value.map{ |v| struct_without_nils(v) }}
+        else
+          new_data = {key => value}
+        end
+        data.merge(new_data)
+      }
+    end
+
+    def clean_view_path(path)
+      return nil if path.nil?
+      path.sub(rails_root, '').sub(VIEWS_PATTERN, '')
+    end
+
+    def extract_render_data_from(event)
+      payload = event.payload
+      RenderedTemplate.new(
+        clean_view_path(payload[:identifier]),
+        event.duration,
+        clean_view_path(payload[:layout])
+      )
+    end
+
+    def rails_root
+      @rails_root ||= "#{Rails.root}/"
+    end
+
+    def struct_without_nils(struct)
+      struct.to_h.reject{ |_, value| value.nil? }
+    end
+  end
+end