lograge-with-time 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac5cfd309efdd6412c63cc4295d0ba9117eb9c65
+  data.tar.gz: a80420cf987a1d75c1e8fcb4a070bfc6873bd9eb
+SHA512:
+  metadata.gz: 4936ec0831533e52689c7d0ede3e586da8da4da5cb9d3dd4fc38fd5e952aae8685cf379e0423a091084e05ed1cf0157a1b74dbd9a493a773f107798a67156721
+  data.tar.gz: 2b52005718728e6d3f6ac9c5fbe9bd304342f033f80ea359d725eb401bcc978c97358da74e8b044efddba5939d4df6978f9eed6da58ea4b6cab4e7ef2fdbe4bb

data/lib/lograge.rb

@@ -0,0 +1,149 @@
+require 'lograge/version'
+require 'lograge/formatters/cee'
+require 'lograge/formatters/json'
+require 'lograge/formatters/graylog2'
+require 'lograge/formatters/key_value'
+require 'lograge/formatters/l2met'
+require 'lograge/formatters/lines'
+require 'lograge/formatters/logstash'
+require 'lograge/formatters/raw'
+require 'lograge/log_subscriber'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/ordered_options'
+
+module Lograge
+  module_function
+
+  mattr_accessor :logger, :application, :ignore_tests
+
+  # Custom options that will be appended to log line
+  #
+  # Currently supported formats are:
+  #  - Hash
+  #  - Any object that responds to call and returns a hash
+  #
+  mattr_writer :custom_options
+  self.custom_options = nil
+
+  def self.custom_options(event)
+    if @@custom_options.respond_to?(:call)
+      @@custom_options.call(event)
+    else
+      @@custom_options
+    end
+  end
+
+  # Before format allows you to change the structure of the output.
+  # You've to pass in something callable
+  #
+  mattr_writer :before_format
+  self.before_format = nil
+
+  def self.before_format(data, payload)
+    result = nil
+    result = @@before_format.call(data, payload) if @@before_format
+    result || data
+  end
+
+  # Set conditions for events that should be ignored
+  #
+  # Currently supported formats are:
+  #  - A single string representing a controller action, e.g. 'users#sign_in'
+  #  - An array of strings representing controller actions
+  #  - An object that responds to call with an event argument and returns
+  #    true iff the event should be ignored.
+  #
+  # The action ignores are given to 'ignore_actions'. The callable ignores
+  # are given to 'ignore'.  Both methods can be called multiple times, which
+  # just adds more ignore conditions to a list that is checked before logging.
+
+  def self.ignore_actions(actions)
+    ignore(lambda do |event|
+             params = event.payload[:params]
+             Array(actions).include?("#{params['controller']}##{params['action']}")
+           end)
+  end
+
+  def ignore_tests
+    @ignore_tests ||= []
+  end
+
+  def self.ignore(test)
+    ignore_tests.push(test) if test
+  end
+
+  def ignore_nothing
+    @ignore_tests = []
+  end
+
+  def self.ignore?(event)
+    ignore_tests.any? { |ignore_test| ignore_test.call(event) }
+  end
+
+  # Loglines are emitted with this log level
+  mattr_accessor :log_level
+  self.log_level = :info
+
+  # The emitted log format
+  #
+  # Currently supported formats are>
+  #  - :lograge - The custom tense lograge format
+  #  - :logstash - JSON formatted as a Logstash Event.
+  mattr_accessor :formatter
+
+  def self.remove_existing_log_subscriptions
+    ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+      case subscriber
+      when ActionView::LogSubscriber
+        unsubscribe(:action_view, subscriber)
+      when ActionController::LogSubscriber
+        unsubscribe(:action_controller, subscriber)
+      end
+    end
+  end
+
+  def self.unsubscribe(component, subscriber)
+    events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+    events.each do |event|
+      ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
+        if listener.instance_variable_get('@delegate') == subscriber
+          ActiveSupport::Notifications.unsubscribe listener
+        end
+      end
+    end
+  end
+
+  def self.setup(app)
+    self.application = app
+    app.config.action_dispatch.rack_cache[:verbose] = false if app.config.action_dispatch.rack_cache
+    require 'lograge/rails_ext/rack/logger'
+    Lograge.remove_existing_log_subscriptions
+    Lograge::RequestLogSubscriber.attach_to :action_controller
+    Lograge.custom_options = lograge_config.custom_options
+    Lograge.before_format = lograge_config.before_format
+    Lograge.log_level = lograge_config.log_level || :info
+    support_deprecated_config # TODO: Remove with version 1.0
+    Lograge.formatter = lograge_config.formatter || Lograge::Formatters::KeyValue.new
+    Lograge.ignore_actions(lograge_config.ignore_actions)
+    Lograge.ignore(lograge_config.ignore_custom)
+  end
+
+  # TODO: Remove with version 1.0
+
+  def support_deprecated_config
+    return unless lograge_config.log_format
+
+    legacy_log_format = lograge_config.log_format
+    warning = 'config.lograge.log_format is deprecated. Use config.lograge.formatter instead.'
+    ActiveSupport::Deprecation.warn(warning, caller)
+    legacy_log_format = :key_value if legacy_log_format == :lograge
+    lograge_config.formatter = "Lograge::Formatters::#{legacy_log_format.to_s.classify}".constantize.new
+  end
+
+  def lograge_config
+    application.config.lograge
+  end
+end
+
+require 'lograge/railtie' if defined?(Rails)

