1
2
3
4
5
6
7
8
9
10
11
12
13
14 package org.eclipse.jetty.util.log;
15
16 import java.lang.reflect.Method;
17
18
19
20
21 public class LoggerLog implements Logger
22 {
23 private final Object _logger;
24 private final Method _debugMT;
25 private final Method _debugMAA;
26 private final Method _infoMT;
27 private final Method _infoMAA;
28 private final Method _warnMT;
29 private final Method _warnMAA;
30 private final Method _setDebugEnabledE;
31 private final Method _getLoggerN;
32 private final Method _getName;
33 private volatile boolean _debug;
34
35 public LoggerLog(Object logger)
36 {
37 try
38 {
39 _logger = logger;
40 Class<?> lc = logger.getClass();
41 _debugMT = lc.getMethod("debug", new Class[]{String.class, Throwable.class});
42 _debugMAA = lc.getMethod("debug", new Class[]{String.class, Object[].class});
43 _infoMT = lc.getMethod("info", new Class[]{String.class, Throwable.class});
44 _infoMAA = lc.getMethod("info", new Class[]{String.class, Object[].class});
45 _warnMT = lc.getMethod("warn", new Class[]{String.class, Throwable.class});
46 _warnMAA = lc.getMethod("warn", new Class[]{String.class, Object[].class});
47 Method _isDebugEnabled = lc.getMethod("isDebugEnabled");
48 _setDebugEnabledE = lc.getMethod("setDebugEnabled", new Class[]{Boolean.TYPE});
49 _getLoggerN = lc.getMethod("getLogger", new Class[]{String.class});
50 _getName = lc.getMethod("getName");
51
52 _debug = (Boolean)_isDebugEnabled.invoke(_logger);
53 }
54 catch(Exception x)
55 {
56 throw new IllegalStateException(x);
57 }
58 }
59
60 public String getName()
61 {
62 try
63 {
64 return (String)_getName.invoke(_logger);
65 }
66 catch (Exception e)
67 {
68 e.printStackTrace();
69 return null;
70 }
71 }
72
73 public void warn(String msg, Object... args)
74 {
75 try
76 {
77 _warnMAA.invoke(_logger, args);
78 }
79 catch (Exception e)
80 {
81 e.printStackTrace();
82 }
83 }
84
85 public void warn(Throwable thrown)
86 {
87 warn("", thrown);
88 }
89
90 public void warn(String msg, Throwable thrown)
91 {
92 try
93 {
94 _warnMT.invoke(_logger, msg, thrown);
95 }
96 catch (Exception e)
97 {
98 e.printStackTrace();
99 }
100 }
101
102 public void info(String msg, Object... args)
103 {
104 try
105 {
106 _infoMAA.invoke(_logger, args);
107 }
108 catch (Exception e)
109 {
110 e.printStackTrace();
111 }
112 }
113
114 public void info(Throwable thrown)
115 {
116 info("", thrown);
117 }
118
119 public void info(String msg, Throwable thrown)
120 {
121 try
122 {
123 _infoMT.invoke(_logger, msg, thrown);
124 }
125 catch (Exception e)
126 {
127 e.printStackTrace();
128 }
129 }
130
131 public boolean isDebugEnabled()
132 {
133 return _debug;
134 }
135
136 public void setDebugEnabled(boolean enabled)
137 {
138 try
139 {
140 _setDebugEnabledE.invoke(_logger, enabled);
141 _debug = enabled;
142 }
143 catch (Exception e)
144 {
145 e.printStackTrace();
146 }
147 }
148
149 public void debug(String msg, Object... args)
150 {
151 if (!_debug)
152 return;
153
154 try
155 {
156 _debugMAA.invoke(_logger, args);
157 }
158 catch (Exception e)
159 {
160 e.printStackTrace();
161 }
162 }
163
164 public void debug(Throwable thrown)
165 {
166 debug("", thrown);
167 }
168
169 public void debug(String msg, Throwable th)
170 {
171 if (!_debug)
172 return;
173
174 try
175 {
176 _debugMT.invoke(_logger, msg, th);
177 }
178 catch (Exception e)
179 {
180 e.printStackTrace();
181 }
182 }
183
184 public void ignore(Throwable ignored)
185 {
186 if (Log.isIgnored())
187 {
188 warn(Log.IGNORED, ignored);
189 }
190 }
191
192 public Logger getLogger(String name)
193 {
194 try
195 {
196 Object logger=_getLoggerN.invoke(_logger, name);
197 return new LoggerLog(logger);
198 }
199 catch (Exception e)
200 {
201 e.printStackTrace();
202 return this;
203 }
204 }
205 }