View Javadoc

1   /**
2    * Copyright (c) 2004-2011 QOS.ch
3    * All rights reserved.
4    *
5    * Permission is hereby granted, free  of charge, to any person obtaining
6    * a  copy  of this  software  and  associated  documentation files  (the
7    * "Software"), to  deal in  the Software without  restriction, including
8    * without limitation  the rights to  use, copy, modify,  merge, publish,
9    * distribute,  sublicense, and/or sell  copies of  the Software,  and to
10   * permit persons to whom the Software  is furnished to do so, subject to
11   * the following conditions:
12   *
13   * The  above  copyright  notice  and  this permission  notice  shall  be
14   * included in all copies or substantial portions of the Software.
15   *
16   * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
17   * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
18   * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
19   * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20   * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21   * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
22   * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23   *
24   */
25  package org.slf4j.ext;
26  
27  import org.slf4j.Logger;
28  import org.slf4j.Marker;
29  import org.slf4j.MarkerFactory;
30  import org.slf4j.helpers.FormattingTuple;
31  import org.slf4j.helpers.MessageFormatter;
32  import org.slf4j.spi.LocationAwareLogger;
33  
34  /**
35   * A utility that provides standard mechanisms for logging certain kinds of
36   * activities.
37   * 
38   * @author Ralph Goers
39   * @author Ceki Gülcü
40   */
41  public class XLogger extends LoggerWrapper implements Logger {
42  
43      private static final String FQCN = XLogger.class.getName();
44      static Marker FLOW_MARKER = MarkerFactory.getMarker("FLOW");
45      static Marker ENTRY_MARKER = MarkerFactory.getMarker("ENTRY");
46      static Marker EXIT_MARKER = MarkerFactory.getMarker("EXIT");
47  
48      static Marker EXCEPTION_MARKER = MarkerFactory.getMarker("EXCEPTION");
49      static Marker THROWING_MARKER = MarkerFactory.getMarker("THROWING");
50      static Marker CATCHING_MARKER = MarkerFactory.getMarker("CATCHING");
51  
52      static String EXIT_MESSAGE_0 = "exit";
53      static String EXIT_MESSAGE_1 = "exit with ({})";
54  
55      static String ENTRY_MESSAGE_0 = "entry";
56      static String ENTRY_MESSAGE_1 = "entry with ({})";
57      static String ENTRY_MESSAGE_2 = "entry with ({}, {})";
58      static String ENTRY_MESSAGE_3 = "entry with ({}, {}, {})";
59      static String ENTRY_MESSAGE_4 = "entry with ({}, {}, {}, {})";
60      static int ENTRY_MESSAGE_ARRAY_LEN = 5;
61      static String[] ENTRY_MESSAGE_ARRAY = new String[ENTRY_MESSAGE_ARRAY_LEN];
62      static {
63          ENTRY_MARKER.add(FLOW_MARKER);
64          EXIT_MARKER.add(FLOW_MARKER);
65          THROWING_MARKER.add(EXCEPTION_MARKER);
66          CATCHING_MARKER.add(EXCEPTION_MARKER);
67  
68          ENTRY_MESSAGE_ARRAY[0] = ENTRY_MESSAGE_0;
69          ENTRY_MESSAGE_ARRAY[1] = ENTRY_MESSAGE_1;
70          ENTRY_MESSAGE_ARRAY[2] = ENTRY_MESSAGE_2;
71          ENTRY_MESSAGE_ARRAY[3] = ENTRY_MESSAGE_3;
72          ENTRY_MESSAGE_ARRAY[4] = ENTRY_MESSAGE_4;
73      }
74  
75      public enum Level {
76          TRACE("TRACE", LocationAwareLogger.TRACE_INT), DEBUG("DEBUG", LocationAwareLogger.DEBUG_INT), INFO("INFO", LocationAwareLogger.INFO_INT), WARN("WARN",
77                          LocationAwareLogger.WARN_INT), ERROR("ERROR", LocationAwareLogger.ERROR_INT);
78  
79          private final String name;
80          private final int level;
81  
82          public String toString() {
83              return this.name;
84          }
85  
86          public int intValue() {
87              return this.level;
88          }
89  
90          private Level(String name, int level) {
91              this.name = name;
92              this.level = level;
93          }
94      }
95  
96      /**
97       * Given an underlying logger, construct an XLogger
98       * 
99       * @param logger
100      *          underlying logger
101      */
102     public XLogger(Logger logger) {
103         // If class B extends A, assuming B does not override method x(), the caller
104         // of new B().x() is A and not B, see also
105         // http://jira.qos.ch/browse/SLF4J-105
106         super(logger, LoggerWrapper.class.getName());
107     }
108 
109     /**
110      * Log method entry.
111      * 
112      * @param argArray
113      *          supplied parameters
114      */
115     public void entry(Object... argArray) {
116         if (instanceofLAL && logger.isTraceEnabled(ENTRY_MARKER)) {
117             String messagePattern = null;
118             if (argArray.length < ENTRY_MESSAGE_ARRAY_LEN) {
119                 messagePattern = ENTRY_MESSAGE_ARRAY[argArray.length];
120             } else {
121                 messagePattern = buildMessagePattern(argArray.length);
122             }
123             FormattingTuple tp = MessageFormatter.arrayFormat(messagePattern, argArray);
124             ((LocationAwareLogger) logger).log(ENTRY_MARKER, FQCN, LocationAwareLogger.TRACE_INT, tp.getMessage(), argArray, tp.getThrowable());
125         }
126     }
127 
128     /**
129      * Log method exit
130      */
131     public void exit() {
132         if (instanceofLAL && logger.isTraceEnabled(ENTRY_MARKER)) {
133             ((LocationAwareLogger) logger).log(EXIT_MARKER, FQCN, LocationAwareLogger.TRACE_INT, EXIT_MESSAGE_0, null, null);
134         }
135     }
136 
137     /**
138      * Log method exit
139      * 
140      * @param result
141      *          The result of the method being exited
142      */
143     public <T> T exit(T result) {
144         if (instanceofLAL && logger.isTraceEnabled(ENTRY_MARKER)) {
145             FormattingTuple tp = MessageFormatter.format(EXIT_MESSAGE_1, result);
146             ((LocationAwareLogger) logger).log(EXIT_MARKER, FQCN, LocationAwareLogger.TRACE_INT, tp.getMessage(), new Object[] { result }, tp.getThrowable());
147         }
148         return result;
149     }
150 
151     /**
152      * Log an exception being thrown. The generated log event uses Level ERROR.
153      * 
154      * @param throwable
155      *          the exception being caught.
156      */
157     public <T extends Throwable> T throwing(T throwable) {
158         if (instanceofLAL) {
159             ((LocationAwareLogger) logger).log(THROWING_MARKER, FQCN, LocationAwareLogger.ERROR_INT, "throwing", null, throwable);
160         }
161         return throwable;
162     }
163 
164     /**
165      * Log an exception being thrown allowing the log level to be specified.
166      * 
167      * @param level
168      *          the logging level to use.
169      * @param throwable
170      *          the exception being caught.
171      */
172     public <T extends Throwable> T throwing(Level level, T throwable) {
173         if (instanceofLAL) {
174             ((LocationAwareLogger) logger).log(THROWING_MARKER, FQCN, level.level, "throwing", null, throwable);
175         }
176         return throwable;
177     }
178 
179     /**
180      * Log an exception being caught. The generated log event uses Level ERROR.
181      * 
182      * @param throwable
183      *          the exception being caught.
184      */
185     public void catching(Throwable throwable) {
186         if (instanceofLAL) {
187             ((LocationAwareLogger) logger).log(CATCHING_MARKER, FQCN, LocationAwareLogger.ERROR_INT, "catching", null, throwable);
188         }
189     }
190 
191     /**
192      * Log an exception being caught allowing the log level to be specified.
193      * 
194      * @param level
195      *          the logging level to use.
196      * @param throwable
197      *          the exception being caught.
198      */
199     public void catching(Level level, Throwable throwable) {
200         if (instanceofLAL) {
201             ((LocationAwareLogger) logger).log(CATCHING_MARKER, FQCN, level.level, "catching", null, throwable);
202         }
203     }
204 
205     private static String buildMessagePattern(int len) {
206         StringBuilder sb = new StringBuilder();
207         sb.append(" entry with (");
208         for (int i = 0; i < len; i++) {
209             sb.append("{}");
210             if (i != len - 1)
211                 sb.append(", ");
212         }
213         sb.append(')');
214         return sb.toString();
215     }
216 }