data/lib/lograge/formatters/cee.rb

@@ -0,0 +1,9 @@
+module Lograge
+  module Formatters
+    class Cee
+      def call(data)
+        "@cee: #{JSON.dump(data)}"
+      end
+    end
+  end
+end

data/lib/lograge/formatters/graylog2.rb

@@ -0,0 +1,30 @@
+module Lograge
+  module Formatters
+    class Graylog2
+      def call(data)
+        # Cloning because we don't want to mess with the original when mutating keys.
+        data_clone = data.clone
+
+        base = {
+          short_message: short_message(data_clone)
+        }
+
+        # Add underscore to every key to follow GELF additional field syntax.
+        data_clone.keys.each do |key|
+          data_clone[underscore_prefix(key)] = data_clone[key]
+          data_clone.delete(key)
+        end
+
+        data_clone.merge(base)
+      end
+
+      def underscore_prefix(key)
+        "_#{key}".to_sym
+      end
+
+      def short_message(data)
+        "[#{data[:status]}] #{data[:method]} #{data[:path]} (#{data[:controller]}##{data[:action]})"
+      end
+    end
+  end
+end

data/lib/lograge/formatters/json.rb

@@ -0,0 +1,10 @@
+require 'json'
+module Lograge
+  module Formatters
+    class Json
+      def call(data)
+        ::JSON.dump(data)
+      end
+    end
+  end
+end

data/lib/lograge/formatters/key_value.rb

@@ -0,0 +1,38 @@
+module Lograge
+  module Formatters
+    class KeyValue
+      LOGRAGE_FIELDS = [
+        :time, :method, :path, :format, :controller, :action, :status, :error,
+        :duration, :view, :db, :location
+      ]
+
+      def call(data)
+        fields = fields_to_display(data)
+
+        event = fields.reduce([]) do |message, key|
+          next message unless data.key?(key)
+
+          message << format(key, data[key])
+          message
+        end
+        event.join(' ')
+      end
+
+      def fields_to_display(data)
+        LOGRAGE_FIELDS + (data.keys - LOGRAGE_FIELDS)
+      end
+
+      def format(key, value)
+        # Exactly preserve the previous output
+        # Parsing this can be ambigious if the error messages contains
+        # a single quote
+        value = "'#{value}'" if key == :error
+
+        # Ensure that we always have exactly two decimals
+        value = Kernel.format('%.2f', value) if value.is_a? Float
+
+        "#{key}=#{value}"
+      end
+    end
+  end
+end

data/lib/lograge/formatters/l2met.rb

@@ -0,0 +1,36 @@
+require 'lograge/formatters/key_value'
+
+module Lograge
+  module Formatters
+    class L2met < KeyValue
+      L2MET_FIELDS = [
+        :method, :path, :format, :source, :status, :error,
+        :duration, :view, :db, :location
+      ]
+
+      def call(data)
+        super(modify_payload(data))
+      end
+
+      def format(key, value)
+        key = "measure#page.#{key}" if value.is_a?(Float)
+
+        super(key, value)
+      end
+
+      def fields_to_display(data)
+        L2MET_FIELDS + (data.keys - L2MET_FIELDS) - [:controller, :action]
+      end
+
+      def modify_payload(data)
+        data[:source] = source_field(data) if data[:controller] && data[:action]
+
+        data
+      end
+
+      def source_field(data)
+        "#{data[:controller].to_s.gsub('/', '-')}:#{data[:action]}"
+      end
+    end
+  end
+end

data/lib/lograge/formatters/lines.rb

@@ -0,0 +1,18 @@
+module Lograge
+  module Formatters
+    class Lines
+      def call(data)
+        load_dependencies
+
+        ::Lines.dump(data)
+      end
+
+      def load_dependencies
+        require 'lines'
+      rescue LoadError
+        puts 'You need to install the lines gem to use this output.'
+        raise
+      end
+    end
+  end
+end

data/lib/lograge/formatters/logstash.rb

@@ -0,0 +1,20 @@
+module Lograge
+  module Formatters
+    class Logstash
+      def call(data)
+        load_dependencies
+        event = LogStash::Event.new(data)
+
+        event.message = "[#{data[:status]}] #{data[:method]} #{data[:path]} (#{data[:controller]}##{data[:action]})"
+        event.to_json
+      end
+
+      def load_dependencies
+        require 'logstash-event'
+      rescue LoadError
+        puts 'You need to install the logstash-event gem to use the logstash output.'
+        raise
+      end
+    end
+  end
+end

