trinidad 1.4.4 → 1.4.5.B1

data/lib/trinidad/helpers.rb

@@ -0,0 +1,34 @@
+module Trinidad
+  module Helpers
+
+    @@silence = nil # :nodoc
+    # Should we be silent - no warnings will be printed.
+    def self.silence?; @@silence; end
+    # Silence ! (... or I kill you)
+    def self.silence!; @@silence = true; end
+
+    # Print a warning (Kernel.warn).
+    def self.warn(msg)
+      super unless silence? # Kernel.warn
+    end
+    
+    module_function
+
+    @@deprecated = {} # :nodoc
+    
+    # Print a deprecated message (once - no matter how many times it's called).
+    def deprecate(msg, prefix = '[DEPRECATED] ')
+      return nil if @@deprecated[msg]
+      @@deprecated[msg] = true
+      Helpers.warn "#{prefix}#{msg}" # Kernel.warn
+    end
+    
+    def camelize(string)
+      string = string.to_s.sub(/^[a-z\d]*/) { $&.capitalize }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/', '::')
+      string
+    end
+    
+  end
+end

data/lib/trinidad/lifecycle/base.rb

@@ -3,41 +3,42 @@ module Trinidad
     # Trinidad lifecycle listener (generic) base class.
     # Allows hooking into the container's lifecycle using the provided methods.
     class Base
-      
+
       include Trinidad::Tomcat::LifecycleListener
 
+      EVENTS = Trinidad::Tomcat::Lifecycle # :nodoc:
+
       # The base implementation simply routes events to correspondig methods.
       # 
       # http://tomcat.apache.org/tomcat-7.0-doc/api/org/apache/catalina/Lifecycle.html
       # http://tomcat.apache.org/tomcat-7.0-doc/api/org/apache/catalina/LifecycleListener.html
       def lifecycleEvent(event)
-        events = Trinidad::Tomcat::Lifecycle
         case event.type
-        when events::BEFORE_INIT_EVENT then
+        when EVENTS::BEFORE_INIT_EVENT then
           before_init(event)
-        when events::AFTER_INIT_EVENT then
+        when EVENTS::AFTER_INIT_EVENT then
           after_init(event)
-        when events::CONFIGURE_START_EVENT then
-          configure_start(event)
-        when events::CONFIGURE_STOP_EVENT then
-          configure_stop(event)
-        when events::BEFORE_START_EVENT then
+        when EVENTS::BEFORE_START_EVENT then
           before_start(event)
-        when events::START_EVENT then
+        when EVENTS::CONFIGURE_START_EVENT then
+          configure_start(event)
+        when EVENTS::START_EVENT then
           start(event)
-        when events::AFTER_START_EVENT then
+        when EVENTS::AFTER_START_EVENT then
           after_start(event)
-        when events::BEFORE_STOP_EVENT then
+        when EVENTS::BEFORE_STOP_EVENT then
           before_stop(event)
-        when events::STOP_EVENT then
+        when EVENTS::STOP_EVENT then
           stop(event)
-        when events::AFTER_STOP_EVENT then
+        when EVENTS::CONFIGURE_STOP_EVENT then
+          configure_stop(event)
+        when EVENTS::AFTER_STOP_EVENT then
           after_stop(event)
-        when events::BEFORE_DESTROY_EVENT then
+        when EVENTS::BEFORE_DESTROY_EVENT then
           before_destroy(event)
-        when events::AFTER_DESTROY_EVENT then
+        when EVENTS::AFTER_DESTROY_EVENT then
           after_destroy(event)
-        when events::PERIODIC_EVENT then
+        when EVENTS::PERIODIC_EVENT then
           periodic(event)
         else
           raise "unsupported event.type = #{event.type}"
@@ -48,16 +49,15 @@ module Trinidad
       
       def before_init(event); end
       def after_init(event); end
-
-      def configure_start(event); end
-      def configure_stop(event); end
       
       def before_start(event); end
