1 /*
2 * Copyright 2009 Red Hat, Inc.
3 *
4 * Red Hat licenses this file to you under the Apache License, version 2.0
5 * (the "License"); you may not use this file except in compliance with the
6 * License. You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16 package org.jboss.netty.logging;
17
18 import org.jboss.netty.util.internal.StackTraceSimplifier;
19
20 /**
21 * Creates an {@link InternalLogger} or changes the default factory
22 * implementation. This factory allows you to choose what logging framework
23 * Netty should use. The default factory is {@link JdkLoggerFactory}.
24 * You can change it to your preferred logging framework before other Netty
25 * classes are loaded:
26 * <pre>
27 * {@link InternalLoggerFactory}.setDefaultFactory(new {@link Log4JLoggerFactory}());
28 * </pre>
29 * Please note that the new default factory is effective only for the classes
30 * which were loaded after the default factory is changed. Therefore,
31 * {@link #setDefaultFactory(InternalLoggerFactory)} should be called as early
32 * as possible and shouldn't be called more than once.
33 *
34 * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
35 * @author <a href="http://gleamynode.net/">Trustin Lee</a>
36 *
37 * @version $Rev: 2122 $, $Date: 2010-02-02 11:00:04 +0900 (Tue, 02 Feb 2010) $
38 *
39 * @apiviz.landmark
40 * @apiviz.has org.jboss.netty.logging.InternalLogger oneway - - creates
41 */
42 public abstract class InternalLoggerFactory {
43 private static volatile InternalLoggerFactory defaultFactory = new JdkLoggerFactory();
44
45 static {
46 // Load the dependent classes in advance to avoid the case where
47 // the VM fails to load the required classes because of too many open
48 // files.
49 StackTraceSimplifier.simplify(new Exception());
50 }
51
52 /**
53 * Returns the default factory. The initial default factory is
54 * {@link JdkLoggerFactory}.
55 */
56 public static InternalLoggerFactory getDefaultFactory() {
57 return defaultFactory;
58 }
59
60 /**
61 * Changes the default factory.
62 */
63 public static void setDefaultFactory(InternalLoggerFactory defaultFactory) {
64 if (defaultFactory == null) {
65 throw new NullPointerException("defaultFactory");
66 }
67 InternalLoggerFactory.defaultFactory = defaultFactory;
68 }
69
70 /**
71 * Creates a new logger instance with the name of the specified class.
72 */
73 public static InternalLogger getInstance(Class<?> clazz) {
74 return getInstance(clazz.getName());
75 }
76
77 /**
78 * Creates a new logger instance with the specified name.
79 */
80 public static InternalLogger getInstance(String name) {
81 final InternalLogger logger = getDefaultFactory().newInstance(name);
82 return new InternalLogger() {
83
84 public void debug(String msg) {
85 logger.debug(msg);
86 }
87
88 public void debug(String msg, Throwable cause) {
89 StackTraceSimplifier.simplify(cause);
90 logger.debug(msg, cause);
91 }
92
93 public void error(String msg) {
94 logger.error(msg);
95 }
96
97 public void error(String msg, Throwable cause) {
98 StackTraceSimplifier.simplify(cause);
99 logger.error(msg, cause);
100 }
101
102 public void info(String msg) {
103 logger.info(msg);
104 }
105
106 public void info(String msg, Throwable cause) {
107 StackTraceSimplifier.simplify(cause);
108 logger.info(msg, cause);
109 }
110
111 public boolean isDebugEnabled() {
112 return logger.isDebugEnabled();
113 }
114
115 public boolean isErrorEnabled() {
116 return logger.isErrorEnabled();
117 }
118
119 public boolean isInfoEnabled() {
120 return logger.isInfoEnabled();
121 }
122
123 public boolean isWarnEnabled() {
124 return logger.isWarnEnabled();
125 }
126
127 public void warn(String msg) {
128 logger.warn(msg);
129 }
130
131 public void warn(String msg, Throwable cause) {
132 StackTraceSimplifier.simplify(cause);
133 logger.warn(msg, cause);
134 }
135
136 public boolean isEnabled(InternalLogLevel level) {
137 return logger.isEnabled(level);
138 }
139
140 public void log(InternalLogLevel level, String msg) {
141 logger.log(level, msg);
142 }
143
144 public void log(InternalLogLevel level, String msg, Throwable cause) {
145 StackTraceSimplifier.simplify(cause);
146 logger.log(level, msg, cause);
147 }
148 };
149 }
150
151 /**
152 * Creates a new logger instance with the specified name.
153 */
154 public abstract InternalLogger newInstance(String name);
155 }