logging-rails-kiriyenko 0.4.0

data/History.txt

@@ -0,0 +1,18 @@
+== 0.3.0 / 2011-09-19
+
+Enhancements
+- Appending default "log_to" destinations to the configuration files
+- Remove the LogTail middleware if present
+- Removing the Rails version check
+
+== 0.2.0 / 2011-09-16
+
+Enhancements
+- Using the ActionMailer smtp settings
+- Sanity checks for Rails and Rails.version
+- Handling difference in "config.paths" between Rails 3.0 and Rails 3.1
+
+== 0.1.0 / 2011-09-16
+
+Enhancements
+- Birthday!

data/README.md

@@ -0,0 +1,122 @@
+logging-rails
+=============
+
+A Railtie for for integrating the [Logging](https://github.com/TwP/logging)
+framework into your Rails 3 application.
+
+Features
+--------
+
+The railtie provides only one feature - integration of the **Logging**
+framework into your Rails appcliation. But this gives you quite a bit of
+flexibility to format your log messages and direct them to multiple logging
+destiations: stdout with colors, a rolling log file, email, or even get a
+growl notification.
+
+Install
+-------
+
+Add the ```logging-rails``` railtie gem to your Rails project's Gemfile and run ```bundle install```.
+
+```ruby
+gem 'logging-rails', :require => 'logging/rails'
+````
+
+A generator is included with the railtie that will create a ```config/logging.rb```
+configuration file for use in your Rails project. Please run this generator
+before attempting to use the **Logging** framework.
+
+```
+rails generate logging:install
+```
+
+Usage
+-----
+
+Out of the box, the **Logging** framework is configured to behave in the same
+way as the standard Rails logger setup. The major exception is that the log
+file will be rolled daily - gone are the days of 2GB log files on production
+servers.
+
+The railtie adds a configuration option, ```log_to```, that determines where
+log messages will be sent. This is an array of appender names (an appender
+writes log messages to some destination such as a file, STDOUT, syslog, email,
+etc.). The appender configuration should be set in your environment specific
+configuration file. For example, in production we would want to log to a file
+and send emails on error:
+
+```ruby
+config.log_to = %w[file email]
+```
+
+The **Logging** framework sets the global log level from the ```log_level```
+configuration item. However, each class can be assigned its own log level.
+This is very useful when debugging a single controller or model in your
+Rails application. Consider the example below. The overall log level for the
+application is set to ```:info```, but the log level for the *User* model and
+controller is set to ```:debug```.
+
+```ruby
+config.log_level = :info
+Logging.logger['User'].level = :debug
+Logging.logger['UserController'].level = :debug
+```
+
+When using the logging railtie, a small display of the current logging
+configuration will be displayed when the Rails logger is in the debug mode.
+A description of the display can be found [here](https://github.com/TwP/logging/blob/master/lib/logging.rb#L400).
+
+```
+root  ............................................  *debug      -T
+- <Appenders::Stdout:0x806bc058 name="stdout">
+- <Appenders::RollingFile:0x806bbc0c name="file">
+  ActionController::Base  ........................   debug  +A  -T
+  ActiveRecord::Base  ............................   debug  +A  -T
+  ActiveSupport::Cache::FileStore  ...............   debug  +A  -T
+  ActiveSupport::Dependencies  ...................   debug  +A  -T
+  Logging  .......................................    *off  -A  -T
+  Rails  .........................................   debug  +A  -T
+```
+
+This is useful for understanding more complex logging configurations. It can
+be annoying in day-to-day usage. The soluation is to set the Rails logger to
+```:info``` or higher.
+
+```ruby
+Logging.logger['Rails'].level = :info
+```
+
+Author
+------
+
+Original author: [Elliot Winkler](https://github.com/mcmire)
+
+Contributors:
+
+* [Tim Pease](https://github.com/TwP)
+
+License
+-------
+
+The MIT License
+
+Copyright © 2011 by Tim Pease
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+*Software*), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'gem'
+
+Bones {
+  name     'logging-rails-kiriyenko'
+  authors  'Tim Pease, Dmitriy Kiriyenko'
+  email    'dmitriy.kiriyenko@gmail.com'
+  url      'http://rubygems.org/gems/logging-rails-kiriyenko'
+
+  use_gmail
+
+  depend_on 'logging', '~> 1.6.1'
+}
+

data/lib/logging/rails/generators/USAGE

@@ -0,0 +1,12 @@
+Description:
+    Generates the configuration file used by the Logging framework.
+
+Example:
+    rails generate logging:install
+
+    This will create:
+        config/logging.rb
+
+    And it will append "log_to" destinations to:
+        config/environments/development.rb
+        config/environments/production.rb

data/lib/logging/rails/generators/install_generator.rb

@@ -0,0 +1,20 @@
+
+module Logging::Rails
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      namespace 'logging:install'
+      source_root File.expand_path('../templates', __FILE__)
+
+      def generate_config
+        template 'logging.rb.erb', 'config/logging.rb'
+      end
+
+      def insert_log_to_destinations
+        comment = "\n  # Set the logging destination(s)\n  %s\n"
+        insert_into_file 'config/environments/development.rb', comment % 'config.log_to = %w[stdout file]', :before => %r/^end\s*$/
+        insert_into_file 'config/environments/production.rb', comment % 'config.log_to = %w[file]', :before => %r/^end\s*$/
+      end
+    end
+  end
+end
+

data/lib/logging/rails/generators/templates/logging.rb.erb

@@ -0,0 +1,111 @@
+
+Logging::Rails.configure do |config|
+
+  # Objects will be converted to strings using the :format_as method.
+  Logging.format_as :inspect
+
+  # The default layout used by the appenders.
+  layout = Logging.layouts.pattern(:pattern => '[%d] %-5l %c : %m\n')
+
+  # Setup a color scheme called 'bright' than can be used to add color codes
+  # to the pattern layout. Color schemes should only be used with appenders
+  # that write to STDOUT or STDERR; inserting terminal color codes into a file
+  # is generally considered bad form.
+  #
+  Logging.color_scheme( 'bright',
+    :levels => {
+      :info  => :green,
+      :warn  => :yellow,
+      :error => :red,
+      :fatal => [:white, :on_red]
+    },
+    :date => :blue,
+    :logger => :cyan,
+    :message => :magenta
+  )
+
+  # Configure an appender that will write log events to STDOUT. A colorized
+  # pattern layout is used to format the log events into strings before
+  # writing.
+  #
+  Logging.appenders.stdout( 'stdout',
+    :auto_flushing => true,
+    :layout => Logging.layouts.pattern(
+      :pattern => '[%d] %-5l %c : %m\n',
+      :color_scheme => 'bright'
+    )
+  ) if config.log_to.include? 'stdout'
+
+  # Configure an appender that will write log events to a file. The file will
+  # be rolled on a daily basis, and the past 7 rolled files will be kept.
+  # Older files will be deleted. The default pattern layout is used when
+  # formatting log events into strings.
+  #
+  Logging.appenders.rolling_file( 'file',
+    :filename => config.paths<%= Rails.version < "3.1" ? ".log" : "['log']" %>.first,
+    :keep => 7,
+    :age => 'daily',
+    :truncate => false,
+    :auto_flushing => true,
+    :layout => layout
+  ) if config.log_to.include? 'file'
+
+  # Configure an appender that will send an email for "error" and "fatal" log
+  # events. All other log events will be ignored. Furthermore, log events will
+  # be buffered for one minute (or 200 events) before an email is sent. This
+  # is done to prevent a flood of messages.
+  #
+  Logging.appenders.email( 'email',
+    :from     => "server@#{config.action_mailer.smtp_settings[:domain]}",
+    :to       => "developers@#{config.action_mailer.smtp_settings[:domain]}",
+    :subject  => "Rails Error [#{%x(uname -n).strip}]",
+    :server   => config.action_mailer.smtp_settings[:address],
+    :domain   => config.action_mailer.smtp_settings[:domain],
+    :acct     => config.action_mailer.smtp_settings[:user_name],
+    :passwd   => config.action_mailer.smtp_settings[:password],
+    :authtype => config.action_mailer.smtp_settings[:authentication],
+
+    :auto_flushing => 200,     # send an email after 200 messages have been buffered
+    :flush_period  => 60,      # send an email after one minute
+    :level         => :error,  # only process log events that are "error" or "fatal"
+    :layout        => layout
+  ) if config.log_to.include? 'email'
+
+  # Setup the root logger with the Rails log level and the desired set of
+  # appenders. The list of appenders to use should be set in the environment
+  # specific configuration file.
+  #
+  # For example, in a production application you would not want to log to
+  # STDOUT, but you would want to send an email for "error" and "fatal"
+  # messages:
+  #
+  # => config/environments/production.rb
+  #
+  #     config.log_to = %w[file email]
+  #
+  # In development you would want to log to STDOUT and possibly to a file:
+  #
+  # => config/environments/development.rb
+  #
+  #     config.log_to = %w[stdout file]
+  #
+  Logging.logger.root.level = config.log_level
+  Logging.logger.root.appenders = config.log_to unless config.log_to.empty?
+
+  # Under Phusion Passenger smart spawning, we need to reopen all IO streams
+  # after workers have forked.
+  #
+  # The rolling file appender uses shared file locks to ensure that only one
+  # process will roll the log file. Each process writing to the file must have
+  # its own open file descriptor for `flock` to function properly. Reopening
+  # the file descriptors after forking ensures that each worker has a unique
+  # file descriptor.
+  #
+  if defined?(PhusionPassenger)
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+      Logging.reopen if forked
+    end
+  end
+
+end
+

data/lib/logging/rails/mixin.rb

@@ -0,0 +1,42 @@
+
+module Logging::Rails
+
+  # Include this module into your ApplicationController to provide
+  # per-controller log level configurability. You can also include this module
+  # into your models or anywhere else you would like to control the log level.
+  #
+  # Alternatively, you can use the `include Logging.globally` trick to add a
+  # `logger` method to every Object in the ruby interpreter. See
+  # https://github.com/TwP/logging/blob/master/lib/logging.rb#L214 for more
+  # details.
+  #
+  module Mixin
+
+    LOGGER_METHOD = RUBY_VERSION < '1.9' ? 'logger' : :logger
+
+    # This method is called when the module is included into a class. It will
+    # extend the including class so it also has a class-level `logger` method.
+    #
+    def self.included( other )
+      other.__send__(:remove_method, LOGGER_METHOD.to_sym) if other.instance_methods.include? LOGGER_METHOD
+      other.extend self
+    end
+
+    # This method is called when the modules is extended into another class or
+    # module. It will remove any existing `logger` method and insert its own
+    # version.
+    #
+    def self.extended( other )
+      eigenclass = class << other; self; end
+      eigenclass.__send__(:remove_method, LOGGER_METHOD.to_sym) if eigenclass.instance_methods.include? LOGGER_METHOD
+    end
+
+    # Returns the logger instance.
+    #
+    def logger
+      @logger ||= ::Logging::Logger[self]
+    end
+  end  # Mixin
+
+end  # Logging::Rails
+

data/lib/logging/rails/railtie.rb

@@ -0,0 +1,53 @@
+
+module Logging::Rails
+
+  # The Railtie is used to inject the Logging framework into the Rails
+  # application.
+  #
+  class Railtie < ::Rails::Railtie
+
+    generators do
+      require File.expand_path('../generators/install_generator', __FILE__)
+    end
+
+    config.before_configuration do
+      config.log_to = %w[file]
+    end
+
+    initializer 'logging.configure', :before => 'initialize_logger' do |app|
+      file = ::Rails.root.join('config/logging.rb')
+      load file if File.exists? file
+      ::Logging::Rails.configuration.call app.config if ::Logging::Rails.configuration
+    end
+
+    initializer 'logging.initialize', :before => 'initialize_logger' do
+      ::Rails.logger = ::Logging::Logger[::Rails]
+    end
+
+    initializer 'logging.active_record.logger', :before => 'active_record.logger' do
+      ActiveSupport.on_load(:active_record) { self.__send__(:include, ::Logging::Rails::Mixin) }
+    end
+
+    initializer 'logging.action_controller.logger', :before => 'action_controller.logger' do
+      ActiveSupport.on_load(:action_controller) { self.__send__(:include, ::Logging::Rails::Mixin) }
+    end
+
+    initializer 'logging.action_mailer.logger', :before => 'action_mailer.logger' do
+      ActiveSupport.on_load(:action_mailer) { self.__send__(:include, ::Logging::Rails::Mixin) }
+    end
+
+    initializer 'logging.active_support.dependencies.logger' do
+      ActiveSupport::Dependencies.logger = ::Logging::Logger[ActiveSupport::Dependencies]
+    end
+
+    initializer 'logging.initialize_cache', :after => 'initialize_cache' do
+      ::Rails.cache.logger = ::Logging::Logger[::Rails.cache]
+    end
+
+    config.after_initialize do
+      ::Logging.show_configuration if ::Logging::Logger[::Rails].debug?
+    end
+
+  end  # Railtie
+end  # Logging::Rails
+

data/lib/logging/rails.rb

@@ -0,0 +1,90 @@
+
+require 'logging'
+
+require 'rails' if !defined? Rails or Rails.version
+
+if Rails.version < '3'
+  abort("The Logging Railtie only works with Rails 3 or higher - you are running Rails #{Rails.version}")
+end
+
+module Logging::Rails
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path('../..', __FILE__) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  class << self
+    # Returns the version string for the library.
+    #
+    def version
+      @version ||= File.read(path('version.txt')).strip
+    end
+
+    # Stores the given Logging configuration block for later evalution by the
+    # Railtie. This method is used in the 'config/logging.rb' configuration
+    # file.
+    #
+    def configure( &block )
+      @configuration = block
+    end
+
+    attr_reader :configuration
+
+    # Returns the path for Mr Bones. If any arguments are given,
+    # they will be joined to the end of the path using <tt>File.join</tt>.
+    #
+    def path( *args )
+      rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+      if block_given?
+        begin
+          $LOAD_PATH.unshift PATH
+          rv = yield
+        ensure
+          $LOAD_PATH.shift
+        end
+      end
+      return rv
+    end
+
+    # Returns the lib path for Mr Bones. If any arguments are given,
+    # they will be joined to the end of the path using <tt>File.join</tt>.
+    #
+    def libpath( *args )
+      rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+      if block_given?
+        begin
+          $LOAD_PATH.unshift LIBPATH
+          rv = yield
+        ensure
+          $LOAD_PATH.shift
+        end
+      end
+      return rv
+    end
+  end
+
+  libpath {
+    require 'logging/rails/railtie'
+    require 'logging/rails/mixin'
+  }
+
+end  # Logging::Rails
+
+
+# Here we need to remove the Rails LogTailer from the list of middlewares. The
+# Logging framework is fully capable of sending log events to multiple logging
+# destinations.
+#
+module Rails
+  class Server < ::Rack::Server
+    def middleware_without_log_tailer
+      middlewares = middleware_with_log_tailer['anything']
+      middlewares.delete_if { |middleware| Rails::Rack::LogTailer == middleware.first }
+      Hash.new(middlewares)
+    end
+    alias :middleware_with_log_tailer :middleware
+    alias :middleware :middleware_without_log_tailer
+  end
+end
+

data/lib/logging-rails.rb

@@ -0,0 +1 @@
+require File.expand_path('../logging/rails.rb', __FILE__)

data/version.txt

@@ -0,0 +1 @@
+0.3.0

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: logging-rails-kiriyenko
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- Tim Pease, Dmitriy Kiriyenko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-13 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: logging
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 3
+        - 7
+        - 3
+        version: 3.7.3
+  type: :development
+  version_requirements: *id002
+description: |-
+  A Railtie for for integrating the [Logging](https://github.com/TwP/logging)
+  framework into your Rails 3 application.
+email: dmitriy.kiriyenko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- lib/logging/rails/generators/USAGE
+- lib/logging/rails/generators/templates/logging.rb.erb
+files: 
+- History.txt
+- README.md
+- Rakefile
+- lib/logging-rails.rb
+- lib/logging/rails.rb
+- lib/logging/rails/generators/USAGE
+- lib/logging/rails/generators/install_generator.rb
+- lib/logging/rails/generators/templates/logging.rb.erb
+- lib/logging/rails/mixin.rb
+- lib/logging/rails/railtie.rb
+- version.txt
+has_rdoc: true
+homepage: http://rubygems.org/gems/logging-rails-kiriyenko
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: logging-rails-kiriyenko
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A Railtie for for integrating the [Logging](https://github.
+test_files: []
+