org.apache.logging.log4j.core.pattern.JAnsiTextRenderer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of log4j-core Show documentation
Show all versions of log4j-core Show documentation
The Apache Log4j Implementation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache license, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the license for the specific language governing permissions and
* limitations under the license.
*/
package org.apache.logging.log4j.core.pattern;
import static org.fusesource.jansi.AnsiRenderer.Code.BG_RED;
import static org.fusesource.jansi.AnsiRenderer.Code.BOLD;
import static org.fusesource.jansi.AnsiRenderer.Code.RED;
import static org.fusesource.jansi.AnsiRenderer.Code.WHITE;
import static org.fusesource.jansi.AnsiRenderer.Code.YELLOW;
import java.util.Collections;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import org.apache.logging.log4j.status.StatusLogger;
import org.fusesource.jansi.Ansi;
import org.fusesource.jansi.AnsiRenderer;
import org.fusesource.jansi.AnsiRenderer.Code;
/**
* Renders an input as ANSI escaped output.
*
* Uses the JAnsi rendering syntax as the default to render a message into an ANSI escaped string.
*
* The default syntax for embedded ANSI codes is:
*
*
* @|code(,code)* text|@
*
*
* For example, to render the message {@code "Hello"} in green, use:
*
*
* @|green Hello|@
*
*
* To render the message {@code "Hello"} in bold and red, use:
*
*
* @|bold,red Warning!|@
*
*
* You can also define custom style names in the configuration with the syntax:
*
*
* %message{ansi}{StyleName=value(,value)*( StyleName=value(,value)*)*}%n
*
*
* For example:
*
*
* %message{ansi}{WarningStyle=red,bold KeyStyle=white ValueStyle=blue}%n
*
*
* The call site can look like this:
*
*
* logger.info("@|KeyStyle {}|@ = @|ValueStyle {}|@", entry.getKey(), entry.getValue());
*
*
* Note: This class originally copied and then heavily modified code from JAnsi's AnsiRenderer (which is licensed as
* Apache 2.0.)
*
* @see AnsiRenderer
*/
public final class JAnsiTextRenderer implements TextRenderer {
public static final Map DefaultExceptionStyleMap;
static final Map DefaultMessageStyleMap;
private static final Map> PrefedinedStyleMaps;
private static void put(final Map map, final String name, final Code... codes) {
map.put(name, codes);
}
static {
final Map> tempPreDefs = new HashMap<>();
// Default style: Spock
{
// TODO Should the keys be in an enum?
final Map map = new HashMap<>();
put(map, "Prefix", WHITE);
put(map, "Name", BG_RED, WHITE);
put(map, "NameMessageSeparator", BG_RED, WHITE);
put(map, "Message", BG_RED, WHITE, BOLD);
put(map, "At", WHITE);
put(map, "CauseLabel", WHITE);
put(map, "Text", WHITE);
put(map, "More", WHITE);
put(map, "Suppressed", WHITE);
// StackTraceElement
put(map, "StackTraceElement.ClassName", YELLOW);
put(map, "StackTraceElement.ClassMethodSeparator", YELLOW);
put(map, "StackTraceElement.MethodName", YELLOW);
put(map, "StackTraceElement.NativeMethod", YELLOW);
put(map, "StackTraceElement.FileName", RED);
put(map, "StackTraceElement.LineNumber", RED);
put(map, "StackTraceElement.Container", RED);
put(map, "StackTraceElement.ContainerSeparator", WHITE);
put(map, "StackTraceElement.UnknownSource", RED);
// ExtraClassInfo
put(map, "ExtraClassInfo.Inexact", YELLOW);
put(map, "ExtraClassInfo.Container", YELLOW);
put(map, "ExtraClassInfo.ContainerSeparator", YELLOW);
put(map, "ExtraClassInfo.Location", YELLOW);
put(map, "ExtraClassInfo.Version", YELLOW);
// Save
DefaultExceptionStyleMap = Collections.unmodifiableMap(map);
tempPreDefs.put("Spock", DefaultExceptionStyleMap);
}
// Style: Kirk
{
// TODO Should the keys be in an enum?
final Map map = new HashMap<>();
put(map, "Prefix", WHITE);
put(map, "Name", BG_RED, YELLOW, BOLD);
put(map, "NameMessageSeparator", BG_RED, YELLOW);
put(map, "Message", BG_RED, WHITE, BOLD);
put(map, "At", WHITE);
put(map, "CauseLabel", WHITE);
put(map, "Text", WHITE);
put(map, "More", WHITE);
put(map, "Suppressed", WHITE);
// StackTraceElement
put(map, "StackTraceElement.ClassName", BG_RED, WHITE);
put(map, "StackTraceElement.ClassMethodSeparator", BG_RED, YELLOW);
put(map, "StackTraceElement.MethodName", BG_RED, YELLOW);
put(map, "StackTraceElement.NativeMethod", BG_RED, YELLOW);
put(map, "StackTraceElement.FileName", RED);
put(map, "StackTraceElement.LineNumber", RED);
put(map, "StackTraceElement.Container", RED);
put(map, "StackTraceElement.ContainerSeparator", WHITE);
put(map, "StackTraceElement.UnknownSource", RED);
// ExtraClassInfo
put(map, "ExtraClassInfo.Inexact", YELLOW);
put(map, "ExtraClassInfo.Container", WHITE);
put(map, "ExtraClassInfo.ContainerSeparator", WHITE);
put(map, "ExtraClassInfo.Location", YELLOW);
put(map, "ExtraClassInfo.Version", YELLOW);
// Save
tempPreDefs.put("Kirk", Collections.unmodifiableMap(map));
}
{
final Map temp = new HashMap<>();
// TODO
DefaultMessageStyleMap = Collections.unmodifiableMap(temp);
}
PrefedinedStyleMaps = Collections.unmodifiableMap(tempPreDefs);
}
private final String beginToken;
private final int beginTokenLen;
private final String endToken;
private final int endTokenLen;
private final Map styleMap;
public JAnsiTextRenderer(final String[] formats, final Map defaultStyleMap) {
String tempBeginToken = AnsiRenderer.BEGIN_TOKEN;
String tempEndToken = AnsiRenderer.END_TOKEN;
Map map;
if (formats.length > 1) {
final String allStylesStr = formats[1];
// Style def split
final String[] allStyleAssignmentsArr = allStylesStr.split(" ");
map = new HashMap<>(allStyleAssignmentsArr.length + defaultStyleMap.size());
map.putAll(defaultStyleMap);
for (final String styleAssignmentStr : allStyleAssignmentsArr) {
final String[] styleAssignmentArr = styleAssignmentStr.split("=");
if (styleAssignmentArr.length != 2) {
StatusLogger.getLogger().warn("{} parsing style \"{}\", expected format: StyleName=Code(,Code)*",
getClass().getSimpleName(), styleAssignmentStr);
} else {
final String styleName = styleAssignmentArr[0];
final String codeListStr = styleAssignmentArr[1];
final String[] codeNames = codeListStr.split(",");
if (codeNames.length == 0) {
StatusLogger.getLogger().warn(
"{} parsing style \"{}\", expected format: StyleName=Code(,Code)*",
getClass().getSimpleName(), styleAssignmentStr);
} else {
switch (styleName) {
case "BeginToken":
tempBeginToken = codeNames[0];
break;
case "EndToken":
tempEndToken = codeNames[0];
break;
case "StyleMapName":
final String predefinedMapName = codeNames[0];
final Map predefinedMap = PrefedinedStyleMaps.get(predefinedMapName);
if (predefinedMap != null) {
map.putAll(predefinedMap);
} else {
StatusLogger.getLogger().warn("Unknown predefined map name {}, pick one of {}",
predefinedMapName, null);
}
break;
default:
final Code[] codes = new Code[codeNames.length];
for (int i = 0; i < codes.length; i++) {
codes[i] = toCode(codeNames[i]);
}
map.put(styleName, codes);
}
}
}
}
} else {
map = defaultStyleMap;
}
styleMap = map;
beginToken = tempBeginToken;
endToken = tempEndToken;
beginTokenLen = tempBeginToken.length();
endTokenLen = tempEndToken.length();
}
public Map getStyleMap() {
return styleMap;
}
private void render(final Ansi ansi, final Code code) {
if (code.isColor()) {
if (code.isBackground()) {
ansi.bg(code.getColor());
} else {
ansi.fg(code.getColor());
}
} else if (code.isAttribute()) {
ansi.a(code.getAttribute());
}
}
private void render(final Ansi ansi, final Code... codes) {
for (final Code code : codes) {
render(ansi, code);
}
}
/**
* Renders the given text with the given names which can be ANSI code names or Log4j style names.
*
* @param text
* The text to render
* @param names
* ANSI code names or Log4j style names.
* @return A rendered string containing ANSI codes.
*/
private String render(final String text, final String... names) {
final Ansi ansi = Ansi.ansi();
for (final String name : names) {
final Code[] codes = styleMap.get(name);
if (codes != null) {
render(ansi, codes);
} else {
render(ansi, toCode(name));
}
}
return ansi.a(text).reset().toString();
}
// EXACT COPY OF StringBuilder version of the method but typed as String for input
@Override
public void render(final String input, final StringBuilder output, final String styleName)
throws IllegalArgumentException {
output.append(render(input, styleName));
}
@Override
public void render(final StringBuilder input, final StringBuilder output) throws IllegalArgumentException {
int i = 0;
int j, k;
while (true) {
j = input.indexOf(beginToken, i);
if (j == -1) {
if (i == 0) {
output.append(input);
return;
}
output.append(input.substring(i, input.length()));
return;
}
output.append(input.substring(i, j));
k = input.indexOf(endToken, j);
if (k == -1) {
output.append(input);
return;
}
j += beginTokenLen;
final String spec = input.substring(j, k);
final String[] items = spec.split(AnsiRenderer.CODE_TEXT_SEPARATOR, 2);
if (items.length == 1) {
output.append(input);
return;
}
final String replacement = render(items[1], items[0].split(","));
output.append(replacement);
i = k + endTokenLen;
}
}
private Code toCode(final String name) {
return Code.valueOf(name.toUpperCase(Locale.ENGLISH));
}
@Override
public String toString() {
return "JAnsiMessageRenderer [beginToken=" + beginToken + ", beginTokenLen=" + beginTokenLen + ", endToken="
+ endToken + ", endTokenLen=" + endTokenLen + ", styleMap=" + styleMap + "]";
}
}