log4jruby 2.0.1-java → 3.0.0.rc1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8355e0417b5b8fa90580b2b5d47380ed4c70d634
-  data.tar.gz: 1a981572aafc5d7350c2aa0c2975bcec80a39976
+SHA256:
+  metadata.gz: 63ae3e7cb5a390af7767e58ce30270c32cc3c770ba877ce0932627e3efab1607
+  data.tar.gz: d80186abc03df7b0a2b10befcdda3084eef5cffeb4e1960ce957930d6be1e850
 SHA512:
-  metadata.gz: 2100d066da86f23d7a5a7d818d5e46bbb6811630d853def7c869acb0930e2c23e913039e8b5e63a56aba7fa0683c21d8f97f3310b788988a151dceb7b9af9442
-  data.tar.gz: abe6cbfceb161761850e867c5f9df6d339f7e3807ba9bb104822fca7db2b380c9fdd147c22f713e1678b6a1c919936ba5b04f9ce71980e1da7154b1f0c61be85
+  metadata.gz: bbc3e978c3d27fe325b135ff988b063f928daadec1a3608d8cfd891766ab2eefa3e0dc08c60ae3dae9835760236fbcb6e84152bcc2cef8faebfb7d8f2b407bf9
+  data.tar.gz: 61d52687aa0b3d1658fb29c0c543e0e7ba45789799ebaabc640fa4f2570ea1d395972c856118bfb2e34e45d3c4780dd3e1e45285c609ae7c8c26455a4a9595ad

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # log4jruby Changelog
 
