log4j2_logger_bridge 1.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f03bc99125d4e93d9c2b50ffa1e105881bf26d933faeb179caa55cda476bf0c0
+  data.tar.gz: 6d2de401a6ea49ca9f932edfc2852da7152c5eb86c52fe27d0626e945b4826ac
+SHA512:
+  metadata.gz: 544eb01b920127d42859a28a96b3e31da2091e589735de2d8ebedb9999e580fbf5c3d318b456890b885aabe1c709a3942f1250e48a041d0562b00238ae1005da
+  data.tar.gz: cb8ddfbd3ae21e86376a89695d14dbff8b4e137fb38039238d4f8e2004623b4e2f24fa1d691484d9a82f73c72daea8a73aafeedf8802777c522142ee0acd18f3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Nels Nelson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,8 @@
+# log4j2_logger_bridge
+
+This gem is a bridge between Apache log4j-2 and the Ruby logger gem.
+
+It attempts to provide a single unified interface for both logging
+technologies, so that switching between either backend can be accomplished
+without much effort.
+

data/Rakefile

@@ -0,0 +1,65 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require 'rake'
+require 'rake/clean'
+
+PROJECT = File.basename(__dir__) unless defined?(PROJECT)
+
+load "#{PROJECT}.gemspec"
+
+CLEAN.add File.join('tmp', '**', '*'), 'tmp'
+CLOBBER.add '*.gem', 'pkg'
+
+task default: %i[package]
+
+desc 'Run the rubocop linter'
+task :lint do
+  system('bundle', 'exec', 'rubocop') or abort
+end
+
+desc 'Run the spec tests'
+task :test do
+  system('bundle', 'exec', 'rspec') or abort
+end
+task test: :lint
+
+desc 'Explode the gem'
+task :explode do
+  system('jgem', 'install', '--no-document', '--install-dir=tmp', '*.gem')
+end
+task explode: :clean
+
+desc 'Package the gem'
+task :package do
+  system('jgem', 'build')
+end
+task package: %i[clean clobber test]
+
+desc 'Verify the gem'
+task :verify do
+  env = {
+    'GEM_HOME' => 'tmp',
+    'GEM_PATH' => 'tmp',
+    'BUNDLE_GEMFILE' => nil,
+    'RUBYOPT' => nil
+  }
+
+  # cmd = ['jruby', '-S', 'rspec', 'spec/verify']
+  cmd = ['bundle', 'exec', 'rspec', 'spec/verify']
+  system(env, *cmd) or abort
+end
+task verify: :explode
+
+desc 'Publish the gem'
+task :publish do
+  system('jgem', 'push', latest_gem)
+end
+task publish: :verify
+
+def latest_gem
+  `ls -t #{GEM_SPEC.name}*.gem`.strip.split("\n").first
+end

