@@ -31,7 +31,7 @@ module Merb subklasses = subclasses.dup until subclasses.empty? bootloader = subclasses.shift - puts "Loading: #{bootloader}" if ENV['DEBUG'] + Merb.logger.debug!("Loading: #{bootloader}")if ENV['DEBUG'] Object.full_const_get(bootloader).run end subclasses = subklasses @@ -382,18 +382,20 @@ class Merb::BootLoader::MixinSessionContainer < Merb::BootLoader Merb.framework_root / "merb-core" / "dispatch" / "session" / "memory", "Using in-memory sessions; sessions will be lost whenever the server stops.") + Merb.register_session_type('memcache', + Merb.framework_root / "merb-core" / "dispatch" / "session" / "memcached", + "Using 'memcached' sessions") + Merb.register_session_type('cookie', # Last session type becomes the default Merb.framework_root / "merb-core" / "dispatch" / "session" / "cookie", "Using 'share-nothing' cookie sessions (4kb limit per client)") - Merb.register_session_type('memcache', # Last session type becomes the default - Merb.framework_root / "merb-core" / "dispatch" / "session" / "memcached", - "Using 'memcached' sessions") + Merb::Controller.class_eval do session_store = Merb::Config[:session_store].to_s if ["", "false", "none"].include?(session_store) - Merb.logger.info "Not Using Sessions" + Merb.logger.warn "Not Using Sessions" elsif reg = Merb.registered_session_types[session_store] if session_store == "cookie" Merb::BootLoader::MixinSessionContainer.check_for_secret_key @@ -401,15 +403,15 @@ class Merb::BootLoader::MixinSessionContainer < Merb::BootLoader end require reg[:file] include ::Merb::SessionMixin - Merb.logger.info reg[:description] + Merb.logger.warn reg[:description] else - Merb.logger.info "Session store not found, '#{Merb::Config[:session_store]}'." - Merb.logger.info "Defaulting to CookieStore Sessions" + Merb.logger.warn "Session store not found, '#{Merb::Config[:session_store]}'." + Merb.logger.warn "Defaulting to CookieStore Sessions" Merb::BootLoader::MixinSessionContainer.check_for_secret_key Merb::BootLoader::MixinSessionContainer.check_for_session_id_key require Merb.registered_session_types['cookie'][:file] include ::Merb::SessionMixin - Merb.logger.info "(plugin not installed?)" + Merb.logger.warn "(plugin not installed?)" end end @@ -427,7 +429,7 @@ class Merb::BootLoader::MixinSessionContainer < Merb::BootLoader # does not exist or is shorter than 16 charaters. def self.check_for_secret_key unless Merb::Config[:session_secret_key] && (Merb::Config[:session_secret_key].length >= 16) - Merb.logger.info("You must specify a session_secret_key in your merb.yml, and it must be at least 16 characters\nbailing out...") + Merb.logger.warn("You must specify a session_secret_key in your merb.yml, and it must be at least 16 characters\nbailing out...") exit! end Merb::Controller._session_secret_key = Merb::Config[:session_secret_key] lib/merb-core/bootloader.rb @@ -25,14 +25,14 @@ module Kernel else gem(name, *ver) if ver require name - Merb.logger.info("loading gem '#{name}' from #{__app_file_trace__.first} ...") + Merb.logger.info!("loading gem '#{name}' from #{__app_file_trace__.first} ...") end rescue LoadError if try_framework try_framework = false retry else - Merb.logger.info("loading gem '#{name}' from #{__app_file_trace__.first} ...") + Merb.logger.info!("loading gem '#{name}' from #{__app_file_trace__.first} ...") # Failed requiring as a gem, let's try loading with a normal require. require name end @@ -292,7 +292,7 @@ module Kernel # Define debugger method so that code even works if debugger was not # requested. Drops a note to the logs that Debugger was not available. def debugger - Merb.logger.info "\n***** Debugger requested, but was not " + + Merb.logger.info! "\n***** Debugger requested, but was not " + "available: Start server with --debugger " + "to enable *****\n" end lib/merb-core/core_ext/kernel.rb @@ -11,7 +11,6 @@ module Merb # ==== Parameters # base<Class>:: The class to which the SessionMixin is mixed into. def setup_session - Merb.logger.info("Setting Up Cookie Store Sessions") request.session = Merb::CookieSession.new(cookies[_session_id_key], _session_secret_key) @original_session = request.session.read_cookie end @@ -19,7 +18,6 @@ module Merb # Finalizes the session by storing the session in a cookie, if the session # has changed. def finalize_session - Merb.logger.info("Finalize Cookie Store Session") new_session = request.session.read_cookie if @original_session != new_session lib/merb-core/dispatch/session/cookie.rb @@ -8,7 +8,6 @@ module Merb # ==== Parameters # base<Class>:: The class to which the SessionMixin is mixed into. def setup_session - Merb.logger.info("Setting up session") before = cookies[_session_id_key] request.session , cookies[_session_id_key] = Merb::MemorySession.persist(cookies[_session_id_key]) @_new_cookie = cookies[_session_id_key] != before @@ -17,7 +16,6 @@ module Merb # Finalizes the session by storing the session ID in a cookie, if the # session has changed. def finalize_session - Merb.logger.info("Finalize session") set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie) end lib/merb-core/dispatch/session/memory.rb @@ -14,6 +14,13 @@ require "time" # httpdate # Merb.logger.info(message<String>,&block) # Merb.logger.debug(message<String>,&block) # +# Logging with autoflush: +# Merb.logger.fatal!(message<String>,&block) +# Merb.logger.error!(message<String>,&block) +# Merb.logger.warn!(message<String>,&block) +# Merb.logger.info!(message<String>,&block) +# Merb.logger.debug!(message<String>,&block) +# # Flush the buffer to # Merb.logger.flush # @@ -130,7 +137,7 @@ module Merb if log_level && Levels[log_level.to_sym] @level = Levels[log_level.to_sym] elsif Merb.environment == "production" - @level = Levels[:error] + @level = Levels[:warn] else @level = Levels[:debug] end @@ -168,10 +175,6 @@ module Merb message = "" message << delimiter message << string if string - if block_given? - message << delimiter - message << yield - end message << "\n" unless message[-1] == ?\n @buffer << message flush if @auto_flush @@ -185,19 +188,33 @@ module Merb class_eval <<-LEVELMETHODS, __FILE__, __LINE__ # Appends a message to the log if the log level is at least as high as - # the log level of the logger. The methods yield to an optional block and - # the output of this block will be appended to the message. + # the log level of the logger. # # ==== Parameters # string<String>:: The message to be logged. Defaults to nil. - # &block:: The output of this block is added to the message. # # ==== Returns - # String:: The resulting message added to the log file. - def #{name}(message = nil, &block) - self.<<(message, &block) if #{number} >= level + # self:: The logger object for chaining. + def #{name}(message = nil) + self << message if #{number} >= level + self end + # Appends a message to the log if the log level is at least as high as + # the log level of the logger. The bang! version of the method also auto + # flushes the log buffer to disk. + # + # ==== Parameters + # string<String>:: The message to be logged. Defaults to nil. + # + # ==== Returns + # self:: The logger object for chaining. + def #{name}!(message = nil) + self << message if #{number} >= level + flush + self + end + # ==== Returns # Boolean:: True if this level will be logged by this logger. def #{name}? lib/merb-core/logger.rb @@ -14,8 +14,7 @@ module Merb # :port<Fixnum>:: The port Thin should bind to. # :app<String>>:: The application name. def self.start(opts={}) - Merb.logger.info("Using Ebb adapter") - Merb.logger.flush + Merb.logger.warn!("Using Ebb adapter") server = ::Ebb::Server.new(opts[:app], opts) server.start end lib/merb-core/rack/adapter/ebb.rb @@ -14,8 +14,7 @@ module Merb # :port<Fixnum>:: The port Mongrel should bind to. # :app<String>>:: The application name. def self.start(opts={}) - Merb.logger.info("Using EventedMongrel adapter: #{opts.inspect}") - Merb.logger.flush + Merb.logger.warn!("Using EventedMongrel adapter") server = ::Mongrel::HttpServer.new(opts[:host], opts[:port].to_i) server.register('/', ::Merb::Rack::Handler::Mongrel.new(opts[:app])) server.run.join lib/merb-core/rack/adapter/evented_mongrel.rb @@ -8,8 +8,7 @@ module Merb # ==== Options (opts) # :app<String>>:: The application name. def self.start(opts={}) - Merb.logger.info("Using FastCGI adapter") - Merb.logger.flush + Merb.logger.warn!("Using FastCGI adapter") Rack::Handler::FastCGI.run(opts[:app]) end end lib/merb-core/rack/adapter/fcgi.rb @@ -15,8 +15,7 @@ module Merb # :port<Fixnum>:: The port Mongrel should bind to. # :app<String>>:: The application name. def self.start(opts={}) - Merb.logger.info("Using Mongrel adapter") - Merb.logger.flush + Merb.logger.warn!("Using Mongrel adapter") server = ::Mongrel::HttpServer.new(opts[:host], opts[:port].to_i) server.register('/', ::Merb::Rack::Handler::Mongrel.new(opts[:app])) server.run.join lib/merb-core/rack/adapter/mongrel.rb @@ -14,8 +14,7 @@ module Merb # :port<Fixnum>:: The port Thin should bind to. # :app<String>>:: The application name. def self.start(opts={}) - Merb.logger.info("Using Thin adapter") - Merb.logger.flush + Merb.logger.warn!("Using Thin adapter") if opts[:host].include?('/') opts[:host] = "#{opts[:host]}-#{opts[:port]}" end lib/merb-core/rack/adapter/thin.rb @@ -14,8 +14,7 @@ module Merb # :port<Fixnum>:: The port WEBrick should bind to. # :app<String>>:: The application name. def self.start(opts={}) - Merb.logger.info("Using Webrick adapter") - Merb.logger.flush + Merb.logger.warn!("Using Webrick adapter") options = { :Port => opts[:port], lib/merb-core/rack/adapter/webrick.rb @@ -50,7 +50,7 @@ module Merb # ==== Returns # Boolean:: True if file exists under the server root and is readable. def file_exist?(path) - full_path = ::File.join(@static_server.root, ::Rack::Utils.unescape(path)) + full_path = ::File.join(@static_server.root, ::Merb::Request.unescape(path)) ::File.file?(full_path) && ::File.readable?(full_path) end lib/merb-core/rack/application.rb @@ -163,7 +163,7 @@ module Merb # ==== Alternatives # If group is left out, the user will be used as the group. def change_privilege(user, group=user) - Merb.logger.info "Changing privileges to #{user}:#{group}" + Merb.logger.warn! "Changing privileges to #{user}:#{group}" uid, gid = Process.euid, Process.egid target_uid = Etc.getpwnam(user).uid lib/merb-core/server.rb @@ -52,7 +52,7 @@ describe "Kernel misc." do end it "should throw a useful error if there's no debugger" do - Merb.logger.should_receive(:info).with "\n***** Debugger requested, but was not " + + Merb.logger.should_receive(:info!).with "\n***** Debugger requested, but was not " + "available: Start server with --debugger " + "to enable *****\n" Kernel.debugger spec/private/core_ext/kernel_spec.rb @@ -47,7 +47,7 @@ describe Merb::Logger do it "should set the log level to :error (6) when Merb.environment is production" do Merb.should_receive(:environment).twice.and_return("production") @logger.set_log(Merb.log_path / "production.log") - @logger.level.should eql(6) + @logger.level.should eql(4) end it "should initialize the buffer to an empty array" do spec/public/logger/logger_spec.rb a90df4f413db9c6377f776b32da67e3b83131880 Ezra Zygmuntowicz ez@engineyard.com http://github.com/wycats/merb-core/commit/d4e533e96774982ff117c82bc209e1245be64a49 d4e533e96774982ff117c82bc209e1245be64a49 2008-03-06T00:04:49-08:00 2008-03-06T00:04:49-08:00 update the logger. no longer accept an optional block to call. added bang! versions of all the debug,info,warn log levels that flushes the log buffer immediately. adapt the code base to use the bnag! version for bootloader log messages default log level in production mode is now :warn 5891218bee97d71d9e81f40d0cc30ad02281350a Ezra Zygmuntowicz ez@engineyard.com