+      def configure_start(event); end
       def start(event); end
       def after_start(event); end
       
       def before_stop(event); end
       def stop(event); end
+      def configure_stop(event); end
       def after_stop(event); end
       
       def before_destroy(event); end

data/lib/trinidad/lifecycle/host.rb

@@ -2,8 +2,13 @@ require 'trinidad/lifecycle/base'
 
 module Trinidad
   module Lifecycle
-    # A host lifecycle listener - monitors deployed web apps.
-    class Host < Base
+    # Host listener - monitors deployed applications 
+    # (re-invented HostConfig with Ruby/Rack semantics).
+    class Host # TODO < Tomcat::HostConfig !
+
+      include Trinidad::Tomcat::LifecycleListener
+
+      EVENTS = Trinidad::Tomcat::Lifecycle # :nodoc:
       
       attr_reader :server, :app_holders
       # @deprecated (<= 1.3.5)
@@ -21,21 +26,40 @@ module Trinidad
         end
         @server, @app_holders = server, app_holders
       end
-      
-      # @see Trinidad::Lifecycle::Base#before_start
+
+      def lifecycleEvent(event) # :nodoc:
+        case event.type
+        when EVENTS::BEFORE_START_EVENT then
+          before_start(event)
+        when EVENTS::START_EVENT then
+          start(event)
+        when EVENTS::STOP_EVENT then
+          stop(event)
+        when EVENTS::PERIODIC_EVENT then
+          periodic(event)
+        end
+      end
+
       def before_start(event)
         init_monitors
       end
 
-      # @see Trinidad::Lifecycle::Base#periodic
+      def start(event); end # :nodoc:
+
       def periodic(event)
-        check_monitors
+        check_changes event.lifecycle
       end
 
-      def tomcat; @server.tomcat; end # for backwards compatibility
+      def stop(event); end # :nodoc:
+
+      def tomcat; @server.tomcat; end # :nodoc: for backwards compatibility
       
       protected
       
+      def check_changes(host)
+        check_monitors
+      end
+
       def init_monitors
         app_holders.each do |app_holder|
           monitor = app_holder.monitor
@@ -80,8 +104,9 @@ module Trinidad
         strategy = (app_holder.web_app.reload_strategy || :default).to_sym
         strategy = RELOAD_STRATEGIES[ strategy ]
         strategy = strategy ? self.class.const_get(strategy) : RestartReload
-        strategy.instance_method(:initialize).arity != 0 ?
-          strategy.new(server).reload!(app_holder) : strategy.new.reload!(app_holder)
+        new_args = []
+        new_args << server if strategy.instance_method(:initialize).arity != 0
+        strategy.new(*new_args).reload!(app_holder)
       end
       
     end

data/lib/trinidad/lifecycle/host/rolling_reload.rb

@@ -16,19 +16,32 @@ module Trinidad
 
         web_app.reset! # force a new class loader + re-read state (from config)
         no_host = org.apache.catalina.Host.impl {} # do not add to parent yet
-        new_context = @server.add_web_app(web_app, no_host)
-        new_context.add_lifecycle_listener(Takeover.new(old_context))
+        new_context = @server.add_web_app(web_app, no_host, false)
         # Tomcat requires us to have unique names for its containers :
         new_context.name = "#{old_context.name}-#{java.lang.System.currentTimeMillis}"
-
+        new_context.add_lifecycle_listener(takeover = Takeover.new(old_context))
         app_holder.context = new_context
 
         Thread.new do
           begin
             logger.debug "Starting a new Context for [#{new_context.path}]"
             old_context.parent.add_child new_context # NOTE: likely starts!