data/lib/log4j2_logger_bridge/backend.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require_relative 'utils'
+
+if Log4j2LoggerBridge::Utils.jruby?
+  require 'java'
+  require 'apache-log4j-2'
+
+  java_import 'org.apache.logging.log4j.Level'
+  java_import 'org.apache.logging.log4j.core.appender.ConsoleAppender'
+  java_import 'org.apache.logging.log4j.core.config.builder.api.' \
+    'ConfigurationBuilderFactory'
+  java_import 'org.apache.logging.log4j.core.config.Configurator'
+  java_import 'org.apache.logging.log4j.core.config.LoggerConfig'
+  java_import 'org.apache.logging.log4j.core.LoggerContext'
+  java_import 'org.apache.logging.log4j.LogManager'
+  java_import 'org.apache.logging.log4j.ThreadContext'
+end
+
+require 'fileutils'
+require 'logger'
+
+require_relative 'helpers'
+require_relative 'injection'
+require_relative 'log4j2_initialization_methods'
+require_relative 'ruby_logger_initialization_methods'
+require_relative 'proxy'
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  extend RubyLoggerInitializationMethods unless Utils.jruby?
+  extend Log4j2InitializationMethods if Utils.jruby?
+
+  module_function
+
+  def backend
+    @backend ||= init_backend
+  end
+
+  def proxy
+    @proxy ||= Proxy.new
+  end
+
+  def init_backend
+    return init_log4j_backend if Utils.jruby?
+    init_ruby_logger_backend
+  end
+
+  def dispatch(level, *args, &block)
+    return backend.public_send(level, *args, &block) if Utils.jruby?
+
+    case level
+    when :fatal then backend.fatal(*args, &block)
+    when :warn then backend.warn(*args, &block)
+    else
+      backend.public_send(level, *args, &block)
+    end
+  end
+
+  # rubocop: disable Metrics/MethodLength
+  def with_category(category)
+    if Utils.jruby?
+      prev = ThreadContext.get('category')
+
+      begin
+        ThreadContext.put('category', category)
+        yield
+      ensure
+        if prev.nil?
+          ThreadContext.remove('category')
+        else
+          ThreadContext.put('category', prev)
+        end
+      end
+    else
+      prev = Thread.current[:logging_category]
+
+      begin
+        Thread.current[:logging_category] = category
+        yield
+      ensure
+        Thread.current[:logging_category] = prev
+      end
+    end
+  end
+  # rubocop: enable Metrics/MethodLength
+
+  def log_level
+    @log_level ||= :info
+  end
+
+  def log_level=(level)
+    @log_level = case level
+    when Integer
+      int_to_symbol_level(level)
+    when Symbol, String
+      level.to_s.downcase.to_sym
+    else
+      :info
+    end
+
+    apply_backend_level(@log_level)
+  end
+
+  def apply_backend_level(sym)
+    if Utils.jruby?
+      ctx = @log4j2_context || LoggerContext.getContext(false)
+      app_cfg = app_config(ctx.getConfiguration, sym)
+      app_cfg.setLevel(symbol_to_java_level(sym))
+      ctx.updateLoggers
+    else
+      backend.level = symbol_to_ruby_logger_level(sym)
+    end
+
+    sym
+  end
+
+  def app_config(context_configuration, sym)
+    app_cfg = context_configuration.getLoggerConfig(app_logger_name)
+    return app_cfg if !app_cfg.nil? && app_cfg.getName == app_logger_name
+
+    init_app_logging_config(context_configuration, app_logger_name, sym)
+  end
+
+  def init_app_logging_config(context_configuration, app_logger_name, sym)
+    app_cfg = LoggerConfig.newBuilder.withConfig(context_configuration)
+      .withLoggerName(app_logger_name).withLevel(symbol_to_java_level(sym))
+      .withAdditivity(false).build
+    if (appender = context_configuration.getAppender('stdout')).nil?
+      app_cfg.setAdditive(true)
+    else
+      app_cfg.addAppender(appender, Level::INFO, nil)
+    end
+    context_configuration.addLogger(app_logger_name, app_cfg)
+    app_cfg
+  end
+end
+# end Log4j2LoggerBridge

data/lib/log4j2_logger_bridge/constants.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The Constants module
+  module Constants
+    DEFAULT_TIME_FORMAT = '%Y-%m-%d %H:%M:%S'.freeze
+    DEFAULT_APP_NAME = 'app'.freeze
+    DEFAULT_LOG_PATTERN = '%d{ABSOLUTE} %-5p [%X{category}] %m%n'.freeze
+    DEFAULT_RUBY_LOG_FORMAT =
+      "%<timestamp>s %-5<severity>s [%<category>s] %<msg>s\n".freeze
+    EMPTY_STRING = ''.freeze
+
+    NUMERIC_TO_SYMBOL = {
+      5 => :off,
+      4 => :fatal,
+      3 => :error,
+      2 => :warn,
+      1 => :info,
+      0 => :debug,
+      -1 => :trace
+    }.freeze
+
+    SYMBOL_TO_RUBY = {
+      off: Logger::FATAL,
+      fatal: Logger::FATAL,
+      error: Logger::ERROR,
+      warn: Logger::WARN,
+      info: Logger::INFO,
+      debug: Logger::DEBUG,
+      trace: Logger::DEBUG,
+      all: Logger::DEBUG
+    }.freeze
+  end
+end
+# module Log4j2LoggerBridge

