Jdk13LumberjackLogger.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *      http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */

  18. package org.apache.commons.logging.impl;

  20. import java.io.PrintWriter;
  21. import java.io.Serializable;
  22. import java.io.StringWriter;
  23. import java.util.StringTokenizer;
  24. import java.util.logging.Level;
  25. import java.util.logging.LogRecord;
  26. import java.util.logging.Logger;

  28. import org.apache.commons.logging.Log;

  30. /**
  31.  * Implements the {@code org.apache.commons.logging.Log}
  32.  * interface tp wrap the standard JDK logging mechanisms that are
  33.  * available in SourceForge's Lumberjack for JDKs prior to 1.4.
  34.  *
  35.  * @since 1.1
  36.  * @deprecated Scheduled for removal because the Lumberjack Project has been discontinued.
  37.  */
  38. @Deprecated
  39. public class Jdk13LumberjackLogger implements Log, Serializable {

  41.     /** Serializable version identifier. */
  42.     private static final long serialVersionUID = -8649807923527610591L;

  44.     /**
  45.      * This member variable simply ensures that any attempt to initialize
  46.      * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError.
  47.      * It must not be private, as an optimizing compiler could detect that it
  48.      * is not used and optimize it away.
  49.      *
  50.      * @deprecated No longer used.
  51.      */
  52.     @Deprecated
  53.     protected static final Level dummyLevel = Level.FINE;

  55.     /**
  56.      * The underlying Logger implementation we are using.
  57.      */
  58.     protected transient Logger logger;

  60.     /**
  61.      * Name.
  62.      */
  63.     protected String name;

  65.     /** Source class name. */
  66.     private String sourceClassName = "unknown";

  68.     /** Source method name. */
  69.     private String sourceMethodName = "unknown";

  71.     /** Class and method found flag. */
  72.     private boolean classAndMethodFound;

  74.     /**
  75.      * Constructs a named instance of this Logger.
  76.      *
  77.      * @param name Name of the logger to be constructed
  78.      */
  79.     public Jdk13LumberjackLogger(final String name) {
  80.         this.name = name;
  81.         logger = getLogger();
  82.     }

  84.     /**
  85.      * Logs a message with {@link java.util.logging.Level#FINE}.
  86.      *
  87.      * @param message to log
  88.      * @see org.apache.commons.logging.Log#debug(Object)
  89.      */
  90.     @Override
  91.     public void debug(final Object message) {
  92.         log(Level.FINE, String.valueOf(message), null);
  93.     }

  95.     /**
  96.      * Logs a message with {@link java.util.logging.Level#FINE}.
  97.      *
  98.      * @param message to log
  99.      * @param exception log this cause
  100.      * @see org.apache.commons.logging.Log#debug(Object, Throwable)
  101.      */
  102.     @Override
  103.     public void debug(final Object message, final Throwable exception) {
  104.         log(Level.FINE, String.valueOf(message), exception);
  105.     }

  107.     /**
  108.      * Logs a message with {@link java.util.logging.Level#SEVERE}.
  109.      *
  110.      * @param message to log
  111.      * @see org.apache.commons.logging.Log#error(Object)
  112.      */
  113.     @Override
  114.     public void error(final Object message) {
  115.         log(Level.SEVERE, String.valueOf(message), null);
  116.     }

  118.     /**
  119.      * Logs a message with {@link java.util.logging.Level#SEVERE}.
  120.      *
  121.      * @param message to log
  122.      * @param exception log this cause
  123.      * @see org.apache.commons.logging.Log#error(Object, Throwable)
  124.      */
  125.     @Override
  126.     public void error(final Object message, final Throwable exception) {
  127.         log(Level.SEVERE, String.valueOf(message), exception);
  128.     }

  130.     /**
  131.      * Logs a message with {@link java.util.logging.Level#SEVERE}.
  132.      *
  133.      * @param message to log
  134.      * @see org.apache.commons.logging.Log#fatal(Object)
  135.      */
  136.     @Override
  137.     public void fatal(final Object message) {
  138.         log(Level.SEVERE, String.valueOf(message), null);
  139.     }

  141.     /**
  142.      * Logs a message with {@link java.util.logging.Level#SEVERE}.
  143.      *
  144.      * @param message to log
  145.      * @param exception log this cause
  146.      * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
  147.      */
  148.     @Override
  149.     public void fatal(final Object message, final Throwable exception) {
  150.         log(Level.SEVERE, String.valueOf(message), exception);
  151.     }

  153.     /**
  154.      * Gets the class and method by looking at the stack trace for the
  155.      * first entry that is not this class.
  156.      */
  157.     private void getClassAndMethod() {
  158.         try {
  159.             final Throwable throwable = new Throwable();
  160.             throwable.fillInStackTrace();
  161.             final StringWriter stringWriter = new StringWriter();
  162.             final PrintWriter printWriter = new PrintWriter(stringWriter);
  163.             throwable.printStackTrace(printWriter);
  164.             final String traceString = stringWriter.toString();
  165.             final StringTokenizer tokenizer = new StringTokenizer(traceString, "\n");
  166.             tokenizer.nextToken();
  167.             String line = tokenizer.nextToken();
  168.             while (!line.contains(this.getClass().getName())) {
  169.                 line = tokenizer.nextToken();
  170.             }
  171.             while (line.contains(this.getClass().getName())) {
  172.                 line = tokenizer.nextToken();
  173.             }
  174.             final int start = line.indexOf("at ") + 3;
  175.             final int end = line.indexOf('(');
  176.             final String temp = line.substring(start, end);
  177.             final int lastPeriod = temp.lastIndexOf('.');
  178.             sourceClassName = temp.substring(0, lastPeriod);
  179.             sourceMethodName = temp.substring(lastPeriod + 1);
  180.         } catch (final Exception ex) {
  181.             // ignore - leave class and methodname unknown
  182.         }
  183.         classAndMethodFound = true;
  184.     }

  186.     /**
  187.      * Gets the native Logger instance we are using.
  188.      *
  189.      * @return the native Logger instance we are using.
  190.      */
  191.     public Logger getLogger() {
  192.         if (logger == null) {
  193.             logger = Logger.getLogger(name);
  194.         }
  195.         return logger;
  196.     }

  198.     /**
  199.      * Logs a message with {@link java.util.logging.Level#INFO}.
  200.      *
  201.      * @param message to log
  202.      * @see org.apache.commons.logging.Log#info(Object)
  203.      */
  204.     @Override
  205.     public void info(final Object message) {
  206.         log(Level.INFO, String.valueOf(message), null);
  207.     }

  209.     /**
  210.      * Logs a message with {@link java.util.logging.Level#INFO}.
  211.      *
  212.      * @param message to log
  213.      * @param exception log this cause
  214.      * @see org.apache.commons.logging.Log#info(Object, Throwable)
  215.      */
  216.     @Override
  217.     public void info(final Object message, final Throwable exception) {
  218.         log(Level.INFO, String.valueOf(message), exception);
  219.     }

  221.     /**
  222.      * Is debug logging currently enabled?
  223.      */
  224.     @Override
  225.     public boolean isDebugEnabled() {
  226.         return getLogger().isLoggable(Level.FINE);
  227.     }

  229.     /**
  230.      * Is error logging currently enabled?
  231.      */
  232.     @Override
  233.     public boolean isErrorEnabled() {
  234.         return getLogger().isLoggable(Level.SEVERE);
  235.     }

  237.     /**
  238.      * Is fatal logging currently enabled?
  239.      */
  240.     @Override
  241.     public boolean isFatalEnabled() {
  242.         return getLogger().isLoggable(Level.SEVERE);
  243.     }

  245.     /**
  246.      * Is info logging currently enabled?
  247.      */
  248.     @Override
  249.     public boolean isInfoEnabled() {
  250.         return getLogger().isLoggable(Level.INFO);
  251.     }

  253.     /**
  254.      * Is trace logging currently enabled?
  255.      */
  256.     @Override
  257.     public boolean isTraceEnabled() {
  258.         return getLogger().isLoggable(Level.FINEST);
  259.     }

  261.     /**
  262.      * Is warn logging currently enabled?
  263.      */
  264.     @Override
  265.     public boolean isWarnEnabled() {
  266.         return getLogger().isLoggable(Level.WARNING);
  267.     }

  269.     private void log( final Level level, final String msg, final Throwable ex ) {
  270.         if ( getLogger().isLoggable(level) ) {
  271.             final LogRecord record = new LogRecord(level, msg);
  272.             if ( !classAndMethodFound ) {
  273.                 getClassAndMethod();
  274.             }
  275.             record.setSourceClassName(sourceClassName);
  276.             record.setSourceMethodName(sourceMethodName);
  277.             if ( ex != null ) {
  278.                 record.setThrown(ex);
  279.             }
  280.             getLogger().log(record);
  281.         }
  282.     }

  284.     /**
  285.      * Logs a message with {@link java.util.logging.Level#FINEST}.
  286.      *
  287.      * @param message to log
  288.      * @see org.apache.commons.logging.Log#trace(Object)
  289.      */
  290.     @Override
  291.     public void trace(final Object message) {
  292.         log(Level.FINEST, String.valueOf(message), null);
  293.     }

  295.     /**
  296.      * Logs a message with {@link java.util.logging.Level#FINEST}.
  297.      *
  298.      * @param message to log
  299.      * @param exception log this cause
  300.      * @see org.apache.commons.logging.Log#trace(Object, Throwable)
  301.      */
  302.     @Override
  303.     public void trace(final Object message, final Throwable exception) {
  304.         log(Level.FINEST, String.valueOf(message), exception);
  305.     }

  307.     /**
  308.      * Logs a message with {@link java.util.logging.Level#WARNING}.
  309.      *
  310.      * @param message to log
  311.      * @see org.apache.commons.logging.Log#warn(Object)
  312.      */
  313.     @Override
  314.     public void warn(final Object message) {
  315.         log(Level.WARNING, String.valueOf(message), null);
  316.     }

  318.     /**
  319.      * Logs a message with {@link java.util.logging.Level#WARNING}.
  320.      *
  321.      * @param message to log
  322.      * @param exception log this cause
  323.      * @see org.apache.commons.logging.Log#warn(Object, Throwable)
  324.      */
  325.     @Override
  326.     public void warn(final Object message, final Throwable exception) {
  327.         log(Level.WARNING, String.valueOf(message), exception);
  328.     }
  329. }
Created with JaCoCo 0.8.12.202403310830