-            new_context.start unless new_context.state_name =~ /START/i
-            logger.info "Context with name [#{old_context.name}] has completed rolling"
+            
+            new_context.start unless new_context.state_name =~ /START|STOP|FAILED/i
+            
+            if new_context.state_name =~ /STOP|FAILED/i
+              logger.error("Context with name [#{old_context.name}] failed rolling")
+              takeover.failed!(new_context)
+            else
+              logger.info "Context with name [#{old_context.name}] has completed rolling"
+            end
+          rescue => error
+            e = org.jruby.exceptions.RaiseException.new(error)
+            logger.error("Context with name [#{old_context.name}] failed rolling", e)
+            takeover.failed!(new_context)
+          rescue java.lang.Exception => e
+            logger.error("Context with name [#{old_context.name}] failed rolling", e)
+            takeover.failed!(new_context)
           ensure
             app_holder.unlock
           end
@@ -39,9 +52,9 @@ module Trinidad
       def self.logger # log into the same location as context.reload does :
         Trinidad::Logging::LogFactory.getLog('org.apache.catalina.core.StandardContext')
       end
-
+      
       class Takeover < Trinidad::Lifecycle::Base # :nodoc
-
+        
         def initialize(context)
           @old_context = context
         end
@@ -53,12 +66,21 @@ module Trinidad
           logger.debug "Stoping the old Context for [#{@old_context.path}]"
 
           @old_context.stop
+          @old_context.work_dir = nil # make sure it's not deleted
           @old_context.destroy
           # NOTE: name might not be changed once added to a parent
-          new_context.name = @old_context.name
+          #new_context.name = @old_context.name
           super
         end
 
+        def failed!(new_context)
+          # NOTE: this will also likely destroy() the child - new context :
+          @old_context.parent.remove_child new_context
+          logger.info "Failed to start new Context for [#{@old_context.path}] " + 
+                      "(check application logs) keeping the old one running ..."
+          new_context.remove_lifecycle_listener(self)
+        end
+        
         private
         
         def logger
@@ -66,7 +88,7 @@ module Trinidad
         end
         
       end
-
+      
     end
   end
 end

data/lib/trinidad/lifecycle/web_app/default.rb

@@ -31,7 +31,7 @@ module Trinidad
         def configure_deployment_descriptor(context)
           descriptor = web_app.deployment_descriptor
           if descriptor && File.exist?(descriptor)
-            listeners = context.findLifecycleListeners
+            listeners = context.find_lifecycle_listeners
             context_config = listeners && listeners.find do |listener|
               listener.is_a?(Trinidad::Tomcat::ContextConfig)
             end

data/lib/trinidad/lifecycle/web_app/shared.rb

@@ -12,6 +12,12 @@ module Trinidad
           @web_app = web_app
         end
 
+        def before_init(event)
+          #context = event.lifecycle
+          #context.name = context.path if context.name
+          super
+        end
+
         # @see Trinidad::Lifecycle::Base#before_start
         def before_start(event)
           super
@@ -30,7 +36,12 @@ module Trinidad
         protected
         
         def adjust_context(context)
-          context.name = web_app.context_name if web_app.context_name
+          context_name = web_app.context_name
+          # on (rolling) reloads the name may have been set already :
+          if context_name && ! (context.name || '').index(context_name)
+            context.name = context_name
+          end
+
           context.doc_base = web_app.doc_base if web_app.doc_base
           context.work_dir = web_app.work_dir if web_app.work_dir
           context.aliases  = web_app.aliases  if web_app.aliases
@@ -47,19 +58,15 @@ module Trinidad
         
         def configure_default_servlet(context)
           configure_builtin_servlet(context, 
-            web_app.default_servlet, 
-            Trinidad::WebApp::DEFAULT_SERVLET_NAME
+            web_app.default_servlet, Trinidad::WebApp::DEFAULT_SERVLET_NAME
           )
         end
         
         def configure_jsp_servlet(context)
           wrapper = configure_builtin_servlet(context, 
-            web_app.jsp_servlet, 
-            Trinidad::WebApp::JSP_SERVLET_NAME
+            web_app.jsp_servlet, Trinidad::WebApp::JSP_SERVLET_NAME
           )
-          if wrapper == false # jsp servlet removed
-            context.process_tlds = false
-          end
+          context.process_tlds = false if wrapper == false # jsp servlet removed
           wrapper
         end
         