data/lib/log4j2_logger_bridge/helpers.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require_relative 'constants'
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The Helpers module
+  module Helpers
+    include Constants
+
+    module_function
+
+    def app_name
+      DEFAULT_APP_NAME
+    end
+
+    def app_logger_name
+      DEFAULT_APP_NAME
+    end
+
+    def time_format
+      DEFAULT_TIME_FORMAT
+    end
+
+    def ruby_log_format
+      DEFAULT_RUBY_LOG_FORMAT
+    end
+
+    def java_log_pattern
+      DEFAULT_LOG_PATTERN
+    end
+
+    def int_to_symbol_level(level)
+      NUMERIC_TO_SYMBOL.fetch(level) do
+        level > 5 ? :off : :all
+      end
+    end
+
+    # rubocop: disable Metrics/CyclomaticComplexity
+    def symbol_to_java_level(sym)
+      case sym
+      when :off then Level::OFF
+      when :fatal then Level::FATAL
+      when :error then Level::ERROR
+      when :warn then Level::WARN
+      when :debug then Level::DEBUG
+      when :trace then Level::TRACE
+      when :all then Level::ALL
+      else Level::INFO
+      end
+    end
+    # rubocop: enable Metrics/CyclomaticComplexity
+
+    def symbol_to_ruby_logger_level(sym, default_level = Logger::INFO)
+      SYMBOL_TO_RUBY.fetch(sym, default_level)
+    end
+  end
+  # module Helpers
+
+  extend Helpers
+end
+# module Log4j2LoggerBridge

data/lib/log4j2_logger_bridge/injection.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The Injection module
+  module Injection
+    # Make `log` and `logger` available everywhere, capturing receiver + callsite.
+    def logger
+      Thread.current[:logging_receiver] = self
+      Thread.current[:logging_callsite] = caller_locations(1, 1).first
+      Log4j2LoggerBridge.proxy
+    end
+    alias log logger
+  end
+end

data/lib/log4j2_logger_bridge/log4j2_initialization_methods.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+return unless Log4j2LoggerBridge::Utils.jruby?
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The Log4j2InitializationMethods module
+  module Log4j2InitializationMethods
+    def init_log4j_backend
+      init_log4j2!
+      apply_backend_level(log_level)
+      LogManager.getLogger(app_logger_name)
+    end
+
+    def init_log4j2!
+      return if @log4j2_initialized
+
+      Java::java.lang.System.setProperty(
+        'log4j.shutdownHookEnabled', Java::java.lang.Boolean.toString(false))
+
+      configure_log4j
+
+      @log4j2_initialized = true
+    end
+
+    def configure_log4j
+      @log4j2_context = Configurator.initialize(log4j_configuration.build)
+      @log4j2_context.updateLoggers
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def log4j_configuration(
+        config = ConfigurationBuilderFactory.newConfigurationBuilder)
+      layout = config.newLayout('PatternLayout')
+        .addAttribute('pattern', java_log_pattern)
+      console = config.newAppender('stdout', 'CONSOLE')
+        .addAttribute('target', ConsoleAppender::Target::SYSTEM_OUT).add(layout)
+      config.add(console)
+      root = config.newRootLogger(Level::INFO)
+        .add(config.newAppenderRef('stdout'))
+      config.add(root)
+      app_logger = config.newLogger(app_logger_name, Level::INFO)
+        .add(config.newAppenderRef('stdout'))
+        .addAttribute('additivity', false)
+      config.add(app_logger)
+      config
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def derive_category(receiver, callsite)
+      if receiver.is_a?(Module)
+        receiver.name.to_s
+      elsif receiver.respond_to?(:class) && receiver.class.respond_to?(:name)
+        receiver.class.name.to_s
+      else
+        Log4j2LoggerBridge::Constants::EMPTY_STRING
+      end.tap do |cat|
+        return cat unless cat.empty?
+      end
+
+      File.basename(callsite.path.to_s)
+    end
+  end
+  # module RubyLoggerInitializationMethods
+end
+# module Log4j2LoggerBridge