data/lib/lograge/formatters/raw.rb

@@ -0,0 +1,9 @@
+module Lograge
+  module Formatters
+    class Raw
+      def call(data)
+        data
+      end
+    end
+  end
+end

data/lib/lograge/log_subscriber.rb

@@ -0,0 +1,104 @@
+require 'json'
+
+require 'active_support/core_ext/class/attribute'
+require 'active_support/log_subscriber'
+
+module Lograge
+  class RequestLogSubscriber < ActiveSupport::LogSubscriber
+    def process_action(event)
+      return if Lograge.ignore?(event)
+
+      payload = event.payload
+
+      data      = extract_time(event)
+      data.merge! extract_request(payload)
+      data.merge! extract_status(payload)
+      data.merge! runtimes(event)
+      data.merge! location(event)
+      data.merge! custom_options(event)
+
+      data = before_format(data, payload)
+      formatted_message = Lograge.formatter.call(data)
+      logger.send(Lograge.log_level, formatted_message)
+    end
+
+    def redirect_to(event)
+      Thread.current[:lograge_location] = event.payload[:location]
+    end
+
+    def logger
+      Lograge.logger.presence || super
+    end
+
+    private
+    
+    def extract_time(event)
+      {
+        time: event.time
+      }
+    end
+
+    def extract_request(payload)
+      {
+        method: payload[:method],
+        path: extract_path(payload),
+        format: extract_format(payload),
+        controller: payload[:params]['controller'],
+        action: payload[:params]['action']
+      }
+    end
+
+    def extract_path(payload)
+      payload[:path].split('?').first
+    end
+
+    def extract_format(payload)
+      if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0
+        payload[:formats].first
+      else
+        payload[:format]
+      end
+    end
+
+    def extract_status(payload)
+      if payload[:status]
+        { status: payload[:status].to_i }
+      elsif payload[:exception]
+        exception, message = payload[:exception]
+        { status: 500, error: "#{exception}:#{message}" }
+      else
+        { status: 0 }
+      end
+    end
+
+    def custom_options(event)
+      Lograge.custom_options(event) || {}
+    end
+
+    def before_format(data, payload)
+      Lograge.before_format(data, payload)
+    end
+
+    def runtimes(event)
+      {
+        duration: event.duration,
+        view: event.payload[:view_runtime],
+        db: event.payload[:db_runtime]
+      }.reduce({}) do |runtimes, (name, runtime)|
+        runtimes[name] = runtime.to_f.round(2) if runtime
+        runtimes
+      end
+    end
+
+    def location(_event)
+      location = Thread.current[:lograge_location]
+
+      if location
+        Thread.current[:lograge_location] = nil
+        { location: location }
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/lograge/rails_ext/rack/logger.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    # Overwrites defaults of Rails::Rack::Logger that cause
+    # unnecessary logging.
+    # This effectively removes the log lines from the log
+    # that say:
+    # Started GET / for 192.168.2.1...
+    class Logger
+      # Overwrites Rails 3.2 code that logs new requests
+      def call_app(*args)
+        env = args.last
+        @app.call(env)
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      # Overwrites Rails 3.0/3.1 code that logs new requests
+      def before_dispatch(_env)
+      end
+    end
+  end
+end

data/lib/lograge/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails/railtie'
+require 'action_view/log_subscriber'
+require 'action_controller/log_subscriber'
+
+module Lograge
+  class Railtie < Rails::Railtie
+    config.lograge = ActiveSupport::OrderedOptions.new
+    config.lograge.enabled = false
+
+    initializer :lograge do |app|
+      Lograge.setup(app) if app.config.lograge.enabled
+    end
+  end
+end

data/lib/lograge/version.rb

@@ -0,0 +1,3 @@
+module Lograge
+  VERSION = '0.4.0'
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: lograge-with-time
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Mathias Meyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Tame Rails' multi-line logging into a single line per request
+email:
+- meyer@paperplanes.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lograge.rb
+- lib/lograge/formatters/cee.rb
+- lib/lograge/formatters/graylog2.rb
+- lib/lograge/formatters/json.rb
+- lib/lograge/formatters/key_value.rb
+- lib/lograge/formatters/l2met.rb
+- lib/lograge/formatters/lines.rb
+- lib/lograge/formatters/logstash.rb
+- lib/lograge/formatters/raw.rb
+- lib/lograge/log_subscriber.rb
+- lib/lograge/rails_ext/rack/logger.rb
+- lib/lograge/railtie.rb
+- lib/lograge/version.rb
+homepage: https://github.com/roidrage/lograge
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Tame Rails' multi-line logging into a single line per request
+test_files: []