log4jruby 0.4.0

data/README.rdoc

@@ -0,0 +1,87 @@
+= Log4jruby
+
+* https://github.com/lenny/log4jruby
+
+== 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]. Logging is configured via traditional Log4j methods.
+
+* 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>
+
+    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
+
+    log4j.logger.jruby=info,Ruby
+    log4j.logger.jruby.MyClass=debug
+
+=== Examples
+
+    def foo
+      logger.debug("hello from foo")
+      begin
+        bar
+      rescue => e
+        logger.error(e)
+      end
+    end
+
+    DEBUG jruby.MyClass foo:15 - hello from foo
+    DEBUG jruby.MyClass bar:24 - hello from bar
+    DEBUG jruby.MyClass baz:29 - hello from baz
+    ERROR jruby.MyClass foo:19 - error from baz
+      examples/simple.rb:30:in `baz'
+      examples/simple.rb:25:in `bar'
+      examples/simple.rb:17:in `foo'
+      examples/simple.rb:35
+
+
+Mix It In
+
+	class MyClass
+	  include Log4jruby::LoggerForClass
+  
+	  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 examples/logger_per_class.rb my_class_method:11 - hello from class method
+	INFO examples/logger_per_class.rb my_method:16 - hello from instance method
+	
+See more in {log4jruby/examples}[http://github.com/lenny/log4jruby/tree/master/examples/]. They should be runnable from the source.
+
+== Installation
+  > gem install log4jruby
+  
+  or
+  
+	> git clone git://github.com/lenny/log4jruby.git
+	
+== Usage
+
+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.
+
+=== 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.
+
+   require 'log4jruby/rails'
+   Log4jruby::Rails.configure do |c|
+      c.logger_name = 'MyApp'
+   end

data/lib/log4jruby.rb

@@ -0,0 +1 @@
+require 'log4jruby/logger'

data/lib/log4jruby/log4j_args.rb

@@ -0,0 +1,40 @@
+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/logger.rb

@@ -0,0 +1,202 @@
+require 'log4jruby/log4j_args'
+
+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}) 
+  class Logger
+    BLANK_CALLER = ['', '', ''] #:nodoc:
+    
+    # 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
+
+    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
+      end
+      
+      # same as [] but acceptions 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)
+        end
+        log4jruby
+      end   
+    end
+    
+    def attributes=(values)
+      if values
+        values.each_pair do |k, v|
+          setter = "#{k}="
+          send(setter, v) if respond_to?(setter)
+        end
+      end
+    end
+    
+    # Shortcut for setting log levels. (:debug, :info, :warn, :error)
+    def level=(level)
+      @logger.level = case level
+      when :debug
+        then Java::org.apache.log4j.Level::DEBUG
+      when :info
+        then Java::org.apache.log4j.Level::INFO
+      when :warn
+        then Java::org.apache.log4j.Level::WARN
+      when :error
+        then Java::org.apache.log4j.Level::ERROR
+      else
+        raise NotImplementedError
+      end
+    end
+    
+    def level
+      @logger.level
+    end
+    
+    def flush
+      #rails compatability
+    end
+
+    def debug(object = nil, &block)
+      if debug?
+        send_to_log4j(:debug, object, nil, &block)
+      end
+    end
+
+    def info(object = nil, &block)
+      if info?
+        send_to_log4j(:info, object, nil, &block)
+      end
+    end
+
+    def warn(object = nil, &block)
+      if warn?
+        send_to_log4j(:warn, object, nil, &block)
+      end
+    end
+
+    def error(object = nil, &block)
+      send_to_log4j(:error, object, nil, &block)
+    end
+
+    def log_error(msg, error)
+      send_to_log4j(:error, msg, error)
+    end
+
+    def fatal(object = nil, &block)
+      send_to_log4j(:fatal, object, nil, &block)
+    end
+
+    def log_fatal(msg, error)
+      send_to_log4j(:fatal, msg, error)
+    end
+
+    # return org.apache.log4j.Logger instance backing this Logger
+    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?
+        end
+      else
+        tracing == true
+      end
+    end
+    
+    def parent
+      logger_mapping[log4j_logger.parent] || Logger.root
+    end
+    
+    private
+    
+    def logger_mapping
+      Logger.logger_mapping
+    end
+
+    def initialize(logger, values = {}) # :nodoc:
+      @logger = logger  
+     
+      Logger.logger_mapping[@logger] = self
+      
+      self.attributes = values
+    end
+    
+    def with_context # :nodoc:
+      file_line_method = tracing? ? parse_caller(caller(3).first) : BLANK_CALLER
+
+      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
+
+    def send_to_log4j(level, object, error, &block)
+      msg, throwable = Log4jArgs.convert(object, error, &block)
+      with_context do
+        @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
+    
+  end
+end

data/lib/log4jruby/logger_for_class.rb

@@ -0,0 +1,26 @@
+require 'log4jruby'
+
+module Log4jruby
+  
+  # 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
+    end
+
+    def logger
+      self.class.logger
+    end
+  end
+end

data/lib/log4jruby/rails.rb

@@ -0,0 +1,62 @@
+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

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: log4jruby
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 4
+    - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+  - Lenny Marks
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-02 00:00:00 -05:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 1
+              - 3
+              - 1
+            version: 1.3.1
+    type: :development
+    version_requirements: *id001
+description: "  Log4jruby is a thin wrapper around the Log4j Logger. It is geared more toward \n  those who are using JRuby to integrate with and build on top of Java code that \n  uses Log4j. The Log4jruby::Logger provides an interface much like the standard \n  ruby Logger. Your ruby loggers are given a .jruby prefix and can be configured \n  along with the loggers for your Java code.\n"
+email: 
+  - lenny@aps.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.rdoc
+files: 
+  - lib/log4jruby.rb
+  - lib/log4jruby/logger.rb
+  - lib/log4jruby/logger_for_class.rb
+  - lib/log4jruby/log4j_args.rb
+  - lib/log4jruby/rails.rb
+  - README.rdoc
+  - History.txt
+has_rdoc: true
+homepage: https://github.com/lenny/log4jruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.rdoc
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: 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.
+test_files: []
+