1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.logging.log4j.core.config;
18
19 import java.net.URI;
20 import java.util.ArrayList;
21 import java.util.List;
22 import java.util.Map;
23
24 import org.apache.logging.log4j.Level;
25 import org.apache.logging.log4j.LogManager;
26 import org.apache.logging.log4j.Logger;
27 import org.apache.logging.log4j.core.LoggerContext;
28 import org.apache.logging.log4j.core.impl.Log4jContextFactory;
29 import org.apache.logging.log4j.core.util.NetUtils;
30 import org.apache.logging.log4j.spi.LoggerContextFactory;
31 import org.apache.logging.log4j.status.StatusLogger;
32 import org.apache.logging.log4j.util.Strings;
33
34
35
36
37
38 public final class Configurator {
39
40 private static final String FQCN = Configurator.class.getName();
41
42 private static final Logger LOGGER = StatusLogger.getLogger();
43
44 private static Log4jContextFactory getFactory() {
45 final LoggerContextFactory factory = LogManager.getFactory();
46 if (factory instanceof Log4jContextFactory) {
47 return (Log4jContextFactory) factory;
48 } else if (factory != null) {
49 LOGGER.error("LogManager returned an instance of {} which does not implement {}. Unable to initialize Log4j.",
50 factory.getClass().getName(), Log4jContextFactory.class.getName());
51 return null;
52 } else {
53 LOGGER.fatal("LogManager did not return a LoggerContextFactory. This indicates something has gone terribly wrong!");
54 return null;
55 }
56 }
57
58
59
60
61
62
63
64 public static LoggerContext initialize(final ClassLoader loader,
65 final ConfigurationSource source) {
66 return initialize(loader, source, null);
67 }
68
69
70
71
72
73
74
75
76
77 public static LoggerContext initialize(final ClassLoader loader,
78 final ConfigurationSource source,
79 final Object externalContext)
80 {
81
82 try {
83 final Log4jContextFactory factory = getFactory();
84 return factory == null ? null :
85 factory.getContext(FQCN, loader, externalContext, false, source);
86 } catch (final Exception ex) {
87 LOGGER.error("There was a problem obtaining a LoggerContext using the configuration source [{}]", source, ex);
88 }
89 return null;
90 }
91
92
93
94
95
96
97
98
99 public static LoggerContext initialize(final String name, final ClassLoader loader, final String configLocation) {
100 return initialize(name, loader, configLocation, null);
101
102 }
103
104
105
106
107
108
109
110
111
112 public static LoggerContext initialize(final String name, final ClassLoader loader, final String configLocation,
113 final Object externalContext) {
114 if (Strings.isBlank(configLocation)) {
115 return initialize(name, loader, (URI) null, externalContext);
116 }
117 if (configLocation.contains(",")) {
118 final String[] parts = configLocation.split(",");
119 String scheme = null;
120 final List<URI> uris = new ArrayList<>(parts.length);
121 for (final String part : parts) {
122 final URI uri = NetUtils.toURI(scheme != null ? scheme + ":" + part.trim() : part.trim());
123 if (scheme == null && uri.getScheme() != null) {
124 scheme = uri.getScheme();
125 }
126 uris.add(uri);
127 }
128 return initialize(name, loader, uris, externalContext);
129 } else {
130 return initialize(name, loader, NetUtils.toURI(configLocation), externalContext);
131 }
132 }
133
134
135
136
137
138
139
140
141 public static LoggerContext initialize(final String name, final ClassLoader loader, final URI configLocation) {
142 return initialize(name, loader, configLocation, null);
143 }
144
145
146
147
148
149
150
151
152
153 public static LoggerContext initialize(final String name, final ClassLoader loader, final URI configLocation,
154 final Object externalContext) {
155
156 try {
157 final Log4jContextFactory factory = getFactory();
158 return factory == null ? null :
159 factory.getContext(FQCN, loader, externalContext, false, configLocation, name);
160 } catch (final Exception ex) {
161 LOGGER.error("There was a problem initializing the LoggerContext [{}] using configuration at [{}].",
162 name, configLocation, ex);
163 }
164 return null;
165 }
166
167 public static LoggerContext initialize(final String name, final ClassLoader loader, final List<URI> configLocations,
168 final Object externalContext) {
169 try {
170 final Log4jContextFactory factory = getFactory();
171 return factory == null ?
172 null :
173 factory.getContext(FQCN, loader, externalContext, false, configLocations, name);
174 } catch (final Exception ex) {
175 LOGGER.error("There was a problem initializing the LoggerContext [{}] using configurations at [{}].", name,
176 configLocations, ex);
177 }
178 return null;
179 }
180
181
182
183
184
185
186
187 public static LoggerContext initialize(final String name, final String configLocation) {
188 return initialize(name, null, configLocation);
189 }
190
191
192
193
194
195
196 public static LoggerContext initialize(final Configuration configuration) {
197 return initialize(null, configuration, null);
198 }
199
200
201
202
203
204
205
206 public static LoggerContext initialize(final ClassLoader loader, final Configuration configuration) {
207 return initialize(loader, configuration, null);
208 }
209
210
211
212
213
214
215
216
217 public static LoggerContext initialize(final ClassLoader loader, final Configuration configuration, final Object externalContext) {
218 try {
219 final Log4jContextFactory factory = getFactory();
220 return factory == null ? null :
221 factory.getContext(FQCN, loader, externalContext, false, configuration);
222 } catch (final Exception ex) {
223 LOGGER.error("There was a problem initializing the LoggerContext using configuration {}",
224 configuration.getName(), ex);
225 }
226 return null;
227 }
228
229
230
231
232
233
234 public static void setAllLevels(final String parentLogger, final Level level) {
235
236
237
238
239
240 final LoggerContext loggerContext = LoggerContext.getContext(false);
241 final Configuration config = loggerContext.getConfiguration();
242 boolean set = setLevel(parentLogger, level, config);
243 for (final Map.Entry<String, LoggerConfig> entry : config.getLoggers().entrySet()) {
244 if (entry.getKey().startsWith(parentLogger)) {
245 set |= setLevel(entry.getValue(), level);
246 }
247 }
248 if (set) {
249 loggerContext.updateLoggers();
250 }
251 }
252
253 private static boolean setLevel(final LoggerConfig loggerConfig, final Level level) {
254 final boolean set = !loggerConfig.getLevel().equals(level);
255 if (set) {
256 loggerConfig.setLevel(level);
257 }
258 return set;
259 }
260
261
262
263
264
265
266
267
268 public static void setLevel(final Map<String, Level> levelMap) {
269 final LoggerContext loggerContext = LoggerContext.getContext(false);
270 final Configuration config = loggerContext.getConfiguration();
271 boolean set = false;
272 for (final Map.Entry<String, Level> entry : levelMap.entrySet()) {
273 final String loggerName = entry.getKey();
274 final Level level = entry.getValue();
275 set |= setLevel(loggerName, level, config);
276 }
277 if (set) {
278 loggerContext.updateLoggers();
279 }
280 }
281
282
283
284
285
286
287
288
289
290 public static void setLevel(final String loggerName, final Level level) {
291 final LoggerContext loggerContext = LoggerContext.getContext(false);
292 if (Strings.isEmpty(loggerName)) {
293 setRootLevel(level);
294 } else {
295 if (setLevel(loggerName, level, loggerContext.getConfiguration())) {
296 loggerContext.updateLoggers();
297 }
298 }
299 }
300
301 private static boolean setLevel(final String loggerName, final Level level, final Configuration config) {
302 boolean set;
303 LoggerConfig loggerConfig = config.getLoggerConfig(loggerName);
304 if (!loggerName.equals(loggerConfig.getName())) {
305
306 loggerConfig = new LoggerConfig(loggerName, level, true);
307 config.addLogger(loggerName, loggerConfig);
308 loggerConfig.setLevel(level);
309 set = true;
310 } else {
311 set = setLevel(loggerConfig, level);
312 }
313 return set;
314 }
315
316
317
318
319
320
321
322 public static void setRootLevel(final Level level) {
323 final LoggerContext loggerContext = LoggerContext.getContext(false);
324 final LoggerConfig loggerConfig = loggerContext.getConfiguration().getRootLogger();
325 if (!loggerConfig.getLevel().equals(level)) {
326 loggerConfig.setLevel(level);
327 loggerContext.updateLoggers();
328 }
329 }
330
331
332
333
334
335 public static void shutdown(final LoggerContext ctx) {
336 if (ctx != null) {
337 ctx.stop();
338 }
339 }
340
341 private Configurator() {
342
343 }
344 }