data/lib/log4j2_logger_bridge/proxy.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The Proxy class
+  class Proxy
+    SEVERITIES = %i[trace debug info warn error fatal].freeze
+
+    def method_missing(method_name, *args, &block)
+      return super unless SEVERITIES.include?(method_name)
+
+      receiver = Thread.current[:logging_receiver]
+      callsite = Thread.current[:logging_callsite] || caller_locations(2, 1).first
+      category = Log4j2LoggerBridge.derive_category(receiver, callsite)
+
+      Log4j2LoggerBridge.with_category(category) do
+        Log4j2LoggerBridge.dispatch(method_name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      SEVERITIES.include?(method_name) || super
+    end
+  end
+end

data/lib/log4j2_logger_bridge/ruby_logger_initialization_methods.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+return if Log4j2LoggerBridge::Utils.jruby?
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The RubyLoggerInitializationMethods module
+  module RubyLoggerInitializationMethods
+    TRACE_STRING = 'TRACE'.freeze
+    TRACE_SEVERITY = -1
+
+    def init_ruby_logger_backend
+      ruby_logger = Logger.new($stdout)
+      ruby_logger.formatter = method(:ruby_formatter)
+      @backend = ruby_logger
+      install_trace_level!
+      apply_backend_level(log_level)
+      ruby_logger
+    end
+
+    def ruby_formatter(severity, datetime, _progname, msg)
+      category = (Thread.current[:logging_category] || app_name).to_s
+      timestamp = datetime.strftime(time_format)
+      format(ruby_log_format, timestamp: timestamp,
+        severity: severity_label(severity), category: category, msg: msg)
+    end
+
+    def severity_label(severity)
+      return TRACE_STRING if severity == ::Logger::Severity::TRACE
+      ::Logger::SEV_LABEL[severity] || severity.to_s
+    end
+
+    # rubocop: disable Metrics/MethodLength
+    def install_trace_level!(sev = ::Logger::Severity)
+      sev.const_set(:TRACE, TRACE_SEVERITY) unless sev.const_defined?(:TRACE)
+
+      ::Logger.class_eval do
+        unless method_defined?(:trace)
+          def trace(progname = nil, &block)
+            add(sev::TRACE, nil, progname, &block)
+          end
+        end
+
+        unless method_defined?(:trace?)
+          def trace?
+            level <= sev::TRACE
+          end
+        end
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+  end
+  # module RubyLoggerInitializationMethods
+end
+# module Log4j2LoggerBridge

data/lib/log4j2_logger_bridge/utils.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# The Log4j2LoggerBridge module
+module Log4j2LoggerBridge
+  # The Utils module
+  module Utils
+    module_function
+
+    def jruby?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && defined?(Java)
+    end
+  end
+
+  extend Utils
+end

data/lib/log4j2_logger_bridge/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+module Log4j2LoggerBridge
+  VERSION = '1.0.1'.freeze
+end

data/lib/log4j2_logger_bridge.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require_relative 'log4j2_logger_bridge/backend'
+
+Object.include(Log4j2LoggerBridge::Injection)

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: log4j2_logger_bridge
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: java
+authors:
+- Nels Nelson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: apache-log4j-2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.25.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.25.3
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: Bridge between Log4j2 and the Ruby Logger.
+email: nels@nelsnelson.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/log4j2_logger_bridge.rb
+- lib/log4j2_logger_bridge/backend.rb
+- lib/log4j2_logger_bridge/constants.rb
+- lib/log4j2_logger_bridge/helpers.rb
+- lib/log4j2_logger_bridge/injection.rb
+- lib/log4j2_logger_bridge/log4j2_initialization_methods.rb
+- lib/log4j2_logger_bridge/proxy.rb
+- lib/log4j2_logger_bridge/ruby_logger_initialization_methods.rb
+- lib/log4j2_logger_bridge/utils.rb
+- lib/log4j2_logger_bridge/version.rb
+homepage: https://rubygems.org/gems/log4j2_logger_bridge
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://gitlab.com/nelsnelson/log4j2_logger_bridge
+  bug_tracker_uri: https://gitlab.com/nelsnelson/log4j2_logger_bridge/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Bridge between Log4j2 and the Ruby Logger packaged as a gem.
+test_files: []