data/lib/trinidad/lifecycle/web_app/war.rb

@@ -7,45 +7,45 @@ module Trinidad
       class War < Base
         include Shared
         
-        def before_start(event)
-          expand_war_app(event.lifecycle)
-          super # Shared#before_start
-        end
-        
-        def after_start(event)
+        def before_init(event)
+          # NOTE: esp. important for .war applications that the name matches the path
+          # to work-around ProxyDirContext constructor's `contextPath = contextName;`
+          # @see {#adjust_context} also need to restore possible context name change!
+          context = event.lifecycle
+          context.name = context.path if context.name
           super
-          remove_war_app(event.lifecycle)
         end
         
         def configure(context)
-          super # TODO assuming warbler .war !
+          super # Shared#configure
           configure_class_loader(context)
         end
-
+        
         protected
         
+        def adjust_context(context)
+          name = context.name
+          super
+        ensure # @see {#before_init}
+          context.name = name
+          # NOTE: mimics HostConfig#deploWAR and should be removed
+          # once Lifecycle::Host inherits func from HostConfig ...
+          # context_name = Trinidad::Tomcat::ContextName.new(name)
+          # context.setName context_name.getName()
+          # context.setPath context_name.getPath()
+          # context.setWebappVersion context_name.getVersion()
+          # context.setDocBase context_name.getBaseName() + '.war'
+        end
+
         def configure_class_loader(context)
-          loader = Trinidad::Tomcat::WebappLoader.new(web_app.class_loader)
+          class_loader = web_app.class_loader || JRuby.runtime.jruby_class_loader
+          loader = Trinidad::Tomcat::WebappLoader.new(class_loader)
           loader.container = context
           context.loader = loader
         end
 
-        private
-
-        def expand_war_app(context)
-          unless File.exist?(context.doc_base)
-            host = context.parent
-            war_file = java.io.File.new(web_app.root_dir)
-            war = java.net.URL.new("jar:" + war_file.toURI.toURL.to_s + "!/")
-            path_name = File.basename(context.doc_base)
-
-            Trinidad::Tomcat::ExpandWar.expand(host, war, path_name)
-          end
-        end
-        
-        def remove_war_app(context)
-          require 'fileutils'
-          FileUtils.rm_rf web_app.root_dir.gsub(/\.war$/, '')
+        def remove_defaults(context = nil)
+          # NOTE: do not remove defaults (welcome files)
         end
         
       end

data/lib/trinidad/logging.rb

@@ -12,17 +12,13 @@ module Trinidad
     # Configure the "global" Trinidad logging.
     def self.configure(log_level = nil)
       return false if @@configured
+      @@configured = true
       
       root_logger = JUL::Logger.getLogger('')
       level = parse_log_level(log_level, :INFO)
       
       out_handler = new_console_handler JRuby.runtime.out
       out_handler.formatter = console_formatter
-
-      err_handler = new_console_handler JRuby.runtime.err
-      err_handler.formatter = console_formatter
-      err_handler.level = level.intValue > JUL::Level::WARNING.intValue ?
-        level : JUL::Level::WARNING # only >= WARNING on STDERR
       
       root_logger.synchronized do
         root_logger.handlers.to_a.each do |handler|
@@ -30,24 +26,35 @@ module Trinidad
         end
 
         root_logger.add_handler(out_handler)
-        root_logger.add_handler(err_handler)
-        root_logger.level = level
+        if JRuby.runtime.out != Java::JavaLang::System.out ||
+           JRuby.runtime.err != Java::JavaLang::System.err
+         # NOTE: only add err handler if customized STDOUT or STDERR :
+        err_handler = new_console_handler JRuby.runtime.err
+        err_handler.formatter = console_formatter
+        err_handler.level = level.intValue > JUL::Level::WARNING.intValue ?
+          level : JUL::Level::WARNING # only >= WARNING on STDERR
+        
+         root_logger.add_handler(err_handler)
+        end
+        set_log_level(root_logger, level)
       end