+## v3.0.0.rc1
+
+* JRuby 9.3.x/Ruby 2.6 support - Ruby >= 2.6.8 now required
+* Updated for Log4j2
+  Note:
+  > In Log4j 1.x the Logger Hierarchy was maintained through a relationship between Loggers. 
+    In Log4j 2 this relationship no longer exists. Instead, the hierarchy is maintained in the 
+    relationship between LoggerConfig objects. 
+  from the [Log4j 2 Architecture page](https://logging.apache.org/log4j/2.x/manual/architecture.html)
+* Formatters and logging output
+   * Consistent treatment for Ruby and Java exceptions - Previously, ruby exception backtraces were
+  not passed directly to Log4j. Instead a backtrace string was generated and included in the exception
+  message. JRuby now handles mapping Ruby exceptions/errors to Java exceptions that can be
+  passed directly as the `Throwable` parameter to Log4j.
+   * Formatter parity with the standard Ruby Logger - Custom formatters
+     (see [formatter in the
+      Ruby Logger docs](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/Logger.html)
+ now receive the same arguments from Log4Jruby as they would from the standard Ruby Logger
+ given the same logging invocation.
+   * Default formatter - The [standard Ruby Logger](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/Logger.html)
+     uses a default formatter that outputs backtraces (without nested causes). Log4jruby now uses
+     a default formatter that outputs `progname` and `msg` only. Severity and timestamp are output
+     according to your Log4j configuration. E.g. [PatternLayout](https://logging.apache.org/log4j/2.x/manual/layouts.html)
+   * The output of the `formatter` is passed as the `message` parameter of the 
+     [Log4j log methods](https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/Category.html) 
+* Nested ruby exceptions are now handled - E.g. The backtrace output from `logger.error { ruby_error_with_nested_causes }` will
+  include nested causes for both Ruby and Java exceptions.
+* Log4jruby no longer utilizes deprecated [JRuby Persistence](https://github.com/jruby/jruby/wiki/Persistence)
+* Development
+   * Rubocop introduced and violations squashed
+   * Mavenized log4j development dependency, added `dev:java_deps` Rake task, and removed bundled log4j jar
+   
 ## v2.0.1
 
 * JRuby 9K compatibility - https://github.com/lenny/log4jruby/issues/14

data/README.md

@@ -1,94 +1,176 @@
+# Log4jruby
 
+`Log4jruby` provides an interface mostly compatible with the standard ruby [Logger](http://ruby-doc.org/core/classes/Logger.html) but backed by  [Log4j 2](https://logging.apache.org/log4j/2.x/).
+This makes the granular log output configuration, stacktrace output, and other facilities of `log4j` available to Java and Ruby code alike. For projects that extend/integrate Java already dependent on `log4j`, it allows log configuration for Java and Ruby code in one spot.
 
-# Log4jruby
+* Automatic stacktrace output (including nested causes) for logged Java and Ruby exceptions
+* Configure Java and Ruby logging together (e.g a single `log4j2.properties` file) and gain `log4j` features such as runtime output targets for Ruby code.
+* Ability to configure logging per distinct logger name (typically a class)
+* Supports inclusion of filename, line number, and method name in log messages via [ThreadContext](https://logging.apache.org/log4j/2.x/manual/thread-context.html). Note: `tracing` must be enabled.
+* High level support for class based logging via the `enable_logger` macro. 
+* Compatible with the `Rails` logging.
 
-* https://github.com/lenny/log4jruby
 
-## Description:
+## Usage and examples
 
-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 ```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.
+Enable class level logging via `enable_logger`
 
-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,
-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.
+```ruby
+ require 'log4jruby'
 
-### Features
+ class MyClass
+   enable_logger
 
-* 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>
+   class << self
+     def my_class_method
+       logger.info("hello from class method")
+     end
+   end
 
-    log4j.appender.Ruby=org.apache.log4j.ConsoleAppender
-    log4j.appender.Ruby.layout=org.apache.log4j.PatternLayout
-    log4j.appender.Ruby.layout.ConversionPattern=%5p %.50X{fileName} %X{methodName}:%X{lineNumber} - %m%n
+   def my_method
+     logger.info("hello from instance method")
+   end
+ end
+```
 
-    log4j.logger.jruby=info,Ruby
-    log4j.logger.jruby.MyClass=debug
+Custom logger name
 
-### Configuration
+```ruby
+logger = Log4jruby::Logger.get('my.logger')
+logger.debug('something')
+```
 
-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 add 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.
+Log4jruby logger names are prefixed with `.jruby`.
+
+e.g. `log4j2.properties`
+
+See [examples/log4j2.properties](examples/log4j2.properties) for complete example
+
+```ini
+ ...
+ # JRuby logger
+logger.jruby.name = jruby
+logger.jruby.level = debug
+logger.jruby.additivity = false
+logger.jruby.appenderRef.stdout.ref = JRuby
+```
+
+Inclusion of filename, line number, and method name in log messages via [ThreadContext](https://logging.apache.org/log4j/2.x/manual/thread-context.html)
+
+e.g.
+
+```ini
+appender.jruby.layout.pattern = %d %5p %c %X{methodName}:%X{lineNumber} %m%throwable%n
+```
+
+enable tracing globally
+
+```
+Log4jruby::Logger.root.tracing = true
+```
+
+or for specific logger
+
+```
+Log4jruby::Logger.get('MyClass', tracing: true)
+```
+
+produces log statements like: 
+
+```
+2022-08-12 17:36:05,819 DEBUG jruby.MyClass foo:20 -- : hello from foo
+```
+
+Exceptions are logged with backtraces
+
+```bash
+> ruby ./examples/nested_ruby_exceptions.rb
+2022-08-25 19:50:47,050 ERROR jruby.test <main>:31 -- : raised from foo org.jruby.exceptions.RuntimeError: (RuntimeError) raised from foo
+	at $_dot_.examples.nested_ruby_exceptions.foo(./examples/nested_ruby_exceptions.rb:15)
+	at $_dot_.examples.nested_ruby_exceptions.<main>(./examples/nested_ruby_exceptions.rb:29)
+Caused by: org.jruby.exceptions.RuntimeError: (RuntimeError) raised from bar
+	at $_dot_.examples.nested_ruby_exceptions.bar(./examples/nested_ruby_exceptions.rb:21)
+	at $_dot_.examples.nested_ruby_exceptions.foo(./examples/nested_ruby_exceptions.rb:13)
+	... 1 more
+Caused by: org.jruby.exceptions.RuntimeError: (RuntimeError) raised from baz
+	at $_dot_.examples.nested_ruby_exceptions.baz(./examples/nested_ruby_exceptions.rb:25)
+	at $_dot_.examples.nested_ruby_exceptions.bar(./examples/nested_ruby_exceptions.rb:19)
+	... 2 more
+
+
+```
+
+```
+logger.warn(exception)
+```
+
+```
+logger.warn { exception }
+```
+
+```
+logger.error(msg) { exception)
+```
+
+See additional examples in [log4jruby/examples](examples).
+
+
+## Configuration
+
+Configuring log4j is left to the client via the [standard log4j configuration process](https://logging.apache.org/log4j/2.x/manual/configuration.html).
+
+E.g.
+
+Create a `log4j2.properties` file and make sure it is available in your classpath.
+
+The log4j-api-2.n.jar and log4j-core-2.n.jars must be found in your classpath when `log4jruby` is loaded.
+
+* Place files somewhere already in your classpath such as `$TOMCAT/lib` for Tomcat. 
+* Configure classpath via `JAVA_OPTS`
+* Amend `$CLASSPATH` at runtime before loading log4jruby. See [examples/setup.rb](examples/setup.rb). 
   
-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'))
-    
+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.
+```ini
+ config.logger = ActiveSupport::TaggedLogging.new(Log4jruby::Logger.get('MyApp'))
+```
 or older versions of Rails
+```ini
+ config.logger = Log4jruby::Logger.get('MyApp')
+```
+
+## Formatters
 
-    config.logger = Log4jruby::Logger.get('MyApp')
-                           
-### Examples
+See [`formatter` in the
+Ruby ::Logger docs](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/Logger.html)
 
-    def foo
-      logger.debug("hello from foo")
-      bar
-    rescue => e
-      logger.error(e)
-    end
+Log4jruby passes the same arguments to a `formatter` as would be passed using the standard Ruby Logger given the same logging invocations. 
 
-    DEBUG jruby.MyClass foo:17 - hello from foo
-    DEBUG jruby.MyClass bar:24 - hello from bar
-    DEBUG jruby.MyClass baz:29 - hello from baz
-    ERROR jruby.MyClass foo:20 - error from baz
-      examples/simple.rb:30:in `baz'
-      examples/simple.rb:25:in `bar'
-      examples/simple.rb:18:in `foo'
-      examples/simple.rb:35:in `(root)'
+The default Log4jruby formatter outputs `progname` and `msg` only (as opposed to the default formatter of the Ruby Logger).
+Severity, timestamp, and backtraces are handed according to your `Log4j` configuration. 
+E.g. [PatternLayout](https://logging.apache.org/log4j/2.x/manual/layouts.html).
 
-See more in [log4jruby/examples](examples).
+The output of the `formatter` is passed as the `message` parameter of the [Log4j log methods](https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/Category.html#log(org.apache.log4j.Priority,%20java.lang.Object).
 
-### Usage
+## Development
 
-    class MyClass
-      enable_logger
+Install log4j for tests and examples
 
-      class << self
-        def my_class_method
-          logger.info("hello from class method")
-        end
-      end
+`rake dev:java_deps`
 
-      def my_method
-        logger.info("hello from instance method")
-      end
-    end
+```
+e.g.
 
-    INFO jruby.MyModule.A my_class_method:14 - hello from class method
-    INFO jruby.MyModule.A my_method:19 - hello from instance method
+ruby ./examples/simple.rb
+```
 
-See more in [log4jruby/examples](examples)..
-They should be runnable from the source.
+### IRB
 
+```
+bundle exec irb
+irb(main):002:0> require './examples/setup.rb'
+irb(main):003:0> require 'log4jruby'
+irb(main):006:0> Log4jruby::Logger.root.debug('test')
+DEBUG jruby : - test
+```

data/lib/log4jruby/logger.rb

@@ -1,37 +1,27 @@
-require 'log4jruby/support/log4j_args'
+# frozen_string_literal: true
 
+require 'log4jruby/support/log4j_args'
+require 'log4jruby/support/levels'
+require 'log4jruby/support/location'
+require 'log4jruby/support/log_manager'
 require 'logger'
 
 module Log4jruby
-
   # Author::    Lenny Marks
   #
-  # Wrapper around org.apache.log4j.Logger with interface similar to standard ruby Logger.
+  # Wrapper around org.apache.logging.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
-    LOG4J_LEVELS = {
-        Java::org.apache.log4j.Level::DEBUG => ::Logger::DEBUG,
-        Java::org.apache.log4j.Level::INFO => ::Logger::INFO,
-        Java::org.apache.log4j.Level::WARN => ::Logger::WARN,
-        Java::org.apache.log4j.Level::ERROR => ::Logger::ERROR,
-        Java::org.apache.log4j.Level::FATAL => ::Logger::FATAL,
-    }
-
-    # 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
+    Support::LogManager.configure(logger_class: self)
 
     class << self
       # get Logger for name
       def[](name)
-        name = name.nil? ? 'jruby' : "jruby.#{name.gsub('::', '.')}"
-        log4j = Java::org.apache.log4j.Logger.getLogger(name)
-        fetch_logger(log4j)
+        name = name.nil? ? root.name : "#{root.name}.#{name.gsub('::', '.')}"
+        Support::LogManager.get_or_create(name)
       end
 
       # same as [] but accepts attributes
@@ -43,193 +33,139 @@ module Log4jruby
 
       # Return root Logger(i.e. jruby)
       def root
-        log4j = Java::org.apache.log4j.Logger.getLogger('jruby')
-        fetch_logger(log4j)
-      end
-
-      def reset # :nodoc:
-        Java::org.apache.log4j.LogManager.getCurrentLoggers.each do |l|
-          l.ruby_logger = nil
-        end
-      end
-
-      private
-
-      def fetch_logger(log4j_logger)
-        Java::org.apache.log4j.Logger.getLogger(log4j_logger.getName).ruby_logger
+        Support::LogManager.root
       end
     end
 
     def attributes=(values)
-      if values
-        values.each_pair do |k, v|
-          setter = "#{k}="
-          send(setter, v) if respond_to?(setter)
-        end
+      values&.each_pair do |k, v|
+        setter = "#{k}="
+        send(setter, v) if respond_to?(setter)
       end
     end
 
+    def name
+      log4j_logger.name
+    end
+
     # Shortcut for setting log levels. (:debug, :info, :warn, :error, :fatal)
     def level=(level)
-      @logger.level = case level
-      when :debug, ::Logger::DEBUG
-        Java::org.apache.log4j.Level::DEBUG
-      when :info, ::Logger::INFO
-        Java::org.apache.log4j.Level::INFO
-      when :warn, ::Logger::WARN
-        Java::org.apache.log4j.Level::WARN
-      when :error, ::Logger::ERROR
-        Java::org.apache.log4j.Level::ERROR
-      when :fatal, ::Logger::FATAL
-        Java::org.apache.log4j.Level::FATAL
-      else
-        raise NotImplementedError
-      end
+      @log4j_logger.level = Support::Levels.log4j_level(level)
     end
 
     def level
-      LOG4J_LEVELS[@logger.effectiveLevel]
+      Support::Levels.ruby_logger_level(@log4j_logger.level)
     end
 
     def flush
-      #rails compatability
+      # rails compatability
     end
 
     def debug(object = nil, &block)
-      if debug?
-        send_to_log4j(:debug, object, nil, &block)
-      end
+      send_to_log4j(:debug, object, &block) if debug?
     end
 
     def info(object = nil, &block)
-      if info?
-        send_to_log4j(:info, object, nil, &block)
-      end
+      send_to_log4j(:info, object, &block) if info?
     end
 
     def warn(object = nil, &block)
-      if warn?
-        send_to_log4j(:warn, object, nil, &block)
-      end
+      send_to_log4j(:warn, object, &block) if warn?
     end
 
     def error(object = nil, &block)
-      send_to_log4j(:error, object, nil, &block)
+      send_to_log4j(:error, object, &block)
     end
 
     def log_error(msg, error)
-      send_to_log4j(:error, msg, error)
+      send_to_log4j(:error, msg) { error }
     end
 
     def fatal(object = nil, &block)
-      send_to_log4j(:fatal, object, nil, &block)
+      send_to_log4j(:fatal, object, &block)
     end
 
     def log_fatal(msg, error)
-      send_to_log4j(:fatal, msg, error)
+      send_to_log4j(:fatal, msg) { error }
     end
 
-    # return org.apache.log4j.Logger instance backing this Logger
-    def log4j_logger
-      @logger
-    end
+    # return org.apache.logging.log4j.Logger instance backing this Logger
+    attr_reader :log4j_logger
 
     def debug?
-      @logger.isEnabledFor(Java::org.apache.log4j.Priority::DEBUG)
+      @log4j_logger.isEnabled(Java::org.apache.logging.log4j.Level::DEBUG)
     end
 
     def info?
-      @logger.isEnabledFor(Java::org.apache.log4j.Priority::INFO)
+      @log4j_logger.isEnabled(Java::org.apache.logging.log4j.Level::INFO)
     end
 
     def warn?
-      @logger.isEnabledFor(Java::org.apache.log4j.Priority::WARN)
+      @log4j_logger.isEnabled(Java::org.apache.logging.log4j.Level::WARN)
     end
 
     def tracing?
-      return @cached_tracing if defined?(@cached_tracing)
-      @cached_tracing = begin
-        if tracing.nil? && self != Logger.root
-          parent.tracing?
-        else
-          tracing == true
-        end
-      end
+      return @tracing if defined?(@tracing)
+
+      @tracing = self == Logger.root ? false : parent.tracing?
+    end
+    alias tracing tracing?
+
+    # turn tracing on to make fileName, lineNumber, and methodName available to
+    # appender layout through MDC(ie. %X{fileName} %X{lineNumber} %X{methodName})
+    def tracing=(bool)
+      @tracing = !!bool
     end
 
-    def effective_formatter
+    def formatter
       return @formatter if defined?(@formatter)
-      @formatter = begin
-        if @formatter.nil? && self != Logger.root
-          parent.formatter
-        else
-          @formatter
-        end
-      end
+
+      @formatter = if self == Logger.root
+                     ->(_severity, _datetime, progname, msg) { "-- #{progname}: #{msg}" }
+                   else
+                     parent.formatter
+                   end
     end
 
+    # @param [::Logger::Formatter]
+    attr_writer :formatter
+
     def parent
-      fetch_logger(log4j_logger.parent)
+      Support::LogManager.parent(log4j_logger.name)
     end
 
     # 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
+    def silence(temporary_level = ::Logger::ERROR, &blk)
+      with_level(temporary_level, &blk)
     end
 
-    private
+    def with_level(temporary_level = ::Logger::ERROR)
+      old_logger_level = level
+      self.level = temporary_level
+      yield self
+    ensure
+      self.level = old_logger_level
+    end
 
     def initialize(logger) # :nodoc:
-      @logger = logger
+      @log4j_logger = logger
     end
 
-    def with_context # :nodoc:
-      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)
-
-      begin
-        yield
-      ensure
-        mdc.remove('fileName')
-        mdc.remove('lineNumber')
-        mdc.remove('methodName')
-      end
-    end
+    private
 
-    def send_to_log4j(level, object, error, &block)
-      msg, throwable = Support::Log4jArgs.convert(object, error, &block)
-      if (f = effective_formatter)
-        msg = f.call(level, Time.now, @logger.getName, msg)
+    def send_to_log4j(level, object, &block)
+      progname, msg, throwable = Support::Log4jArgs.convert(object, &block)
+      if (f = formatter)
+        msg = f.call(level, Time.now, progname, msg)
       end
       if tracing?
-        with_context do
-          @logger.send(level, msg, throwable)
+        Support::Location.with_location do
+          @log4j_logger.send(level, msg, throwable)
         end
       else
-        @logger.send(level, msg, throwable)
+        @log4j_logger.send(level, msg, throwable)
       end
     end
-
-    def parse_caller(at) # :nodoc:
-      at.match(/^(.+?):(\d+)(?::in `(.*)')?/).captures
-    end
-
-    def 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/logger_for_class.rb

@@ -1,19 +1,19 @@
+# frozen_string_literal: true
+
 require 'log4jruby'
 
 module Log4jruby
-  
-  # Gives class its own Logger and makes it available via class and instance method. 
+  # Gives class its own Logger and makes it available via class and instance method.
   module LoggerForClass
-    
     def self.included(klass)
       def klass.logger
         @logger ||= Logger.get(name)
       end
-      
+
       def klass.logger=(logger)
         @logger = logger
       end
-      
+
       def klass.set_logger(name, options = {})
         @logger = Logger.get(name, options)
       end
@@ -23,4 +23,4 @@ module Log4jruby
       self.class.logger
     end
   end
-end
+end

data/lib/log4jruby/support/levels.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Log4jruby
+  module Support
+    # Utility methods for dealing with log levels
+    class Levels
+      LOG4J_LEVELS = {
+        Java::org.apache.logging.log4j.Level::DEBUG => ::Logger::DEBUG,
+        Java::org.apache.logging.log4j.Level::INFO => ::Logger::INFO,
+        Java::org.apache.logging.log4j.Level::WARN => ::Logger::WARN,
+        Java::org.apache.logging.log4j.Level::ERROR => ::Logger::ERROR,
+        Java::org.apache.logging.log4j.Level::FATAL => ::Logger::FATAL
+      }.freeze
+
+      class << self
+        def ruby_logger_level(log4j_level)
+          LOG4J_LEVELS[log4j_level]
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def log4j_level(ruby_logger_level)
+          case ruby_logger_level
+          when :debug, ::Logger::DEBUG
+            Java::org.apache.logging.log4j.Level::DEBUG
+          when :info, ::Logger::INFO
+            Java::org.apache.logging.log4j.Level::INFO
+          when :warn, ::Logger::WARN
+            Java::org.apache.logging.log4j.Level::WARN
+          when :error, ::Logger::ERROR
+            Java::org.apache.logging.log4j.Level::ERROR
+          when :fatal, ::Logger::FATAL
+            Java::org.apache.logging.log4j.Level::FATAL
+          when nil
+            # noop
+          else
+            raise NotImplementedError
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/log4jruby/support/location.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Log4jruby
+  module Support
+    # Utility methods for interacting with Log4j
+    # MDC (mapped diagnostic contexts)
+    # https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/MDC.html
+    class Location
+      class << self
+        def with_location # :nodoc:
+          file_line_method = parse_caller(caller(3).first)
+          context_put(file_line_method)
+          begin
+            yield
+          ensure
+            context_remove
+          end
+        end
+
+        private
+
+        def context_put((file, line, method))
+          thread_context.put('fileName', file)
+          thread_context.put('lineNumber', line)
+          thread_context.put('methodName', method.to_s)
+        end
+
+        def context_remove
+          thread_context.remove('fileName')
+          thread_context.remove('lineNumber')
+          thread_context.remove('methodName')
+        end
+
+        def parse_caller(at) # :nodoc:
+          at.match(/^(.+?):(\d+)(?::in `(.*)')?/).captures
+        end
+
+        def thread_context
+          Java::org.apache.logging.log4j.ThreadContext
+        end
+      end
+    end
+  end
+end

data/lib/log4jruby/support/log4j_args.rb

@@ -1,40 +1,43 @@
+# frozen_string_literal: true
+
 module Log4jruby
   module Support
+    # Translate logger args for use by Ruby Logger formatter and log4j.
+    # Intention is to matches the Ruby Logger for common parameters
     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
+        # Adapt permutations of ruby Logger arguments into arguments
+        # for Log4j Logger with explicit throwable when possible.
+        #
+        # The :progname and :msg returned by this method matches
+        # the arguments that would be passed to a
+        # Ruby Logger#formatter
+        #
+        # @param object [String | Exception] - Correlates to the `progname` param of the
+        #     ruby Logger. Exception passed to Log4j as throwable when no other
+        #     arguments are provided.
+        # @yield [] Return object to be used as the :msg (See Ruby ::Logger). Exceptions
+        #    will be used as Throwable arg to log4j.
+        #
+        # @return [Array<Object, Object, Java::Throwable>] -
+        #   Ruby Logger progname, Ruby Logger msg, throwable for log4j
+        def convert(object = nil)
+          # This implementation is very complex in order to support
+          yielded_val = block_given? ? yield : nil
 
-          [msg, exception]
+          exception = exception(yielded_val) || exception(object)
+          msg = yielded_val || object || exception
+          [progname(object, yielded_val), msg, exception&.to_java]
         end
 
         private
 
-        def append_ruby_error(msg, error)
-          append(msg, "#{error}\n  " + error.backtrace.join("\n  "))
+        def progname(object, yielded_val)
+          object && yielded_val ? object : nil
         end
 
-        def append(msg, s)
-          msg << "\n#{s}"
-          msg.lstrip!
+        def exception(obj)
+          obj.is_a?(::Exception) || obj.is_a?(Java::java.lang.Throwable) ? obj : nil
         end
       end
     end

data/lib/log4jruby/support/log_manager.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Log4jruby
+  module Support
+    # Internal class for tracking loggers in a thread safe manor
+    class LogManager
+      @loggers = {}
+      @mutex = Mutex.new.freeze
+
+      class << self
+        attr_reader :logger_class
+
+        def configure(logger_class:)
+          @logger_class = logger_class
+        end
+
+        def get_or_create(name)
+          raise 'name required' if name.to_s.match?(/^\s+$/)
+
+          @mutex.synchronize do
+            @loggers[name] ||= new_logger(name)
+          end
+        end
+
+        def get(name)
+          @mutex.synchronize { @loggers[name] }
+        end
+
+        # nodoc: testing only
+        def reset
+          @mutex.synchronize { @loggers.clear }
+          Java::org.apache.logging.log4j.LogManager.rootLogger.context.stop
+        end
+
+        def root
+          get_or_create('jruby')
+        end
+
+        def parent(name)
+          _parent(name.split('.'))
+        end
+
+        private
+
+        def new_logger(name)
+          log4j_logger = Java::org.apache.logging.log4j.LogManager.getLogger(name)
+          @logger_class.new(log4j_logger)
+        end
+
+        def _parent(name_path)
+          return root if name_path.empty?
+
+          parent_path = name_path[0, name_path.size - 1]
+          parent_name = parent_path.join('.')
+
+          get(parent_name) || _parent(parent_path)
+        end
+      end
+    end
+  end
+end

data/lib/log4jruby/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Log4jruby
-  VERSION = '2.0.1'
+  VERSION = '3.0.0.rc1'
 end

data/lib/log4jruby.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Log4jruby
+  # Support namespace
   module Support
   end
 end
 
-require 'log4jruby/support/bootstrap'
 require 'log4jruby/logger'
 require 'log4jruby/logger_for_class'
 

metadata

@@ -1,16 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: log4jruby
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0.rc1
 platform: java
 authors:
 - Lenny Marks
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2022-09-06 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.
+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:
 - lenny@aps.org
 executables: []
@@ -22,31 +24,37 @@ files:
 - lib/log4jruby.rb
 - lib/log4jruby/logger.rb
 - lib/log4jruby/logger_for_class.rb
-- lib/log4jruby/support/bootstrap.rb
+- lib/log4jruby/support/levels.rb
+- lib/log4jruby/support/location.rb
 - lib/log4jruby/support/log4j_args.rb
+- lib/log4jruby/support/log_manager.rb
 - lib/log4jruby/version.rb
 homepage: https://github.com/lenny/log4jruby
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 3.2.29
 signing_key:
 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.
+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/lib/log4jruby/support/bootstrap.rb

@@ -1,25 +0,0 @@
-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
-
-# https://github.com/lenny/log4jruby/issues/14
-# https://github.com/jruby/jruby/wiki/Persistence
-if Java::org.apache.log4j.Logger.respond_to?(:__persistent__)
-  Java::org.apache.log4j.Logger.__persistent__ = true
-end
-