1 /*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.nashorn.internal.runtime;
27
28 import java.util.HashMap;
29 import java.util.Map;
30 import java.util.Map.Entry;
31 import java.util.logging.ConsoleHandler;
32 import java.util.logging.Formatter;
33 import java.util.logging.Handler;
34 import java.util.logging.Level;
35 import java.util.logging.LogRecord;
36 import java.util.logging.Logger;
37
38 /**
39 * Logging system for getting loggers for arbitrary subsystems as
40 * specified on the command line. Supports all standard log levels
41 *
42 */
43 public final class Logging {
44
45 private Logging() {
46 }
47
48 /** Loggers */
49
50 private static final Logger disabledLogger = Logger.getLogger("disabled");
51
52 static {
53 try {
54 Logging.disabledLogger.setLevel(Level.OFF);
55 } catch (final SecurityException e) {
56 //ignored
57 }
58 }
59
60 /** Maps logger name to loggers. Names are typically per package */
61 private static final Map<String, Logger> loggers = new HashMap<>();
62
63 private static String lastPart(final String packageName) {
64 final String[] parts = packageName.split("\\.");
65 if (parts.length == 0) {
66 return packageName;
67 }
68 return parts[parts.length - 1];
69 }
70
71 /**
72 * Get a logger for a given class, generating a logger name based on the
73 * class name
74 *
75 * @param name the name to use as key for the logger
76 * @return the logger
77 */
78 public static Logger getLogger(final String name) {
79 final Logger logger = Logging.loggers.get(name);
80 if (logger != null) {
81 return logger;
82 }
83 return Logging.disabledLogger;
84 }
85
86 /**
87 * Get a logger for a given name or create it if not already there, typically
88 * used for mapping system properties to loggers
89 *
90 * @param name the name to use as key
91 * @param level log lever to reset existing logger with, or create new logger with
92 * @return the logger
93 */
94 public static Logger getOrCreateLogger(final String name, final Level level) {
95 final Logger logger = Logging.loggers.get(name);
96 if (logger == null) {
97 return instantiateLogger(name, level);
98 }
99 logger.setLevel(level);
100 return logger;
101 }
102
103 /**
104 * Initialization function that is called to instantiate the logging system. It takes
105 * logger names (keys) and logging labels respectively
106 *
107 * @param map a map where the key is a logger name and the value a logging level
108 * @throws IllegalArgumentException if level or names cannot be parsed
109 */
110 public static void initialize(final Map<String, String> map) throws IllegalArgumentException {
111 try {
112 for (final Entry<String, String> entry : map.entrySet()) {
113 Level level;
114
115 final String key = entry.getKey();
116 final String value = entry.getValue();
117 if ("".equals(value)) {
118 level = Level.INFO;
119 } else {
120 level = Level.parse(value.toUpperCase());
121 }
122
123 final String name = Logging.lastPart(key);
124 final Logger logger = instantiateLogger(name, level);
125
126 Logging.loggers.put(name, logger);
127 }
128 } catch (final IllegalArgumentException | SecurityException e) {
129 throw e;
130 }
131 }
132
133 private static Logger instantiateLogger(final String name, final Level level) {
134 final Logger logger = java.util.logging.Logger.getLogger(name);
135 for (final Handler h : logger.getHandlers()) {
136 logger.removeHandler(h);
137 }
138
139 logger.setLevel(level);
140 logger.setUseParentHandlers(false);
141 final Handler c = new ConsoleHandler();
142
143 c.setFormatter(new Formatter() {
144 @Override
145 public String format(final LogRecord record) {
146 final StringBuilder sb = new StringBuilder();
147
148 sb.append('[')
149 .append(record.getLoggerName())
150 .append("] ")
151 .append(record.getMessage())
152 .append('\n');
153
154 return sb.toString();
155 }
156 });
157 logger.addHandler(c);
158 c.setLevel(level);
159
160 return logger;
161 }
162
163 }
--- EOF ---