-      adjust_tomcat_loggers
+      silence_tomcat_loggers
       
-      @@configured = true
       root_logger
     end
     
     # Force logging (re-)configuration.
     # @see #configure
     def self.configure!(log_level = nil)
-      @@configured = false
-      configure(log_level)
+      ( @@configured = false ) || configure(log_level)
+    end
+    
+    def self.configure_web_app!(web_app, context)
+      configure_web_app!(web_app, context, true)
     end
     
     # Configure logging for a web application.
-    def self.configure_web_app(web_app, context)
+    def self.configure_web_app(web_app, context, reset = nil)
       param_name, param_value = 'jruby.rack.logging', 'JUL'
       # 1. delegate (jruby-rack) servlet log to JUL
       if set_value = web_app_context_param(web_app, context, param_name)
@@ -62,12 +69,15 @@ module Trinidad
         # org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/foo]
         context.add_parameter(param_name, logger_name = context.send(:logName))
       end
-      configure # make sure 'global' logging if configured
+      configure # make sure 'global' logging is configured
       
       logger = JUL::Logger.getLogger(logger_name) # exclusive for web app
-      # avoid duplicate calls - do not configure our FileHandler twice :
-      return false if logger.handlers.find { |h| h.is_a?(FileHandler) }
+      logger.handlers.each { |h| logger.remove_handler(h); h.close } if reset
+      # avoid duplicate calls - do not configure (e.g. FileHandler) twice :
+      return false unless logger.handlers.empty?
+      
       logging = web_app.logging
+      
       logger.level = parse_log_level(logging[:level], nil)
       # delegate to root (console) output only in development mode :
       logger.use_parent_handlers = logging[:use_parent_handlers]
@@ -112,16 +122,26 @@ module Trinidad
       JUL::Level.parse(log_level) if log_level
     end
     
-    def self.adjust_tomcat_loggers
+    def self.set_log_level(logger, level)
+      logger.level = level; LogFactory.getLog(logger.name)
+    end
+
+    def self.silence_tomcat_loggers
       # org.apache.coyote.http11.Http11Protocol   INFO: Initializing ProtocolHandler ["http-bio-3000"]
       # org.apache.catalina.core.StandardService  INFO: Starting service Tomcat
       # org.apache.catalina.core.StandardEngine   INFO: Starting Servlet Engine: Apache Tomcat/7.0.27
       # org.apache.catalina.startup.ContextConfig INFO: No global web.xml found
       # org.apache.coyote.http11.Http11Protocol   INFO: Starting ProtocolHandler ["http-bio-3000"]
-      logger = JUL::Logger.get_logger('org.apache.catalina.core.StandardService')
-      logger.level = JUL::Level::WARNING if logger
-      logger = JUL::Logger.get_logger('org.apache.catalina.startup.ContextConfig')
-      logger.level = JUL::Level::WARNING if logger
+      level = JUL::Level::WARNING
+      logger_names = [
+        'org.apache.catalina.core.StandardService',
+        'org.apache.catalina.core.StandardEngine',
+        'org.apache.catalina.startup.ContextConfig',
+      ]
+      for name in logger_names
+        logger = JUL::Logger.getLogger(name)
+        set_log_level(logger, level) if logger
+      end
     end
     
     def self.web_app_context_param(web_app, context, name)
@@ -146,78 +166,82 @@ module Trinidad
       handler
     end
     
