logged 0.0.1

data/lib/logged/logger.rb

@@ -0,0 +1,109 @@
+require 'logger'
+require 'logged/tagged_logging'
+
+module Logged
+  # Logger wrapping a component
+  class Logger
+    include TaggedLogging
+
+    attr_reader :loggers, :component
+
+    def initialize(loggers, component, formatter)
+      @loggers   = loggers
+      @component = component
+      @formatter = formatter
+    end
+
+    def add(severity, message = nil, progname = nil)
+      message = yield    if block_given? && message.blank?
+      message = progname if message.blank?
+
+      data, event = extract_data_and_event(message)
+
+      return if data.blank?
+
+      level = Logged.level_to_sym(severity)
+
+      @loggers.each do |logger, options|
+        next unless logger.send("#{level}?")
+
+        add_to_logger(level, event, data, logger, options)
+      end
+    end
+    alias_method :log, :add
+
+    %w(info debug warn error fatal unknown).each do |level|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{level}?
+          @loggers.keys.any? { |l| l.#{level}? }
+        end
+
+        def #{level}(progname = nil, &block)
+          add(::Logger::#{level.upcase}, nil, progname, &block)
+        end
+      METHOD
+    end
+
+    def close
+      @loggers.keys.each do |logger|
+        logger.close if logger.respond_to?(:close)
+      end
+    end
+
+    def datetime_format; end
+
+    def datetime_format=(_format); end
+
+    def <<(_msg); end
+
+    private
+
+    def prepare_data(event, data, options)
+      config = Logged.config[component].loggers[options[:name]]
+
+      return nil if Logged.ignore?(config, event)
+
+      Logged.custom_data(config, event, data)
+    end
+
+    def add_to_logger(level, event, data, logger, options)
+      data = prepare_data(event, data, options)
+
+      return if data.blank?
+
+      formatter = options[:formatter] || @formatter
+
+      msg = formatter.call(data)
+
+      return if msg.blank?
+
+      log_data(logger, level, msg)
+    end
+
+    def log_data(logger, level, msg)
+      if logger.respond_to?(:tagged)
+        logger.tagged(*current_tags) do
+          logger.send(level, msg)
+        end
+      else
+        logger.send(level, msg)
+      end
+    end
+
+    def extract_data_and_event(message)
+      return if message.blank?
+
+      message = { message: message } if message.is_a?(String)
+
+      event = message.delete('@event')
+
+      message = Logged.custom_data(Logged.config, event, message)
+      return [nil, nil] if message.blank?
+
+      message = Logged.custom_data(Logged.config[component], event, message)
+      return [nil, nil] if message.blank?
+
+      [message, event]
+    end
+  end
+end

data/lib/logged/rack/logger.rb

@@ -0,0 +1,73 @@
+require 'action_dispatch/http/request'
+
+module Logged
+  module Rack
+    # Handle tagged logging much like Rails::Rack::Logger
+    class Logger
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Thread.current[:logged_request_env] = env
+
+        request = ActionDispatch::Request.new(env)
+
+        loggers = Logged.components.map { |c| Logged.logger_by_component(c) }.compact.uniq
+
+        if loggers.length > 0
+          loggers_tagged(loggers, request) { @app.call(env) }
+        else
+          @app.call(env)
+        end
+      ensure
+        Thread.current[:logged_request_env] = nil
+      end
+
+      private
+
+      def loggers_tagged(loggers, request, &block)
+        logger = loggers.shift
+        tags   = tags_for_component(logger.component, request)
+
+        if loggers.length > 0
+          tagged_block(logger, tags) { loggers_tagged(loggers, request, &block) }
+        else
+          tagged_block(logger, tags) { block.call }
+        end
+      end
+
+      def tagged_block(logger, tags, &block)
+        if logger.respond_to?(:tagged)
+          logger.tagged(*tags, &block)
+        else
+          dummy_tagged(&block)
+        end
+      end
+
+      def dummy_tagged
+        yield
+      end
+
+      def tags_for_component(component, request)
+        tags  = Logged.config.tags || []
+        tags += Logged.config[component].tags || []
+
+        compute_tags(tags, request)
+      end
+
+      def compute_tags(tags, request)
+        tags.map do |tag|
+          case tag
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logged/railtie.rb

@@ -0,0 +1,13 @@
+require 'rails/railtie'
+require 'logged/configuration'
+
+module Logged
+  # Railtie for logged
+  class Railtie < Rails::Railtie
+    config.logged = Configuration.new
+
+    initializer :logged do |app|
+      Logged.setup(app) if app.config.logged.enabled
+    end
+  end
+end

data/lib/logged/tagged_logging.rb

@@ -0,0 +1,30 @@
+module Logged
+  # Tagged logging support
+  module TaggedLogging
+    def tagged(*tags)
+      new_tags = push_tags(*tags)
+
+      yield self
+    ensure
+      pop_tags(new_tags.size)
+    end
+
+    def flush
+      current_tags.clear
+    end
+
+    def push_tags(*tags)
+      tags.flatten.reject(&:blank?).tap do |new_tags|
+        current_tags.concat(new_tags)
+      end
+    end
+
+    def pop_tags(size = 1)
+      current_tags.pop(size)
+    end
+
+    def current_tags
+      Thread.current["logged_logger_tags_#{component}"] ||= []
+    end
+  end
+end

data/lib/logged/version.rb

@@ -0,0 +1,4 @@
+module Logged
+  # Version
+  VERSION = '0.0.1'
+end

data/lib/logged.rb

@@ -0,0 +1,220 @@
+require 'logged/version'
+require 'logged/level_conversion'
+require 'logged/logger'
+require 'logged/formatter/raw'
+require 'logged/formatter/key_value'
+require 'logged/formatter/json'
+require 'logged/formatter/single_key'
+require 'logged/formatter/logstash'
+require 'logged/railtie'
+require 'logged/rack/logger'
+
+# logged
+module Logged
+  extend Logged::LevelConversion
+
+  # special keys which not represent a component
+  CONFIG_KEYS = Configuration::DEFAULT_VALUES.keys + %i( loggers disable_rails_logging )
+
+  mattr_accessor :app, :config
+
+  # setup logged
+  def self.setup(app)
+    self.app    = app
+    self.config = app.config.logged
+
+    app.config.middleware.insert_after ::Rails::Rack::Logger, Logged::Rack::Logger
+
+    components.each do |component|
+      remove_rails_subscriber(component) if config[component].disable_rails_logging
+
+      next unless config[component].enabled
+
+      enable_component(component)
+    end
+  end
+
+  # default log level
+  def self.default_level
+    config.level || :info
+  end
+
+  # default log formatter
+  def self.default_formatter
+    config.formatter || (@default_formatter ||= Logged::Formatter::KeyValue.new)
+  end
+
+  # logger wrapper for component
+  def self.logger_by_component(component)
+    return nil unless config.enabled
+
+    key = "component_#{component}"
+
+    return @component_loggers[key] if @component_loggers.key?(key)
+
+    loggers = loggers_for(component)
+
+    if loggers.blank?
+      @component_loggers[key] = nil
+
+      return nil
+    end
+
+    formatter = config[component].formatter || default_formatter
+
+    @component_loggers[key] = Logger.new(loggers, component, formatter)
+  end
+
+  # loggers for component
+  def self.loggers_for(component)
+    loggers_from_config(config)
+      .merge(loggers_from_config(config[component]))
+  end
+
+  def self.[](component)
+    loggers_for(component)
+  end
+
+  # loggers from config level
+  def self.loggers_from_config(conf)
+    loggers = {}
+
+    return loggers unless conf.enabled
+
+    conf.loggers.each do |name, c|
+      logger, options = load_logger(name, c)
+
+      next unless logger && options
+
+      loggers[logger] = options
+    end
+
+    loggers
+  end
+
+  # load logger from configuration
+  def self.load_logger(name, conf)
+    return [nil, nil] unless conf.enabled
+
+    options = conf.dup
+    options[:name] = name
+
+    logger = options.delete(:logger)
+
+    logger = Rails.logger if logger == :rails
+
+    return [nil, nil] unless logger
+
+    [logger, options]
+  end
+
+  # configure and enable component
+  def self.enable_component(component)
+    loggers = loggers_for(component)
+
+    loggers.each do |logger, options|
+      level = options[:level] || config[component].level || default_level
+
+      logger.level = level_to_const(level) if logger.respond_to?(:'level=')
+    end
+
+    # only attach subscribers with loggers
+    if loggers.any?
+      @subscribers[component].each do |subscriber|
+        subscriber.attach_to(component)
+      end
+    end
+  end
+
+  # check if event should be ignored
+  def self.ignore?(conf, event)
+    return false unless event
+    return false unless conf.enabled
+
+    if !event.is_a?(String) && conf.ignore.is_a?(Array)
+      return true if conf.ignore.include?(event.name)
+    end
+
+    if conf.custom_ignore.respond_to?(:call)
+      return conf.custom_ignore.call(event)
+    end
+
+    false
+  end
+
+  # run data callbacks
+  def self.custom_data(conf, event, data)
+    return data unless conf.enabled
+    return data unless conf.custom_data.respond_to?(:call)
+
+    conf.custom_data.call(event, data)
+  end
+
+  # configured components
+  def self.components
+    config.keys - CONFIG_KEYS
+  end
+
+  # remove rails log subscriber by component name
+  def self.remove_rails_subscriber(component)
+    subscriber = rails_subscriber(component)
+
+    return unless subscriber
+
+    unsubscribe(component, subscriber)
+  end
+
+  # try to guess and get rails log subscriber by component name
+  def self.rails_subscriber(component)
+    class_name = "::#{component.to_s.camelize}::LogSubscriber"
+
+    return unless Object.const_defined?(class_name)
+
+    clazz = class_name.constantize
+
+    ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+      return subscriber if subscriber.is_a?(clazz)
+    end
+
+    nil
+  end
+
+  # unsubscribe a subscriber from a component
+  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
+
+  # register log subscriber with logged
+  def self.register(component, subscriber)
+    return if @subscribers[component].include?(subscriber)
+
+    @subscribers[component] << subscriber
+  end
+
+  def self.request_env
+    Thread.current[:logged_request_env]
+  end
+
+  private
+
+  def self.init
+    @subscribers ||= Hash.new { |hash, key| hash[key] = [] }
+
+    @component_loggers = {}
+  end
+
+  init
+end
+
+require 'logged/log_subscriber/action_controller' if defined?(ActionController)
+require 'logged/log_subscriber/action_view'       if defined?(ActionView)
+require 'logged/log_subscriber/active_record'     if defined?(ActiveRecord)
+require 'logged/log_subscriber/action_mailer'     if defined?(ActionMailer)

data/logged.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'logged/version'
+
+Gem::Specification.new do |spec|
+  rails_version      = '>= 4.0', '< 5.0'
+
+  spec.name          = 'logged'
+  spec.version       = Logged::VERSION
+  spec.authors       = ['Florian Schwab']
+  spec.email         = ['me@ydkn.de']
+  spec.summary       = %q(Better logging for rails)
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler',      '~> 1.7'
+  spec.add_development_dependency 'rake',         '~> 10.0'
+  spec.add_development_dependency 'rspec',        '~> 3.1'
+  spec.add_development_dependency 'actionpack',   rails_version
+  spec.add_development_dependency 'actionview',   rails_version
+  spec.add_development_dependency 'actionmailer', rails_version
+  spec.add_development_dependency 'activerecord', rails_version
+
+  spec.add_dependency 'railties', rails_version
+end

data/spec/formatter/json_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'logged'
+
+RSpec.describe Logged::Formatter::JSON do
+  subject { described_class.new }
+
+  it 'serializes data' do
+    expect(subject.call(foo: 'bar')).to eq('{"foo":"bar"}')
+  end
+end

data/spec/formatter/key_value_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'logged'
+
+RSpec.describe Logged::Formatter::KeyValue do
+  subject { described_class.new }
+
+  it 'serializes data' do
+    expect(subject.call(foo: 'bar')).to eq("foo='bar'")
+  end
+end

data/spec/formatter/raw_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'logged'
+
+RSpec.describe Logged::Formatter::Raw do
+  subject { described_class.new }
+
+  it 'serializes data' do
+    expect(subject.call(foo: 'bar')).to eq(foo: 'bar')
+  end
+end

data/spec/logged_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'logged'
+require 'active_support/notifications'
+require 'active_support/log_subscriber'
+require 'action_controller/log_subscriber'
+require 'action_view/log_subscriber'
+require 'action_mailer/log_subscriber'
+require 'active_record/log_subscriber'
+
+RSpec.describe Logged do
+  context 'when removing Rails log subscribers' do
+    after do
+      log_subscribers = []
+
+      ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+        events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+        events.each do |event|
+          ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{subscriber.class.to_s.split('::').first.underscore}").each do |listener|
+            delegate = listener.instance_variable_get('@delegate')
+            log_subscribers << subscriber.class if delegate == subscriber
+          end
+        end
+      end
+
+      ActionController::LogSubscriber.attach_to :action_controller unless log_subscribers.include?(ActionController::LogSubscriber)
+      ActionView::LogSubscriber.attach_to :action_view unless log_subscribers.include?(ActionView::LogSubscriber)
+      ActionMailer::LogSubscriber.attach_to :action_mailer unless log_subscribers.include?(ActionMailer::LogSubscriber)
+      ActiveRecord::LogSubscriber.attach_to :active_record unless log_subscribers.include?(ActiveRecord::LogSubscriber)
+    end
+
+    it 'removes subscribers for action_controller events' do
+      expect {
+        Logged.remove_rails_subscriber(:action_controller)
+      }.to change {
+        ActiveSupport::Notifications.notifier.listeners_for('process_action.action_controller')
+      }
+    end
+
+    it 'removes subscribers for action_view events' do
+      expect {
+        Logged.remove_rails_subscriber(:action_view)
+      }.to change {
+        ActiveSupport::Notifications.notifier.listeners_for('render_template.action_view')
+      }
+    end
+
+    it 'removes subscribers for action_mailer events' do
+      expect {
+        Logged.remove_rails_subscriber(:action_mailer)
+      }.to change {
+        ActiveSupport::Notifications.notifier.listeners_for('deliver.action_mailer')
+      }
+    end
+
+    it 'removes subscribers for active_record events' do
+      expect {
+        Logged.remove_rails_subscriber(:active_record)
+      }.to change {
+        ActiveSupport::Notifications.notifier.listeners_for('sql.active_record')
+      }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end