log4jruby 1.0.0.rc1-java → 2.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 123749780219fb12c1e95b794ea13a73c473a785
+  data.tar.gz: c0bfb65f10f261e5343442feb2ac1cc7516bc5ee
+SHA512:
+  metadata.gz: d96660a9830a4d0dd2197de2c1b98742b1c5964717a0f8647932260697df64cf44f73f09630031317dcb9b4673c2e5f50925b89963160bb8329c156ffb229ff0
+  data.tar.gz: 29ad95b74510eb71a4c37e0e9a510bdfa778f4fa89cfa1980810901704036ec1419dc1f56d0d326a3a5ade619828cc98d025d775d8443e061fba74e21545952b

data/CHANGELOG.md

@@ -0,0 +1,37 @@
+# log4jruby Changelog
+
+## v2.0.0
+
+* Documentation additions, corrections.
+
+## v2.0.0.rc3
+
+* Add Logger#silence for ActiveSupport::Logger compatibility - https://github.com/lenny/log4jruby/pull/11
+
+## v2.0.0.rc2
+
+* Internal implementation changes - https://github.com/lenny/log4jruby/pull/8
+
+## v2.0.0.rc1
+
+* ```Log4jruby::Rails``` has been removed - Rails apps seem better off configuring
+  logging using standard/vanilla means to more easily facilitate usage of TaggedLogging, etc..
+  ```
+
+   e.g.
+   config.logger = ActiveSupport::TaggedLogging.new(Log4jruby::Logger.get('appname'))
+  ```
+* Internal support classes moved to Log4jruby::Support
+* specs updated to Rspec 3 syntax
+* Deadlock/thread-safety issues https://github.com/lenny/log4jruby/issues/2
+* Support for formatters (Rails 4 compatibility - https://github.com/lenny/log4jruby/issues/1)
+* Performance optimizations (https://github.com/lenny/log4jruby/commit/e9a2a2ac347de38431e243b062602c5055163f2c)
+
+## v1.0.0 - Same as v1.0.0.rc1
+
+## v1.0.0.rc1
+
+* setting level now accepts ::Logger constants and symbols
+* Logger#level now returns ::Logger constant values instead of Log4j log level classes.
+ Note, you can still get at log4j constants via #log4_logger.level
+* Logger#level now returns effective log level (i.e. parent logger's level when not explicitly set)

data/{README.rdoc → README.md}

@@ -1,24 +1,26 @@
-= Log4jruby
+
+
+# Log4jruby
 
 * https://github.com/lenny/log4jruby
 
-== Description:
+## Description:
 
 Log4jruby is a thin wrapper around the {Log4j Logger}[http://logging.apache.org/log4j/1.2/apidocs/index.html].
 It is geared more toward those who are using JRuby to integrate with and build on top of Java code that uses Log4j.
-The <tt>Log4jruby::Logger</tt> provides an interface much like the standard ruby {Logger}[http://ruby-doc.org/core/classes/Logger.html].
+The ```Log4jruby::Logger``` provides an interface much like the standard ruby [Logger](http://ruby-doc.org/core/classes/Logger.html).
 Logging is configured via traditional Log4j methods.
 
-The primary use case(i.e. mine) for this library is that you are already up and running with Log4j and now you want
+The primary use case (i.e., mine) for this library is that you are already up and running with Log4j and now you want
 to use it for your Ruby code too. There is not much help here for configuration. In our environment, we deploy Rails
-apps that call and extend Java code into Tomcat as WARs and use a log4j.properties to configure. For the most part, 
+apps that call and extend Java code into Tomcat as WARs and use a log4j.properties to configure. For the most part,
 all there is to using log4jruby is making sure the log4j jar is <tt>required</tt> and that Log4j is at least minimally
-configured(e.g. log4j.properties in the CLASSPATH). The examples should give you the idea.
+configured (e.g., log4j.properties in the CLASSPATH). The examples should give you the idea.
 
-=== Features
+### Features
 
-* Filename, line number, and method name are available(if tracing is on) to your appender layout via {MDC}[http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/MDC.html].
-* Exceptions can be logged directly and are output with backtraces. Java Exceptions(i.e. NativeExceptions)
+* Filename, line number, and method name are available (if tracing is on) to your appender layout via {MDC}[http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/MDC.html].
+* Exceptions can be logged directly and are output with backtraces. Java Exceptions (i.e., NativeExceptions)
   are logged with full java backtrace(including nested exceptions).
 * Logging config for your ruby code can be added to your existing configuration. Ruby logger names are mapped to dot separated names prefixed with <tt>.jruby</tt>
 
@@ -29,7 +31,26 @@ configured(e.g. log4j.properties in the CLASSPATH). The examples should give you
     log4j.logger.jruby=info,Ruby
     log4j.logger.jruby.MyClass=debug
 
-=== Examples
+### Configuration
+
+As noted above, configuring log4j is left to the client. **You must load and configure log4j before requiring log4jruby**.
+There are multiple ways to do so. 
+In our environment, we deploy Rails apps that call and extend Java code to Tomcat as WAR files.
+We provision our app servers with ```log4j.jar``` and a ```log4j.properties``` file in in ```$TOMCAT_HOME/lib```. 
+You may also addd log4j.jar and path to config file into CLASSPATH via environment variables, JAVA_OPTS, JAVA_OPTS, etc...
+Or add them into ```$CLASSPATH``` at runtime before loading log4jruby. See [examples/setup.rb](examples/setup.rb). 
+  
+Note: If you're using bundler, you can specify ```gem 'log4jruby', require: false``` in your Gemfile to delay loading the gem too early.
+  
+In a Rails application, add the following in ```config/application.rb``` or the appropriate ```config/environments``` file.
+   
+    config.logger = ActiveSupport::TaggedLogging.new(Log4jruby::Logger.get('MyApp'))
+    
+or older versions of Rails
+
+    config.logger = Log4jruby::Logger.get('MyApp')
+                           
+### Examples
 
     def foo
       logger.debug("hello from foo")
@@ -47,45 +68,27 @@ configured(e.g. log4j.properties in the CLASSPATH). The examples should give you
       examples/simple.rb:18:in `foo'
       examples/simple.rb:35:in `(root)'
 
-See more in {log4jruby/examples}[http://github.com/lenny/log4jruby/tree/master/examples/].
-
-=== Installation
+See more in [log4jruby/examples](examples).
 
-gem install log4jruby
-
-=== Usage
+### Usage
 
     class MyClass
       enable_logger
-                        
+
       class << self
         def my_class_method
           logger.info("hello from class method")
         end
       end
-        
+
       def my_method
         logger.info("hello from instance method")
       end
     end
-    	
+
     INFO jruby.MyModule.A my_class_method:14 - hello from class method
     INFO jruby.MyModule.A my_method:19 - hello from instance method
-      
-See more in {log4jruby/examples}[http://github.com/lenny/log4jruby/tree/master/examples/].
-They should be runnable from the source.
-
-=== Rails
 
-First try to add the following to one of your config/environment* files.
-
-   require 'log4jruby'
-   config.logger = Log4jruby::Logger.get('MyApp')
-
-Depending on your runtime environment and how it differs between development and production that may not work for you
-due to CLASSPATH issues. Alternatively you may add the following to one of your config/initializers/* files.
+See more in [log4jruby/examples](examples)..
+They should be runnable from the source.
 
-   require 'log4jruby/rails'
-   Log4jruby::Rails.configure do |c|
-      c.logger_name = 'MyApp'
-   end

data/lib/log4jruby.rb

@@ -1,14 +1,16 @@
-require 'log4jruby/logger'
-require 'log4jruby/logger_for_class'
-
 module Log4jruby
-
+  module Support
+  end
 end
 
+require 'log4jruby/support/bootstrap'
+require 'log4jruby/logger'
+require 'log4jruby/logger_for_class'
+
 Object.class_eval do
   class << self
     def enable_logger
       send(:include, Log4jruby::LoggerForClass)
     end
   end
-end
+end

data/lib/log4jruby/logger.rb

@@ -1,18 +1,16 @@
-require 'log4jruby/log4j_args'
+require 'log4jruby/support/log4j_args'
 
 require 'logger'
 
 module Log4jruby
-  
+
   # Author::    Lenny Marks
   #
   # Wrapper around org.apache.log4j.Logger with interface similar to standard ruby Logger.
   #
   # * Ruby and Java exceptions are logged with backtraces.
-  # * fileName, lineNumber, methodName available to appender layouts via MDC variables(e.g. %X{lineNumber}) 
+  # * fileName, lineNumber, methodName available to appender layouts via MDC variables(e.g. %X{lineNumber})
   class Logger
-    BLANK_CALLER = ['', '', ''] #:nodoc:
-
     LOG4J_LEVELS = {
         Java::org.apache.log4j.Level::DEBUG => ::Logger::DEBUG,
         Java::org.apache.log4j.Level::INFO => ::Logger::INFO,
@@ -21,48 +19,47 @@ module Log4jruby
         Java::org.apache.log4j.Level::FATAL => ::Logger::FATAL,
     }
 
-    # turn tracing on to make fileName, lineNumber, and methodName available to 
+    # turn tracing on to make fileName, lineNumber, and methodName available to
     # appender layout through MDC(ie. %X{fileName} %X{lineNumber} %X{methodName})
     attr_accessor :tracing
 
+    # ::Logger::Formatter
+    attr_accessor :formatter
+
     class << self
-      def logger_mapping
-        @logger_mapping ||= {}
-      end
-      
       # get Logger for name
       def[](name)
         name = name.nil? ? 'jruby' : "jruby.#{name.gsub('::', '.')}"
-       
         log4j = Java::org.apache.log4j.Logger.getLogger(name)
-        log4jruby = logger_mapping[log4j]
-        
-        unless log4jruby
-          log4jruby = new(log4j)
-        end
-        
-        log4jruby
+        fetch_logger(log4j)
       end
-      
+
       # same as [] but accepts attributes
       def get(name, values = {})
         logger = self[name]
         logger.attributes = values
         logger
       end
-      
+
       # Return root Logger(i.e. jruby)
       def root
         log4j = Java::org.apache.log4j.Logger.getLogger('jruby')
-        
-        log4jruby = logger_mapping[log4j]
-        unless log4jruby
-          log4jruby = new(log4j)
+        fetch_logger(log4j)
+      end
+
+      def reset # :nodoc:
+        Java::org.apache.log4j.LogManager.getCurrentLoggers.each do |l|
+          l.ruby_logger = nil
         end
-        log4jruby
-      end   
+      end
+
+      private
+
+      def fetch_logger(log4j_logger)
+        Java::org.apache.log4j.Logger.getLogger(log4j_logger.getName).ruby_logger
+      end
     end
-    
+
     def attributes=(values)
       if values
         values.each_pair do |k, v|
@@ -71,7 +68,7 @@ module Log4jruby
         end
       end
     end
-    
+
     # Shortcut for setting log levels. (:debug, :info, :warn, :error, :fatal)
     def level=(level)
       @logger.level = case level
@@ -89,11 +86,11 @@ module Log4jruby
         raise NotImplementedError
       end
     end
-    
+
     def level
       LOG4J_LEVELS[@logger.effectiveLevel]
     end
-    
+
     def flush
       #rails compatability
     end
@@ -136,65 +133,88 @@ module Log4jruby
     def log4j_logger
       @logger
     end
-    
+
     def debug?
       @logger.isEnabledFor(Java::org.apache.log4j.Priority::DEBUG)
     end
-    
+
     def info?
       @logger.isEnabledFor(Java::org.apache.log4j.Priority::INFO)
     end
-    
+
     def warn?
       @logger.isEnabledFor(Java::org.apache.log4j.Priority::WARN)
     end
-    
+
     def tracing?
-      if tracing.nil?
-        if parent == Logger.root
-          Logger.root.tracing == true
-        else 
-         parent.tracing?
+      return @cached_tracing if defined?(@cached_tracing)
+      @cached_tracing = begin
+        if tracing.nil? && self != Logger.root
+          parent.tracing?
+        else
+          tracing == true
+        end
+      end
+    end
+
+    def effective_formatter
+      return @formatter if defined?(@formatter)
+      @formatter = begin
+        if @formatter.nil? && self != Logger.root
+          parent.formatter
+        else
+          @formatter
         end
-      else
-        tracing == true
       end
     end
-    
+
     def parent
-      logger_mapping[log4j_logger.parent] || Logger.root
+      fetch_logger(log4j_logger.parent)
     end
-    
-    private
-    
-    def logger_mapping
-      Logger.logger_mapping
+
+    # Compatibility with ActiveSupport::Logger
+    # needed to use a Log4jruby::Logger as an ActiveRecord::Base.logger
+    def silence(temporary_level = ::Logger::ERROR)
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
     end
 
+    private
+
     def initialize(logger) # :nodoc:
       @logger = logger
-      Logger.logger_mapping[@logger] = self
     end
-    
+
     def with_context # :nodoc:
-      file_line_method = tracing? ? parse_caller(caller(3).first) : BLANK_CALLER
+      file_line_method = parse_caller(caller(3).first)
 
-      mdc.put("fileName", file_line_method[0])
-      mdc.put("lineNumber", file_line_method[1])
-      mdc.put("methodName", file_line_method[2].to_s)
+      mdc.put('fileName', file_line_method[0])
+      mdc.put('lineNumber', file_line_method[1])
+      mdc.put('methodName', file_line_method[2].to_s)
 
       begin
         yield
       ensure
-        mdc.remove("fileName")
-        mdc.remove("lineNumber")
-        mdc.remove("methodName")
+        mdc.remove('fileName')
+        mdc.remove('lineNumber')
+        mdc.remove('methodName')
       end
     end
 
     def send_to_log4j(level, object, error, &block)
-      msg, throwable = Log4jArgs.convert(object, error, &block)
-      with_context do
+      msg, throwable = Support::Log4jArgs.convert(object, error, &block)
+      if (f = effective_formatter)
+        msg = f.call(level, Time.now, @logger.getName, msg)
+      end
+      if tracing?
+        with_context do
+          @logger.send(level, msg, throwable)
+        end
+      else
         @logger.send(level, msg, throwable)
       end
     end
@@ -202,10 +222,14 @@ module Log4jruby
     def parse_caller(at) # :nodoc:
       at.match(/^(.+?):(\d+)(?::in `(.*)')?/).captures
     end
-    
+
     def mdc
-      Java::org.apache.log4j.MDC 
+      Java::org.apache.log4j.MDC
+    end
+
+    def fetch_logger(log4j_logger)
+      self.class.send(:fetch_logger, log4j_logger)
     end
-    
   end
 end
+

data/lib/log4jruby/support/bootstrap.rb

@@ -0,0 +1,18 @@
+require 'thread'
+
+Java::org.apache.log4j.Logger.class_eval do
+  attr_accessor :ruby_logger
+  @ruby_logger_lock = Mutex.new
+
+  class << self
+    def ruby_logger_lock
+      @ruby_logger_lock
+    end
+  end
+
+  def ruby_logger
+    self.class.ruby_logger_lock.synchronize do
+      @ruby_logger ||= Log4jruby::Logger.new(self)
+    end
+  end
+end

data/lib/log4jruby/support/log4j_args.rb

@@ -0,0 +1,42 @@
+module Log4jruby
+  module Support
+    class Log4jArgs
+      class << self
+        def convert(object = nil, exception = nil)
+          msg = ''
+
+          if exception
+            msg << object.to_s
+          else
+            exception = block_given? ? yield : object
+          end
+
+          if exception.is_a?(NativeException)
+            append_ruby_error(msg, exception)
+            msg << "\nNativeException:"
+            exception = exception.cause
+          elsif exception.is_a?(::Exception)
+            append_ruby_error(msg, exception)
+            exception = nil
+          elsif !exception.is_a?(java.lang.Throwable)
+            msg << exception.to_s
+            exception = nil
+          end
+
+          [msg, exception]
+        end
+
+        private
+
+        def append_ruby_error(msg, error)
+          append(msg, "#{error}\n  " + error.backtrace.join("\n  "))
+        end
+
+        def append(msg, s)
+          msg << "\n#{s}"
+          msg.lstrip!
+        end
+      end
+    end
+  end
+end

data/lib/log4jruby/version.rb

@@ -1,3 +1,3 @@
 module Log4jruby
-  VERSION = '1.0.0.rc1'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: log4jruby
 version: !ruby/object:Gem::Version
-  prerelease: 6
-  version: 1.0.0.rc1
+  version: 2.0.0
 platform: java
 authors:
 - Lenny Marks
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
+date: 2016-03-07 00:00:00.000000000 Z
 dependencies: []
 description: Ruby Logger using Log4j, geared toward those who use JRuby to write Ruby code using/extending Java code. Ruby and Java are configured together using traditional Log4j methods.
 email:
@@ -18,37 +17,36 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- README.md
 - lib/log4jruby.rb
-- lib/log4jruby/log4j_args.rb
 - lib/log4jruby/logger.rb
 - lib/log4jruby/logger_for_class.rb
-- lib/log4jruby/rails.rb
+- lib/log4jruby/support/bootstrap.rb
+- lib/log4jruby/support/log4j_args.rb
 - lib/log4jruby/version.rb
-- README.rdoc
-- History.txt
 homepage: https://github.com/lenny/log4jruby
-licenses: []
+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'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
-  none: false
+      version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 1.8.24
+rubygems_version: 2.4.8
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: Log4jruby is a thin wrapper around the Log4j Logger. It is geared more toward  those who are using JRuby to integrate with and build on top of Java code that  uses Log4j. The Log4jruby::Logger provides an interface much like the standard  ruby Logger. Your ruby loggers are given a .jruby prefix and can be configured  along with the loggers for your Java code.
 test_files: []
-...

data/History.txt

@@ -1,6 +0,0 @@
-1.0.0.rc1
-
-* setting level now accepts ::Logger constants and symbols
-* Logger#level now returns ::Logger constant values instead of Log4j log level classes.
-  Note, you can still get at log4j constants via #log4_logger.level
-* Logger#level now returns effective log level (i.e. parent logger's level when not explicitly set)

data/lib/log4jruby/log4j_args.rb

@@ -1,40 +0,0 @@
-module Log4jruby
-  class Log4jArgs
-    class << self
-      def convert(object = nil, exception = nil)
-        msg = ''
-
-        if exception
-          msg << object.to_s
-        else
-          exception = block_given? ? yield : object
-        end
-
-        if exception.is_a?(NativeException)
-          append_ruby_error(msg, exception)
-          msg << "\nNativeException:"
-          exception = exception.cause
-        elsif exception.is_a?(::Exception)
-          append_ruby_error(msg, exception)
-          exception = nil
-        elsif !exception.is_a?(java.lang.Throwable)
-          msg << exception.to_s
-          exception = nil
-        end
-
-        [msg, exception]
-      end
-
-      private
-
-      def append_ruby_error(msg, error)
-        append(msg, "#{error}\n  " + error.backtrace.join("\n  "))
-      end
-
-      def append(msg, s)
-        msg << "\n#{s}"
-        msg.lstrip!
-      end
-    end
-  end
-end

data/lib/log4jruby/rails.rb

@@ -1,62 +0,0 @@
-require 'log4jruby'
-
-module Log4jruby
-  
-  # Configure Rails logging from a config/initializers file
-  # 
-  # Setting up log4j using config.logger from within the Rails initialization
-  # process may not be possible if the CLASSPATH has not yet been setup.
-  # This class can be used to configure the logging from within a config/initializers/
-  # file.
-  #
-  # ex.
-  #   require 'log4jruby/rails'
-  #   Log4jruby::Rails.configure do |c|
-  #     c.logger_name = 'MyApp'
-  #   end
-  # 
-  # @attr [String] logger_name     Default is 'Rails'
-  # @attr [String] tracing         Defaults to false in 'production' or true otherwise
-  # 
-  #
-  class Rails
-    attr_accessor :logger_name, :tracing
-
-    def initialize #:nodoc:
-      @logger_name = 'Rails'
-      @tracing = (::Rails.env != 'production')
-
-      yield(self)
-    end
-
-    class << self
-      
-      # Sets rails Base loggers(e.g. ActionController::Base, ActiveRecord::Base, etc)
-      # 
-      # @yield [config] Block to customize configuration
-      # @yeildparam [Rails] config 
-      def configure(&block)
-        config = new(&block)
-
-        Logger.root.tracing = config.tracing
-
-        logger = Log4jruby::Logger.get(config.logger_name)
-
-        set_logger('ActionController', logger)
-        set_logger('ActiveRecord', logger)
-        set_logger('ActiveResource', logger)
-        set_logger('ActionMailer', logger)
-      end
-
-      private
-      
-      def set_logger(framework, logger)
-        begin
-          Kernel.const_get(framework).const_get('Base').logger = logger
-        rescue
-          logger.info "Skipping logger setup for #{framework}"
-        end
-      end
-    end
-  end
-end