-    # we'd achieve logging to a production.log file while rotating it (daily)
-    class FileHandler < Java::OrgApacheJuli::FileHandler # :nodoc
-      
-      field_reader :directory, :prefix, :suffix
-      field_accessor :rotatable, :bufferSize => :buffer_size
-      
-      # JULI::FileHandler internals :
-      field_accessor :date => :_date # current date string e.g. 2012-06-26
-      
-      def initialize(directory, prefix, suffix)
-        super(directory, prefix, suffix)
-        self._date = nil # to openWriter on first #publish(record)
-      end
-      
-      def openWriter
-        # NOTE: following code is heavily based on super's internals !
-        synchronized do
-          # we're normally in the lock here (from #publish) 
-          # thus we do not perform any more synchronization
-          prev_rotatable = self.rotatable
-          begin
-            self.rotatable = false
-            # thus current file name will be always {prefix}{suffix} :
-            # due super's `prefix + (rotatable ? _date : "") + suffix`
-            super
-          ensure
-            self.rotatable = prev_rotatable
-          end
+    if ( Java::JavaClass.for_name('rb.trinidad.logging.FileHandler') rescue nil )
+      FileHandler = Java::RbTrinidadLogging::FileHandler # recent trinidad_jars
+    else
+      # we'd achieve logging to a production.log file while rotating it (daily)
+      class FileHandler < Java::OrgApacheJuli::FileHandler # :nodoc
+
+        field_reader :directory, :prefix, :suffix
+        field_accessor :rotatable, :bufferSize => :buffer_size
+
+        # JULI::FileHandler internals :
+        field_accessor :date => :_date # current date string e.g. 2012-06-26
+
+        def initialize(directory, prefix, suffix)
+          super(directory, prefix, suffix)
+          self._date = nil # to openWriter on first #publish(record)
         end
-      end
 
-      def close
-        @_close = true
-        super
-        @_close = nil
-      end
-      
-      def closeWriter
-        date = _date
-        super # sets `date = null`
-        # the additional trick here is to rotate the closed file
-        synchronized do
-          # we're normally in the lock here (from #publish) 
-          # thus we do not perform any more synchronization
-          dir = java.io.File.new(directory).getAbsoluteFile
-          log = java.io.File.new(dir, prefix + "" + suffix)
-          if log.exists
-            if ! date || date.empty?
-              date = log.lastModified
-              # we abuse Timestamp to get a date formatted !
-              # just like super does internally (just in case)
-              date = java.sql.Timestamp.new(date).toString[0, 10]
-            end
-            today = java.lang.System.currentTimeMillis
-            today = java.sql.Timestamp.new(today).toString[0, 10]
-            return if date == today # no need to rotate just yet
-            to_file = java.io.File.new(dir, prefix + date + suffix)
-            if to_file.exists
-              file = java.io.RandomAccessFile.new(to_file, 'rw')
-              file.seek(file.length)
-              log_channel = java.io.FileInputStream.new(log).getChannel
-              log_channel.transferTo(0, log_channel.size, file.getChannel)
-              file.close
-              log_channel.close
-              log.delete
-            else
-              log.renameTo(to_file)
+        def openWriter
+          # NOTE: following code is heavily based on super's internals !
+          synchronized do
+            # we're normally in the lock here (from #publish) 
+            # thus we do not perform any more synchronization
+            prev_rotatable = self.rotatable
+            begin
+              self.rotatable = false
+              # thus current file name will be always {prefix}{suffix} :
+              # due super's `prefix + (rotatable ? _date : "") + suffix`
+              super
+            ensure
+              self.rotatable = prev_rotatable
             end
           end
-        end if rotatable && ! @_close
+        end
+
+        def close
+          @_close = true
+          super
+          @_close = nil
+        end
+
+        def closeWriter
+          date = _date
+          super # sets `date = null`
+          # the additional trick here is to rotate the closed file
+          synchronized do
+            # we're normally in the lock here (from #publish) 
+            # thus we do not perform any more synchronization
+            dir = java.io.File.new(directory).getAbsoluteFile
+            log = java.io.File.new(dir, prefix + "" + suffix)
+            if log.exists
+              if ! date || date.empty?
+                date = log.lastModified
+                # we abuse Timestamp to get a date formatted !
+                # just like super does internally (just in case)
+                date = java.sql.Timestamp.new(date).toString[0, 10]
+              end
+              today = java.lang.System.currentTimeMillis
+              today = java.sql.Timestamp.new(today).toString[0, 10]
+              return if date == today # no need to rotate just yet
+              to_file = java.io.File.new(dir, prefix + date + suffix)
+              if to_file.exists
+                file = java.io.RandomAccessFile.new(to_file, 'rw')
+                file.seek(file.length)
+                log_channel = java.io.FileInputStream.new(log).getChannel
+                log_channel.transferTo(0, log_channel.size, file.getChannel)
+                file.close
+                log_channel.close
+                log.delete
+              else
+                log.renameTo(to_file)
+              end
+            end
+          end if rotatable && ! @_close
+        end
+
       end
-      
     end
     
     # We're truly missing a #formatThrown exception helper method.
@@ -265,47 +289,52 @@ module Trinidad
       
     end
     
-    # A formatter that formats application file logs (e.g. production.log).
-    class DefaultFormatter < JUL::Formatter # :nodoc
+    if ( Java::JavaClass.for_name('rb.trinidad.logging.DefaultFormatter') rescue nil )
+      DefaultFormatter = Java::RbTrinidadLogging::DefaultFormatter # recent trinidad_jars
+    else
+      # A formatter that formats application file logs (e.g. production.log).
+      class DefaultFormatter < JUL::Formatter # :nodoc
 
-      # Allows customizing the date format + the time zone to be used.
-      def initialize(format = nil, time_zone = nil)
-        super()
-        @format = format ? 
-          Java::JavaText::SimpleDateFormat.new(format) : 
-            Java::JavaText::SimpleDateFormat.new
-        case time_zone
-        when Java::JavaUtil::Calendar then
-          @format.calendar = time_zone
-        when Java::JavaUtil::TimeZone then
-          @format.time_zone = time_zone
-        when String then
-          time_zone = Java::JavaUtil::TimeZone.getTimeZone(time_zone)
-          @format.time_zone = time_zone
-        when Numeric then
-          time_zones = Java::JavaUtil::TimeZone.getAvailableIDs(time_zone)
-          if time_zones.length > 0
-            time_zone = Java::JavaUtil::TimeZone.getTimeZone(time_zones[0])
+        # Allows customizing the date format + the time zone to be used.
+        def initialize(format = nil, time_zone = nil)
+          super()
+          @format = format ? 
+            Java::JavaText::SimpleDateFormat.new(format) : 
+              Java::JavaText::SimpleDateFormat.new
+          case time_zone
+          when Java::JavaUtil::Calendar then
+            @format.calendar = time_zone
+          when Java::JavaUtil::TimeZone then
             @format.time_zone = time_zone
-          end
-        end if time_zone
-      end
+          when String then
+            time_zone = Java::JavaUtil::TimeZone.getTimeZone(time_zone)
+            @format.time_zone = time_zone
+          when Numeric then
+            time_zones = Java::JavaUtil::TimeZone.getAvailableIDs(time_zone)
+            if time_zones.length > 0
+              time_zone = Java::JavaUtil::TimeZone.getTimeZone(time_zones[0])
+              @format.time_zone = time_zone
+            end
+          end if time_zone
+        end
 
-      JDate = Java::JavaUtil::Date
+        JDate = Java::JavaUtil::Date
 
-      def format(record)
-        timestamp = @format.synchronized do 
-          @format.format JDate.new(record.millis)
+        def format(record)
+          timestamp = @format.synchronized do 
+            @format.format JDate.new(record.millis)
+          end
+          level = record.level.name
+          message = formatMessage(record)
+
+          out = "#{timestamp} #{level}: #{message}"
+          out << formatThrown(record).to_s
+          (lns = "\n") == out[-1, 1] ? out : out << lns
         end
-        level = record.level.name
-        message = formatMessage(record)
 
-        out = "#{timestamp} #{level}: #{message}"
-        out << formatThrown(record).to_s
-        (lns = "\n") == out[-1, 1] ? out : out << lns
       end
-
     end
+    
   end
   LogFormatter = Logging::DefaultFormatter # backwards compatibility
 end